mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Make Iterate contain Assign's not Var's
This commit is contained in:
1 parent
cd9ab50f63
commit
d552f88738
13 files changed
+91
-91
No files matched your search
@@ -736,7 +736,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, &k, true, true, true); err != nil {
|
||||
if err := g.writeVars(b, &k, true, true); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
@@ -258,7 +258,7 @@ func (g *gen) writeFuncImplPrologue(b *buffer) error {
|
||||
b.writes("\n")
|
||||
|
||||
// Generate the local variables.
|
||||
if err := g.writeVars(b, &g.currFunk, false, true, false); err != nil {
|
||||
if err := g.writeVars(b, &g.currFunk, false, false); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes("\n")
|
||||
|
||||
@@ -380,13 +380,14 @@ func (h *resumabilityHelper) doIf(r resumabilities, n *a.If, depth uint32) error
|
||||
func (h *resumabilityHelper) doIterate(r resumabilities, n *a.Iterate, depth uint32) error {
|
||||
// TODO: ban jumps, rets and coroutine calls inside an iterate. Also ensure
|
||||
// that the iterate variable values are all pure expressions.
|
||||
for _, v := range n.Variables() {
|
||||
v := v.AsVar()
|
||||
if err := h.doExpr(r, v.Value()); err != nil {
|
||||
for _, o := range n.Assigns() {
|
||||
o := o.AsAssign()
|
||||
if err := h.doExpr(r, o.RHS()); err != nil {
|
||||
return err
|
||||
}
|
||||
if i, ok := h.vars[v.Name()]; !ok {
|
||||
return fmt.Errorf("unrecognized variable %q", v.Name().Str(h.tm))
|
||||
name := o.LHS().Ident()
|
||||
if i, ok := h.vars[name]; !ok {
|
||||
return fmt.Errorf("unrecognized variable %q", name.Str(h.tm))
|
||||
} else {
|
||||
r.lowerWeakToNone(i)
|
||||
}
|
||||
|
||||
@@ -339,26 +339,26 @@ func (g *gen) writeStatementIf(b *buffer, n *a.If, depth uint32) error {
|
||||
}
|
||||
|
||||
func (g *gen) writeStatementIterate(b *buffer, n *a.Iterate, depth uint32) error {
|
||||
vars := n.Variables()
|
||||
if len(vars) == 0 {
|
||||
assigns := n.Assigns()
|
||||
if len(assigns) == 0 {
|
||||
return nil
|
||||
}
|
||||
if len(vars) != 1 {
|
||||
return fmt.Errorf("TODO: iterate over more than one variable")
|
||||
if len(assigns) != 1 {
|
||||
return fmt.Errorf("TODO: iterate over more than one assign")
|
||||
}
|
||||
v := vars[0].AsVar()
|
||||
name := v.Name().Str(g.tm)
|
||||
o := assigns[0].AsAssign()
|
||||
name := o.LHS().Ident().Str(g.tm)
|
||||
b.writes("{\n")
|
||||
|
||||
// TODO: don't assume that the slice is a slice of base.u8. In
|
||||
// particular, the code gen can be subtle if the slice element type has
|
||||
// zero size, such as the empty struct.
|
||||
b.printf("wuffs_base__slice_u8 %sslice_%s =", iPrefix, name)
|
||||
if err := g.writeExpr(b, v.Value(), 0); err != nil {
|
||||
if err := g.writeExpr(b, o.RHS(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(";\n")
|
||||
b.printf("wuffs_base__slice_u8 %s%s = %sslice_%s;\n", vPrefix, name, iPrefix, name)
|
||||
b.printf("%s%s = %sslice_%s;\n", vPrefix, name, iPrefix, name)
|
||||
// TODO: look at n.HasContinue() and n.HasBreak().
|
||||
|
||||
round := uint32(0)
|
||||
|
||||
@@ -344,15 +344,12 @@ func (g *gen) writeResumeSuspend(b *buffer, f *funk, suspend bool, initBoolTyped
|
||||
return nil
|
||||
}
|
||||
|
||||
func (g *gen) writeVars(b *buffer, f *funk, skipPointerTypes bool, skipIterateVariables bool, skipNonresumable bool) error {
|
||||
func (g *gen) writeVars(b *buffer, f *funk, skipPointerTypes bool, skipNonresumable bool) error {
|
||||
for _, n := range f.varList {
|
||||
typ := n.XType()
|
||||
if skipPointerTypes && typ.HasPointers() {
|
||||
continue
|
||||
}
|
||||
if skipIterateVariables && n.IterateVariable() {
|
||||
continue
|
||||
}
|
||||
if skipNonresumable && (f.varResumables == nil || !f.varResumables[n.Name()]) {
|
||||
continue
|
||||
}
|
||||
|
||||
+12
-14
@@ -434,20 +434,18 @@ func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign {
|
||||
}
|
||||
}
|
||||
|
||||
// Var is "var ID2 LHS" or "var ID2 LHS = RHS" or "var ID2 LHS =? etc!?(etc)"
|
||||
// or an iterate variable declaration "ID1 LHS =: RHS":
|
||||
// - ID0: <0|IDEq|IDEqColon|IDEqQuestion>
|
||||
// Var is "var ID2 LHS" or "var ID2 LHS = RHS" or "var ID2 LHS =? etc!?(etc)":
|
||||
// - ID0: <0|IDEq|IDEqQuestion>
|
||||
// - ID2: name
|
||||
// - LHS: <TypeExpr>
|
||||
// - RHS: <nil|Expr>
|
||||
type Var Node
|
||||
|
||||
func (n *Var) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Var) Operator() t.ID { return n.id0 }
|
||||
func (n *Var) IterateVariable() bool { return n.id0 == t.IDEqColon }
|
||||
func (n *Var) Name() t.ID { return n.id2 }
|
||||
func (n *Var) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
func (n *Var) Value() *Expr { return n.rhs.AsExpr() }
|
||||
func (n *Var) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Var) Operator() t.ID { return n.id0 }
|
||||
func (n *Var) Name() t.ID { return n.id2 }
|
||||
func (n *Var) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
func (n *Var) Value() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewVar(op t.ID, name t.ID, xType *TypeExpr, value *Expr) *Var {
|
||||
return &Var{
|
||||
@@ -501,14 +499,14 @@ func NewIOBind(keyword t.ID, io *Expr, arg1 *Expr, body []*Node) *IOBind {
|
||||
}
|
||||
|
||||
// Iterate is
|
||||
// "iterate:ID1 (vars)(length:ID2, unroll:ID0), List1 { List2 } else RHS":
|
||||
// "iterate:ID1 (assigns)(length:ID2, unroll:ID0), List1 { List2 } else RHS":
|
||||
// - FlagsHasBreak is the iterate has an explicit break
|
||||
// - FlagsHasContinue is the iterate has an explicit continue
|
||||
// - ID0: unroll
|
||||
// - ID1: <0|label>
|
||||
// - ID2: length
|
||||
// - RHS: <nil|Iterate>
|
||||
// - List0: <Var> vars
|
||||
// - List0: <Assign> assigns
|
||||
// - List1: <Assert> asserts
|
||||
// - List2: <Statement> body
|
||||
type Iterate Node
|
||||
@@ -520,21 +518,21 @@ func (n *Iterate) Unroll() t.ID { return n.id0 }
|
||||
func (n *Iterate) Label() t.ID { return n.id1 }
|
||||
func (n *Iterate) Length() t.ID { return n.id2 }
|
||||
func (n *Iterate) ElseIterate() *Iterate { return n.rhs.AsIterate() }
|
||||
func (n *Iterate) Variables() []*Node { return n.list0 }
|
||||
func (n *Iterate) Assigns() []*Node { return n.list0 }
|
||||
func (n *Iterate) Asserts() []*Node { return n.list1 }
|
||||
func (n *Iterate) Body() []*Node { return n.list2 }
|
||||
|
||||
func (n *Iterate) SetHasBreak() { n.flags |= FlagsHasBreak }
|
||||
func (n *Iterate) SetHasContinue() { n.flags |= FlagsHasContinue }
|
||||
|
||||
func NewIterate(label t.ID, vars []*Node, length t.ID, unroll t.ID, asserts []*Node, body []*Node, elseIterate *Iterate) *Iterate {
|
||||
func NewIterate(label t.ID, assigns []*Node, length t.ID, unroll t.ID, asserts []*Node, body []*Node, elseIterate *Iterate) *Iterate {
|
||||
return &Iterate{
|
||||
kind: KIterate,
|
||||
id0: unroll,
|
||||
id1: label,
|
||||
id2: length,
|
||||
rhs: elseIterate.AsNode(),
|
||||
list0: vars,
|
||||
list0: assigns,
|
||||
list1: asserts,
|
||||
list2: body,
|
||||
}
|
||||
|
||||
@@ -256,8 +256,9 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
|
||||
case a.KIterate:
|
||||
n := n.AsIterate()
|
||||
for _, o := range n.Variables() {
|
||||
if err := q.bcheckVar(o.AsVar()); err != nil {
|
||||
for _, o := range n.Assigns() {
|
||||
o := o.AsAssign()
|
||||
if err := q.bcheckAssignment(o.LHS(), o.Operator(), o.RHS()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -265,12 +266,12 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
// execute-exactly-once block. We should have pre / inv / post
|
||||
// conditions, a la bcheckWhile.
|
||||
|
||||
variables := n.Variables()
|
||||
assigns := n.Assigns()
|
||||
for ; n != nil; n = n.ElseIterate() {
|
||||
q.facts = q.facts[:0]
|
||||
for _, o := range variables {
|
||||
v := o.AsVar()
|
||||
q.facts = append(q.facts, makeSliceLengthEqEq(v.Name(), v.XType(), n.Length()))
|
||||
for _, o := range assigns {
|
||||
lhs := o.AsAssign().LHS()
|
||||
q.facts = append(q.facts, makeSliceLengthEqEq(lhs.Ident(), lhs.MType(), n.Length()))
|
||||
}
|
||||
if err := q.bcheckBlock(n.Body()); err != nil {
|
||||
return err
|
||||
|
||||
+7
-15
@@ -44,9 +44,6 @@ func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
|
||||
case a.KIterate:
|
||||
for o := o.AsIterate(); o != nil; o = o.ElseIterate() {
|
||||
if err := q.tcheckVars(o.Variables()); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := q.tcheckVars(o.Body()); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -150,10 +147,15 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
|
||||
case a.KIterate:
|
||||
for n := n.AsIterate(); n != nil; n = n.ElseIterate() {
|
||||
for _, o := range n.Variables() {
|
||||
for _, o := range n.Assigns() {
|
||||
if err := q.tcheckStatement(o); err != nil {
|
||||
return err
|
||||
}
|
||||
o := o.AsAssign()
|
||||
if typ := o.LHS().MType(); !typ.IsSliceType() {
|
||||
return fmt.Errorf("check: iterate assignment to %q, of type %q, does not have slice type",
|
||||
o.LHS().Str(q.tm), typ.Str(q.tm))
|
||||
}
|
||||
}
|
||||
// TODO: prohibit jumps (breaks, continues), rets (returns, yields) and
|
||||
// retry-calling ? methods while inside an iterate body.
|
||||
@@ -223,17 +225,7 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
lTyp := n.XType()
|
||||
rTyp := value.MType()
|
||||
if n.IterateVariable() {
|
||||
if !lTyp.IsSliceType() {
|
||||
return fmt.Errorf("check: iterate variable %q, of type %q, does not have a slice type",
|
||||
n.Name().Str(q.tm), lTyp.Str(q.tm))
|
||||
}
|
||||
if !lTyp.Eq(rTyp) {
|
||||
return fmt.Errorf("check: cannot iterate %q of type %q over %q of type %q "+
|
||||
"as their types don't match",
|
||||
n.Name().Str(q.tm), lTyp.Str(q.tm), value.Str(q.tm), rTyp.Str(q.tm))
|
||||
}
|
||||
} else if err := q.tcheckEq(n.Name(), nil, lTyp, value, rTyp); err != nil {
|
||||
if err := q.tcheckEq(n.Name(), nil, lTyp, value, rTyp); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
|
||||
+37
-29
@@ -558,7 +558,7 @@ func (p *parser) parseStatement() (*a.Node, error) {
|
||||
if n != nil {
|
||||
n.AsRaw().SetFilenameLine(p.filename, line)
|
||||
if n.Kind() == a.KIterate {
|
||||
for _, o := range n.AsIterate().Variables() {
|
||||
for _, o := range n.AsIterate().Assigns() {
|
||||
o.AsRaw().SetFilenameLine(p.filename, line)
|
||||
}
|
||||
}
|
||||
@@ -610,7 +610,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
|
||||
case t.IDVar:
|
||||
p.src = p.src[1:]
|
||||
return p.parseVarNode(false)
|
||||
return p.parseVarNode()
|
||||
|
||||
case t.IDWhile:
|
||||
p.src = p.src[1:]
|
||||
@@ -636,7 +636,10 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
}
|
||||
return a.NewWhile(label, condition, asserts, body).AsNode(), nil
|
||||
}
|
||||
return p.parseAssignNode()
|
||||
}
|
||||
|
||||
func (p *parser) parseAssignNode() (*a.Node, error) {
|
||||
lhs := (*a.Expr)(nil)
|
||||
rhs, err := p.parseExpr()
|
||||
if err != nil {
|
||||
@@ -651,6 +654,10 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
return nil, fmt.Errorf(`parse: assignment LHS %q is not effect-free at %s:%d`,
|
||||
lhs.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
if lhs.Operator() == 0 && lhs.Ident().IsLiteral(p.tm) {
|
||||
return nil, fmt.Errorf(`parse: assignment LHS %q is a literal at %s:%d`,
|
||||
lhs.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
rhs, err = p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -668,6 +675,24 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
return a.NewAssign(op, lhs, rhs).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIterateAssignNode() (*a.Node, error) {
|
||||
n, err := p.parseAssignNode()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
o := n.AsAssign()
|
||||
if op := o.Operator(); op != t.IDEq {
|
||||
return nil, fmt.Errorf(`parse: expected "=", got %q at %s:%d`, op.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
if lhs := o.LHS(); lhs.Operator() != 0 {
|
||||
return nil, fmt.Errorf(`parse: expected variable, got %q at %s:%d`, lhs.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
if rhs := o.RHS(); rhs.Effect() != 0 {
|
||||
return nil, fmt.Errorf(`parse: value %q is not effect-free at %s:%d`, rhs.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
return o.AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseAsserts() ([]*a.Node, error) {
|
||||
asserts := []*a.Node(nil)
|
||||
if p.peek1() == t.IDComma {
|
||||
@@ -805,18 +830,18 @@ func (p *parser) parseIterateNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
vars, err := p.parseList(t.IDCloseParen, (*parser).parseIterateVarNode)
|
||||
assigns, err := p.parseList(t.IDCloseParen, (*parser).parseIterateAssignNode)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
n, err := p.parseIterateBlock(label, vars)
|
||||
n, err := p.parseIterateBlock(label, assigns)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return n.AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIterateBlock(label t.ID, vars []*a.Node) (*a.Iterate, error) {
|
||||
func (p *parser) parseIterateBlock(label t.ID, assigns []*a.Node) (*a.Iterate, error) {
|
||||
if x := p.peek1(); x != t.IDOpenParen {
|
||||
got := p.tm.ByID(x)
|
||||
return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`, got, p.filename, p.line())
|
||||
@@ -891,7 +916,7 @@ func (p *parser) parseIterateBlock(label t.ID, vars []*a.Node) (*a.Iterate, erro
|
||||
}
|
||||
}
|
||||
|
||||
return a.NewIterate(label, vars, length, unroll, asserts, body, elseIterate), nil
|
||||
return a.NewIterate(label, assigns, length, unroll, asserts, body, elseIterate), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseArgNode() (*a.Node, error) {
|
||||
@@ -931,11 +956,7 @@ func (p *parser) parseIOBindExprNode() (*a.Node, error) {
|
||||
return nil, fmt.Errorf(`parse: expected "args.something", got %q at %s:%d`, e.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
|
||||
func (p *parser) parseIterateVarNode() (*a.Node, error) {
|
||||
return p.parseVarNode(true)
|
||||
}
|
||||
|
||||
func (p *parser) parseVarNode(inIterate bool) (*a.Node, error) {
|
||||
func (p *parser) parseVarNode() (*a.Node, error) {
|
||||
id, err := p.parseIdent()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -947,23 +968,7 @@ func (p *parser) parseVarNode(inIterate bool) (*a.Node, error) {
|
||||
value := (*a.Expr)(nil)
|
||||
|
||||
op := t.ID(0)
|
||||
if inIterate {
|
||||
op = t.IDEqColon
|
||||
if x := p.peek1(); x != t.IDEqColon {
|
||||
got := p.tm.ByID(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
|
||||
}
|
||||
if value.Effect() != 0 {
|
||||
return nil, fmt.Errorf(`parse: iterate value %q is not effect-free at %s:%d`,
|
||||
value.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
|
||||
} else if eqOp := p.peek1(); eqOp == t.IDEq || eqOp == t.IDEqQuestion {
|
||||
if eqOp := p.peek1(); eqOp == t.IDEq || eqOp == t.IDEqQuestion {
|
||||
op = eqOp
|
||||
p.src = p.src[1:]
|
||||
value, err = p.parseExpr()
|
||||
@@ -1133,7 +1138,10 @@ func (p *parser) parseOperand() (*a.Expr, error) {
|
||||
case t.IDDot:
|
||||
p.src = p.src[1:]
|
||||
|
||||
if x := p.peek1(); x.IsStrLiteral(p.tm) {
|
||||
if x := p.peek1(); x.IsLiteral(p.tm) {
|
||||
if x.IsNumLiteral(p.tm) {
|
||||
return nil, fmt.Errorf(`parse: dot followed by numeric literal at %s:%d`, p.filename, p.line())
|
||||
}
|
||||
if !first {
|
||||
return nil, fmt.Errorf(`parse: string literal %s has too many package qualifiers at %s:%d`,
|
||||
x.Str(p.tm), p.filename, p.line())
|
||||
|
||||
+1
-4
@@ -240,8 +240,7 @@ const (
|
||||
IDTildeSatMinusEq = ID(0x1E)
|
||||
|
||||
IDEq = ID(0x20)
|
||||
IDEqColon = ID(0x21)
|
||||
IDEqQuestion = ID(0x22)
|
||||
IDEqQuestion = ID(0x21)
|
||||
)
|
||||
|
||||
const (
|
||||
@@ -630,7 +629,6 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
IDTildeSatMinusEq: "~sat-=",
|
||||
|
||||
IDEq: "=",
|
||||
IDEqColon: "=:",
|
||||
IDEqQuestion: "=?",
|
||||
|
||||
IDPlus: "+",
|
||||
@@ -1001,7 +999,6 @@ var lexers = [256][]suffixLexer{
|
||||
},
|
||||
'=': {
|
||||
{"=", IDEqEq},
|
||||
{":", IDEqColon},
|
||||
{"?", IDEqQuestion},
|
||||
{"", IDEq},
|
||||
},
|
||||
|
||||
@@ -4209,10 +4209,12 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self,
|
||||
uint32_t v_s1;
|
||||
uint32_t v_s2;
|
||||
wuffs_base__slice_u8 v_remaining;
|
||||
wuffs_base__slice_u8 v_p;
|
||||
|
||||
v_s1 = 0;
|
||||
v_s2 = 0;
|
||||
v_remaining = ((wuffs_base__slice_u8){});
|
||||
v_p = ((wuffs_base__slice_u8){});
|
||||
if (!self->private_impl.f_started) {
|
||||
self->private_impl.f_started = true;
|
||||
self->private_impl.f_state = 1;
|
||||
@@ -4227,7 +4229,7 @@ wuffs_adler32__hasher__update(wuffs_adler32__hasher* self,
|
||||
}
|
||||
{
|
||||
wuffs_base__slice_u8 i_slice_p = a_x;
|
||||
wuffs_base__slice_u8 v_p = i_slice_p;
|
||||
v_p = i_slice_p;
|
||||
v_p.len = 1;
|
||||
uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 8) * 8;
|
||||
while (v_p.ptr < i_end0_p) {
|
||||
@@ -5051,12 +5053,14 @@ wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self,
|
||||
}
|
||||
|
||||
uint32_t v_s;
|
||||
wuffs_base__slice_u8 v_p;
|
||||
|
||||
v_s = 0;
|
||||
v_p = ((wuffs_base__slice_u8){});
|
||||
v_s = (4294967295 ^ self->private_impl.f_state);
|
||||
{
|
||||
wuffs_base__slice_u8 i_slice_p = a_x;
|
||||
wuffs_base__slice_u8 v_p = i_slice_p;
|
||||
v_p = i_slice_p;
|
||||
v_p.len = 16;
|
||||
uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 32) * 32;
|
||||
while (v_p.ptr < i_end0_p) {
|
||||
|
||||
@@ -25,6 +25,7 @@ pub func hasher.update!(x slice base.u8) base.u32 {
|
||||
var s1 base.u32
|
||||
var s2 base.u32
|
||||
var remaining slice base.u8
|
||||
var p slice base.u8
|
||||
|
||||
if not this.started {
|
||||
this.started = true
|
||||
@@ -41,7 +42,7 @@ pub func hasher.update!(x slice base.u8) base.u32 {
|
||||
args.x = args.x[:5552]
|
||||
}
|
||||
|
||||
iterate (p slice base.u8 =: args.x)(length:1, unroll:8) {
|
||||
iterate (p = args.x)(length:1, unroll:8) {
|
||||
s1 ~mod+= p[0] as base.u32
|
||||
s2 ~mod+= s1
|
||||
}
|
||||
|
||||
@@ -22,12 +22,13 @@ pub struct ieee_hasher?(
|
||||
// C code, be "struct{ uint32_t checksum; wuffs_crc32__status status }"?
|
||||
pub func ieee_hasher.update!(x slice base.u8) base.u32 {
|
||||
var s base.u32
|
||||
var p slice base.u8
|
||||
|
||||
s = 0xFFFFFFFF ^ this.state
|
||||
|
||||
// See "Multi-Byte Lookup Tables" in std/crc32/README.md for more detail on
|
||||
// the slicing-by-M algorithm. We use an M of 16.
|
||||
iterate (p slice base.u8 =: args.x)(length:16, unroll:2) {
|
||||
iterate (p = args.x)(length:16, unroll:2) {
|
||||
s ^= ((p[0x00] as base.u32) << 0) |
|
||||
((p[0x01] as base.u32) << 8) |
|
||||
((p[0x02] as base.u32) << 16) |
|
||||
|
||||
Reference in new issue
Block a user