diff --git a/cmd/wuffs-c/internal/cgen/base-header.h b/cmd/wuffs-c/internal/cgen/base-header.h index 580c5ee2..4924cc80 100644 --- a/cmd/wuffs-c/internal/cgen/base-header.h +++ b/cmd/wuffs-c/internal/cgen/base-header.h @@ -561,26 +561,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -590,7 +584,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -599,7 +593,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index edf0b6af..f27240e7 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -50,8 +50,7 @@ const baseHeader = "" + "in_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);\n r.max_exclusive_x =\n wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);\n r.max_exclusive_y =\n wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__width(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_x, r.min_inclusive_x);\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__height(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);\n}\n\n" + "" + "// ---------------- I/O\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limit* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef" + - " struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n\nstatic inline wuffs_base__io_reader wuffs_base__io_buffer__reader(\n" + - " wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n if (buf) {\n ret.buf = buf;\n }\n return ret;\n}\n\nstatic inline wuffs_base__io_writer wuffs_base__io_buffer__writer(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n if (buf) {\n ret.buf = buf;\n }\n return ret;\n}\n\n" + + " struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_buffer* buf;\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_buffer* buf;\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n\nstatic inline wuffs_base__io_reader wuffs_base__io_buffer__reader(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n if (buf) {\n ret.private_impl.buf = buf;\n }\n return ret;\n}\n\nstatic inline wuffs_base__io_writer wuffs_base__io_buffer__writer(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n if (buf) {\n ret.private_impl.buf = buf;\n }\n return ret;\n}\n\n" + "" + "// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The bit fields of a wuffs_base" + "__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index). The distance\n// between s" + @@ -101,7 +100,7 @@ type template_args_short_read struct { } func template_short_read(b *buffer, args template_args_short_read) error { - b.printf("short_read_%s:\nif (a_%s.buf && a_%s.buf->closed &&\n!a_%s.private_impl.limit.ptr_to_len) {\nstatus = %sERROR_UNEXPECTED_EOF;\ngoto exit;\n}\nstatus = %sSUSPENSION_SHORT_READ;\ngoto suspend;\n", + b.printf("short_read_%s:\nif (a_%s.private_impl.buf && a_%s.private_impl.buf->closed &&\n!a_%s.private_impl.limit.ptr_to_len) {\nstatus = %sERROR_UNEXPECTED_EOF;\ngoto exit;\n}\nstatus = %sSUSPENSION_SHORT_READ;\ngoto suspend;\n", args.name, args.name, args.name, diff --git a/cmd/wuffs-c/internal/cgen/templates.h b/cmd/wuffs-c/internal/cgen/templates.h index af6badb8..1330206d 100644 --- a/cmd/wuffs-c/internal/cgen/templates.h +++ b/cmd/wuffs-c/internal/cgen/templates.h @@ -23,7 +23,7 @@ template short_read(string qPKGPREFIXq, string qnameq) { short_read_qnameq: - if (a_qnameq.buf && a_qnameq.buf->closed && + if (a_qnameq.private_impl.buf && a_qnameq.private_impl.buf->closed && !a_qnameq.private_impl.limit.ptr_to_len) { status = qPKGPREFIXqERROR_UNEXPECTED_EOF; goto exit; diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index e885d587..1bd57e2e 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -100,15 +100,16 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header b.printf("uint8_t* %srstart_%s = NULL;", bPrefix, nameStr) b.printf("uint8_t* %srend_%s = NULL;", bPrefix, nameStr) } - b.printf("if (%s%s.buf) {", aPrefix, nameStr) + b.printf("if (%s%s.private_impl.buf) {", aPrefix, nameStr) - b.printf("%srptr_%s = %s%s.buf->ptr + %s%s.buf->ri;", + b.printf("%srptr_%s = %s%s.private_impl.buf->ptr + %s%s.private_impl.buf->ri;", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) if header { b.printf("%srstart_%s = %srptr_%s;", bPrefix, nameStr, bPrefix, nameStr) - b.printf("uint64_t len = %s%s.buf->wi - %s%s.buf->ri;", aPrefix, nameStr, aPrefix, nameStr) + b.printf("uint64_t len = %s%s.private_impl.buf->wi - %s%s.private_impl.buf->ri;", + aPrefix, nameStr, aPrefix, nameStr) b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) @@ -128,17 +129,18 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header b.printf("uint8_t* %swstart_%s = NULL;", bPrefix, nameStr) b.printf("uint8_t* %swend_%s = NULL;", bPrefix, nameStr) } - b.printf("if (%s%s.buf) {", aPrefix, nameStr) + b.printf("if (%s%s.private_impl.buf) {", aPrefix, nameStr) - b.printf("%swptr_%s = %s%s.buf->ptr + %s%s.buf->wi;", + b.printf("%swptr_%s = %s%s.private_impl.buf->ptr + %s%s.private_impl.buf->wi;", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) if header { b.printf("%swstart_%s = %swptr_%s;", bPrefix, nameStr, bPrefix, nameStr) b.printf("%swend_%s = %swptr_%s;", bPrefix, nameStr, bPrefix, nameStr) - b.printf("if (!%s%s.buf->closed) {", aPrefix, nameStr) - b.printf("uint64_t len = %s%s.buf->len - %s%s.buf->wi;", aPrefix, nameStr, aPrefix, nameStr) + b.printf("if (!%s%s.private_impl.buf->closed) {", aPrefix, nameStr) + b.printf("uint64_t len = %s%s.private_impl.buf->len - %s%s.private_impl.buf->wi;", + aPrefix, nameStr, aPrefix, nameStr) b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) @@ -172,11 +174,11 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer nameStr := name.Str(g.tm) switch typ.QID() { case t.QID{t.IDBase, t.IDIOReader}: - b.printf("if (%s%s.buf) {", aPrefix, nameStr) + b.printf("if (%s%s.private_impl.buf) {", aPrefix, nameStr) - b.printf("size_t n = %srptr_%s - (%s%s.buf->ptr + %s%s.buf->ri);", + b.printf("size_t n = %srptr_%s - (%s%s.private_impl.buf->ptr + %s%s.private_impl.buf->ri);", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) - b.printf("%s%s.buf->ri += n;", aPrefix, nameStr) + b.printf("%s%s.private_impl.buf->ri += n;", aPrefix, nameStr) b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) @@ -193,11 +195,11 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer b.printf("}\n") case t.QID{t.IDBase, t.IDIOWriter}: - b.printf("if (%s%s.buf) {", aPrefix, nameStr) + b.printf("if (%s%s.private_impl.buf) {", aPrefix, nameStr) - b.printf("size_t n = %swptr_%s - (%s%s.buf->ptr + %s%s.buf->wi);", + b.printf("size_t n = %swptr_%s - (%s%s.private_impl.buf->ptr + %s%s.private_impl.buf->wi);", bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr) - b.printf("%s%s.buf->wi += n;", aPrefix, nameStr) + b.printf("%s%s.private_impl.buf->wi += n;", aPrefix, nameStr) b.printf("wuffs_base__io_limit* lim;\n") b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr) diff --git a/gen/c/std/adler32.c b/gen/c/std/adler32.c index c2ff14f5..2e471560 100644 --- a/gen/c/std/adler32.c +++ b/gen/c/std/adler32.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/c/std/crc32.c b/gen/c/std/crc32.c index 9acad614..30fc91b1 100644 --- a/gen/c/std/crc32.c +++ b/gen/c/std/crc32.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/c/std/deflate.c b/gen/c/std/deflate.c index 83f81f13..d4c812ef 100644 --- a/gen/c/std/deflate.c +++ b/gen/c/std/deflate.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -1764,12 +1758,12 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1795,9 +1789,10 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = b_wptr_dst - + (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1807,8 +1802,8 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( } wuffs_deflate__status t_0 = wuffs_deflate__decoder__decode_blocks(self, a_dst, a_src); - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; } v_z = t_0; } @@ -1878,9 +1873,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1907,10 +1903,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1951,9 +1947,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( self->private_impl.f_n_bits -= 3; if (v_type == 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1963,8 +1960,8 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } status = wuffs_deflate__decoder__decode_uncompressed(self, a_dst, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -1978,9 +1975,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } } else if (v_type == 2) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1989,8 +1987,8 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } } status = wuffs_deflate__decoder__init_dynamic_huffman(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2001,9 +1999,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } self->private_impl.f_end_of_block = false; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2012,8 +2011,8 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } } status = wuffs_deflate__decoder__decode_huffman_fast(self, a_dst, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2022,9 +2021,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( goto label_0_continue; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2033,8 +2033,8 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks( } } status = wuffs_deflate__decoder__decode_huffman_slow(self, a_dst, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2061,9 +2061,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2077,7 +2078,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2097,12 +2099,12 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2115,10 +2117,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2213,9 +2215,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2225,9 +2228,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2241,7 +2245,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2333,10 +2338,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2555,9 +2560,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2571,7 +2577,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2883,12 +2890,12 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2901,10 +2908,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -3212,9 +3219,10 @@ label_0_break:; } goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3224,9 +3232,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3263,12 +3272,12 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -3281,10 +3290,10 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -3648,9 +3657,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3660,9 +3670,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3676,7 +3687,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_DEFLATE__ERROR_UNEXPECTED_EOF; goto exit; } diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 6b4936c8..81f08955 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -1762,10 +1756,10 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1788,9 +1782,10 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( goto exit; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1799,16 +1794,17 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( } } status = wuffs_gif__decoder__decode_header(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1817,8 +1813,8 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( } } status = wuffs_gif__decoder__decode_lsd(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -1838,9 +1834,10 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( goto label_0_break; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1849,8 +1846,8 @@ wuffs_gif__status wuffs_gif__decoder__decode_config( } } status = wuffs_gif__decoder__decode_extension(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -1874,9 +1871,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1891,7 +1889,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -1917,10 +1916,10 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1957,9 +1956,10 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame( } if (self->private_impl.f_block_type == 33) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1968,17 +1968,18 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame( } } status = wuffs_gif__decoder__decode_extension(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; } } else if (self->private_impl.f_block_type == 44) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -1987,8 +1988,8 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame( } } status = wuffs_gif__decoder__decode_id(self, a_dst, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2020,9 +2021,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2037,7 +2039,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2056,10 +2059,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_header( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2112,9 +2115,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2128,7 +2132,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2148,10 +2153,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_lsd( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2237,9 +2242,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2253,7 +2259,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2271,10 +2278,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2304,9 +2311,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( if (v_label == 249) { } else if (v_label == 255) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2315,8 +2323,8 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( } } status = wuffs_gif__decoder__decode_ae(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2325,9 +2333,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( goto ok; } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2336,8 +2345,8 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension( } } status = wuffs_gif__decoder__skip_blocks(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2356,9 +2365,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2372,7 +2382,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2390,10 +2401,10 @@ static wuffs_gif__status wuffs_gif__decoder__skip_blocks( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2450,9 +2461,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2466,7 +2478,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2487,10 +2500,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2641,9 +2654,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae( } label_0_break:; WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2652,8 +2666,8 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae( } } status = wuffs_gif__decoder__skip_blocks(self, a_src); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } if (status) { goto suspend; @@ -2675,9 +2689,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2691,7 +2706,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -2716,10 +2732,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2927,9 +2943,10 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( wuffs_base__io_reader__mark(&v_r, b_rptr_src); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - (a_src.private_impl.buf->ptr + + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2941,8 +2958,9 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id( wuffs_gif__status t_14 = wuffs_gif__lzw_decoder__decode( &self->private_impl.f_lzw, a_dst, wuffs_base__io_reader__limit(&v_r, &l_rlimit0)); - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = + a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } v_z = t_14; } @@ -2997,9 +3015,10 @@ suspend: goto exit; exit: - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3013,7 +3032,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } @@ -3049,12 +3069,12 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode( uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -3067,10 +3087,10 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode( uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -3218,9 +3238,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3230,9 +3251,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -3246,7 +3268,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GIF__ERROR_UNEXPECTED_EOF; goto exit; } diff --git a/gen/c/std/gzip.c b/gen/c/std/gzip.c index f616b4fe..112023ff 100644 --- a/gen/c/std/gzip.c +++ b/gen/c/std/gzip.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -1907,12 +1901,12 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1925,10 +1919,10 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -2091,9 +2085,10 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = b_wptr_dst - + (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2101,9 +2096,10 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, } } } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2113,11 +2109,11 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, } wuffs_gzip__status t_8 = wuffs_deflate__decoder__decode( &self->private_impl.f_flate, a_dst, a_src); - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; } - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } v_z = t_8; } @@ -2231,9 +2227,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2243,9 +2240,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2260,7 +2258,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_GZIP__ERROR_UNEXPECTED_EOF; goto exit; } diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 24f8517a..4137cd2f 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -1903,12 +1897,12 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, uint8_t* b_wptr_dst = NULL; uint8_t* b_wstart_dst = NULL; uint8_t* b_wend_dst = NULL; - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; b_wstart_dst = b_wptr_dst; b_wend_dst = b_wptr_dst; - if (!a_dst.buf->closed) { - uint64_t len = a_dst.buf->len - a_dst.buf->wi; + if (!a_dst.private_impl.buf->closed) { + uint64_t len = a_dst.private_impl.buf->len - a_dst.private_impl.buf->wi; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1921,10 +1915,10 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, uint8_t* b_rptr_src = NULL; uint8_t* b_rstart_src = NULL; uint8_t* b_rend_src = NULL; - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; b_rstart_src = b_rptr_src; - uint64_t len = a_src.buf->wi - a_src.buf->ri; + uint64_t len = a_src.private_impl.buf->wi - a_src.private_impl.buf->ri; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { @@ -1994,9 +1988,10 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, wuffs_base__io_writer__mark(&a_dst, b_wptr_dst); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = b_wptr_dst - + (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2004,9 +1999,10 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } } } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = b_rptr_src - + (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2016,11 +2012,11 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, } wuffs_zlib__status t_2 = wuffs_deflate__decoder__decode( &self->private_impl.f_flate, a_dst, a_src); - if (a_dst.buf) { - b_wptr_dst = a_dst.buf->ptr + a_dst.buf->wi; + if (a_dst.private_impl.buf) { + b_wptr_dst = a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi; } - if (a_src.buf) { - b_rptr_src = a_src.buf->ptr + a_src.buf->ri; + if (a_src.private_impl.buf) { + b_rptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri; } v_z = t_2; } @@ -2091,9 +2087,10 @@ suspend: goto exit; exit: - if (a_dst.buf) { - size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi); - a_dst.buf->wi += n; + if (a_dst.private_impl.buf) { + size_t n = + b_wptr_dst - (a_dst.private_impl.buf->ptr + a_dst.private_impl.buf->wi); + a_dst.private_impl.buf->wi += n; wuffs_base__io_limit* lim; for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2103,9 +2100,10 @@ exit: WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wstart_dst); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(b_wend_dst); } - if (a_src.buf) { - size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri); - a_src.buf->ri += n; + if (a_src.private_impl.buf) { + size_t n = + b_rptr_src - (a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri); + a_src.private_impl.buf->ri += n; wuffs_base__io_limit* lim; for (lim = &a_src.private_impl.limit; lim; lim = lim->next) { if (lim->ptr_to_len) { @@ -2120,7 +2118,8 @@ exit: return status; short_read_src: - if (a_src.buf && a_src.buf->closed && !a_src.private_impl.limit.ptr_to_len) { + if (a_src.private_impl.buf && a_src.private_impl.buf->closed && + !a_src.private_impl.limit.ptr_to_len) { status = WUFFS_ZLIB__ERROR_UNEXPECTED_EOF; goto exit; } diff --git a/gen/h/std/adler32.h b/gen/h/std/adler32.h index 9f53c0ab..913fe689 100644 --- a/gen/h/std/adler32.h +++ b/gen/h/std/adler32.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/h/std/crc32.h b/gen/h/std/crc32.h index c1e63546..89fc7373 100644 --- a/gen/h/std/crc32.h +++ b/gen/h/std/crc32.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/h/std/deflate.h b/gen/h/std/deflate.h index ff922343..5d60df0b 100644 --- a/gen/h/std/deflate.h +++ b/gen/h/std/deflate.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/h/std/gif.h b/gen/h/std/gif.h index d0cc7940..854c4779 100644 --- a/gen/h/std/gif.h +++ b/gen/h/std/gif.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/h/std/gzip.h b/gen/h/std/gzip.h index bb734182..a38cedbe 100644 --- a/gen/h/std/gzip.h +++ b/gen/h/std/gzip.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index 54daecbd..6f8c7016 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -564,26 +564,20 @@ typedef struct wuffs_base__io_limit { } wuffs_base__io_limit; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; } wuffs_base__io_reader; typedef struct { - // TODO: move buf into private_impl? As it is, it looks like users can modify - // the buf field to point to a different buffer, which can turn the limit and - // mark fields into dangling pointers. - wuffs_base__io_buffer* buf; // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__io_buffer* buf; wuffs_base__io_limit limit; uint8_t* mark; } private_impl; @@ -593,7 +587,7 @@ static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } @@ -602,7 +596,7 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); if (buf) { - ret.buf = buf; + ret.private_impl.buf = buf; } return ret; } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 063acef0..17dacd16 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -51,7 +51,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the void test_basic_bad_receiver() { CHECK_FOCUS(__func__); wuffs_base__image_config ic = {{0}}; - wuffs_base__io_reader src = {0}; + wuffs_base__io_reader src = {{0}}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(NULL, &ic, src); if (status != WUFFS_GIF__ERROR_BAD_RECEIVER) { FAIL("decode_config: got %d, want %d", status, @@ -63,7 +63,7 @@ void test_basic_initializer_not_called() { CHECK_FOCUS(__func__); wuffs_gif__decoder dec = {{0}}; wuffs_base__image_config ic = {{0}}; - wuffs_base__io_reader src = {0}; + wuffs_base__io_reader src = {{0}}; wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src); if (status != WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) { FAIL("decode_config: got %d, want %d", status,