From 19f56ebfd2c204af0d7ab2675cc3b943d7acd516 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Tue, 13 Jun 2023 16:06:38 +1000 Subject: [PATCH] lang: allow "slice_var as ptr array[etc] etc" --- doc/changelog.md | 1 + internal/cgen/expr.go | 20 ++++++++++++++++++++ internal/cgen/var.go | 4 ++++ lang/ast/ast.go | 10 ++++++++++ lang/check/assert.go | 13 +++++++++++++ lang/check/bounds.go | 24 +++++++++++++++++++++--- lang/check/type.go | 16 ++++++++++++++-- 7 files changed, 83 insertions(+), 5 deletions(-) diff --git a/doc/changelog.md b/doc/changelog.md index 577f93e0..efdea195 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -4,6 +4,7 @@ ## Work In Progress - Added `example/toy-aux-image`. +- Added `slice_var as nptr array[etc] etc` conversion. - Added `std/jpeg`. - Added `std/netpbm`. - Changed `lzw.set_literal_width` to `lzw.set_quirk`. diff --git a/internal/cgen/expr.go b/internal/cgen/expr.go index b4d08e72..85b53dcc 100644 --- a/internal/cgen/expr.go +++ b/internal/cgen/expr.go @@ -404,6 +404,26 @@ func (g *gen) writeExprXMinusY(b *buffer, x *a.Expr, y *a.Expr, depth uint32) er } func (g *gen) writeExprAs(b *buffer, lhs *a.Expr, rhs *a.TypeExpr, depth uint32) error { + if rhs.IsPointerType() { + if !lhs.MType().IsEitherSliceType() { + // TODO: fix this. + return fmt.Errorf("cannot convert Wuffs conversion from %q to %q to C", lhs.Str(g.tm), rhs.Str(g.tm)) + } + if (lhs.Operator() == t.IDDotDot) && (lhs.MHS() == nil) && (lhs.RHS() == nil) { + b.writes("&") + if err := g.writeExpr(b, lhs.LHS().AsExpr(), false, depth); err != nil { + return err + } + b.writes("[0u]") + return nil + } + if err := g.writeExpr(b, lhs, false, depth); err != nil { + return err + } + b.writes(".ptr") + return nil + } + // Drop the "& redundantMask" in "(foo & redundantMask) as base.uxx". It's // redundant in C/C++ (but not in Wuffs). if rhs.IsNumType() { diff --git a/internal/cgen/var.go b/internal/cgen/var.go index bce8c62f..54a6aa4c 100644 --- a/internal/cgen/var.go +++ b/internal/cgen/var.go @@ -342,6 +342,10 @@ func (g *gen) writeVars(b *buffer, f *funk, inStructDecl bool) error { return fmt.Errorf("TODO: support token_{reader,writer} typed variables") } + if typ.IsPointerType() && typ.IsRecursivelyReadOnly() { + b.writes("const ") + } + if err := g.writeCTypeName(b, typ, vPrefix, name); err != nil { return err } diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 2c270ea1..12db0eed 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -941,6 +941,16 @@ func (n *TypeExpr) IsReadOnly() bool { return (n.id0 == t.IDRoarray) || (n.id0 == t.IDRoslice) || (n.id0 == t.IDRotable) } +func (n *TypeExpr) IsRecursivelyReadOnly() bool { + for ; n != nil; n = n.Inner() { + switch n.id0 { + case t.IDRoarray, t.IDRoslice, t.IDRotable: + return true + } + } + return false +} + func (n *TypeExpr) IsContainerOfSpecificNumType(container t.ID, numType t.ID) bool { return (n.id0 == container) && n.Inner().IsNumType() && (n.Inner().id2 == numType) } diff --git a/lang/check/assert.go b/lang/check/assert.go index c3680bc6..077568d0 100644 --- a/lang/check/assert.go +++ b/lang/check/assert.go @@ -17,6 +17,7 @@ package check import ( "errors" "fmt" + "math/big" a "github.com/google/wuffs/lang/ast" t "github.com/google/wuffs/lang/token" @@ -382,3 +383,15 @@ func (q *checker) proveRecvNotEqNullptr(recv *a.Expr) error { } return fmt.Errorf("check: cannot prove %q", recv.Str(q.tm)+" <> nullptr") } + +func (q *checker) proveSliceLengthAtLeast(n *a.Expr, minInclLength *big.Int) error { + if (n.Operator() == t.IDDotDot) && (n.MHS() == nil) && (n.RHS() == nil) { + if lTyp := n.LHS().AsExpr().MType(); lTyp.IsEitherArrayType() && + lTyp.ArrayLength().ConstValue().Cmp(minInclLength) >= 0 { + return nil + } + } + // TODO: the general case, where n isn't "foo[..]" and foo isn't an array + // of length >= minInclLength. + return fmt.Errorf("check: cannot prove %q", n.Str(q.tm)+".length() >= "+minInclLength.String()) +} diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 4fb37736..1e19f26d 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -953,10 +953,28 @@ func (q *checker) bcheckExpr1(n *a.Expr, depth uint32) (bounds, error) { case op.IsXUnaryOp(): return q.bcheckExprUnaryOp(n, depth) case op.IsXBinaryOp(): - if op == t.IDXBinaryAs { - return q.bcheckExpr(n.LHS().AsExpr(), depth) + if op != t.IDXBinaryAs { + return q.bcheckExprBinaryOp(op, n.LHS().AsExpr(), n.RHS().AsExpr(), depth) } - return q.bcheckExprBinaryOp(op, n.LHS().AsExpr(), n.RHS().AsExpr(), depth) + b, err := q.bcheckExpr(n.LHS().AsExpr(), depth) + if err != nil { + return bounds{}, err + } else if lhs := n.LHS().AsExpr(); lhs.MType().IsEitherSliceType() { + cv := (*big.Int)(nil) + rhs := n.RHS().AsTypeExpr() + if (rhs.Decorator() == t.IDPtr) && (rhs.Inner().IsEitherArrayType()) { + cv = rhs.Inner().ArrayLength().ConstValue() + } + if cv == nil { + // TODO: fix this. + return bounds{}, fmt.Errorf("check: cannot bounds-check conversion to %q", rhs.Str(q.tm)) + } + if err := q.proveSliceLengthAtLeast(lhs, cv); err != nil { + return bounds{}, err + } + b = bounds{one, maxPointerBounds} + } + return b, nil case op.IsXAssociativeOp(): return q.bcheckExprAssociativeOp(n, depth) } diff --git a/lang/check/type.go b/lang/check/type.go index 775334b3..1508fc27 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -332,9 +332,11 @@ func (q *checker) tcheckAssign(n *a.Assign) error { return err } for l := lhs; l != nil; l = l.LHS().AsExpr() { - if (l.Operator() == t.IDOpenBracket) && l.LHS().MType().IsReadOnly() { + if l.Operator() != t.IDOpenBracket { + // No-op. + } else if lTyp := l.LHS().MType(); lTyp.IsRecursivelyReadOnly() { return fmt.Errorf("check: assignment %q: assignee fragment %q, of type %q, has read-only type", - n.Operator().Str(q.tm), l.LHS().AsExpr().Str(q.tm), l.LHS().AsExpr().MType().Str(q.tm)) + n.Operator().Str(q.tm), l.LHS().AsExpr().Str(q.tm), lTyp.Str(q.tm)) } } lTyp := lhs.MType() @@ -848,6 +850,16 @@ func (q *checker) tcheckExprBinaryOp(n *a.Expr, depth uint32) error { if lTyp.IsNumTypeOrIdeal() && rhs.IsNumType() { n.SetMType(rhs) return nil + } else if lTyp.IsEitherSliceType() && + (rhs.Decorator() == t.IDPtr) && + rhs.Inner().IsEitherArrayType() && + lTyp.Inner().Eq(rhs.Inner().Inner()) { + if lTyp.IsReadOnly() || rhs.IsRecursivelyReadOnly() { + // TODO. + } else { + n.SetMType(rhs) + return nil + } } return fmt.Errorf("check: cannot convert expression %q, of type %q, as type %q", lhs.Str(q.tm), lTyp.Str(q.tm), rhs.Str(q.tm))