From 712641a0efca8e5b3deed5d66b857add83ad8c3c Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Wed, 1 Apr 2026 11:46:25 +0100 Subject: [PATCH 1/7] A new grammar definition --- README.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 473612f..641f20e 100644 --- a/README.md +++ b/README.md @@ -7,10 +7,11 @@ This implementation is written in Go. # Grammar ``` -expression -> literal | unary | binary | grouping ; -literal -> NUMBER | STRING | "true" | "false" | "nil" ; -grouping -> "(" expression ")" ; -unary -> ( "-" | "!" ) expression ; -binary -> expression operator expression ; -operator -> "==" | "!=" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" ; +expression -> equality +equality -> comparison ( ( "!=" | "==" ) comparison )* ; +comparison -> term ( ( ">" | ">=" | "<" | "<=" ) term )* ; +term -> factor ( ( "-" | "+" ) factor )* ; +factor -> unary ( ( "/" | "*" ) unary )* ; +unary -> ( "!" | "-" ) unary | primary ; +primary -> NUMBER | STRING | "true" | "false" | "nil" | "(" expression ")" ; ``` From d5f96903b7f23e9064937f1c30ecf85e7137c6d1 Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Wed, 1 Apr 2026 13:28:54 +0100 Subject: [PATCH 2/7] Creating the parsers, without the proper error handling/propagation --- Makefile | 2 +- parser/parser.go | 163 ++++++++++++++++++++++++++++++++++++++++++ parser/parser_test.go | 56 +++++++++++++++ 3 files changed, 220 insertions(+), 1 deletion(-) create mode 100644 parser/parser.go create mode 100644 parser/parser_test.go diff --git a/Makefile b/Makefile index 78cd83f..90bd7e9 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ BINAY_NAME=glox TESTS_DIR=./tests -TEST_SET=. ./utils ./reporting ./token ./scanner ./expression ./astprinter ./cmd/ast +TEST_SET=. ./utils ./reporting ./token ./scanner ./expression ./astprinter ./parser ./cmd/ast build: go build -o glox . diff --git a/parser/parser.go b/parser/parser.go new file mode 100644 index 0000000..a44d7f9 --- /dev/null +++ b/parser/parser.go @@ -0,0 +1,163 @@ +package parser + +import ( + "errors" + "fmt" + + "github.com/ByteHunter/glox/expression" + "github.com/ByteHunter/glox/token" +) + +type Parser struct { + tokens []token.Token + current int +} + +func NewParser(tokens []token.Token) *Parser { + return &Parser{ + tokens: tokens, + } +} + +func (p *Parser) Parse() expression.Expression { + if len(p.tokens) == 0 { + return nil + } + return p.Expression() +} + +func (p *Parser) Expression() expression.Expression { + return p.Equality() +} + +func (p *Parser) Equality() expression.Expression { + var expr expression.Expression = p.Comparison() + + for p.match(token.BANQ_EQUAL, token.EQUAL_EQUAL) { + var operator token.Token = p.previous() + var right expression.Expression = p.Comparison() + expr = expression.NewBinary(expr, operator, right) + } + + return expr +} + +func (p *Parser) Comparison() expression.Expression { + var expr expression.Expression = p.Term() + + for p.match(token.GREATER, token.GREATER_EQUAL, token.LESS, token.LESS_EQUAL) { + var operator token.Token = p.previous() + var right expression.Expression = p.Term() + expr = expression.NewBinary(expr, operator, right) + } + + return expr +} + +func (p *Parser) Term() expression.Expression { + var expr expression.Expression = p.Factor() + + for p.match(token.MINUS, token.PLUS) { + var operator token.Token = p.previous() + var right expression.Expression = p.Factor() + expr = expression.NewBinary(expr, operator, right) + } + + return expr +} + +func (p *Parser) Factor() expression.Expression { + var expr expression.Expression = p.Unary() + + for p.match(token.MINUS, token.PLUS) { + var operator token.Token = p.previous() + var right expression.Expression = p.Unary() + expr = expression.NewBinary(expr, operator, right) + } + + return expr +} + +func (p *Parser) Unary() expression.Expression { + if p.match(token.BANG, token.MINUS) { + var operator token.Token = p.previous() + var right expression.Expression = p.Unary() + return expression.NewUnary(operator, right) + } + + return p.Primary() +} + +func (p *Parser) Primary() expression.Expression { + if p.match(token.FALSE) { + return expression.NewLiteral(false) + } + if p.match(token.TRUE) { + return expression.NewLiteral(true) + } + if p.match(token.NIL) { + return expression.NewLiteral(nil) + } + + if p.match(token.NUMBER, token.STRING) { + return expression.NewLiteral(p.previous().Literal) + } + + if p.match(token.LEFT_PAREN) { + var expr expression.Expression = p.Expression() + _, err := p.consume(token.RIGHT_PAREN, "Expect ')' after expression.") + if err != nil { + fmt.Println(err.Error()) + } + return expression.NewGrouping(expr) + } + + return nil +} + +func (p *Parser) match(tokenTypes ...token.TokenType) bool { + for _, tokenType := range tokenTypes { + if p.check(tokenType) { + p.advance() + return true + } + } + + return false +} + +func (p *Parser) check(expected token.TokenType) bool { + if p.isAtEnd() { + return false + } + + return p.peek().Type == expected +} + +func (p *Parser) isAtEnd() bool { + return p.peek().Type == token.EOF +} + +func (p *Parser) advance() token.Token { + if !p.isAtEnd() { + p.current++ + } + + return p.previous() +} + +func (p *Parser) peek() token.Token { + return p.tokens[p.current] +} + +func (p *Parser) previous() token.Token { + return p.tokens[p.current-1] +} + +func (p *Parser) consume(expected token.TokenType, message string) (token.Token, error) { + if p.check(expected) { + return p.advance(), nil + } + + return token.Token{}, errors.New(message) +} diff --git a/parser/parser_test.go b/parser/parser_test.go new file mode 100644 index 0000000..18507e9 --- /dev/null +++ b/parser/parser_test.go @@ -0,0 +1,56 @@ +package parser + +import ( + "fmt" + + "github.com/ByteHunter/glox/token" +) + +func ExampleNewParser_empty() { + parser := NewParser([]token.Token{}) + + fmt.Println(parser) + // Output: + // &{[] 0} +} + +func ExampleNewParser_with_tokens() { + parser := NewParser([]token.Token{ + *token.NewToken(token.LEFT_PAREN, "(", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.RIGHT_PAREN, ")", nil, 1), + }) + + fmt.Println(parser) + // Output: + // &{[{0 ( 1} {21 42 42 1} {1 ) 1}] 0} +} + +func ExampleParser_Parse_empty() { + parser := NewParser([]token.Token{}) + + fmt.Println(parser.Parse()) + // Output: + // +} + +func ExampleParser_Parse_only_eof() { + parser := NewParser([]token.Token{ + *token.NewToken(token.EOF, "", nil, 1), + }) + + fmt.Println(parser.Parse()) + // Output: + // +} + +func ExampleParser_Parse_simple() { + parser := NewParser([]token.Token{ + *token.NewToken(token.TRUE, "true", true, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + fmt.Println(parser.Parse()) + // Output: + // &{ true} +} From 72b1d7a86c82713df0cfd0eac4d2b4a2de8e2514 Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Wed, 1 Apr 2026 18:10:47 +0100 Subject: [PATCH 3/7] Covering the Parser with tests --- parser/parser.go | 2 +- parser/parser_test.go | 234 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 230 insertions(+), 6 deletions(-) diff --git a/parser/parser.go b/parser/parser.go index a44d7f9..6a06aa8 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -69,7 +69,7 @@ func (p *Parser) Term() expression.Expression { func (p *Parser) Factor() expression.Expression { var expr expression.Expression = p.Unary() - for p.match(token.MINUS, token.PLUS) { + for p.match(token.SLASH, token.STAR) { var operator token.Token = p.previous() var right expression.Expression = p.Unary() expr = expression.NewBinary(expr, operator, right) diff --git a/parser/parser_test.go b/parser/parser_test.go index 18507e9..5039390 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -3,9 +3,15 @@ package parser import ( "fmt" + "github.com/ByteHunter/glox/astprinter" + "github.com/ByteHunter/glox/expression" "github.com/ByteHunter/glox/token" ) +func printExpression(expr expression.Expression) { + fmt.Printf("%s", astprinter.NewAstPrinter().Print(expr)) +} + func ExampleNewParser_empty() { parser := NewParser([]token.Token{}) @@ -26,7 +32,7 @@ func ExampleNewParser_with_tokens() { // &{[{0 ( 1} {21 42 42 1} {1 ) 1}] 0} } -func ExampleParser_Parse_empty() { +func ExampleParser_Parse_empty_tokens_slice() { parser := NewParser([]token.Token{}) fmt.Println(parser.Parse()) @@ -44,13 +50,231 @@ func ExampleParser_Parse_only_eof() { // } -func ExampleParser_Parse_simple() { - parser := NewParser([]token.Token{ +func ExampleParser_Primary_false() { + p := NewParser([]token.Token{ + *token.NewToken(token.FALSE, "false", false, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // false +} + +func ExampleParser_Primary_true() { + p := NewParser([]token.Token{ *token.NewToken(token.TRUE, "true", true, 1), *token.NewToken(token.EOF, "", nil, 1), }) - fmt.Println(parser.Parse()) + printExpression(p.Primary()) + // Output: + // true +} + +func ExampleParser_Primary_nil() { + p := NewParser([]token.Token{ + *token.NewToken(token.NIL, "nil", nil, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // nil +} + +func ExampleParser_Primary_number() { + p := NewParser([]token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // 42 +} + +func ExampleParser_Primary_string() { + p := NewParser([]token.Token{ + *token.NewToken(token.STRING, "test", "test", 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // test +} + +func ExampleParser_Primary_parenthesis() { + p := NewParser([]token.Token{ + *token.NewToken(token.LEFT_PAREN, "(", nil, 1), + *token.NewToken(token.NIL, "nil", nil, 1), + *token.NewToken(token.RIGHT_PAREN, ")", nil, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // (group nil) +} + +func ExampleParser_Primary_parenthesis_true() { + p := NewParser([]token.Token{ + *token.NewToken(token.LEFT_PAREN, "(", nil, 1), + *token.NewToken(token.TRUE, "true", true, 1), + *token.NewToken(token.RIGHT_PAREN, ")", nil, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // (group true) +} + +func ExampleParser_Primary_parenthesize_with_grouping() { + p := NewParser([]token.Token{ + *token.NewToken(token.LEFT_PAREN, "(", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EQUAL_EQUAL, "==", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.RIGHT_PAREN, ")", nil, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // (group (== 42 42)) +} + +func ExampleParser_Primary_parenthesize_with_error() { + p := NewParser([]token.Token{ + *token.NewToken(token.LEFT_PAREN, "(", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EQUAL_EQUAL, "==", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Primary()) + // Output: + // Expect ')' after expression. + // (group (== 42 42)) +} + +func ExampleParser_Comparison() { + var examples = []struct { + tokens []token.Token + }{ + {tokens: []token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.GREATER, ">", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }}, + {tokens: []token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.GREATER_EQUAL, ">=", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }}, + {tokens: []token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.LESS, "<", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }}, + {tokens: []token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.LESS_EQUAL, "<=", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }}, + } + + for _,e := range examples { + p := NewParser(e.tokens) + printExpression(p.Comparison()) + fmt.Println() + } + // Output: + // (> 42 42) + // (>= 42 42) + // (< 42 42) + // (<= 42 42) +} + +func ExampleParser_Term_minus() { + p := NewParser([]token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.MINUS, "-", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Term()) + // Output: + // (- 42 42) +} + +func ExampleParser_Term_plus() { + p := NewParser([]token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.PLUS, "+", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Term()) + // Output: + // (+ 42 42) +} + +func ExampleParser_Factor_slash() { + p := NewParser([]token.Token{ + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.SLASH, "/", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Factor()) + // Output: + // (/ 42 42) +} + +func ExampleParser_Factor_star() { + p := NewParser([]token.Token{ + *token.NewToken(token.NUMBER, "21", 21, 1), + *token.NewToken(token.STAR, "*", nil, 1), + *token.NewToken(token.NUMBER, "2", 2, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Factor()) + // Output: + // (* 21 2) +} + +func ExampleParser_Unary_bang() { + p := NewParser([]token.Token{ + *token.NewToken(token.BANG, "!", nil, 1), + *token.NewToken(token.TRUE, "true", true, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Unary()) + // Output: + // (! true) +} + +func ExampleParser_Unary_minus() { + p := NewParser([]token.Token{ + *token.NewToken(token.MINUS, "-", nil, 1), + *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + + printExpression(p.Unary()) // Output: - // &{ true} + // (- 42) } From d0d37e6a9480700fffb785c8d795598edb65e966 Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Thu, 2 Apr 2026 17:18:51 +0100 Subject: [PATCH 4/7] Propagating the ParseError back --- parser/parser.go | 112 ++++++++++++++++++++++++++++++------------ parser/parser_test.go | 23 +++++++-- reporting/report.go | 11 +++++ 3 files changed, 110 insertions(+), 36 deletions(-) diff --git a/parser/parser.go b/parser/parser.go index 6a06aa8..a7e4448 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -1,13 +1,29 @@ package parser import ( - "errors" "fmt" "github.com/ByteHunter/glox/expression" + "github.com/ByteHunter/glox/reporting" "github.com/ByteHunter/glox/token" ) +type ParseError struct { + token token.Token + message string +} + +func NewParseError(token token.Token, message string) *ParseError { + return &ParseError{ + token: token, + message: message, + } +} + +func (p ParseError) Error() string { + return fmt.Sprintf("ParseError %s", p.message) +} + type Parser struct { tokens []token.Token current int @@ -23,96 +39,127 @@ func (p *Parser) Parse() expression.Expression { if len(p.tokens) == 0 { return nil } - return p.Expression() + + expr, err := p.Expression() + if err != nil { + return nil + } + + return expr } -func (p *Parser) Expression() expression.Expression { +func (p *Parser) Expression() (expression.Expression, error) { return p.Equality() } -func (p *Parser) Equality() expression.Expression { - var expr expression.Expression = p.Comparison() +func (p *Parser) Equality() (expression.Expression, error) { + expr, err := p.Comparison() + if err != nil { + return expr, err + } for p.match(token.BANQ_EQUAL, token.EQUAL_EQUAL) { var operator token.Token = p.previous() - var right expression.Expression = p.Comparison() + right, err := p.Comparison() expr = expression.NewBinary(expr, operator, right) + if err != nil { + return expr, err + } } - return expr + return expr, nil } -func (p *Parser) Comparison() expression.Expression { - var expr expression.Expression = p.Term() +func (p *Parser) Comparison() (expression.Expression, error) { + expr, err := p.Term() + if err != nil { + return expr, err + } for p.match(token.GREATER, token.GREATER_EQUAL, token.LESS, token.LESS_EQUAL) { var operator token.Token = p.previous() - var right expression.Expression = p.Term() + right, err := p.Term() expr = expression.NewBinary(expr, operator, right) + if err != nil { + return expr, err + } } - return expr + return expr, nil } -func (p *Parser) Term() expression.Expression { - var expr expression.Expression = p.Factor() +func (p *Parser) Term() (expression.Expression, error) { + expr, err := p.Factor() + if err != nil { + return expr, err + } for p.match(token.MINUS, token.PLUS) { var operator token.Token = p.previous() - var right expression.Expression = p.Factor() + right, err := p.Factor() expr = expression.NewBinary(expr, operator, right) + if err != nil { + return expr, err + } } - return expr + return expr, nil } -func (p *Parser) Factor() expression.Expression { - var expr expression.Expression = p.Unary() +func (p *Parser) Factor() (expression.Expression, error) { + expr, err := p.Unary() + if err != nil { + return expr, err + } for p.match(token.SLASH, token.STAR) { var operator token.Token = p.previous() - var right expression.Expression = p.Unary() + right, err := p.Unary() expr = expression.NewBinary(expr, operator, right) + if err != nil { + return expr, err + } } - return expr + return expr, nil } -func (p *Parser) Unary() expression.Expression { +func (p *Parser) Unary() (expression.Expression, error) { if p.match(token.BANG, token.MINUS) { var operator token.Token = p.previous() - var right expression.Expression = p.Unary() - return expression.NewUnary(operator, right) + right, err := p.Unary() + return expression.NewUnary(operator, right), err } return p.Primary() } -func (p *Parser) Primary() expression.Expression { +func (p *Parser) Primary() (expression.Expression, error) { if p.match(token.FALSE) { - return expression.NewLiteral(false) + return expression.NewLiteral(false), nil } if p.match(token.TRUE) { - return expression.NewLiteral(true) + return expression.NewLiteral(true), nil } if p.match(token.NIL) { - return expression.NewLiteral(nil) + return expression.NewLiteral(nil), nil } if p.match(token.NUMBER, token.STRING) { - return expression.NewLiteral(p.previous().Literal) + return expression.NewLiteral(p.previous().Literal), nil } if p.match(token.LEFT_PAREN) { - var expr expression.Expression = p.Expression() + expr, _ := p.Expression() _, err := p.consume(token.RIGHT_PAREN, "Expect ')' after expression.") if err != nil { - fmt.Println(err.Error()) + return expression.NewGrouping(expr), err } - return expression.NewGrouping(expr) + return expression.NewGrouping(expr), nil } - return nil + reporting.LoxTokenError(p.peek(), "Expected expression") + return nil, NewParseError(p.peek(), "Expected expression.") } func (p *Parser) match(tokenTypes ...token.TokenType) bool { @@ -159,5 +206,6 @@ func (p *Parser) consume(expected token.TokenType, message string) (token.Token, return p.advance(), nil } - return token.Token{}, errors.New(message) + reporting.LoxTokenError(p.previous(), message) + return p.previous(), NewParseError(p.previous(), message) } diff --git a/parser/parser_test.go b/parser/parser_test.go index 5039390..8f35e0b 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -2,13 +2,14 @@ package parser import ( "fmt" + "testing" "github.com/ByteHunter/glox/astprinter" "github.com/ByteHunter/glox/expression" "github.com/ByteHunter/glox/token" ) -func printExpression(expr expression.Expression) { +func printExpression(expr expression.Expression, _ error) { fmt.Printf("%s", astprinter.NewAstPrinter().Print(expr)) } @@ -47,6 +48,7 @@ func ExampleParser_Parse_only_eof() { fmt.Println(parser.Parse()) // Output: + // [line 1] Error at end: Expected expression // } @@ -151,14 +153,14 @@ func ExampleParser_Primary_parenthesize_with_error() { *token.NewToken(token.LEFT_PAREN, "(", nil, 1), *token.NewToken(token.NUMBER, "42", 42, 1), *token.NewToken(token.EQUAL_EQUAL, "==", nil, 1), - *token.NewToken(token.NUMBER, "42", 42, 1), + *token.NewToken(token.NUMBER, "41", 41, 1), *token.NewToken(token.EOF, "", nil, 1), }) printExpression(p.Primary()) // Output: - // Expect ')' after expression. - // (group (== 42 42)) + // [line 1] Error at '41': Expect ')' after expression. + // (group (== 42 41)) } func ExampleParser_Comparison() { @@ -278,3 +280,16 @@ func ExampleParser_Unary_minus() { // Output: // (- 42) } + +func TestPeek(t *testing.T) { + p := NewParser([]token.Token{ + *token.NewToken(token.MINUS, "-", nil, 1), + *token.NewToken(token.EOF, "", nil, 1), + }) + tok := p.peek() + actual := tok.Type + expected := token.MINUS + if actual != expected { + t.Errorf("Expected to be '%v' but got '%v'", expected, actual) + } +} diff --git a/reporting/report.go b/reporting/report.go index 7ff086a..4c8b437 100644 --- a/reporting/report.go +++ b/reporting/report.go @@ -3,8 +3,19 @@ package reporting import ( "fmt" "os" + + "github.com/ByteHunter/glox/token" ) +func LoxTokenError(t token.Token, message string) { + if t.Type == token.EOF { + LoxReport(t.Line, "at end", message) + return + } + + LoxReport(t.Line, "at '" + t.Lexeme + "'", message) +} + func LoxError(line int, message string) { LoxReport(line, "", message) } From cad7fcec01943e8025f86122cb1f1b46cd8f0b13 Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Thu, 2 Apr 2026 19:02:29 +0100 Subject: [PATCH 5/7] Preparing the synchronizing method for future use --- parser/parser.go | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/parser/parser.go b/parser/parser.go index a7e4448..0d53e12 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -209,3 +209,28 @@ func (p *Parser) consume(expected token.TokenType, message string) (token.Token, reporting.LoxTokenError(p.previous(), message) return p.previous(), NewParseError(p.previous(), message) } + +func (p *Parser) synchronize() { + p.advance() + + for !p.isAtEnd() { + if p.previous().Type == token.SEMICOLON { + return + } + + switch p.peek().Type { + case + token.CLASS, + token.FUN, + token.VAR, + token.FOR, + token.IF, + token.WHILE, + token.PRINT, + token.RETURN: + return + } + + p.advance() + } +} From 3738313967f96475af411f5936ff51e779396bd1 Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Thu, 2 Apr 2026 19:09:03 +0100 Subject: [PATCH 6/7] Wiring up the parser in the main programm --- main.go | 5 ++++- scanner/scanner.go | 4 ++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/main.go b/main.go index 39c9746..39c125d 100644 --- a/main.go +++ b/main.go @@ -6,6 +6,7 @@ import ( "fmt" "os" + "github.com/ByteHunter/glox/parser" scan "github.com/ByteHunter/glox/scanner" ) @@ -73,7 +74,9 @@ func run(source string) error { } scanner := scan.NewScanner(source) - scanner.ScanTokens() + t, _ := scanner.ScanTokens() + parser := parser.NewParser(t) + parser.Parse() return nil } diff --git a/scanner/scanner.go b/scanner/scanner.go index cc11131..b61c47e 100644 --- a/scanner/scanner.go +++ b/scanner/scanner.go @@ -42,6 +42,10 @@ func NewScanner(source string) *Scanner { } } +func (s *Scanner) GetTokens() []token.Token { + return s.tokens +} + func (s *Scanner) ScanTokens() ([]token.Token, error) { for !s.isAtEnd() { s.start = s.current From 8d69a1f166ca3ed6b46b3b407fbcd9e35cf0646a Mon Sep 17 00:00:00 2001 From: ByteHunter Date: Thu, 2 Apr 2026 19:12:23 +0100 Subject: [PATCH 7/7] Printing the resulting AST after parsing --- main.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/main.go b/main.go index 39c125d..488ffd5 100644 --- a/main.go +++ b/main.go @@ -6,6 +6,7 @@ import ( "fmt" "os" + "github.com/ByteHunter/glox/astprinter" "github.com/ByteHunter/glox/parser" scan "github.com/ByteHunter/glox/scanner" ) @@ -76,7 +77,8 @@ func run(source string) error { scanner := scan.NewScanner(source) t, _ := scanner.ScanTokens() parser := parser.NewParser(t) - parser.Parse() + expr := parser.Parse() + fmt.Println(astprinter.NewAstPrinter().Print(expr)) return nil }