mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Add peek_uxx methods
This commit is contained in:
1 parent
3896c1940f
commit
bb4477d91f
6 files changed
+187
-44
No files matched your search
@@ -131,6 +131,19 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args []
|
||||
".len = (size_t)(ioptr_src - %ssrc.private_impl.bounds[0]), })",
|
||||
aPrefix, aPrefix)
|
||||
return nil
|
||||
|
||||
case t.IDPeekU8:
|
||||
b.writes("(*ioptr_src)")
|
||||
return nil
|
||||
}
|
||||
|
||||
if method >= t.IDPeekU8 {
|
||||
if m := method - t.IDPeekU8; m < t.ID(len(peekMethods)) {
|
||||
if p := peekMethods[m]; p.n != 0 {
|
||||
b.printf("wuffs_base__load_u%d%ce(ioptr_src)", p.n, p.endianness)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return g.writeBuiltinIO(b, recv, method, args, rp, depth)
|
||||
@@ -473,3 +486,24 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
|
||||
}
|
||||
return errNoSuchBuiltin
|
||||
}
|
||||
|
||||
var peekMethods = [...]struct {
|
||||
n uint8
|
||||
endianness uint8
|
||||
}{
|
||||
// t.IDPeekU8 is a special case, neither big nor little endian.
|
||||
t.IDPeekU16BE - t.IDPeekU8: {16, 'b'},
|
||||
t.IDPeekU16LE - t.IDPeekU8: {16, 'l'},
|
||||
t.IDPeekU24BE - t.IDPeekU8: {24, 'b'},
|
||||
t.IDPeekU24LE - t.IDPeekU8: {24, 'l'},
|
||||
t.IDPeekU32BE - t.IDPeekU8: {32, 'b'},
|
||||
t.IDPeekU32LE - t.IDPeekU8: {32, 'l'},
|
||||
t.IDPeekU40BE - t.IDPeekU8: {40, 'b'},
|
||||
t.IDPeekU40LE - t.IDPeekU8: {40, 'l'},
|
||||
t.IDPeekU48BE - t.IDPeekU8: {48, 'b'},
|
||||
t.IDPeekU48LE - t.IDPeekU8: {48, 'l'},
|
||||
t.IDPeekU56BE - t.IDPeekU8: {56, 'b'},
|
||||
t.IDPeekU56LE - t.IDPeekU8: {56, 'l'},
|
||||
t.IDPeekU64BE - t.IDPeekU8: {64, 'b'},
|
||||
t.IDPeekU64LE - t.IDPeekU8: {64, 'l'},
|
||||
}
|
||||
@@ -21,6 +21,7 @@
|
||||
- Redesigned iterate blocks.
|
||||
- Added a `base.image_config` type.
|
||||
- Added a `reset` method.
|
||||
- Added `peek_uxx` methods.
|
||||
- Tweaked how marks and limits work.
|
||||
- Supported animated (not just single frame) GIFs.
|
||||
- Marked the `std/gif` LZW decoder as private.
|
||||
|
||||
@@ -157,6 +157,24 @@ var Funcs = []string{
|
||||
"io_reader.read_u64be?()(ret u64)",
|
||||
"io_reader.read_u64le?()(ret u64)",
|
||||
|
||||
// TODO: these methods should have an explicit precondition on "available()
|
||||
// >= N". For now, that's implicitly checked (i.e. hard coded).
|
||||
"io_reader.peek_u8()(ret u8)",
|
||||
"io_reader.peek_u16be()(ret u16)",
|
||||
"io_reader.peek_u16le()(ret u16)",
|
||||
"io_reader.peek_u24be()(ret u32[..0xFFFFFF])",
|
||||
"io_reader.peek_u24le()(ret u32[..0xFFFFFF])",
|
||||
"io_reader.peek_u32be()(ret u32)",
|
||||
"io_reader.peek_u32le()(ret u32)",
|
||||
"io_reader.peek_u40be()(ret u64[..0xFFFFFFFFFF])",
|
||||
"io_reader.peek_u40le()(ret u64[..0xFFFFFFFFFF])",
|
||||
"io_reader.peek_u48be()(ret u64[..0xFFFFFFFFFFFF])",
|
||||
"io_reader.peek_u48le()(ret u64[..0xFFFFFFFFFFFF])",
|
||||
"io_reader.peek_u56be()(ret u64[..0xFFFFFFFFFFFFFF])",
|
||||
"io_reader.peek_u56le()(ret u64[..0xFFFFFFFFFFFFFF])",
|
||||
"io_reader.peek_u64be()(ret u64)",
|
||||
"io_reader.peek_u64le()(ret u64)",
|
||||
|
||||
"io_reader.available()(ret u64)",
|
||||
"io_reader.set!(s slice u8, closed bool)()",
|
||||
"io_reader.set_limit!(l u64)()",
|
||||
|
||||
+78
-30
@@ -800,36 +800,10 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
if err := q.bcheckExprCall(n, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
// Special case for a numeric type's low_bits, high_bits, etc. methods.
|
||||
// The bound on the output is dependent on bound on the input, similar
|
||||
// to dependent types, and isn't expressible in Wuffs' function syntax
|
||||
// and type system.
|
||||
if recv := lhs.MType().Receiver(); recv != nil && recv.IsNumType() {
|
||||
switch methodName := lhs.Ident(); methodName {
|
||||
case t.IDLowBits, t.IDHighBits:
|
||||
_, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
return zero, bitMask(int(aMax.Int64())), nil
|
||||
case t.IDMin, t.IDMax:
|
||||
// TODO: lhs has already been bcheck'ed. There should be no
|
||||
// need to bcheck lhs.LHS().Expr() twice.
|
||||
lMin, lMax, err := q.bcheckExpr(lhs.LHS().Expr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
aMin, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
if methodName == t.IDMin {
|
||||
return min(lMin, aMin), min(lMax, aMax), nil
|
||||
} else {
|
||||
return max(lMin, aMin), max(lMax, aMax), nil
|
||||
}
|
||||
}
|
||||
if nMin, nMax, err := q.bcheckExprCallSpecialCases(n, depth); err != nil {
|
||||
return nil, nil, err
|
||||
} else if nMin != nil || nMax != nil {
|
||||
return nMin, nMax, nil
|
||||
}
|
||||
|
||||
case t.IDOpenBracket:
|
||||
@@ -956,6 +930,80 @@ func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) {
|
||||
lhs := n.LHS().Expr()
|
||||
recv := lhs.LHS().Expr()
|
||||
method := lhs.Ident()
|
||||
|
||||
if recvTyp := recv.MType(); recvTyp == nil {
|
||||
return nil, nil, nil
|
||||
|
||||
} else if recvTyp.IsNumType() {
|
||||
// For a numeric type's low_bits, etc. methods. The bound on the output
|
||||
// is dependent on bound on the input, similar to dependent types, and
|
||||
// isn't expressible in Wuffs' function syntax and type system.
|
||||
switch method {
|
||||
case t.IDLowBits, t.IDHighBits:
|
||||
_, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
return zero, bitMask(int(aMax.Int64())), nil
|
||||
|
||||
case t.IDMin, t.IDMax:
|
||||
// TODO: lhs has already been bcheck'ed. There should be no
|
||||
// need to bcheck lhs.LHS().Expr() twice.
|
||||
lMin, lMax, err := q.bcheckExpr(lhs.LHS().Expr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
aMin, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
if method == t.IDMin {
|
||||
return min(lMin, aMin), min(lMax, aMax), nil
|
||||
} else {
|
||||
return max(lMin, aMin), max(lMax, aMax), nil
|
||||
}
|
||||
}
|
||||
|
||||
} else if recvTyp.IsIOType() {
|
||||
if method >= t.IDPeekU8 {
|
||||
if m := method - t.IDPeekU8; m < t.ID(len(ioMethodAdvances)) {
|
||||
if advance := ioMethodAdvances[m]; advance != nil {
|
||||
if ok, err := q.optimizeIOMethodAdvance(recv, advance, false); err != nil {
|
||||
return nil, nil, err
|
||||
} else if !ok {
|
||||
return nil, nil, fmt.Errorf("check: could not prove %s precondition: %s.available() >= %v",
|
||||
method.Str(q.tm), recv.Str(q.tm), advance)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil, nil, nil
|
||||
}
|
||||
|
||||
var ioMethodAdvances = [...]*big.Int{
|
||||
t.IDPeekU8 - t.IDPeekU8: one,
|
||||
t.IDPeekU16BE - t.IDPeekU8: two,
|
||||
t.IDPeekU16LE - t.IDPeekU8: two,
|
||||
t.IDPeekU24BE - t.IDPeekU8: three,
|
||||
t.IDPeekU24LE - t.IDPeekU8: three,
|
||||
t.IDPeekU32BE - t.IDPeekU8: four,
|
||||
t.IDPeekU32LE - t.IDPeekU8: four,
|
||||
t.IDPeekU40BE - t.IDPeekU8: five,
|
||||
t.IDPeekU40LE - t.IDPeekU8: five,
|
||||
t.IDPeekU48BE - t.IDPeekU8: six,
|
||||
t.IDPeekU48LE - t.IDPeekU8: six,
|
||||
t.IDPeekU56BE - t.IDPeekU8: seven,
|
||||
t.IDPeekU56LE - t.IDPeekU8: seven,
|
||||
t.IDPeekU64BE - t.IDPeekU8: eight,
|
||||
t.IDPeekU64LE - t.IDPeekU8: eight,
|
||||
}
|
||||
|
||||
// makeSliceLength returns "x.length()".
|
||||
func makeSliceLength(slice *a.Expr) *a.Expr {
|
||||
x := a.NewExpr(0, t.IDDot, 0, t.IDLength, slice.Node(), nil, nil, nil)
|
||||
|
||||
+24
-14
@@ -213,14 +213,21 @@ func (q *checker) optimizeSuspendible(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
if advance := ioMethodAdvance(nMethod); advance != nil {
|
||||
return q.optimizeIOMethodAdvance(n, nReceiver, advance)
|
||||
if ok, err := q.optimizeIOMethodAdvance(nReceiver, advance, true); err != nil {
|
||||
return err
|
||||
} else if ok {
|
||||
n.SetProvenNotToSuspend()
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (q *checker) optimizeIOMethodAdvance(n *a.Expr, receiver *a.Expr, advance *big.Int) error {
|
||||
return q.facts.update(func(x *a.Expr) (*a.Expr, error) {
|
||||
func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, update bool) (retOK bool, retErr error) {
|
||||
retErr = q.facts.update(func(x *a.Expr) (*a.Expr, error) {
|
||||
// TODO: update (discard?) any facts that merely mention
|
||||
// receiver.available(), even if they aren't an exact match.
|
||||
|
||||
op := x.Operator()
|
||||
if op != t.IDXBinaryGreaterEq && op != t.IDXBinaryGreaterThan {
|
||||
return x, nil
|
||||
@@ -247,33 +254,36 @@ func (q *checker) optimizeIOMethodAdvance(n *a.Expr, receiver *a.Expr, advance *
|
||||
|
||||
// Check if the bytes available is >= the bytes needed. If so, update
|
||||
// rcv to be the bytes remaining. If not, discard the fact x.
|
||||
//
|
||||
// TODO: mark the call as proven not to suspend.
|
||||
if op == t.IDXBinaryGreaterThan {
|
||||
op = t.IDXBinaryGreaterEq
|
||||
rcv = big.NewInt(0).Add(rcv, one)
|
||||
}
|
||||
if rcv.Cmp(advance) < 0 {
|
||||
if !update {
|
||||
return x, nil
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
rcv = big.NewInt(0).Sub(rcv, advance)
|
||||
|
||||
// Create a new a.Expr to hold the adjusted RHS constant value rcv.
|
||||
id, err := q.tm.Insert(rcv.String())
|
||||
retOK = true
|
||||
|
||||
if !update {
|
||||
return x, nil
|
||||
}
|
||||
|
||||
// Create a new a.Expr to hold the adjusted RHS constant value, newRCV.
|
||||
newRCV := big.NewInt(0).Sub(rcv, advance)
|
||||
id, err := q.tm.Insert(newRCV.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
o := a.NewExpr(0, 0, 0, id, nil, nil, nil, nil)
|
||||
o.SetConstValue(rcv)
|
||||
o.SetConstValue(newRCV)
|
||||
o.SetMType(typeExprIdeal)
|
||||
|
||||
if !n.CallSuspendible() {
|
||||
return nil, fmt.Errorf("check: internal error: inconsistent suspendible-ness for %q", n.Str(q.tm))
|
||||
}
|
||||
n.SetProvenNotToSuspend()
|
||||
|
||||
return a.NewExpr(x.Node().Raw().Flags(), t.IDXBinaryGreaterEq, 0, 0, x.LHS(), nil, o.Node(), nil), nil
|
||||
})
|
||||
return retOK, retErr
|
||||
}
|
||||
|
||||
func ioMethodAdvance(x t.ID) *big.Int {
|
||||
|
||||
@@ -461,6 +461,22 @@ const (
|
||||
IDReadU64BE = ID(0x14E)
|
||||
IDReadU64LE = ID(0x14F)
|
||||
|
||||
IDPeekU8 = ID(0x151)
|
||||
IDPeekU16BE = ID(0x152)
|
||||
IDPeekU16LE = ID(0x153)
|
||||
IDPeekU24BE = ID(0x154)
|
||||
IDPeekU24LE = ID(0x155)
|
||||
IDPeekU32BE = ID(0x156)
|
||||
IDPeekU32LE = ID(0x157)
|
||||
IDPeekU40BE = ID(0x158)
|
||||
IDPeekU40LE = ID(0x159)
|
||||
IDPeekU48BE = ID(0x15A)
|
||||
IDPeekU48LE = ID(0x15B)
|
||||
IDPeekU56BE = ID(0x15C)
|
||||
IDPeekU56LE = ID(0x15D)
|
||||
IDPeekU64BE = ID(0x15E)
|
||||
IDPeekU64LE = ID(0x15F)
|
||||
|
||||
// TODO: IDUnwriteU8?
|
||||
IDWriteU8 = ID(0x161)
|
||||
IDWriteU16BE = ID(0x162)
|
||||
@@ -703,6 +719,22 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
IDReadU64BE: "read_u64be",
|
||||
IDReadU64LE: "read_u64le",
|
||||
|
||||
IDPeekU8: "peek_u8",
|
||||
IDPeekU16BE: "peek_u16be",
|
||||
IDPeekU16LE: "peek_u16le",
|
||||
IDPeekU24BE: "peek_u24be",
|
||||
IDPeekU24LE: "peek_u24le",
|
||||
IDPeekU32BE: "peek_u32be",
|
||||
IDPeekU32LE: "peek_u32le",
|
||||
IDPeekU40BE: "peek_u40be",
|
||||
IDPeekU40LE: "peek_u40le",
|
||||
IDPeekU48BE: "peek_u48be",
|
||||
IDPeekU48LE: "peek_u48le",
|
||||
IDPeekU56BE: "peek_u56be",
|
||||
IDPeekU56LE: "peek_u56le",
|
||||
IDPeekU64BE: "peek_u64be",
|
||||
IDPeekU64LE: "peek_u64le",
|
||||
|
||||
IDWriteU8: "write_u8",
|
||||
IDWriteU16BE: "write_u16be",
|
||||
IDWriteU16LE: "write_u16le",
|
||||
|
||||
Reference in new issue
Block a user