You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
251 lines
5.3 KiB
251 lines
5.3 KiB
package forge
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
|
|
"github.com/brettlangdon/forge/token"
|
|
)
|
|
|
|
type Parser struct {
|
|
settings *Section
|
|
scanner *Scanner
|
|
curTok token.Token
|
|
curSection *Section
|
|
previous []*Section
|
|
}
|
|
|
|
func NewParser(reader io.Reader) *Parser {
|
|
settings := NewSection()
|
|
return &Parser{
|
|
scanner: NewScanner(reader),
|
|
settings: settings,
|
|
curSection: settings,
|
|
previous: make([]*Section, 0),
|
|
}
|
|
}
|
|
|
|
func (this *Parser) syntaxError(msg string) error {
|
|
msg = fmt.Sprintf(
|
|
"Syntax error line <%d> column <%d>: %s",
|
|
this.curTok.Line,
|
|
this.curTok.Column,
|
|
msg,
|
|
)
|
|
return errors.New(msg)
|
|
}
|
|
|
|
func (this *Parser) readToken() token.Token {
|
|
this.curTok = this.scanner.NextToken()
|
|
return this.curTok
|
|
}
|
|
|
|
func (this *Parser) parseReference(startingSection *Section, period bool) (Value, error) {
|
|
name := ""
|
|
if period == false {
|
|
name = this.curTok.Literal
|
|
}
|
|
for {
|
|
this.readToken()
|
|
if this.curTok.ID == token.PERIOD && period == false {
|
|
period = true
|
|
} else if period && this.curTok.ID == token.IDENTIFIER {
|
|
if len(name) > 0 {
|
|
name += "."
|
|
}
|
|
name += this.curTok.Literal
|
|
period = false
|
|
} else if this.curTok.ID == token.SEMICOLON {
|
|
break
|
|
} else {
|
|
msg := fmt.Sprintf("expected ';' instead found '%s'", this.curTok.Literal)
|
|
return nil, this.syntaxError(msg)
|
|
}
|
|
}
|
|
if len(name) == 0 {
|
|
return nil, this.syntaxError(
|
|
fmt.Sprintf("expected IDENTIFIER instead found %s", this.curTok.Literal),
|
|
)
|
|
}
|
|
|
|
if period {
|
|
return nil, this.syntaxError(fmt.Sprintf("expected IDENTIFIER after PERIOD"))
|
|
}
|
|
|
|
value, err := startingSection.Resolve(name)
|
|
if err != nil {
|
|
err = errors.New("Reference error, " + err.Error())
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (this *Parser) parseSetting(name string) error {
|
|
var value Value
|
|
this.readToken()
|
|
|
|
read_next := true
|
|
switch this.curTok.ID {
|
|
case token.STRING:
|
|
value = NewString(this.curTok.Literal)
|
|
case token.BOOLEAN:
|
|
boolVal, err := strconv.ParseBool(this.curTok.Literal)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
value = NewBoolean(boolVal)
|
|
case token.NULL:
|
|
value = NewNull()
|
|
case token.INTEGER:
|
|
intVal, err := strconv.ParseInt(this.curTok.Literal, 10, 64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
value = NewInteger(intVal)
|
|
case token.FLOAT:
|
|
floatVal, err := strconv.ParseFloat(this.curTok.Literal, 64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
value = NewFloat(floatVal)
|
|
case token.PERIOD:
|
|
reference, err := this.parseReference(this.curSection, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
value = reference
|
|
read_next = false
|
|
case token.IDENTIFIER:
|
|
reference, err := this.parseReference(this.settings, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
value = reference
|
|
read_next = false
|
|
default:
|
|
return this.syntaxError(
|
|
fmt.Sprintf("expected STRING, INTEGER, FLOAT, BOOLEAN or IDENTIFIER, instead found %s", this.curTok.ID),
|
|
)
|
|
}
|
|
|
|
if read_next {
|
|
this.readToken()
|
|
}
|
|
if this.curTok.ID != token.SEMICOLON {
|
|
msg := fmt.Sprintf("expected ';' instead found '%s'", this.curTok.Literal)
|
|
return this.syntaxError(msg)
|
|
}
|
|
this.readToken()
|
|
|
|
this.curSection.Set(name, value)
|
|
return nil
|
|
}
|
|
|
|
func (this *Parser) parseInclude() error {
|
|
if this.curTok.ID != token.STRING {
|
|
msg := fmt.Sprintf("expected STRING instead found '%s'", this.curTok.ID)
|
|
return this.syntaxError(msg)
|
|
}
|
|
pattern := this.curTok.Literal
|
|
|
|
this.readToken()
|
|
if this.curTok.ID != token.SEMICOLON {
|
|
msg := fmt.Sprintf("expected ';' instead found '%s'", this.curTok.Literal)
|
|
return this.syntaxError(msg)
|
|
}
|
|
|
|
filenames, err := filepath.Glob(pattern)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
oldScanner := this.scanner
|
|
for _, filename := range filenames {
|
|
reader, err := os.Open(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// this.curSection.AddInclude(filename)
|
|
this.scanner = NewScanner(reader)
|
|
this.parse()
|
|
}
|
|
this.scanner = oldScanner
|
|
this.readToken()
|
|
return nil
|
|
}
|
|
|
|
func (this *Parser) parseSection(name string) error {
|
|
section := this.curSection.AddSection(name)
|
|
this.previous = append(this.previous, this.curSection)
|
|
this.curSection = section
|
|
return nil
|
|
}
|
|
|
|
func (this *Parser) endSection() error {
|
|
if len(this.previous) == 0 {
|
|
return this.syntaxError("unexpected section end '}'")
|
|
}
|
|
|
|
pLen := len(this.previous)
|
|
previous := this.previous[pLen-1]
|
|
this.previous = this.previous[0 : pLen-1]
|
|
this.curSection = previous
|
|
return nil
|
|
}
|
|
|
|
func (this *Parser) GetSettings() *Section {
|
|
return this.settings
|
|
}
|
|
|
|
func (this *Parser) parse() error {
|
|
this.readToken()
|
|
for {
|
|
if this.curTok.ID == token.EOF {
|
|
break
|
|
}
|
|
tok := this.curTok
|
|
this.readToken()
|
|
switch tok.ID {
|
|
case token.COMMENT:
|
|
// this.curSection.AddComment(tok.Literal)
|
|
case token.INCLUDE:
|
|
this.parseInclude()
|
|
case token.IDENTIFIER:
|
|
if this.curTok.ID == token.LBRACKET {
|
|
err := this.parseSection(tok.Literal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
this.readToken()
|
|
} else if this.curTok.ID == token.EQUAL {
|
|
err := this.parseSetting(tok.Literal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
case token.RBRACKET:
|
|
err := this.endSection()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
return this.syntaxError(fmt.Sprintf("unexpected token %s", tok))
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (this *Parser) Parse() error {
|
|
err := this.parse()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(this.previous) > 0 {
|
|
return this.syntaxError("expected end of section, instead found EOF")
|
|
}
|
|
|
|
return nil
|
|
}
|