Add an "iterate" keyword.

This commit is contained in:
Nigel Tao committed 2017-10-20 15:33:31 +11:00
1 parent 7b18295688
commit 51bd52239b
12 files changed
+253 -53

No files matched your search

+2 -1
View File
@@ -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
}
}
+1 -1
View File
@@ -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")
+33
View File
@@ -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.
+12 -1
View File
@@ -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
}
+2 -1
View File
@@ -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`
+8
View File
@@ -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]));
+41 -6
View File
@@ -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: <TypeExpr>
// - RHS: <nil|Expr>
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: <Var> variables
// - List1: <Statement> 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
+32 -12
View File
@@ -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")
+38 -1
View File
@@ -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()
+75 -30
View File
@@ -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)
+3
View File
@@ -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<<KeyShift | FlagsOther)
IDConst = ID(0x77<<KeyShift | FlagsOther)
IDTry = ID(0x78<<KeyShift | FlagsOther)
IDIterate = ID(0x79<<KeyShift | FlagsOther)
IDFalse = ID(0x80<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
IDTrue = ID(0x81<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
@@ -617,6 +619,7 @@ var builtInsByKey = [nBuiltInKeys]struct {
KeyPackageID: {"packageid", IDPackageID},
KeyConst: {"const", IDConst},
KeyTry: {"try", IDTry},
KeyIterate: {"iterate", IDIterate},
KeyFalse: {"false", IDFalse},
KeyTrue: {"true", IDTrue},
+6
View File
@@ -65,6 +65,12 @@ pri func adler32.update(x[] u8)(checksum u32) {
}
}
iterate (p ptr u8:in.x) {
// TODO: uncomment this loop body, and delete the while loop below.
// s1 ~+= deref p as u32
// s2 ~+= s1
}
// TODO: can u64 be u32? Does it matter?
var i u64
while i < in.x.length(),