blob: 6e8bba6167aface332cc2bf2f1ae0bab74a8612d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package parser
import (
"fmt"
"mana/ast"
"mana/lexer"
"mana/tokens"
)
// Parser represents a parser.
type Parser struct {
l *lexer.Lexer
curToken tokens.Token
peekToken tokens.Token
errors []string
}
// New returns a new Parser.
func New(l *lexer.Lexer) *Parser {
var p *Parser = &Parser{
l: l,
errors: []string{},
}
// Read two tokens, so curToken and peekToken are both set.
p.nextToken()
p.nextToken()
return p
}
// nextToken advances the tokens.
func (p *Parser) nextToken() {
p.curToken = p.peekToken
p.peekToken = p.l.NextToken()
}
// ParseProgram parses a program.
func (p *Parser) ParseProgram() *ast.Program {
// Initialize the program with an empty slice of statements.
var program *ast.Program = &ast.Program{}
program.Statements = []ast.Statement{}
// Iterate over the tokens until we reach the end of file.
for p.curToken.Type != tokens.EOF {
// Parse the statement and append it to the program.
var stmt ast.Statement = p.parseStatement()
if stmt != nil {
program.Statements = append(program.Statements, stmt)
}
// Advance to the next token.
p.nextToken()
}
// Return the program.
return program
}
// parseStatement parses a statement.
func (p *Parser) parseStatement() ast.Statement {
switch p.curToken.Type {
case tokens.LET:
return p.parseLetStatement()
default:
return nil
}
}
// parseLetStatement parses a let statement.
func (p *Parser) parseLetStatement() *ast.LetStatement {
var stmt *ast.LetStatement = &ast.LetStatement{Token: p.curToken}
if !p.expectPeek(tokens.IDENT) {
return nil
}
stmt.Name = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
if !p.expectPeek(tokens.ASSIGN) {
return nil
}
// TODO: We're skipping the expressions until we
// encounter a semicolon.
for !p.curTokenIs(tokens.SEMICOLON) {
p.nextToken()
}
return stmt
}
// curTokenIs returns true if the current token is of the given type.
func (p *Parser) curTokenIs(t tokens.TokenType) bool {
return p.curToken.Type == t
}
// peekTokenIs returns true if the next token is of the given type.
func (p *Parser) peekTokenIs(t tokens.TokenType) bool {
return p.peekToken.Type == t
}
// expectPeek expects the next token to be of the given type.
func (p *Parser) expectPeek(t tokens.TokenType) bool {
if p.peekTokenIs(t) {
p.nextToken()
return true
} else {
p.peekError(t)
return false
}
}
// Errors returns the parser errors.
func (p *Parser) Errors() []string {
return p.errors
}
// peekError returns an error message.
func (p *Parser) peekError(t tokens.TokenType) {
var msg string = fmt.Sprintf("expected next token to be %s, got %s instead", t, p.peekToken.Type)
p.errors = append(p.errors, msg)
}
|
