113 lines
2.9 KiB
Go
113 lines
2.9 KiB
Go
package fsplParser
|
|
|
|
import "git.tebibyte.media/fspl/fspl/lexer"
|
|
import "git.tebibyte.media/fspl/fspl/errors"
|
|
import "git.tebibyte.media/fspl/fspl/entity"
|
|
|
|
func (this *treeParser) parseLiteralInt () (*entity.LiteralInt, error) {
|
|
err := this.Expect(lexer.Int)
|
|
if err != nil { return nil, err }
|
|
defer this.Next()
|
|
|
|
value, err := parseInteger(this.Value())
|
|
if err != nil { return nil, errors.Errorf(this.Pos(), err.Error()) }
|
|
|
|
return &entity.LiteralInt {
|
|
Pos: this.Pos(),
|
|
Value: int(value), // TODO struct should store as int64
|
|
}, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralFloat () (*entity.LiteralFloat, error) {
|
|
err := this.Expect(lexer.Float)
|
|
if err != nil { return nil, err }
|
|
defer this.Next()
|
|
|
|
value, err := parseFloat(this.Value())
|
|
if err != nil { return nil, errors.Errorf(this.Pos(), err.Error()) }
|
|
|
|
return &entity.LiteralFloat {
|
|
Pos: this.Pos(),
|
|
Value: value,
|
|
}, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralString () (*entity.LiteralString, error) {
|
|
err := this.Expect(lexer.String)
|
|
if err != nil { return nil, err }
|
|
defer this.Next()
|
|
|
|
return &entity.LiteralString {
|
|
Pos: this.Pos(),
|
|
ValueUTF8: this.Value(),
|
|
}, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralBoolean () (*entity.LiteralBoolean, error) {
|
|
err := this.ExpectValueDesc("boolean", lexer.Ident, "true", "false")
|
|
if err != nil { return nil, err }
|
|
defer this.Next()
|
|
|
|
return &entity.LiteralBoolean {
|
|
Pos: this.Pos(),
|
|
Value: this.Value() == "true",
|
|
}, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralNil () (*entity.LiteralNil, error) {
|
|
err := this.ExpectValueDesc("Nil", lexer.Ident, "nil")
|
|
if err != nil { return nil, err }
|
|
defer this.Next()
|
|
|
|
return &entity.LiteralNil {
|
|
Pos: this.Pos(),
|
|
}, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralArrayCore (pos errors.Position) (*entity.LiteralArray, error) {
|
|
literal := &entity.LiteralArray {
|
|
Pos: pos,
|
|
}
|
|
|
|
for {
|
|
err := this.ExpectDesc (
|
|
"array literal element or end",
|
|
appendCopy(startTokensExpression, lexer.RParen)...)
|
|
if err != nil { return nil, err }
|
|
if this.Kind() == lexer.RParen { break }
|
|
|
|
element, err := this.parseExpression()
|
|
if err != nil { return nil, err }
|
|
literal.Elements = append(literal.Elements, element)
|
|
}
|
|
literal.Pos = literal.Position().Union(this.Pos())
|
|
this.Next()
|
|
|
|
return literal, nil
|
|
}
|
|
|
|
func (this *treeParser) parseLiteralStructCore (pos errors.Position) (*entity.LiteralStruct, error) {
|
|
err := this.Expect(lexer.Dot)
|
|
if err != nil { return nil, err }
|
|
literal := &entity.LiteralStruct {
|
|
Pos: pos,
|
|
}
|
|
this.Next()
|
|
|
|
for {
|
|
err := this.ExpectDesc (
|
|
"struct literal member or end",
|
|
appendCopy(startTokensExpression, lexer.RParen)...)
|
|
if err != nil { return nil, err }
|
|
if this.Kind() == lexer.RParen { break }
|
|
|
|
member, err := this.parseMember()
|
|
if err != nil { return nil, err }
|
|
literal.Members = append(literal.Members, member)
|
|
}
|
|
literal.Pos = literal.Position().Union(this.Pos())
|
|
this.Next()
|
|
|
|
return literal, nil
|
|
}
|