From 395890c287ee80b440c921282237535c7718f070 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 28 Apr 2018 11:45:33 +1000 Subject: [PATCH] Add an io_bind keyword --- cmd/wuffs-c/internal/cgen/statement.go | 11 ++++++++ cmd/wuffs-c/internal/cgen/var.go | 9 +++++-- doc/changelog.md | 1 + doc/wuffs-the-language.md | 6 ++--- gen/c/std/gif.c | 2 ++ lang/ast/ast.go | 24 +++++++++++++++++- lang/check/bounds.go | 8 ++++++ lang/check/type.go | 30 ++++++++++++++++++++++ lang/parse/parse.go | 35 ++++++++++++++++++++++---- lang/token/list.go | 2 ++ std/gif/decode_gif.wuffs | 17 +++++++------ 11 files changed, 127 insertions(+), 18 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index 9165b6e8..a67b2900 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -128,6 +128,17 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error { b.writes(";\n") return nil + case a.KIOBind: + n := n.IOBind() + b.writes("// io_bind placeholder {\n") + for _, o := range n.Body() { + if err := g.writeStatement(b, o, depth); err != nil { + return err + } + } + b.writes("// io_bind placeholder }\n") + return nil + case a.KIf: // TODO: for writeSuspendibles, make sure that we get order of // sub-expression evaluation correct. diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index 1bd57e2e..536a3c51 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -276,8 +276,8 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, * } } - case a.KVar: - if err := f(g, b, o.Var()); err != nil { + case a.KIOBind: + if err := g.visitVars(b, o.IOBind().Body(), depth, f); err != nil { return err } @@ -289,6 +289,11 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, * return err } + case a.KVar: + if err := f(g, b, o.Var()); err != nil { + return err + } + case a.KWhile: if err := g.visitVars(b, o.While().Body(), depth, f); err != nil { return err diff --git a/doc/changelog.md b/doc/changelog.md index a3dec520..291247ff 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -5,6 +5,7 @@ - Renamed Puffs to Wuffs. - Added a `skipgendeps` flag. +- Added an `io_bind` keyword. - Added a `use` keyword. - Added a `yield` keyword. - Added `std/adler32`, `std/crc32` and `std/gzip`. diff --git a/doc/wuffs-the-language.md b/doc/wuffs-the-language.md index f459c1a5..e9e36e8f 100644 --- a/doc/wuffs-the-language.md +++ b/doc/wuffs-the-language.md @@ -55,8 +55,8 @@ be enclosed by curly `{}`s. There is no 'dangling else' ambiguity. - `var` -TODO: categorize and, or, not, as, ref, deref, false, true, in, out, this, u8, -u16, etc. +TODO: categorize try, io\_bind. Also: and, or, not, as, ref, deref, false, +true, in, out, this, u8, u16, etc. ## Operators @@ -293,4 +293,4 @@ buffers of bytes, such as an I/O stream or a table of pixel data. --- -Updated on November 2017. +Updated on April 2018. diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 367398b7..62f46191 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -2955,6 +2955,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( } while (true) { wuffs_base__io_reader__mark(&a_src, b_rptr_src); + // io_bind placeholder { v_r = a_src; { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); @@ -2979,6 +2980,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( } v_z = t_14; } + // io_bind placeholder } if (v_z == 0) { goto label_1_break; } diff --git a/lang/ast/ast.go b/lang/ast/ast.go index bb88f0ac..a36a1779 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -41,6 +41,7 @@ const ( KField KFile KFunc + KIOBind KIf KIterate KJump @@ -72,6 +73,7 @@ var kindStrings = [...]string{ KField: "KField", KFile: "KFile", KFunc: "KFunc", + KIOBind: "KIOBind", KIf: "KIf", KIterate: "KIterate", KJump: "KJump", @@ -162,6 +164,7 @@ type Node struct { // Field . . name Field // File . . . File // Func funcName receiverPkg receiverName Func + // IOBind . . . IOBind // If . . . If // Iterate . label . Iterate // Jump keyword label . Jump @@ -198,6 +201,7 @@ func (n *Node) Expr() *Expr { return (*Expr)(n) } 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) IOBind() *IOBind { return (*IOBind)(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) } @@ -488,7 +492,24 @@ func NewField(name t.ID, xType *TypeExpr, defaultValue *Expr) *Field { } } -// Iterate is "iterate.LHS:ID1 (vars), List1 { List2 }": +// IOBind is "io_bind (in_fields) { List2 }": +// - List0: in.something fields +// - List2: loop body +type IOBind Node + +func (n *IOBind) Node() *Node { return (*Node)(n) } +func (n *IOBind) InFields() []*Node { return n.list0 } +func (n *IOBind) Body() []*Node { return n.list2 } + +func NewIOBind(in_fields []*Node, body []*Node) *IOBind { + return &IOBind{ + kind: KIOBind, + list0: in_fields, + list2: body, + } +} + +// Iterate is "iterate[LHS]:ID1 (vars), List1 { List2 }": // - FlagsHasBreak is the iterate has an explicit break // - FlagsHasContinue is the iterate has an explicit continue // - ID1: <0|label> @@ -760,6 +781,7 @@ const MaxBodyDepth = 255 // - Assert // - Assign // - Expr +// - IOBind // - If // - Iterate // - Jump diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 2e131f16..d343d0a9 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -303,6 +303,14 @@ func (q *checker) bcheckStatement(n *a.Node) error { case a.KVar: return q.bcheckVar(n.Var()) + case a.KIOBind: + n := n.IOBind() + if err := q.bcheckBlock(n.Body()); err != nil { + return err + } + // TODO: invalidate any facts regarding the io_bind expressions. + return nil + case a.KIterate: n := n.Iterate() for _, o := range n.Variables() { diff --git a/lang/check/type.go b/lang/check/type.go index d1286bf2..b683a3c9 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -39,6 +39,11 @@ func (q *checker) tcheckVars(block []*a.Node) error { } } + case a.KIOBind: + if err := q.tcheckVars(o.IOBind().Body()); err != nil { + return err + } + case a.KIterate: if err := q.tcheckVars(o.Iterate().Variables()); err != nil { return err @@ -110,6 +115,31 @@ func (q *checker) tcheckStatement(n *a.Node) error { } return nil + case a.KIOBind: + n := n.IOBind() + for _, o := range n.InFields() { + if err := q.tcheckExpr(o.Expr(), 0); err != nil { + return err + } + isIOType := false + if typ := o.Expr().MType(); typ.Decorator() == 0 { + if qid := typ.QID(); qid[0] == t.IDBase && (qid[1] == t.IDIOReader || qid[1] == t.IDIOWriter) { + isIOType = true + } + } + if !isIOType { + return fmt.Errorf("check: io_bind expression %q, of type %q, does not have an I/O type", + o.Expr().Str(q.tm), o.Expr().MType().Str(q.tm)) + } + } + for _, o := range n.Body() { + // TODO: prohibit jumps (breaks, continues), rets (returns, yields) + // and retry-calling ? methods while inside an io_bind body. + if err := q.tcheckStatement(o); err != nil { + return err + } + } + case a.KIterate: n := n.Iterate() unroll := n.UnrollCount() diff --git a/lang/parse/parse.go b/lang/parse/parse.go index c571d055..e723ad11 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -614,6 +614,18 @@ func (p *parser) parseStatement1() (*a.Node, error) { } return a.NewJump(x, label).Node(), nil + case t.IDIOBind: + p.src = p.src[1:] + in_fields, err := p.parseList(t.IDCloseParen, (*parser).parseIOBindExprNode) + if err != nil { + return nil, err + } + body, err := p.parseBlock() + if err != nil { + return nil, err + } + return a.NewIOBind(in_fields, body).Node(), nil + case t.IDIf: o, err := p.parseIf() return o.Node(), err @@ -651,7 +663,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { } p.src = p.src[1:] - vars, err := p.parseList(t.IDCloseParen, (*parser).parseIterateVariableNode) + vars, err := p.parseList(t.IDCloseParen, (*parser).parseIterateVarNode) if err != nil { return nil, err } @@ -678,7 +690,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { case t.IDVar: p.src = p.src[1:] - return p.parseVar(false) + return p.parseVarNode(false) case t.IDWhile: p.src = p.src[1:] @@ -782,11 +794,24 @@ 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) parseIOBindExprNode() (*a.Node, error) { + e, err := p.parseExpr() + if err != nil { + return nil, err + } + if e.Operator() == t.IDDot { + if lhs := e.LHS().Expr(); lhs.Operator() == 0 && lhs.Ident() == t.IDIn { + return e.Node(), nil + } + } + return nil, fmt.Errorf(`parse: expected "in.something", got %q at %s:%d`, e.Str(p.tm), p.filename, p.line()) } -func (p *parser) parseVar(inIterate bool) (*a.Node, error) { +func (p *parser) parseIterateVarNode() (*a.Node, error) { + return p.parseVarNode(true) +} + +func (p *parser) parseVarNode(inIterate bool) (*a.Node, error) { id, err := p.parseIdent() if err != nil { return nil, err diff --git a/lang/token/list.go b/lang/token/list.go index 9cd36955..ea51d685 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -320,6 +320,7 @@ const ( IDTry = ID(0x85) IDIterate = ID(0x86) IDYield = ID(0x87) + IDIOBind = ID(0x88) ) const ( @@ -500,6 +501,7 @@ var builtInsByID = [nBuiltInIDs]string{ IDTry: "try", IDIterate: "iterate", IDYield: "yield", + IDIOBind: "io_bind", IDArray: "array", IDNptr: "nptr", diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index b856cf39..ef5cb1e3 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -313,13 +313,16 @@ pri func decoder.decode_id?(dst base.io_writer, src base.io_reader)() { // TODO: should "mark" be "set_mark"? Unlike "limit", "mark" does // not return a different io_reader. in.src.mark() - var r base.io_reader = in.src - // TODO: remove the dummy param. It's needed for now so that - // writeSaveExprDerivedVars updates e.g. the b_rptr_src derived - // variables. - // - // TODO: enforce that limit can only be called in a "foo?" call? - var z base.status = try this.lzw.decode?(dst:in.dst, src:r.limit(l:block_size), dummy:in.src) + io_bind (in.src) { + var r base.io_reader = in.src + // TODO: remove the dummy param. It's needed for now so that + // writeSaveExprDerivedVars updates e.g. the b_rptr_src derived + // variables. + // + // TODO: enforce that limit can only be called in a "foo?" + // call? + var z base.status = try this.lzw.decode?(dst:in.dst, src:r.limit(l:block_size), dummy:in.src) + } if z.is_ok() { break }