408 lines
8.4 KiB
Go
408 lines
8.4 KiB
Go
package parser
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type Parser struct {
|
|
lexer *Lexer
|
|
buf []Token
|
|
comments []Comment
|
|
pragmas []Pragma
|
|
errors []error
|
|
}
|
|
|
|
func NewParser(input string) *Parser {
|
|
return &Parser{
|
|
lexer: NewLexer(input),
|
|
}
|
|
}
|
|
|
|
func (p *Parser) addError(pos Position, msg string) {
|
|
p.errors = append(p.errors, fmt.Errorf("%d:%d: %s", pos.Line, pos.Column, msg))
|
|
}
|
|
|
|
func (p *Parser) next() Token {
|
|
if len(p.buf) > 0 {
|
|
t := p.buf[0]
|
|
p.buf = p.buf[1:]
|
|
return t
|
|
}
|
|
return p.fetchToken()
|
|
}
|
|
|
|
func (p *Parser) peek() Token {
|
|
return p.peekN(0)
|
|
}
|
|
|
|
func (p *Parser) peekN(n int) Token {
|
|
for len(p.buf) <= n {
|
|
p.buf = append(p.buf, p.fetchToken())
|
|
}
|
|
return p.buf[n]
|
|
}
|
|
|
|
func (p *Parser) fetchToken() Token {
|
|
for {
|
|
tok := p.lexer.NextToken()
|
|
switch tok.Type {
|
|
case TokenComment:
|
|
p.comments = append(p.comments, Comment{Position: tok.Position, Text: tok.Value})
|
|
case TokenDocstring:
|
|
p.comments = append(p.comments, Comment{Position: tok.Position, Text: tok.Value, Doc: true})
|
|
case TokenPragma:
|
|
p.pragmas = append(p.pragmas, Pragma{Position: tok.Position, Text: tok.Value})
|
|
default:
|
|
return tok
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Parser) Parse() (*Configuration, error) {
|
|
config := &Configuration{}
|
|
for {
|
|
tok := p.peek()
|
|
if tok.Type == TokenEOF {
|
|
break
|
|
}
|
|
if tok.Type == TokenPackage {
|
|
p.next()
|
|
config.Package = &Package{
|
|
Position: tok.Position,
|
|
URI: strings.TrimSpace(strings.TrimPrefix(tok.Value, "#package")),
|
|
}
|
|
continue
|
|
}
|
|
|
|
def, ok := p.parseDefinition()
|
|
if ok {
|
|
config.Definitions = append(config.Definitions, def)
|
|
} else {
|
|
// Synchronization: skip token if not consumed to make progress
|
|
if p.peek() == tok {
|
|
p.next()
|
|
}
|
|
}
|
|
}
|
|
config.Comments = p.comments
|
|
config.Pragmas = p.pragmas
|
|
|
|
var err error
|
|
if len(p.errors) > 0 {
|
|
err = p.errors[0]
|
|
}
|
|
return config, err
|
|
}
|
|
|
|
func (p *Parser) parseDefinition() (Definition, bool) {
|
|
tok := p.next()
|
|
switch tok.Type {
|
|
case TokenIdentifier:
|
|
name := tok.Value
|
|
if name == "#var" {
|
|
return p.parseVariableDefinition(tok)
|
|
}
|
|
if p.peek().Type != TokenEqual {
|
|
p.addError(tok.Position, "expected =")
|
|
return nil, false
|
|
}
|
|
p.next() // Consume =
|
|
|
|
nextTok := p.peek()
|
|
if nextTok.Type == TokenLBrace {
|
|
if p.isSubnodeLookahead() {
|
|
sub, ok := p.parseSubnode()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return &ObjectNode{
|
|
Position: tok.Position,
|
|
Name: name,
|
|
Subnode: sub,
|
|
}, true
|
|
}
|
|
}
|
|
|
|
val, ok := p.parseValue()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return &Field{
|
|
Position: tok.Position,
|
|
Name: name,
|
|
Value: val,
|
|
}, true
|
|
|
|
case TokenObjectIdentifier:
|
|
name := tok.Value
|
|
if p.peek().Type != TokenEqual {
|
|
p.addError(tok.Position, "expected =")
|
|
return nil, false
|
|
}
|
|
p.next() // Consume =
|
|
|
|
sub, ok := p.parseSubnode()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return &ObjectNode{
|
|
Position: tok.Position,
|
|
Name: name,
|
|
Subnode: sub,
|
|
}, true
|
|
default:
|
|
p.addError(tok.Position, fmt.Sprintf("unexpected token %v", tok.Value))
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
func (p *Parser) isSubnodeLookahead() bool {
|
|
// We are before '{'.
|
|
// Look inside:
|
|
// peek(0) is '{'
|
|
// peek(1) is first token inside
|
|
|
|
t1 := p.peekN(1)
|
|
if t1.Type == TokenRBrace {
|
|
// {} -> Empty. Assume Array (Value) by default, unless forced?
|
|
// If we return false, it parses as ArrayValue.
|
|
// If user writes "Sig = {}", is it an empty signal?
|
|
// Empty array is more common for value.
|
|
// If "Sig" is a node, it should probably have content or use +Sig.
|
|
return false
|
|
}
|
|
|
|
if t1.Type == TokenIdentifier {
|
|
// Identifier inside.
|
|
// If followed by '=', it's a definition -> Subnode.
|
|
t2 := p.peekN(2)
|
|
if t2.Type == TokenEqual {
|
|
return true
|
|
}
|
|
// Identifier alone or followed by something else -> Reference/Value -> Array
|
|
return false
|
|
}
|
|
|
|
if t1.Type == TokenObjectIdentifier {
|
|
// +Node = ... -> Definition -> Subnode
|
|
return true
|
|
}
|
|
|
|
// Literals -> Array
|
|
return false
|
|
}
|
|
|
|
func (p *Parser) parseSubnode() (Subnode, bool) {
|
|
tok := p.next()
|
|
if tok.Type != TokenLBrace {
|
|
p.addError(tok.Position, "expected {")
|
|
return Subnode{}, false
|
|
}
|
|
sub := Subnode{Position: tok.Position}
|
|
for {
|
|
t := p.peek()
|
|
if t.Type == TokenRBrace {
|
|
endTok := p.next()
|
|
sub.EndPosition = endTok.Position
|
|
break
|
|
}
|
|
if t.Type == TokenEOF {
|
|
p.addError(t.Position, "unexpected EOF, expected }")
|
|
sub.EndPosition = t.Position
|
|
return sub, true
|
|
}
|
|
def, ok := p.parseDefinition()
|
|
if ok {
|
|
sub.Definitions = append(sub.Definitions, def)
|
|
} else {
|
|
if p.peek() == t {
|
|
p.next()
|
|
}
|
|
}
|
|
}
|
|
return sub, true
|
|
}
|
|
|
|
func (p *Parser) parseValue() (Value, bool) {
|
|
return p.parseExpression(0)
|
|
}
|
|
|
|
func getPrecedence(t TokenType) int {
|
|
switch t {
|
|
case TokenStar, TokenSlash, TokenPercent:
|
|
return 5
|
|
case TokenPlus, TokenMinus:
|
|
return 4
|
|
case TokenConcat:
|
|
return 3
|
|
case TokenAmpersand:
|
|
return 2
|
|
case TokenPipe, TokenCaret:
|
|
return 1
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func (p *Parser) parseExpression(minPrecedence int) (Value, bool) {
|
|
left, ok := p.parseAtom()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
|
|
for {
|
|
t := p.peek()
|
|
prec := getPrecedence(t.Type)
|
|
if prec == 0 || prec <= minPrecedence {
|
|
break
|
|
}
|
|
p.next()
|
|
|
|
right, ok := p.parseExpression(prec)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
|
|
left = &BinaryExpression{
|
|
Position: left.Pos(),
|
|
Left: left,
|
|
Operator: t,
|
|
Right: right,
|
|
}
|
|
}
|
|
return left, true
|
|
}
|
|
|
|
func (p *Parser) parseAtom() (Value, bool) {
|
|
tok := p.next()
|
|
switch tok.Type {
|
|
case TokenString:
|
|
return &StringValue{
|
|
Position: tok.Position,
|
|
Value: strings.Trim(tok.Value, "\""),
|
|
Quoted: true,
|
|
}, true
|
|
|
|
case TokenNumber:
|
|
if strings.Contains(tok.Value, ".") || strings.Contains(tok.Value, "e") {
|
|
f, _ := strconv.ParseFloat(tok.Value, 64)
|
|
return &FloatValue{Position: tok.Position, Value: f, Raw: tok.Value}, true
|
|
}
|
|
i, _ := strconv.ParseInt(tok.Value, 0, 64)
|
|
return &IntValue{Position: tok.Position, Value: i, Raw: tok.Value}, true
|
|
case TokenBool:
|
|
return &BoolValue{Position: tok.Position, Value: tok.Value == "true"},
|
|
true
|
|
case TokenIdentifier:
|
|
return &ReferenceValue{Position: tok.Position, Value: tok.Value}, true
|
|
case TokenVariableReference:
|
|
return &VariableReferenceValue{Position: tok.Position, Name: tok.Value}, true
|
|
case TokenMinus:
|
|
val, ok := p.parseAtom()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return &UnaryExpression{Position: tok.Position, Operator: tok, Right: val}, true
|
|
case TokenObjectIdentifier:
|
|
return &VariableReferenceValue{Position: tok.Position, Name: tok.Value}, true
|
|
case TokenSymbol:
|
|
if tok.Value == "(" {
|
|
val, ok := p.parseExpression(0)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
if next := p.next(); next.Type != TokenSymbol || next.Value != ")" {
|
|
p.addError(next.Position, "expected )")
|
|
return nil, false
|
|
}
|
|
return val, true
|
|
}
|
|
fallthrough
|
|
case TokenLBrace:
|
|
arr := &ArrayValue{Position: tok.Position}
|
|
for {
|
|
t := p.peek()
|
|
if t.Type == TokenRBrace {
|
|
endTok := p.next()
|
|
arr.EndPosition = endTok.Position
|
|
break
|
|
}
|
|
if t.Type == TokenComma {
|
|
p.next()
|
|
continue
|
|
}
|
|
val, ok := p.parseValue()
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
arr.Elements = append(arr.Elements, val)
|
|
}
|
|
return arr, true
|
|
default:
|
|
p.addError(tok.Position, fmt.Sprintf("unexpected value token %v", tok.Value))
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
func (p *Parser) parseVariableDefinition(startTok Token) (Definition, bool) {
|
|
nameTok := p.next()
|
|
if nameTok.Type != TokenIdentifier {
|
|
p.addError(nameTok.Position, "expected variable name")
|
|
return nil, false
|
|
}
|
|
|
|
if p.next().Type != TokenColon {
|
|
p.addError(nameTok.Position, "expected :")
|
|
return nil, false
|
|
}
|
|
|
|
var typeTokens []Token
|
|
startLine := nameTok.Position.Line
|
|
|
|
for {
|
|
t := p.peek()
|
|
if t.Position.Line > startLine || t.Type == TokenEOF {
|
|
break
|
|
}
|
|
if t.Type == TokenEqual {
|
|
if p.peekN(1).Type == TokenSymbol && p.peekN(1).Value == "~" {
|
|
p.next()
|
|
p.next()
|
|
typeTokens = append(typeTokens, Token{Type: TokenSymbol, Value: "=~", Position: t.Position})
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
typeTokens = append(typeTokens, p.next())
|
|
}
|
|
|
|
typeExpr := ""
|
|
for _, t := range typeTokens {
|
|
typeExpr += t.Value + " "
|
|
}
|
|
|
|
var defVal Value
|
|
if p.peek().Type == TokenEqual {
|
|
p.next()
|
|
val, ok := p.parseValue()
|
|
if ok {
|
|
defVal = val
|
|
} else {
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
return &VariableDefinition{
|
|
Position: startTok.Position,
|
|
Name: nameTok.Value,
|
|
TypeExpr: strings.TrimSpace(typeExpr),
|
|
DefaultValue: defVal,
|
|
}, true
|
|
}
|
|
|
|
func (p *Parser) Errors() []error {
|
|
return p.errors
|
|
}
|