Let iterate parameters be non-powers-of-2

This commit is contained in:
Nigel Tao committed 2021-01-07 22:48:31 +11:00
1 parent beaf3ef11f
commit d842a20e43
4 files changed
+42 -57

No files matched your search

+9 -2
View File
@@ -16,6 +16,7 @@ package cgen
import (
"fmt"
"strconv"
"strings"
a "github.com/google/wuffs/lang/ast"
@@ -415,8 +416,14 @@ func (g *gen) writeStatementIterate(b *buffer, n *a.Iterate, depth uint32) error
round := uint32(0)
for ; n != nil; n = n.ElseIterate() {
length := n.Length().SmallPowerOf2Value()
unroll := n.Unroll().SmallPowerOf2Value()
length, err := strconv.Atoi(n.Length().Str(g.tm))
if err != nil {
return err
}
unroll, err := strconv.Atoi(n.Unroll().Str(g.tm))
if err != nil {
return err
}
for {
if err := g.writeIterateRound(b, name, n.Body(), round, depth, length, unroll); err != nil {
return err
+7 -7
View File
@@ -18,6 +18,7 @@ import (
"errors"
"fmt"
"math/big"
"strconv"
"github.com/google/wuffs/lib/interval"
@@ -283,7 +284,8 @@ func (q *checker) bcheckStatement(n *a.Node) error {
q.facts = q.facts[:0]
for _, o := range assigns {
lhs := o.AsAssign().LHS()
q.facts = append(q.facts, makeSliceLengthEqEq(lhs.Ident(), lhs.MType(), n.Length()))
q.facts = append(q.facts,
q.makeSliceLengthEqEq(lhs.Ident(), lhs.MType(), n.Length()))
}
if err := q.bcheckBlock(n.Body()); err != nil {
return err
@@ -1343,17 +1345,15 @@ func makeSliceLength(slice *a.Expr) *a.Expr {
}
// makeSliceLengthEqEq returns "x.length() == n".
//
// n must be the t.ID of a small power of 2.
func makeSliceLengthEqEq(x t.ID, xTyp *a.TypeExpr, n t.ID) *a.Expr {
func (q *checker) makeSliceLengthEqEq(x t.ID, xTyp *a.TypeExpr, n t.ID) *a.Expr {
xExpr := a.NewExpr(0, 0, x, nil, nil, nil, nil)
xExpr.SetMType(xTyp)
lhs := makeSliceLength(xExpr)
nValue := n.SmallPowerOf2Value()
if nValue == 0 {
panic("check: internal error: makeSliceLengthEqEq called but not with a small power of 2")
nValue, err := strconv.Atoi(n.Str(q.tm))
if err != nil {
panic("check: internal error: makeSliceLengthEqEq called but not with a small integer")
}
cv := big.NewInt(int64(nValue))
+24 -4
View File
@@ -1177,8 +1177,8 @@ func (p *parser) parseIterateBlock(label t.ID, assigns []*a.Node) (*a.Iterate, e
p.src = p.src[1:]
length := p.peek1()
if length.SmallPowerOf2Value() == 0 {
return nil, fmt.Errorf(`parse: expected power-of-2 length count in [1 ..= 256], got %q at %s:%d`,
if !isSmallPositiveInt256(p.tm, length) {
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:]
@@ -1202,8 +1202,8 @@ func (p *parser) parseIterateBlock(label t.ID, assigns []*a.Node) (*a.Iterate, e
p.src = p.src[1:]
unroll := p.peek1()
if unroll.SmallPowerOf2Value() == 0 {
return nil, fmt.Errorf(`parse: expected power-of-2 unroll count in [1 ..= 256], got %q at %s:%d`,
if !isSmallPositiveInt256(p.tm, unroll) {
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:]
@@ -1243,6 +1243,26 @@ func (p *parser) parseIterateBlock(label t.ID, assigns []*a.Node) (*a.Iterate, e
return n, nil
}
// isSmallPositiveInt256 returns whether id is a numeric literal in the range
// [1 ..= 256].
func isSmallPositiveInt256(tm *t.Map, id t.ID) bool {
if !id.IsNumLiteral(tm) {
return false
}
s := id.Str(tm)
if (len(s) > 3) || (len(s) == 0) || (s[0] < '1') || ('9' < s[0]) {
return false
}
n, s := int(s[0]-'0'), s[1:]
for ; len(s) > 0; s = s[1:] {
if (s[0] < '0') || ('9' < s[0]) {
return false
}
n = (10 * n) + int(s[0]-'0')
}
return n <= 256
}
func (p *parser) parseArgNode() (*a.Node, error) {
name, err := p.parseIdent()
if err != nil {
+2 -44
View File
@@ -130,30 +130,6 @@ func (x ID) IsXUnaryOp() bool { return minXOp <= x && x <= maxXOp && unary
func (x ID) IsXBinaryOp() bool { return minXOp <= x && x <= maxXOp && binaryForms[x] != 0 }
func (x ID) IsXAssociativeOp() bool { return minXOp <= x && x <= maxXOp && associativeForms[x] != 0 }
func (x ID) SmallPowerOf2Value() int {
switch x {
case ID1:
return 1
case ID2:
return 2
case ID4:
return 4
case ID8:
return 8
case ID16:
return 16
case ID32:
return 32
case ID64:
return 64
case ID128:
return 128
case ID256:
return 256
}
return 0
}
// QID is a qualified ID, such as "foo.bar". QID[0] is "foo"'s ID and QID[1] is
// "bar"'s. QID[0] may be 0 for a plain "bar".
type QID [2]ID
@@ -424,16 +400,7 @@ const (
IDNullptr = ID(0xE3)
IDOk = ID(0xE4)
ID0 = ID(0xF0)
ID1 = ID(0xF1)
ID2 = ID(0xF2)
ID4 = ID(0xF3)
ID8 = ID(0xF4)
ID16 = ID(0xF5)
ID32 = ID(0xF6)
ID64 = ID(0xF7)
ID128 = ID(0xF8)
ID256 = ID(0xF9)
ID0 = ID(0xF0)
)
const (
@@ -783,16 +750,7 @@ var builtInsByID = [nBuiltInIDs]string{
IDNullptr: "nullptr",
IDOk: "ok",
ID0: "0",
ID1: "1",
ID2: "2",
ID4: "4",
ID8: "8",
ID16: "16",
ID32: "32",
ID64: "64",
ID128: "128",
ID256: "256",
ID0: "0",
// -------- 0x100 block.