mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
1582 lines
40 KiB
Go
1582 lines
40 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
package parse
|
|
|
|
// TODO: write a formal grammar for the language.
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
a "github.com/google/wuffs/lang/ast"
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
type Options struct {
|
|
AllowBuiltInNames bool
|
|
AllowDoubleUnderscoreNames bool
|
|
}
|
|
|
|
func validConstName(s string) bool {
|
|
if (len(s) >= 2) && (s[0] == '_') && (s[1] == '_') {
|
|
return false
|
|
}
|
|
for i := 0; i < len(s); i++ {
|
|
switch c := s[i]; {
|
|
default:
|
|
return false
|
|
case c == '_':
|
|
case ('0' <= c) && (c <= '9'):
|
|
case ('A' <= c) && (c <= 'Z'): // Upper A-Z but not lower a-z.
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func containsDoubleUnderscore(s string) bool {
|
|
for i := 1; i < len(s); i++ {
|
|
if (s[i-1] == '_') && (s[i] == '_') {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isStatusMessage(s string) bool {
|
|
if s == "" {
|
|
return false
|
|
}
|
|
c := s[0]
|
|
return (c == '@') || (c == '#') || (c == '$')
|
|
}
|
|
|
|
func Parse(tm *t.Map, filename string, src []t.Token, opts *Options) (*a.File, error) {
|
|
p := &parser{
|
|
tm: tm,
|
|
filename: filename,
|
|
src: src,
|
|
}
|
|
if len(src) > 0 {
|
|
p.lastLine = src[len(src)-1].Line
|
|
}
|
|
if opts != nil {
|
|
p.opts = *opts
|
|
}
|
|
return p.parseFile()
|
|
}
|
|
|
|
func ParseExpr(tm *t.Map, filename string, src []t.Token, opts *Options) (*a.Expr, error) {
|
|
p := &parser{
|
|
tm: tm,
|
|
filename: filename,
|
|
src: src,
|
|
}
|
|
if len(src) > 0 {
|
|
p.lastLine = src[len(src)-1].Line
|
|
}
|
|
if opts != nil {
|
|
p.opts = *opts
|
|
}
|
|
return p.parseExpr()
|
|
}
|
|
|
|
type parser struct {
|
|
tm *t.Map
|
|
filename string
|
|
src []t.Token
|
|
opts Options
|
|
lastLine uint32
|
|
funcEffect a.Effect
|
|
loops a.LoopStack
|
|
allowVar bool
|
|
}
|
|
|
|
func (p *parser) line() uint32 {
|
|
if len(p.src) != 0 {
|
|
return p.src[0].Line
|
|
}
|
|
return p.lastLine
|
|
}
|
|
|
|
func (p *parser) peek1() t.ID {
|
|
if len(p.src) > 0 {
|
|
return p.src[0].ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (p *parser) parseFile() (*a.File, error) {
|
|
topLevelDecls := []*a.Node(nil)
|
|
for len(p.src) > 0 {
|
|
d, err := p.parseTopLevelDecl()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
topLevelDecls = append(topLevelDecls, d)
|
|
}
|
|
return a.NewFile(p.filename, topLevelDecls), nil
|
|
}
|
|
|
|
func (p *parser) parseTopLevelDecl() (*a.Node, error) {
|
|
flags := a.Flags(0)
|
|
line := p.src[0].Line
|
|
switch k := p.peek1(); k {
|
|
case t.IDUse:
|
|
p.src = p.src[1:]
|
|
path := p.peek1()
|
|
if !path.IsDQStrLiteral(p.tm) {
|
|
got := p.tm.ByID(path)
|
|
return nil, fmt.Errorf(`parse: expected "-string literal, got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return a.NewUse(p.filename, line, path).AsNode(), nil
|
|
|
|
case t.IDPub:
|
|
flags |= a.FlagsPublic
|
|
fallthrough
|
|
case t.IDPri:
|
|
p.src = p.src[1:]
|
|
switch p.peek1() {
|
|
case t.IDConst:
|
|
p.src = p.src[1:]
|
|
id, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !validConstName(p.tm.ByID(id)) {
|
|
return nil, fmt.Errorf(`parse: invalid const name %q at %s:%d`,
|
|
p.tm.ByID(id), p.filename, p.line())
|
|
}
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
typ, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if p.peek1() != t.IDEq {
|
|
return nil, fmt.Errorf(`parse: const %q has no value at %s:%d`,
|
|
p.tm.ByID(id), p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
value, err := p.parsePossibleListExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return a.NewConst(flags, p.filename, line, id, typ, value).AsNode(), nil
|
|
|
|
case t.IDFunc:
|
|
p.src = p.src[1:]
|
|
id0, id1, err := p.parseQualifiedIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !p.opts.AllowBuiltInNames {
|
|
switch id1 {
|
|
case t.IDInitialize, t.IDReset:
|
|
return nil, fmt.Errorf(`parse: cannot have a method named %q at %s:%d`,
|
|
id1.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
// TODO: should we require id0 != 0? In other words, always methods
|
|
// (attached to receivers) and never free standing functions?
|
|
if !p.opts.AllowDoubleUnderscoreNames && containsDoubleUnderscore(p.tm.ByID(id1)) {
|
|
return nil, fmt.Errorf(`parse: double-underscore %q used for func name at %s:%d`,
|
|
p.tm.ByID(id1), p.filename, p.line())
|
|
}
|
|
|
|
p.funcEffect = p.parseEffect()
|
|
flags |= p.funcEffect.AsFlags()
|
|
argFields, err := p.parseList(t.IDCloseParen, (*parser).parseFieldNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := (*a.TypeExpr)(nil)
|
|
if x := p.peek1(); (x != t.IDOpenCurly) && (x != t.IDComma) {
|
|
out, err = p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
asserts := []*a.Node(nil)
|
|
if p.peek1() == t.IDComma {
|
|
p.src = p.src[1:]
|
|
if p.peek1() == t.IDChoosy {
|
|
p.src = p.src[1:]
|
|
if (flags & a.FlagsPublic) != 0 {
|
|
return nil, fmt.Errorf(`parse: choosy function cannot be pub at %s:%d`,
|
|
p.filename, p.line())
|
|
} else if p.funcEffect.Coroutine() {
|
|
return nil, fmt.Errorf(`parse: choosy function cannot be a coroutine at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
flags |= a.FlagsChoosy
|
|
if p.peek1() != t.IDOpenCurly {
|
|
if x := p.peek1(); x != t.IDComma {
|
|
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`,
|
|
p.tm.ByID(x), p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
}
|
|
}
|
|
|
|
asserts, err = p.parseList(t.IDOpenCurly, (*parser).parseAssertNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := p.assertsSorted(asserts, true); err != nil {
|
|
return nil, err
|
|
}
|
|
for _, o := range asserts {
|
|
o := o.AsAssert()
|
|
if o.Keyword() != t.IDChoose {
|
|
continue
|
|
} else if o.IsChooseCPUArch() {
|
|
flags |= a.FlagsHasChooseCPUArch
|
|
} else {
|
|
return nil, fmt.Errorf(`parse: invalid "choose" condition at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
}
|
|
}
|
|
|
|
p.allowVar = true
|
|
body, err := p.parseBlock(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p.allowVar = false
|
|
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if (flags & a.FlagsHasChooseCPUArch) != 0 {
|
|
if (flags & a.FlagsPublic) != 0 {
|
|
return nil, fmt.Errorf(`parse: cpu_arch function cannot be public at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
if (flags & a.FlagsChoosy) != 0 {
|
|
return nil, fmt.Errorf(`parse: cpu_arch function cannot be choosy at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
}
|
|
p.funcEffect = 0
|
|
in := a.NewStruct(0, p.filename, line, t.IDArgs, nil, argFields)
|
|
return a.NewFunc(flags, p.filename, line, id0, id1, in, out, asserts, body).AsNode(), nil
|
|
|
|
case t.IDStatus:
|
|
p.src = p.src[1:]
|
|
|
|
message := p.peek1()
|
|
if !message.IsDQStrLiteral(p.tm) {
|
|
got := p.tm.ByID(message)
|
|
return nil, fmt.Errorf(`parse: expected "-string literal, got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
if s, _ := t.Unescape(p.tm.ByID(message)); !isStatusMessage(s) {
|
|
return nil, fmt.Errorf(`parse: status message %q does not start with `+
|
|
`@, # or $ at %s:%d`, s, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return a.NewStatus(flags, p.filename, line, message).AsNode(), nil
|
|
|
|
case t.IDStruct:
|
|
p.src = p.src[1:]
|
|
name, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !p.opts.AllowDoubleUnderscoreNames && containsDoubleUnderscore(p.tm.ByID(name)) {
|
|
return nil, fmt.Errorf(`parse: double-underscore %q used for struct name at %s:%d`,
|
|
p.tm.ByID(name), p.filename, p.line())
|
|
}
|
|
|
|
if p.peek1() == t.IDQuestion {
|
|
flags |= a.FlagsClassy
|
|
p.src = p.src[1:]
|
|
}
|
|
|
|
implements := []*a.Node(nil)
|
|
if p.peek1() == t.IDImplements {
|
|
p.src = p.src[1:]
|
|
implements, err = p.parseList(t.IDOpenParen, (*parser).parseQualifiedIdentAsTypeExprNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(implements) > a.MaxImplements {
|
|
return nil, fmt.Errorf(`parse: too many implements listed at %s:%d`, p.filename, p.line())
|
|
}
|
|
}
|
|
|
|
fields, err := p.parseList(t.IDCloseParen, (*parser).parseFieldNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x == t.IDPlus {
|
|
p.src = p.src[1:]
|
|
if x := p.peek1(); x != t.IDOpenParen {
|
|
return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`,
|
|
p.tm.ByID(x), p.filename, p.line())
|
|
}
|
|
extraFields, err := p.parseList(t.IDCloseParen, (*parser).parseExtraFieldNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fields = append(fields, extraFields...)
|
|
}
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return a.NewStruct(flags, p.filename, line, name, implements, fields).AsNode(), nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf(`parse: unrecognized top level declaration at %s:%d`, p.filename, line)
|
|
}
|
|
|
|
func (p *parser) parseQualifiedIdentAsTypeExprNode() (*a.Node, error) {
|
|
pkg, name, err := p.parseQualifiedIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewTypeExpr(0, pkg, name, nil, nil, nil).AsNode(), nil
|
|
}
|
|
|
|
// parseQualifiedIdent parses "foo.bar" or "bar".
|
|
func (p *parser) parseQualifiedIdent() (t.ID, t.ID, error) {
|
|
x, err := p.parseIdent()
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
|
|
if p.peek1() != t.IDDot {
|
|
return 0, x, nil
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
y, err := p.parseIdent()
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
return x, y, nil
|
|
}
|
|
|
|
func (p *parser) parseIdentAsExprNode() (*a.Node, error) {
|
|
id, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewExpr(0, 0, id, nil, nil, nil, nil).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseIdent() (t.ID, error) {
|
|
if len(p.src) == 0 {
|
|
return 0, fmt.Errorf(`parse: expected identifier at %s:%d`, p.filename, p.line())
|
|
}
|
|
x := p.src[0]
|
|
if !x.ID.IsIdent(p.tm) {
|
|
got := p.tm.ByID(x.ID)
|
|
return 0, fmt.Errorf(`parse: expected identifier, got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return x.ID, nil
|
|
}
|
|
|
|
func (p *parser) parseList(stop t.ID, parseElem func(*parser) (*a.Node, error)) ([]*a.Node, error) {
|
|
if stop == t.IDCloseParen {
|
|
if x := p.peek1(); x != t.IDOpenParen {
|
|
return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`,
|
|
p.tm.ByID(x), p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
}
|
|
|
|
ret := []*a.Node(nil)
|
|
for len(p.src) > 0 {
|
|
if id := p.src[0].ID; id == stop {
|
|
if stop == t.IDCloseParen || stop == t.IDCloseBracket {
|
|
p.src = p.src[1:]
|
|
}
|
|
return ret, nil
|
|
} else if (stop == t.IDOpenDoubleCurly) && (id == t.IDOpenCurly) {
|
|
return ret, nil
|
|
}
|
|
|
|
elem, err := parseElem(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ret = append(ret, elem)
|
|
|
|
switch x := p.peek1(); x {
|
|
case stop:
|
|
if stop == t.IDCloseParen || stop == t.IDCloseBracket {
|
|
p.src = p.src[1:]
|
|
}
|
|
return ret, nil
|
|
case t.IDComma:
|
|
p.src = p.src[1:]
|
|
default:
|
|
return nil, fmt.Errorf(`parse: expected %q, got %q at %s:%d`,
|
|
p.tm.ByID(stop), p.tm.ByID(x), p.filename, p.line())
|
|
}
|
|
}
|
|
return nil, fmt.Errorf(`parse: expected %q at %s:%d`, p.tm.ByID(stop), p.filename, p.line())
|
|
}
|
|
|
|
func (p *parser) parseFieldNode() (*a.Node, error) {
|
|
return p.parseFieldNode1(0)
|
|
}
|
|
|
|
func (p *parser) parseExtraFieldNode() (*a.Node, error) {
|
|
n, err := p.parseFieldNode1(a.FlagsPrivateData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
typ := n.AsField().XType()
|
|
for typ.Decorator() == t.IDArray {
|
|
typ = typ.Inner()
|
|
}
|
|
if (typ.Decorator() != 0) ||
|
|
(typ.QID()[0] == t.IDBase) && (!typ.IsNumType() || typ.IsRefined()) {
|
|
|
|
return nil, fmt.Errorf(`parse: invalid extra-field type %q at %s:%d`,
|
|
n.AsField().XType().Str(p.tm), p.filename, p.line())
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (p *parser) parseFieldNode1(flags a.Flags) (*a.Node, error) {
|
|
name, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
typ, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pkg := typ.Innermost().QID()[0]; (pkg != 0) && (pkg != t.IDBase) {
|
|
flags |= a.FlagsPrivateData
|
|
}
|
|
return a.NewField(flags, name, typ).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
|
|
if x := p.peek1(); x == t.IDNptr || x == t.IDPtr {
|
|
p.src = p.src[1:]
|
|
rhs, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewTypeExpr(x, 0, 0, nil, nil, rhs), nil
|
|
}
|
|
|
|
decorator, arrayLength := t.ID(0), (*a.Expr)(nil)
|
|
switch peek1 := p.peek1(); peek1 {
|
|
case t.IDArray, t.IDRoarray:
|
|
decorator = peek1
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDOpenBracket {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "[", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
var err error
|
|
arrayLength, err = p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if x := p.peek1(); x != t.IDCloseBracket {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "]", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
case t.IDRoslice, t.IDRotable, t.IDSlice, t.IDTable:
|
|
decorator = peek1
|
|
p.src = p.src[1:]
|
|
}
|
|
|
|
if decorator != 0 {
|
|
rhs, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewTypeExpr(decorator, 0, 0, arrayLength.AsNode(), nil, rhs), nil
|
|
}
|
|
|
|
pkg, name, err := p.parseQualifiedIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
lhs, mhs := (*a.Expr)(nil), (*a.Expr)(nil)
|
|
if p.peek1() == t.IDOpenBracket {
|
|
_, lhs, mhs, err = p.parseBracket(t.IDDotDotEq)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if name.IsNumType() &&
|
|
((pkg == t.IDBase) || ((pkg == 0) && p.opts.AllowBuiltInNames)) {
|
|
// No-op.
|
|
} else {
|
|
return nil, fmt.Errorf(`parse: cannot refine non-numeric type at %s:%d`, p.filename, p.line())
|
|
}
|
|
}
|
|
|
|
return a.NewTypeExpr(0, pkg, name, lhs.AsNode(), mhs, nil), nil
|
|
}
|
|
|
|
// parseBracket parses "[i .. j]", "[i ..]", "[.. j]" and "[..]". A "..="
|
|
// replaces the ".." if sep is t.IDDotDotEq instead of t.IDDotDot. If sep is
|
|
// t.IDDotDot, it also parses "[x]". The returned op is sep for a range or
|
|
// refinement and t.IDOpenBracket for an index.
|
|
func (p *parser) parseBracket(sep t.ID) (op t.ID, ei *a.Expr, ej *a.Expr, err error) {
|
|
if x := p.peek1(); x != t.IDOpenBracket {
|
|
got := p.tm.ByID(x)
|
|
return 0, nil, nil, fmt.Errorf(`parse: expected "[", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if p.peek1() != sep {
|
|
ei, err = p.parseExpr()
|
|
if err != nil {
|
|
return 0, nil, nil, err
|
|
}
|
|
}
|
|
|
|
switch x := p.peek1(); {
|
|
case x == sep:
|
|
p.src = p.src[1:]
|
|
|
|
case x == t.IDCloseBracket && sep == t.IDDotDot:
|
|
p.src = p.src[1:]
|
|
return a.ExprOperatorIndex, nil, ei, nil
|
|
|
|
default:
|
|
extra := ``
|
|
if sep == t.IDDotDot {
|
|
extra = ` or "]"`
|
|
}
|
|
got := p.tm.ByID(x)
|
|
return 0, nil, nil, fmt.Errorf(`parse: expected %q%s, got %q at %s:%d`,
|
|
p.tm.ByID(sep), extra, got, p.filename, p.line())
|
|
}
|
|
|
|
if p.peek1() != t.IDCloseBracket {
|
|
ej, err = p.parseExpr()
|
|
if err != nil {
|
|
return 0, nil, nil, err
|
|
}
|
|
}
|
|
|
|
if x := p.peek1(); x != t.IDCloseBracket {
|
|
got := p.tm.ByID(x)
|
|
return 0, nil, nil, fmt.Errorf(`parse: expected "]", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
return sep, ei, ej, nil
|
|
}
|
|
|
|
func (p *parser) parseBlock(doubleCurly bool) ([]*a.Node, error) {
|
|
if doubleCurly {
|
|
if x := p.peek1(); x != t.IDOpenDoubleCurly {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "{{", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
} else {
|
|
if x := p.peek1(); x != t.IDOpenCurly {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "{", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
block := []*a.Node(nil)
|
|
for {
|
|
if len(p.src) == 0 {
|
|
return nil, fmt.Errorf(`parse: expected "}" or "}}" at %s:%d`, p.filename, p.line())
|
|
}
|
|
|
|
if doubleCurly {
|
|
if p.src[0].ID == t.IDCloseDoubleCurly {
|
|
break
|
|
}
|
|
} else {
|
|
if p.src[0].ID == t.IDCloseCurly {
|
|
break
|
|
}
|
|
}
|
|
|
|
s, err := p.parseStatement()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
block = append(block, s)
|
|
|
|
if x := p.peek1(); x != t.IDSemicolon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
}
|
|
|
|
p.src = p.src[1:]
|
|
return block, nil
|
|
}
|
|
|
|
func (p *parser) assertsSorted(asserts []*a.Node, allowChoose bool) error {
|
|
seenPre, seenInv, seenPost := false, false, false
|
|
for _, o := range asserts {
|
|
switch o.AsAssert().Keyword() {
|
|
case t.IDAssert:
|
|
return fmt.Errorf(`parse: assertion chain cannot contain "assert", `+
|
|
`only "pre", "inv" and "post" at %s:%d`, p.filename, p.line())
|
|
case t.IDChoose:
|
|
if !allowChoose {
|
|
return fmt.Errorf(`parse: invalid "choose" at %s:%d`, p.filename, p.line())
|
|
}
|
|
if seenPre || seenPost || seenInv {
|
|
break
|
|
}
|
|
continue
|
|
case t.IDPre:
|
|
if seenPost || seenInv {
|
|
break
|
|
}
|
|
seenPre = true
|
|
continue
|
|
case t.IDInv:
|
|
if seenPost {
|
|
break
|
|
}
|
|
seenInv = true
|
|
continue
|
|
default:
|
|
seenPost = true
|
|
continue
|
|
}
|
|
return fmt.Errorf(`parse: assertion chain not in "choose", "pre", "inv", "post" order at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *parser) parseAssertNode() (*a.Node, error) {
|
|
switch x := p.peek1(); x {
|
|
case t.IDAssert, t.IDChoose, t.IDPre, t.IDInv, t.IDPost:
|
|
p.src = p.src[1:]
|
|
condition, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if condition.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: assert-condition %q is not effect-free at %s:%d`,
|
|
condition.Str(p.tm), p.filename, p.line())
|
|
}
|
|
reason, args := t.ID(0), []*a.Node(nil)
|
|
if p.peek1() == t.IDVia {
|
|
p.src = p.src[1:]
|
|
reason = p.peek1()
|
|
if !reason.IsDQStrLiteral(p.tm) {
|
|
got := p.tm.ByID(reason)
|
|
return nil, fmt.Errorf(`parse: expected "-string literal, got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
args, err = p.parseList(t.IDCloseParen, (*parser).parseArgNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return a.NewAssert(x, condition, reason, args).AsNode(), nil
|
|
}
|
|
return nil, fmt.Errorf(`parse: expected "assert", "pre" or "post" at %s:%d`, p.filename, p.line())
|
|
}
|
|
|
|
func (p *parser) parseStatement() (*a.Node, error) {
|
|
line := uint32(0)
|
|
if len(p.src) > 0 {
|
|
line = p.src[0].Line
|
|
}
|
|
n, err := p.parseStatement1()
|
|
if n != nil {
|
|
n.AsRaw().SetFilenameLine(p.filename, line)
|
|
if n.Kind() == a.KIterate {
|
|
for _, o := range n.AsIterate().Assigns() {
|
|
o.AsRaw().SetFilenameLine(p.filename, line)
|
|
}
|
|
}
|
|
}
|
|
return n, err
|
|
}
|
|
|
|
func (p *parser) parseLabel() (t.ID, error) {
|
|
if p.peek1() == t.IDDot {
|
|
p.src = p.src[1:]
|
|
return p.parseIdent()
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
func (p *parser) parseEndwhile(label t.ID) bool {
|
|
if p.peek1() != t.IDEndwhile {
|
|
return false
|
|
}
|
|
p.src = p.src[1:]
|
|
if label != 0 {
|
|
if p.peek1() != t.IDDot {
|
|
return false
|
|
}
|
|
p.src = p.src[1:]
|
|
if p.peek1() != label {
|
|
return false
|
|
}
|
|
p.src = p.src[1:]
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (p *parser) parseStatement1() (*a.Node, error) {
|
|
x := p.peek1()
|
|
if x == t.IDVar {
|
|
if !p.allowVar {
|
|
return nil, fmt.Errorf(`parse: var statement not at the top of a function at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return p.parseVarNode()
|
|
}
|
|
p.allowVar = false
|
|
|
|
switch x {
|
|
case t.IDAssert:
|
|
return p.parseAssertNode()
|
|
|
|
case t.IDBreak, t.IDContinue:
|
|
p.src = p.src[1:]
|
|
label, err := p.parseLabel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
loop := a.Loop(nil)
|
|
if len(p.loops) == 0 {
|
|
// No-op.
|
|
} else if label == 0 {
|
|
loop = p.loops.Top()
|
|
if loop.Label() != 0 {
|
|
return nil, fmt.Errorf(`parse: unlabeled %s for labeled %s.%s at %s:%d`,
|
|
x.Str(p.tm), loop.Keyword().Str(p.tm), loop.Label().Str(p.tm), p.filename, p.line())
|
|
}
|
|
} else {
|
|
for i := len(p.loops) - 1; i >= 0; i-- {
|
|
if l := p.loops[i]; label == l.Label() {
|
|
loop = l
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if loop == nil {
|
|
sepStr, labelStr := "", ""
|
|
if label != 0 {
|
|
sepStr, labelStr = ".", label.Str(p.tm)
|
|
}
|
|
return nil, fmt.Errorf(`parse: no matching while/iterate statement for %s%s%s at %s:%d`,
|
|
x.Str(p.tm), sepStr, labelStr, p.filename, p.line())
|
|
}
|
|
|
|
deep := loop != p.loops.Top()
|
|
if x == t.IDBreak {
|
|
loop.SetHasBreak(deep)
|
|
} else {
|
|
loop.SetHasContinue(deep)
|
|
}
|
|
n := a.NewJump(x, label)
|
|
n.SetJumpTarget(loop)
|
|
return n.AsNode(), nil
|
|
|
|
case t.IDChoose:
|
|
p.src = p.src[1:]
|
|
if p.funcEffect.Pure() {
|
|
return nil, fmt.Errorf(`parse: choose within pure function at %s:%d`, p.filename, p.line())
|
|
}
|
|
name, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDEq {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "=", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
if x := p.peek1(); x != t.IDOpenBracket {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "[", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
args, err := p.parseList(t.IDCloseBracket, (*parser).parseIdentAsExprNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewChoose(name, args).AsNode(), nil
|
|
|
|
case t.IDIOBind, t.IDIOLimit:
|
|
return p.parseIOManipNode()
|
|
|
|
case t.IDIf:
|
|
o, err := p.parseIf()
|
|
return o.AsNode(), err
|
|
|
|
case t.IDIterate:
|
|
return p.parseIterateNode()
|
|
|
|
case t.IDReturn, t.IDYield:
|
|
p.src = p.src[1:]
|
|
if x == t.IDYield {
|
|
if !p.funcEffect.Coroutine() {
|
|
return nil, fmt.Errorf(`parse: yield within non-coroutine at %s:%d`, p.filename, p.line())
|
|
}
|
|
if p.peek1() != t.IDQuestion {
|
|
return nil, fmt.Errorf(`parse: yield not followed by '?' at %s:%d`, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
}
|
|
value, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if value.Effect().Impure() {
|
|
return nil, fmt.Errorf(`parse: %s an impure expression at %s:%d`,
|
|
x.Str(p.tm), p.filename, p.line())
|
|
}
|
|
if (x == t.IDReturn) && (value.Operator() == 0) {
|
|
if s := p.tm.ByID(value.Ident()); (len(s) > 1) && (s[0] == '"') && (s[1] == '$') {
|
|
return nil, fmt.Errorf(`parse: cannot return a suspension at %s:%d`, p.filename, p.line())
|
|
}
|
|
}
|
|
return a.NewRet(x, value).AsNode(), nil
|
|
|
|
case t.IDWhile:
|
|
p.src = p.src[1:]
|
|
label, err := p.parseLabel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
condition, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if condition.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: while-condition %q is not effect-free at %s:%d`,
|
|
condition.Str(p.tm), p.filename, p.line())
|
|
}
|
|
asserts, err := p.parseAsserts()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
n := a.NewWhile(label, condition, asserts)
|
|
if !p.loops.Push(n) {
|
|
return nil, fmt.Errorf(`parse: duplicate loop label %s at %s:%d`,
|
|
label.Str(p.tm), p.filename, p.line())
|
|
}
|
|
doubleCurly := p.peek1() == t.IDOpenDoubleCurly
|
|
if doubleCurly && !n.IsWhileTrue() {
|
|
return nil, fmt.Errorf(`parse: double {{ }} while loop condition isn't "true" at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
body, err := p.parseBlock(doubleCurly)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n.SetBody(body)
|
|
p.loops.Pop()
|
|
|
|
if !p.parseEndwhile(label) {
|
|
dotLabel := ""
|
|
if label != 0 {
|
|
dotLabel = "." + label.Str(p.tm)
|
|
}
|
|
return nil, fmt.Errorf(`parse: expected endwhile%s at %s:%d`,
|
|
dotLabel, p.filename, p.line())
|
|
}
|
|
if !doubleCurly {
|
|
// No-op.
|
|
} else if n.HasContinue() {
|
|
return nil, fmt.Errorf(`parse: double {{ }} while loop has explicit continue at %s:%d`,
|
|
p.filename, p.line())
|
|
} else if !a.Terminates(body) {
|
|
return nil, fmt.Errorf(`parse: double {{ }} while loop doesn't terminate at %s:%d`,
|
|
p.filename, p.line())
|
|
}
|
|
return n.AsNode(), nil
|
|
}
|
|
return p.parseAssignNode()
|
|
}
|
|
|
|
func (p *parser) parseAssignNode() (*a.Node, error) {
|
|
lhs := (*a.Expr)(nil)
|
|
rhs, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
op := p.peek1()
|
|
if op.IsAssign() {
|
|
p.src = p.src[1:]
|
|
lhs = rhs
|
|
if lhs.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: assignment LHS %q is not effect-free at %s:%d`,
|
|
lhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
|
|
for l := lhs; l != nil; l = l.LHS().AsExpr() {
|
|
switch l.Operator() {
|
|
case 0:
|
|
if id := l.Ident(); id.IsLiteral(p.tm) {
|
|
return nil, fmt.Errorf(`parse: assignment LHS %q is a literal at %s:%d`,
|
|
l.Str(p.tm), p.filename, p.line())
|
|
} else if id.IsCannotAssignTo() {
|
|
if l == lhs {
|
|
return nil, fmt.Errorf(`parse: cannot assign to %q at %s:%d`,
|
|
id.Str(p.tm), p.filename, p.line())
|
|
}
|
|
if !p.funcEffect.Impure() {
|
|
return nil, fmt.Errorf(`parse: cannot assign to %q in a pure function at %s:%d`,
|
|
lhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
case t.IDDot, t.IDOpenBracket:
|
|
// No-op.
|
|
default:
|
|
return nil, fmt.Errorf(`parse: invalid assignment LHS %q at %s:%d`,
|
|
lhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
|
|
rhs, err = p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if op == t.IDEqQuestion {
|
|
if (rhs.Operator() != a.ExprOperatorCall) || (!rhs.Effect().Coroutine()) {
|
|
return nil, fmt.Errorf(`parse: expected ?-function call after "=?", got %q at %s:%d`,
|
|
rhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
} else {
|
|
op = t.IDEq
|
|
}
|
|
|
|
if p.funcEffect.WeakerThan(rhs.Effect()) {
|
|
return nil, fmt.Errorf(`parse: value %q's effect %q is stronger than the func's effect %q at %s:%d`,
|
|
rhs.Str(p.tm), rhs.Effect(), p.funcEffect, p.filename, p.line())
|
|
}
|
|
|
|
return a.NewAssign(op, lhs, rhs).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseIterateAssignNode() (*a.Node, error) {
|
|
n, err := p.parseAssignNode()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
o := n.AsAssign()
|
|
if op := o.Operator(); op != t.IDEq {
|
|
return nil, fmt.Errorf(`parse: expected "=", got %q at %s:%d`, op.Str(p.tm), p.filename, p.line())
|
|
}
|
|
if lhs := o.LHS(); lhs.Operator() != 0 {
|
|
return nil, fmt.Errorf(`parse: expected variable, got %q at %s:%d`, lhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
if rhs := o.RHS(); rhs.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: value %q is not effect-free at %s:%d`, rhs.Str(p.tm), p.filename, p.line())
|
|
}
|
|
return o.AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseAsserts() ([]*a.Node, error) {
|
|
asserts := []*a.Node(nil)
|
|
if p.peek1() == t.IDComma {
|
|
p.src = p.src[1:]
|
|
var err error
|
|
if asserts, err = p.parseList(t.IDOpenDoubleCurly, (*parser).parseAssertNode); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := p.assertsSorted(asserts, false); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return asserts, nil
|
|
}
|
|
|
|
func (p *parser) parseIOManipNode() (*a.Node, error) {
|
|
keyword := p.peek1()
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDOpenParen {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDIO {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "io", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
io, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if io.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: argument %q is not effect-free at %s:%d`,
|
|
io.Str(p.tm), p.filename, p.line())
|
|
}
|
|
|
|
arg1Name := t.ID(0)
|
|
if keyword == t.IDIOBind {
|
|
arg1Name = t.IDData
|
|
if io.Operator() != 0 {
|
|
return nil, fmt.Errorf(`parse: invalid %s argument %q at %s:%d`,
|
|
keyword.Str(p.tm), io.Str(p.tm), p.filename, p.line())
|
|
}
|
|
} else {
|
|
arg1Name = t.IDLimit
|
|
if (io.Operator() != 0) && (io.IsArgsDotFoo() == 0) {
|
|
return nil, fmt.Errorf(`parse: invalid %s argument %q at %s:%d`,
|
|
keyword.Str(p.tm), io.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
|
|
if x := p.peek1(); x != t.IDComma {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != arg1Name {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected %q, got %q at %s:%d`, arg1Name.Str(p.tm), got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
arg1, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if arg1.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: argument %q is not effect-free at %s:%d`,
|
|
io.Str(p.tm), p.filename, p.line())
|
|
}
|
|
|
|
histPos := (*a.Expr)(nil)
|
|
if keyword == t.IDIOBind {
|
|
if x := p.peek1(); x != t.IDComma {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDHistoryPosition {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "history_position", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
histPos, err = p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if histPos.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: argument %q is not effect-free at %s:%d`,
|
|
io.Str(p.tm), p.filename, p.line())
|
|
}
|
|
}
|
|
|
|
if x := p.peek1(); x != t.IDCloseParen {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
body, err := p.parseBlock(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return a.NewIOManip(keyword, io, arg1, histPos, body).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseIf() (*a.If, error) {
|
|
if x := p.peek1(); x != t.IDIf {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "if", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
likelihood, err := p.parseLabel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch likelihood {
|
|
case 0, t.IDLikely, t.IDUnlikely:
|
|
default:
|
|
got := p.tm.ByID(likelihood)
|
|
return nil, fmt.Errorf(`parse: expected "if.likely" or "if.unlikely", got %q at %s:%d`, "if."+got, p.filename, p.line())
|
|
}
|
|
condition, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if condition.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: if-condition %q is not effect-free at %s:%d`,
|
|
condition.Str(p.tm), p.filename, p.line())
|
|
}
|
|
bodyIfTrue, err := p.parseBlock(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
elseIf, bodyIfFalse := (*a.If)(nil), ([]*a.Node)(nil)
|
|
if p.peek1() == t.IDElse {
|
|
p.src = p.src[1:]
|
|
if p.peek1() == t.IDIf {
|
|
elseIf, err = p.parseIf()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
bodyIfFalse, err = p.parseBlock(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
return a.NewIf(likelihood, condition, bodyIfTrue, bodyIfFalse, elseIf), nil
|
|
}
|
|
|
|
func (p *parser) parseIterateNode() (*a.Node, error) {
|
|
if p.funcEffect.Coroutine() {
|
|
return nil, fmt.Errorf(`parse: "iterate" inside coroutine at %s:%d`, p.filename, p.line())
|
|
} else if x := p.peek1(); x != t.IDIterate {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "iterate", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
label, err := p.parseLabel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
assigns, err := p.parseList(t.IDCloseParen, (*parser).parseIterateAssignNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n, err := p.parseIterateBlock(label, assigns)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return n.AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseIterateBlock(label t.ID, assigns []*a.Node) (*a.Iterate, error) {
|
|
if x := p.peek1(); x != t.IDOpenParen {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDLength {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "length", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
length := p.peek1()
|
|
lengthInt := asSmallPositiveInt256(p.tm, length)
|
|
if lengthInt == 0 {
|
|
return nil, fmt.Errorf(`parse: expected length count in [1 ..= 256], got %q at %s:%d`,
|
|
p.tm.ByID(length), p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDComma {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDAdvance {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "advance", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
advance := p.peek1()
|
|
advanceInt := asSmallPositiveInt256(p.tm, advance)
|
|
if advanceInt == 0 {
|
|
return nil, fmt.Errorf(`parse: expected advance count in [1 ..= 256], got %q at %s:%d`,
|
|
p.tm.ByID(advance), p.filename, p.line())
|
|
} else if advanceInt > lengthInt {
|
|
return nil, fmt.Errorf(`parse: advance %d is larger than length %d at %s:%d`,
|
|
advanceInt, lengthInt, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDComma {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDUnroll {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected "unroll", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
unroll := p.peek1()
|
|
if asSmallPositiveInt256(p.tm, unroll) == 0 {
|
|
return nil, fmt.Errorf(`parse: expected unroll count in [1 ..= 256], got %q at %s:%d`,
|
|
p.tm.ByID(unroll), p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
if x := p.peek1(); x != t.IDCloseParen {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
|
|
asserts, err := p.parseAsserts()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n := a.NewIterate(label, assigns, length, advance, unroll, asserts)
|
|
// TODO: decide how break/continue work with iterate loops.
|
|
if !p.loops.Push(n) {
|
|
return nil, fmt.Errorf(`parse: duplicate loop label %s at %s:%d`,
|
|
label.Str(p.tm), p.filename, p.line())
|
|
}
|
|
body, err := p.parseBlock(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n.SetBody(body)
|
|
p.loops.Pop()
|
|
|
|
if x := p.peek1(); x == t.IDElse {
|
|
p.src = p.src[1:]
|
|
elseIterate, err := p.parseIterateBlock(0, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
n.SetElseIterate(elseIterate)
|
|
}
|
|
|
|
return n, nil
|
|
}
|
|
|
|
// asSmallPositiveInt256 returns id's value when id is a numeric literal in the
|
|
// range [1 ..= 256]. Otherwise, it returns 0.
|
|
func asSmallPositiveInt256(tm *t.Map, id t.ID) int {
|
|
if !id.IsNumLiteral(tm) {
|
|
return 0
|
|
}
|
|
s := id.Str(tm)
|
|
if (len(s) > 3) || (len(s) == 0) || (s[0] < '1') || ('9' < s[0]) {
|
|
return 0
|
|
}
|
|
n, s := int(s[0]-'0'), s[1:]
|
|
for ; len(s) > 0; s = s[1:] {
|
|
if (s[0] < '0') || ('9' < s[0]) {
|
|
return 0
|
|
}
|
|
n = (10 * n) + int(s[0]-'0')
|
|
}
|
|
if n > 256 {
|
|
return 0
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (p *parser) parseArgNode() (*a.Node, error) {
|
|
name, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
value, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if value.Effect() != 0 {
|
|
return nil, fmt.Errorf(`parse: arg-value %q is not effect-free at %s:%d`,
|
|
value.Str(p.tm), p.filename, p.line())
|
|
}
|
|
return a.NewArg(name, value).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parseVarNode() (*a.Node, error) {
|
|
id, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDColon {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
typ, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewVar(id, typ).AsNode(), nil
|
|
}
|
|
|
|
func (p *parser) parsePossibleListExprNode() (*a.Node, error) {
|
|
n, err := p.parsePossibleListExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return n.AsNode(), err
|
|
}
|
|
|
|
func (p *parser) parsePossibleListExpr() (*a.Expr, error) {
|
|
// TODO: put the [ and ] parsing into parseExpr.
|
|
if x := p.peek1(); x != t.IDOpenBracket {
|
|
return p.parseExpr()
|
|
}
|
|
p.src = p.src[1:]
|
|
args, err := p.parseList(t.IDCloseBracket, (*parser).parsePossibleListExprNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a.NewExpr(0, a.ExprOperatorList, 0, nil, nil, nil, args), nil
|
|
}
|
|
|
|
func (p *parser) parseExpr() (*a.Expr, error) {
|
|
e, err := p.parseExpr1()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if e.SubExprHasEffect() {
|
|
return nil, fmt.Errorf(`parse: expression %q has an effect-ful sub-expression at %s:%d`,
|
|
e.Str(p.tm), p.filename, p.line())
|
|
}
|
|
return e, nil
|
|
}
|
|
|
|
func (p *parser) parseExpr1() (*a.Expr, error) {
|
|
lhs, err := p.parseOperand()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x.IsBinaryOp() {
|
|
p.src = p.src[1:]
|
|
rhs := (*a.Node)(nil)
|
|
if x == t.IDAs {
|
|
o, err := p.parseTypeExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rhs = o.AsNode()
|
|
} else {
|
|
o, err := p.parseOperand()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rhs = o.AsNode()
|
|
}
|
|
|
|
if !x.IsAssociativeOp() || x != p.peek1() {
|
|
op := x.BinaryForm()
|
|
if op == 0 {
|
|
return nil, fmt.Errorf(`parse: internal error: no binary form for token 0x%02X`, x)
|
|
}
|
|
return a.NewExpr(0, op, 0, lhs.AsNode(), nil, rhs, nil), nil
|
|
}
|
|
|
|
args := []*a.Node{lhs.AsNode(), rhs}
|
|
for p.peek1() == x {
|
|
p.src = p.src[1:]
|
|
arg, err := p.parseOperand()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
args = append(args, arg.AsNode())
|
|
}
|
|
op := x.AssociativeForm()
|
|
if op == 0 {
|
|
return nil, fmt.Errorf(`parse: internal error: no associative form for token 0x%02X`, x)
|
|
}
|
|
return a.NewExpr(0, op, 0, nil, nil, nil, args), nil
|
|
}
|
|
return lhs, nil
|
|
}
|
|
|
|
func (p *parser) parseOperand() (*a.Expr, error) {
|
|
switch x := p.peek1(); {
|
|
case x.IsUnaryOp():
|
|
p.src = p.src[1:]
|
|
rhs, err := p.parseOperand()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
op := x.UnaryForm()
|
|
if op == 0 {
|
|
return nil, fmt.Errorf(`parse: internal error: no unary form for token 0x%02X`, x)
|
|
}
|
|
return a.NewExpr(0, op, 0, nil, nil, rhs.AsNode(), nil), nil
|
|
|
|
case x.IsLiteral(p.tm):
|
|
p.src = p.src[1:]
|
|
return a.NewExpr(0, 0, x, nil, nil, nil, nil), nil
|
|
|
|
case x == t.IDOpenParen:
|
|
p.src = p.src[1:]
|
|
expr, err := p.parseExpr()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x := p.peek1(); x != t.IDCloseParen {
|
|
got := p.tm.ByID(x)
|
|
return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line())
|
|
}
|
|
p.src = p.src[1:]
|
|
return expr, nil
|
|
}
|
|
|
|
id, err := p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lhs := a.NewExpr(0, 0, id, nil, nil, nil, nil)
|
|
|
|
for first := true; ; first = false {
|
|
flags := a.Flags(0)
|
|
switch p.peek1() {
|
|
default:
|
|
return lhs, nil
|
|
|
|
case t.IDExclam, t.IDQuestion:
|
|
flags |= p.parseEffect().AsFlags()
|
|
fallthrough
|
|
|
|
case t.IDOpenParen:
|
|
args, err := p.parseList(t.IDCloseParen, (*parser).parseArgNode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lhs = a.NewExpr(flags, a.ExprOperatorCall, 0, lhs.AsNode(), nil, nil, args)
|
|
|
|
case t.IDOpenBracket:
|
|
id0, mhs, rhs, err := p.parseBracket(t.IDDotDot)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lhs = a.NewExpr(0, id0, 0, lhs.AsNode(), mhs.AsNode(), rhs.AsNode(), nil)
|
|
|
|
case t.IDDot:
|
|
p.src = p.src[1:]
|
|
selector := p.peek1()
|
|
if first && selector.IsDQStrLiteral(p.tm) {
|
|
p.src = p.src[1:]
|
|
} else {
|
|
selector, err = p.parseIdent()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
lhs = a.NewExpr(0, a.ExprOperatorSelector, selector, lhs.AsNode(), nil, nil, nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *parser) parseEffect() a.Effect {
|
|
switch p.peek1() {
|
|
case t.IDExclam:
|
|
p.src = p.src[1:]
|
|
return a.EffectImpure
|
|
case t.IDQuestion:
|
|
p.src = p.src[1:]
|
|
return a.EffectImpureCoroutine
|
|
}
|
|
return 0
|
|
}
|