mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Delete old limit- and mark-related code.
This commit is contained in:
1 parent
aa396e7992
commit
cbc8c39375
12 files changed
+10
-167
No files matched your search
@@ -46,7 +46,6 @@ const (
|
||||
cPrefix = "c_" // Coroutine state.
|
||||
fPrefix = "f_" // Struct field.
|
||||
iPrefix = "i_" // Iterate variable.
|
||||
lPrefix = "l_" // Limit length. TODO: delete.
|
||||
tPrefix = "t_" // Temporary local variable.
|
||||
vPrefix = "v_" // Local variable.
|
||||
)
|
||||
|
||||
@@ -404,9 +404,6 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
|
||||
b.writes("private_impl." + fPrefix)
|
||||
b.writes(n.ID1().String(g.tm))
|
||||
return nil
|
||||
|
||||
case t.KeyLimit:
|
||||
panic("TODO: delete t.KeyLimit")
|
||||
}
|
||||
return fmt.Errorf("unrecognized token.Key (0x%X) for writeExprOther", n.ID0().Key())
|
||||
}
|
||||
|
||||
@@ -38,7 +38,6 @@ type funk struct {
|
||||
public bool
|
||||
suspendible bool
|
||||
usesScratch bool
|
||||
limitVarName string // TODO: delete.
|
||||
shortReads []string
|
||||
}
|
||||
|
||||
|
||||
@@ -68,15 +68,6 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
b.writes(";\n")
|
||||
return nil
|
||||
|
||||
case a.KIO:
|
||||
// TODO: is a private_impl.mark the right representation? What if the
|
||||
// function is passed a (ptr writer1) instead of a (writer1)? Do we
|
||||
// still want to have that mark live outside of the function scope?
|
||||
//
|
||||
// TODO: remove this hard-coded hack for "mark in.dst".
|
||||
b.printf("%sdst.private_impl.mark = %swptr_dst;", aPrefix, bPrefix)
|
||||
return nil
|
||||
|
||||
case a.KIf:
|
||||
// TODO: for writeSuspendibles, make sure that we get order of
|
||||
// sub-expression evaluation correct.
|
||||
@@ -257,15 +248,6 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
if err := g.writeSuspendibles(b, v, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if v.ID0().Key() == t.KeyLimit {
|
||||
g.currFunk.limitVarName = n.Name().String(g.tm)
|
||||
b.printf("%s%s =", lPrefix, g.currFunk.limitVarName)
|
||||
if err := g.writeExpr(
|
||||
b, v.LHS().Expr(), replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(";\n")
|
||||
}
|
||||
}
|
||||
switch n.XType().Decorator().Key() {
|
||||
case t.KeyOpenBracket:
|
||||
|
||||
@@ -255,11 +255,10 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, *
|
||||
return nil
|
||||
}
|
||||
|
||||
func (g *gen) writeResumeSuspend1(b *buffer, n *a.Var, prefix string, suspend bool) error {
|
||||
local := fmt.Sprintf("%s%s", prefix, n.Name().String(g.tm))
|
||||
func (g *gen) writeResumeSuspend1(b *buffer, n *a.Var, suspend bool) error {
|
||||
local := fmt.Sprintf("%s%s", vPrefix, n.Name().String(g.tm))
|
||||
|
||||
// TODO: explicitly handle prefix == lPrefix?
|
||||
if typ := n.XType(); prefix == vPrefix && typ.HasPointers() {
|
||||
if typ := n.XType(); typ.HasPointers() {
|
||||
if suspend {
|
||||
return nil
|
||||
}
|
||||
@@ -310,20 +309,12 @@ func (g *gen) writeResumeSuspend1(b *buffer, n *a.Var, prefix string, suspend bo
|
||||
|
||||
func (g *gen) writeResumeSuspend(b *buffer, block []*a.Node, suspend 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 {
|
||||
if err := g.writeResumeSuspend1(b, n, lPrefix, suspend); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return g.writeResumeSuspend1(b, n, vPrefix, suspend)
|
||||
return g.writeResumeSuspend1(b, n, suspend)
|
||||
})
|
||||
}
|
||||
|
||||
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))
|
||||
}
|
||||
if skipPointerTypes && n.XType().HasPointers() {
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -54,11 +54,6 @@ be enclosed by curly `{}`s. There is no 'dangling else' ambiguity.
|
||||
|
||||
- `var`
|
||||
|
||||
2 keywords deal with I/O:
|
||||
|
||||
- `limit`
|
||||
- `mark`
|
||||
|
||||
TODO: categorize and, or, not, as, ref, deref, false, true, in, out, this, u8,
|
||||
u16, etc.
|
||||
|
||||
|
||||
@@ -40,7 +40,6 @@ const (
|
||||
KField
|
||||
KFile
|
||||
KFunc
|
||||
KIO // TODO: delete.
|
||||
KIf
|
||||
KIterate
|
||||
KJump
|
||||
@@ -72,7 +71,6 @@ var kindStrings = [...]string{
|
||||
KField: "KField",
|
||||
KFile: "KFile",
|
||||
KFunc: "KFunc",
|
||||
KIO: "KIO",
|
||||
KIf: "KIf",
|
||||
KIterate: "KIterate",
|
||||
KJump: "KJump",
|
||||
@@ -135,7 +133,6 @@ 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) IO() *IO { return (*IO)(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) }
|
||||
@@ -242,8 +239,6 @@ const MaxExprDepth = 255
|
||||
// For selectors, like "LHS.ID1", ID0 is IDDot.
|
||||
//
|
||||
// For lists, like "$(0, 1, 2)", ID0 is IDDollar.
|
||||
//
|
||||
// For limits, like "limit (LHS) RHS", ID0 is IDLimit.
|
||||
type Expr Node
|
||||
|
||||
func (n *Expr) Node() *Node { return (*Node)(n) }
|
||||
@@ -483,27 +478,6 @@ func NewIf(condition *Expr, elseIf *If, bodyIfTrue []*Node, bodyIfFalse []*Node)
|
||||
}
|
||||
}
|
||||
|
||||
// IO is "mark LHS":
|
||||
// - ID0: <IDMark>
|
||||
// - LHS: <Expr>
|
||||
//
|
||||
// TODO: "mark LHS { List2 }"?
|
||||
//
|
||||
// TODO: also represent "limit LHS"?
|
||||
type IO Node
|
||||
|
||||
func (n *IO) Node() *Node { return (*Node)(n) }
|
||||
func (n *IO) Keyword() t.ID { return n.id0 }
|
||||
func (n *IO) Value() *Expr { return n.lhs.Expr() }
|
||||
|
||||
func NewIO(keyword t.ID, value *Expr) *IO {
|
||||
return &IO{
|
||||
kind: KIO,
|
||||
id0: keyword,
|
||||
lhs: value.Node(),
|
||||
}
|
||||
}
|
||||
|
||||
// Return is "return LHS", "return error ID1" or "return suspension ID1":
|
||||
// - ID0: <0|IDError|IDSuspension>
|
||||
// - ID1: message
|
||||
|
||||
@@ -90,9 +90,6 @@ func (n *Expr) appendString(buf []byte, tm *t.Map, parenthesize bool, depth uint
|
||||
buf = o.Expr().appendString(buf, tm, false, depth)
|
||||
}
|
||||
buf = append(buf, ')')
|
||||
|
||||
case t.KeyLimit:
|
||||
buf = append(buf, "TODO(limit)"...)
|
||||
}
|
||||
|
||||
case t.FlagsUnaryOp:
|
||||
|
||||
@@ -241,10 +241,6 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
_, _, err := q.bcheckExpr(n.Expr(), 0)
|
||||
return err
|
||||
|
||||
case a.KIO:
|
||||
_, _, err := q.bcheckExpr(n.IO().Value(), 0)
|
||||
return err
|
||||
|
||||
case a.KIf:
|
||||
return q.bcheckIf(n.If())
|
||||
|
||||
@@ -889,9 +885,6 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
case t.KeyLimit:
|
||||
return nil, nil, nil
|
||||
|
||||
default:
|
||||
return nil, nil, fmt.Errorf("check: unrecognized token.Key (0x%X) for bcheckExprOther", n.ID0().Key())
|
||||
}
|
||||
|
||||
@@ -84,18 +84,6 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
case a.KExpr:
|
||||
return q.tcheckExpr(n.Expr(), 0)
|
||||
|
||||
case a.KIO:
|
||||
n := n.IO()
|
||||
val := n.Value()
|
||||
if err := q.tcheckExpr(val, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
typ := val.MType()
|
||||
if key := typ.Name().Key(); typ.Decorator() != 0 || (key != t.KeyReader1 && key != t.KeyWriter1) {
|
||||
return fmt.Errorf("check: %s expression %q, of type %q, does not have an I/O type",
|
||||
n.Keyword().String(q.tm), val.String(q.tm), typ.String(q.tm))
|
||||
}
|
||||
|
||||
case a.KIf:
|
||||
for n := n.If(); n != nil; n = n.ElseIf() {
|
||||
cond := n.Condition()
|
||||
@@ -662,34 +650,6 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
n.SetMType(typeExprList)
|
||||
return nil
|
||||
|
||||
case t.KeyLimit:
|
||||
lhs := n.LHS().Expr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if lhs.Impure() {
|
||||
return fmt.Errorf(`check: limit count %q is not pure`, lhs.String(q.tm))
|
||||
}
|
||||
lTyp := lhs.MType()
|
||||
if !lTyp.IsIdeal() && !lTyp.EqIgnoringRefinements(typeExprU64) {
|
||||
return fmt.Errorf("check: limit count %q type %q not compatible with u64",
|
||||
lhs.String(q.tm), lTyp.String(q.tm))
|
||||
}
|
||||
rhs := n.RHS().Expr()
|
||||
if err := q.tcheckExpr(rhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if rhs.Impure() {
|
||||
return fmt.Errorf("check: limit arg %q is not pure", rhs.String(q.tm))
|
||||
}
|
||||
rTyp := rhs.MType()
|
||||
if rTyp.Decorator() != 0 || (rTyp.Name().Key() != t.KeyReader1 && rTyp.Name().Key() != t.KeyWriter1) {
|
||||
return fmt.Errorf(`check: limit arg %q type %q not "reader1" or "writer1"`,
|
||||
rhs.String(q.tm), rTyp.String(q.tm))
|
||||
}
|
||||
n.SetMType(rTyp)
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) in expression %q for tcheckExprOther",
|
||||
n.ID0().Key(), n.String(q.tm))
|
||||
|
||||
+2
-43
@@ -612,14 +612,6 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
}
|
||||
return a.NewIterate(label, unroll, vars, asserts, body).Node(), nil
|
||||
|
||||
case t.KeyMark:
|
||||
p.src = p.src[1:]
|
||||
value, err := p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewIO(x, value).Node(), nil
|
||||
|
||||
case t.KeyReturn:
|
||||
p.src = p.src[1:]
|
||||
keyword, message, value, err := t.ID(0), t.ID(0), (*a.Expr)(nil), error(nil)
|
||||
@@ -780,18 +772,12 @@ func (p *parser) parseVar(inIterate bool) (*a.Node, error) {
|
||||
} 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:
|
||||
if p.peek1().Key() == t.KeyTry {
|
||||
value, err = p.parseTryExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
} else {
|
||||
value, err = p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -815,33 +801,6 @@ func (p *parser) parseDollarExpr() (*a.Expr, error) {
|
||||
return a.NewExpr(0, t.IDDollar, 0, nil, nil, nil, args), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseLimitExpr() (*a.Expr, error) {
|
||||
if x := p.peek1().Key(); x != t.KeyLimit {
|
||||
got := p.tm.ByKey(x)
|
||||
return nil, fmt.Errorf(`parse: expected "limit", got %q at %s:%d`, got, p.filename, p.line())
|
||||
}
|
||||
p.src = p.src[1:]
|
||||
if x := p.peek1().Key(); x != t.KeyOpenParen {
|
||||
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:]
|
||||
lhs, err := p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if x := p.peek1().Key(); x != t.KeyCloseParen {
|
||||
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:]
|
||||
rhs, err := p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewExpr(0, t.IDLimit, 0, lhs.Node(), nil, rhs.Node(), nil), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseTryExpr() (*a.Expr, error) {
|
||||
if x := p.peek1().Key(); x != t.KeyTry {
|
||||
got := p.tm.ByKey(x)
|
||||
|
||||
+4
-7
@@ -237,7 +237,6 @@ const (
|
||||
KeyPri = Key(IDPri >> KeyShift)
|
||||
KeyError = Key(IDError >> KeyShift)
|
||||
KeySuspension = Key(IDSuspension >> KeyShift)
|
||||
KeyLimit = Key(IDLimit >> KeyShift) // TODO: delete.
|
||||
KeyPackageID = Key(IDPackageID >> KeyShift)
|
||||
KeyConst = Key(IDConst >> KeyShift)
|
||||
KeyTry = Key(IDTry >> KeyShift)
|
||||
@@ -425,11 +424,10 @@ const (
|
||||
IDPri = ID(0x72<<KeyShift | FlagsOther)
|
||||
IDError = ID(0x73<<KeyShift | FlagsOther)
|
||||
IDSuspension = ID(0x74<<KeyShift | FlagsOther)
|
||||
IDLimit = ID(0x75<<KeyShift | FlagsOther)
|
||||
IDPackageID = ID(0x76<<KeyShift | FlagsOther)
|
||||
IDConst = ID(0x77<<KeyShift | FlagsOther)
|
||||
IDTry = ID(0x78<<KeyShift | FlagsOther)
|
||||
IDIterate = ID(0x79<<KeyShift | FlagsOther)
|
||||
IDPackageID = ID(0x75<<KeyShift | FlagsOther)
|
||||
IDConst = ID(0x76<<KeyShift | FlagsOther)
|
||||
IDTry = ID(0x77<<KeyShift | FlagsOther)
|
||||
IDIterate = ID(0x78<<KeyShift | FlagsOther)
|
||||
|
||||
IDFalse = ID(0x80<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
|
||||
IDTrue = ID(0x81<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
|
||||
@@ -629,7 +627,6 @@ var builtInsByKey = [nBuiltInKeys]struct {
|
||||
KeyPri: {"pri", IDPri},
|
||||
KeyError: {"error", IDError},
|
||||
KeySuspension: {"suspension", IDSuspension},
|
||||
KeyLimit: {"limit", IDLimit},
|
||||
KeyPackageID: {"packageid", IDPackageID},
|
||||
KeyConst: {"const", IDConst},
|
||||
KeyTry: {"try", IDTry},
|
||||
|
||||
Reference in new issue
Block a user