From 51bd52239bf538e23f9ef200bc20d61fafa182ba Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 20 Oct 2017 14:38:57 +1100 Subject: [PATCH] Add an "iterate" keyword. --- cmd/puffs-c/internal/cgen/cgen.go | 3 +- cmd/puffs-c/internal/cgen/func.go | 2 +- cmd/puffs-c/internal/cgen/statement.go | 33 ++++++++ cmd/puffs-c/internal/cgen/var.go | 13 ++- doc/puffs-the-language.md | 3 +- gen/c/std/flate.c | 8 ++ lang/ast/ast.go | 47 +++++++++-- lang/check/bounds.go | 44 ++++++++--- lang/check/type.go | 39 ++++++++- lang/parse/parse.go | 105 ++++++++++++++++++------- lang/token/list.go | 3 + std/flate/decode_zlib.puffs | 6 ++ 12 files changed, 253 insertions(+), 53 deletions(-) diff --git a/cmd/puffs-c/internal/cgen/cgen.go b/cmd/puffs-c/internal/cgen/cgen.go index 838b8821..456e6fab 100644 --- a/cmd/puffs-c/internal/cgen/cgen.go +++ b/cmd/puffs-c/internal/cgen/cgen.go @@ -45,6 +45,7 @@ const ( bPrefix = "b_" // Derived from a function argument. cPrefix = "c_" // Coroutine state. fPrefix = "f_" // Struct field. + iPrefix = "i_" // Iterate variable. lPrefix = "l_" // Limit length. tPrefix = "t_" // Temporary local variable. vPrefix = "v_" // Local variable. @@ -554,7 +555,7 @@ func (g *gen) writeStruct(b *buffer, n *a.Struct) error { b.writes("struct {\n") if k.coroSuspPoint != 0 { b.writes("uint32_t coro_susp_point;\n") - if err := g.writeVars(b, o.Body(), true); err != nil { + if err := g.writeVars(b, o.Body(), true, true); err != nil { return err } } diff --git a/cmd/puffs-c/internal/cgen/func.go b/cmd/puffs-c/internal/cgen/func.go index 4788e7d5..a21cf5d9 100644 --- a/cmd/puffs-c/internal/cgen/func.go +++ b/cmd/puffs-c/internal/cgen/func.go @@ -194,7 +194,7 @@ func (g *gen) writeFuncImplHeader(b *buffer) error { b.writes("\n") // Generate the local variables. - if err := g.writeVars(b, g.currFunk.astFunc.Body(), false); err != nil { + if err := g.writeVars(b, g.currFunk.astFunc.Body(), false, true); err != nil { return err } b.writes("\n") diff --git a/cmd/puffs-c/internal/cgen/statement.go b/cmd/puffs-c/internal/cgen/statement.go index b0af3b22..9f4eaf54 100644 --- a/cmd/puffs-c/internal/cgen/statement.go +++ b/cmd/puffs-c/internal/cgen/statement.go @@ -234,6 +234,39 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error { } return nil + case a.KIterate: + n := n.Iterate() + vars := n.Variables() + if len(vars) == 0 { + return nil + } + if len(vars) != 1 { + return fmt.Errorf("TODO: iterate over more than one variable") + } + v := vars[0].Var() + name := v.Name().String(g.tm) + b.writes("{\n") + + // TODO: don't assume that the slice is a slice of u8. + b.printf("puffs_base_slice_u8 %sslice_%s =", iPrefix, name) + if err := g.writeExpr(b, v.Value(), replaceCallSuspendibles, parenthesesOptional, 0); err != nil { + return err + } + b.writes(";\n") + b.printf("uint8_t* %sptr_%s = %sslice_%s.ptr;\n", iPrefix, name, iPrefix, name) + b.printf("uint8_t* %send_%s = %sslice_%s.ptr + %sslice_%s.len;\n", + iPrefix, name, iPrefix, name, iPrefix, name) + b.printf("while (%sptr_%s < %send_%s) {\n", iPrefix, name, iPrefix, name) + for _, o := range n.Body() { + if err := g.writeStatement(b, o, depth); err != nil { + return err + } + } + b.printf("%sptr_%s++;\n}\n", iPrefix, name) + + b.writes("}\n") + return nil + case a.KWhile: n := n.While() // TODO: consider suspendible calls. diff --git a/cmd/puffs-c/internal/cgen/var.go b/cmd/puffs-c/internal/cgen/var.go index 2142f925..e5336514 100644 --- a/cmd/puffs-c/internal/cgen/var.go +++ b/cmd/puffs-c/internal/cgen/var.go @@ -246,6 +246,14 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, * return err } + case a.KIterate: + if err := g.visitVars(b, o.Iterate().Variables(), depth, f); err != nil { + return err + } + if err := g.visitVars(b, o.Iterate().Body(), depth, f); err != nil { + return err + } + case a.KWhile: if err := g.visitVars(b, o.While().Body(), depth, f); err != nil { return err @@ -319,7 +327,7 @@ func (g *gen) writeResumeSuspend(b *buffer, block []*a.Node, suspend bool) error }) } -func (g *gen) writeVars(b *buffer, block []*a.Node, skipPointerTypes bool) error { +func (g *gen) writeVars(b *buffer, block []*a.Node, skipPointerTypes bool, skipIterateVariables bool) error { return g.visitVars(b, block, 0, func(g *gen, b *buffer, n *a.Var) error { if v := n.Value(); v != nil && v.ID0().Key() == t.KeyLimit { b.printf("uint64_t %s%v;\n", lPrefix, n.Name().String(g.tm)) @@ -327,6 +335,9 @@ func (g *gen) writeVars(b *buffer, block []*a.Node, skipPointerTypes bool) error if skipPointerTypes && n.XType().HasPointers() { return nil } + if skipIterateVariables && n.IterateVariable() { + return nil + } if err := g.writeCTypeName(b, n.XType(), vPrefix, n.Name().String(g.tm)); err != nil { return err } diff --git a/doc/puffs-the-language.md b/doc/puffs-the-language.md index 5bb1be54..2e48b5bb 100644 --- a/doc/puffs-the-language.md +++ b/doc/puffs-the-language.md @@ -27,12 +27,13 @@ be enclosed by curly `{}`s. There is no 'dangling else' ambiguity. - `pri` - `pub` -6 keywords deal with control flow within a function: +7 keywords deal with control flow within a function: - `break` - `continue` - `else` - `if` +- `iterate` - `return` - `while` diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c index fa0892e9..90dd5f06 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/flate.c @@ -2438,6 +2438,14 @@ uint32_t puffs_flate_adler32_update(puffs_flate_adler32* self, return 0; } } + { + puffs_base_slice_u8 i_slice_p = a_x; + uint8_t* i_ptr_p = i_slice_p.ptr; + uint8_t* i_end_p = i_slice_p.ptr + i_slice_p.len; + while (i_ptr_p < i_end_p) { + i_ptr_p++; + } + } v_i = 0; while (v_i < ((uint64_t)(a_x.len))) { v_s1 += ((uint32_t)(a_x.ptr[v_i])); diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 2d7c1636..bcf89dc9 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -41,6 +41,7 @@ const ( KFile KFunc KIf + KIterate KJump KPackageID KReturn @@ -71,6 +72,7 @@ var kindStrings = [...]string{ KFile: "KFile", KFunc: "KFunc", KIf: "KIf", + KIterate: "KIterate", KJump: "KJump", KPackageID: "KPackageID", KReturn: "KReturn", @@ -129,6 +131,7 @@ func (n *Node) Field() *Field { return (*Field)(n) } func (n *Node) File() *File { return (*File)(n) } func (n *Node) Func() *Func { return (*Func)(n) } func (n *Node) If() *If { return (*If)(n) } +func (n *Node) Iterate() *Iterate { return (*Iterate)(n) } func (n *Node) Jump() *Jump { return (*Jump)(n) } func (n *Node) PackageID() *PackageID { return (*PackageID)(n) } func (n *Node) Raw() *Raw { return (*Raw)(n) } @@ -331,20 +334,24 @@ func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign { } } -// Var is "var ID1 LHS" or "var ID1 LHS = RHS": +// Var is "var ID1 LHS" or "var ID1 LHS = RHS" or an iterate variable +// declaration "ID1 LHS : RHS": +// - ID0: <0|IDEq|IDColon> // - ID1: name // - LHS: // - RHS: type Var Node -func (n *Var) Node() *Node { return (*Node)(n) } -func (n *Var) Name() t.ID { return n.id1 } -func (n *Var) XType() *TypeExpr { return n.lhs.TypeExpr() } -func (n *Var) Value() *Expr { return n.rhs.Expr() } +func (n *Var) Node() *Node { return (*Node)(n) } +func (n *Var) IterateVariable() bool { return n.id0 == t.IDColon } +func (n *Var) Name() t.ID { return n.id1 } +func (n *Var) XType() *TypeExpr { return n.lhs.TypeExpr() } +func (n *Var) Value() *Expr { return n.rhs.Expr() } -func NewVar(name t.ID, xType *TypeExpr, value *Expr) *Var { +func NewVar(op t.ID, name t.ID, xType *TypeExpr, value *Expr) *Var { return &Var{ kind: KVar, + id0: op, id1: name, lhs: xType.Node(), rhs: value.Node(), @@ -371,6 +378,33 @@ func NewField(name t.ID, xType *TypeExpr, defaultValue *Expr) *Field { } } +// Iterate is "iterate:ID1 (vars) { List1 }": +// - FlagsHasBreak is the iterate has an explicit break +// - FlagsHasContinue is the iterate has an explicit continue +// - ID1: <0|label> +// - List0: variables +// - List1: loop body +type Iterate Node + +func (n *Iterate) Node() *Node { return (*Node)(n) } +func (n *Iterate) HasBreak() bool { return n.flags&FlagsHasBreak != 0 } +func (n *Iterate) HasContinue() bool { return n.flags&FlagsHasContinue != 0 } +func (n *Iterate) Label() t.ID { return n.id1 } +func (n *Iterate) Variables() []*Node { return n.list0 } +func (n *Iterate) Body() []*Node { return n.list1 } + +func (n *Iterate) SetHasBreak() { n.flags |= FlagsHasBreak } +func (n *Iterate) SetHasContinue() { n.flags |= FlagsHasContinue } + +func NewIterate(label t.ID, variables []*Node, body []*Node) *Iterate { + return &Iterate{ + kind: KIterate, + id1: label, + list0: variables, + list1: body, + } +} + // While is "while:ID1 LHS, List0 { List1 }": // - FlagsHasBreak is the while has an explicit break // - FlagsHasContinue is the while has an explicit continue @@ -585,6 +619,7 @@ const MaxBodyDepth = 255 // - Assign // - Expr // - If +// - Iterate // - Jump // - Return // - Var diff --git a/lang/check/bounds.go b/lang/check/bounds.go index b3024baf..108ca63f 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -265,22 +265,24 @@ func (q *checker) bcheckStatement(n *a.Node) error { // TODO. case a.KVar: - n := n.Var() - if innTyp := n.XType().Innermost(); innTyp.IsRefined() { - if _, _, err := typeBounds(q.tm, innTyp); err != nil { + return q.bcheckVar(n.Var()) + + case a.KIterate: + n := n.Iterate() + for _, o := range n.Variables() { + if err := q.bcheckVar(o.Var()); err != nil { return err } } - lhs := a.NewExpr(a.FlagsTypeChecked, 0, n.Name(), nil, nil, nil, nil) - lhs.SetMType(n.XType()) - rhs := n.Value() - if rhs == nil { - // "var x T" has an implicit "= 0". - // - // TODO: check that T is an integer type. - rhs = zeroExpr + // TODO: this isn't right, as the body is a loop, not an + // execute-exactly-once block. We should have pre / inv / post + // conditions, a la bcheckWhile. + for _, o := range n.Body() { + if err := q.bcheckStatement(o); err != nil { + return err + } } - return q.bcheckAssignment(lhs, t.IDEq, rhs) + return nil case a.KWhile: return q.bcheckWhile(n.While()) @@ -636,6 +638,24 @@ func (q *checker) bcheckWhile(n *a.While) error { return nil } +func (q *checker) bcheckVar(n *a.Var) error { + if innTyp := n.XType().Innermost(); innTyp.IsRefined() { + if _, _, err := typeBounds(q.tm, innTyp); err != nil { + return err + } + } + lhs := a.NewExpr(a.FlagsTypeChecked, 0, n.Name(), nil, nil, nil, nil) + lhs.SetMType(n.XType()) + rhs := n.Value() + if rhs == nil { + // "var x T" has an implicit "= 0". + // + // TODO: check that T is an integer type. + rhs = zeroExpr + } + return q.bcheckAssignment(lhs, t.IDEq, rhs) +} + func (q *checker) bcheckExpr(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) { if depth > a.MaxExprDepth { return nil, nil, fmt.Errorf("check: expression recursion depth too large") diff --git a/lang/check/type.go b/lang/check/type.go index 909dac11..5cdfd8b9 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -39,6 +39,14 @@ func (q *checker) tcheckVars(block []*a.Node) error { } } + case a.KIterate: + if err := q.tcheckVars(o.Iterate().Variables()); err != nil { + return err + } + if err := q.tcheckVars(o.Iterate().Body()); err != nil { + return err + } + case a.KVar: o := o.Var() name := o.Name() @@ -167,8 +175,24 @@ func (q *checker) tcheckStatement(n *a.Node) error { } lTyp := n.XType() rTyp := value.MType() - if (rTyp.IsIdeal() && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) { + if n.IterateVariable() { + if lTyp.Decorator().Key() != t.KeyPtr { + return fmt.Errorf("check: iterate variable %q, of type %q, does not have a pointer type", + n.Name().String(q.tm), lTyp.String(q.tm)) + } + if rTyp.Decorator().Key() != t.KeyColon { + return fmt.Errorf("check: iterate range %q, of type %q, does not have a slice type", + value.String(q.tm), rTyp.String(q.tm)) + } + if !lTyp.Inner().Eq(rTyp.Inner()) { + return fmt.Errorf("check: cannot iterate %q of type %q over %q of type %q "+ + "as their inner types don't match", + n.Name().String(q.tm), lTyp.String(q.tm), value.String(q.tm), rTyp.String(q.tm)) + } + + } else if (rTyp.IsIdeal() && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) { // No-op. + } else { return fmt.Errorf("check: cannot assign %q of type %q to %q of type %q", value.String(q.tm), rTyp.String(q.tm), n.Name().String(q.tm), lTyp.String(q.tm)) @@ -177,6 +201,19 @@ func (q *checker) tcheckStatement(n *a.Node) error { // TODO: check that the default zero value is assignable to n.XType(). } + case a.KIterate: + n := n.Iterate() + for _, o := range n.Variables() { + if err := q.tcheckStatement(o); err != nil { + return err + } + } + for _, o := range n.Body() { + if err := q.tcheckStatement(o); err != nil { + return err + } + } + case a.KWhile: n := n.While() cond := n.Condition() diff --git a/lang/parse/parse.go b/lang/parse/parse.go index 88fc0913..6f26a6dd 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -538,6 +538,11 @@ func (p *parser) parseStatement() (*a.Node, error) { n, err := p.parseStatement1() if n != nil { n.Raw().SetFilenameLine(p.filename, line) + if n.Kind() == a.KIterate { + for _, o := range n.Iterate().Variables() { + o.Raw().SetFilenameLine(p.filename, line) + } + } } return n, err } @@ -563,6 +568,22 @@ func (p *parser) parseStatement1() (*a.Node, error) { } return a.NewJump(x, label).Node(), nil + case t.KeyIterate: + p.src = p.src[1:] + label, err := p.parseLabel() + if err != nil { + return nil, err + } + vars, err := p.parseList(t.KeyCloseParen, (*parser).parseIterateVariableNode) + if err != nil { + return nil, err + } + body, err := p.parseBlock() + if err != nil { + return nil, err + } + return a.NewIterate(label, vars, body).Node(), nil + case t.KeyWhile: p.src = p.src[1:] label, err := p.parseLabel() @@ -619,36 +640,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { case t.KeyVar: p.src = p.src[1:] - id, err := p.parseIdent() - if err != nil { - return nil, err - } - typ, err := p.parseTypeExpr() - if err != nil { - return nil, err - } - value := (*a.Expr)(nil) - if p.peek1().Key() == t.KeyEq { - p.src = p.src[1:] - switch p.peek1().Key() { - case t.KeyLimit: - value, err = p.parseLimitExpr() - if err != nil { - return nil, err - } - case t.KeyTry: - value, err = p.parseTryExpr() - if err != nil { - return nil, err - } - default: - value, err = p.parseExpr() - if err != nil { - return nil, err - } - } - } - return a.NewVar(id, typ, value).Node(), nil + return p.parseVar(false) } lhs, err := p.parseExpr() @@ -717,6 +709,59 @@ func (p *parser) parseArgNode() (*a.Node, error) { return a.NewArg(name, value).Node(), nil } +func (p *parser) parseIterateVariableNode() (*a.Node, error) { + return p.parseVar(true) +} + +func (p *parser) parseVar(inIterate bool) (*a.Node, error) { + id, err := p.parseIdent() + if err != nil { + return nil, err + } + typ, err := p.parseTypeExpr() + if err != nil { + return nil, err + } + value := (*a.Expr)(nil) + + op := t.ID(0) + if inIterate { + op = t.IDColon + if x := p.peek1().Key(); x != t.KeyColon { + got := p.tm.ByKey(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 + } + + } else if p.peek1().Key() == t.KeyEq { + op = t.IDEq + p.src = p.src[1:] + switch p.peek1().Key() { + case t.KeyLimit: + value, err = p.parseLimitExpr() + if err != nil { + return nil, err + } + case t.KeyTry: + value, err = p.parseTryExpr() + if err != nil { + return nil, err + } + default: + value, err = p.parseExpr() + if err != nil { + return nil, err + } + } + } + + return a.NewVar(op, id, typ, value).Node(), nil +} + func (p *parser) parseDollarExpr() (*a.Expr, error) { if x := p.peek1().Key(); x != t.KeyDollar { got := p.tm.ByKey(x) diff --git a/lang/token/list.go b/lang/token/list.go index de894bfc..dc662b01 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -239,6 +239,7 @@ const ( KeyPackageID = Key(IDPackageID >> KeyShift) KeyConst = Key(IDConst >> KeyShift) KeyTry = Key(IDTry >> KeyShift) + KeyIterate = Key(IDIterate >> KeyShift) KeyFalse = Key(IDFalse >> KeyShift) KeyTrue = Key(IDTrue >> KeyShift) @@ -420,6 +421,7 @@ const ( IDPackageID = ID(0x76<