diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index cc6fb034..c05446b4 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -321,11 +321,12 @@ type gen struct { // generated C code (due to line numbers changing) when editing Wuffs code. genlinenum bool - scalarConstsMap map[t.QID]*a.Const - statusList []status - statusMap map[t.QID]status - structList []*a.Struct - structMap map[t.QID]*a.Struct + privateDataFields map[t.QQID]struct{} + scalarConstsMap map[t.QID]*a.Const + statusList []status + statusMap map[t.QID]status + structList []*a.Struct + structMap map[t.QID]*a.Struct currFunk funk funks map[t.QQID]funk @@ -374,8 +375,16 @@ func (g *gen) generate() ([]byte, error) { return nil, fmt.Errorf("cyclical struct definitions") } g.structMap = map[t.QID]*a.Struct{} + g.privateDataFields = map[t.QQID]struct{}{} for _, n := range g.structList { - g.structMap[n.QID()] = n + qid := n.QID() + g.structMap[qid] = n + for _, f := range n.Fields() { + f := f.AsField() + if f.PrivateData() { + g.privateDataFields[t.QQID{qid[0], qid[1], f.Name()}] = struct{}{} + } + } } g.funks = map[t.QQID]funk{} @@ -745,7 +754,7 @@ func (g *gen) writeStructPrivateImpl(b *buffer, n *a.Struct) error { for _, o := range n.Fields() { o := o.AsField() - if o.XType().Eq(typeExprUtility) { + if o.PrivateData() || o.XType().Eq(typeExprUtility) { continue } if err := g.writeCTypeName(b, o.XType(), fPrefix, o.Name().Str(g.tm)); err != nil { @@ -782,6 +791,20 @@ func (g *gen) writeStructPrivateImpl(b *buffer, n *a.Struct) error { b.writes("struct {\n") oldOuterLenB1 := len(*b) + for _, o := range n.Fields() { + o := o.AsField() + if !o.PrivateData() || o.XType().Eq(typeExprUtility) { + continue + } + if err := g.writeCTypeName(b, o.XType(), fPrefix, o.Name().Str(g.tm)); err != nil { + return err + } + b.writes(";\n") + } + if oldOuterLenB1 != len(*b) { + b.writeb('\n') + } + for _, file := range g.files { for _, tld := range file.TopLevelDecls() { if tld.Kind() != a.KFunc { @@ -1011,7 +1034,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error { b.printf("{\n") b.printf("wuffs_base__status z = %s%s__initialize("+ - "&self->private_impl.%s%s, sizeof(self->private_impl.%s%s), WUFFS_VERSION, initialize_flags);\n", + "&self->private_data.%s%s, sizeof(self->private_data.%s%s), WUFFS_VERSION, initialize_flags);\n", prefix, qid[1].Str(g.tm), fPrefix, f.Name().Str(g.tm), fPrefix, f.Name().Str(g.tm)) b.printf("if (z) { return z; }\n") b.printf("}\n") diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index ba68674c..84d26e09 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -217,13 +217,29 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { } else { b.writes(".") } - b.writes("private_impl." + fPrefix) + + b.writes(g.privateImplData(lhs.MType(), n.Ident())) + b.writeb('.') + b.writes(fPrefix) b.writes(n.Ident().Str(g.tm)) return nil } return fmt.Errorf("unrecognized token (0x%X) for writeExprOther", n.Operator()) } +func (g *gen) privateImplData(typ *a.TypeExpr, fieldName t.ID) string { + if p := typ.Decorator(); p == t.IDNptr || p == t.IDPtr { + typ = typ.Inner() + } + if s := g.structMap[typ.QID()]; s != nil { + qid := s.QID() + if _, ok := g.privateDataFields[t.QQID{qid[0], qid[1], fieldName}]; ok { + return "private_data" + } + } + return "private_impl" +} + func (g *gen) writeExprUnaryOp(b *buffer, n *a.Expr, depth uint32) error { op := n.Operator() opName := cOpName(op) diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 10a7cf53..422b800b 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -102,6 +102,7 @@ const ( FlagsClassy = Flags(0x00001000) FlagsSubExprHasEffect = Flags(0x00002000) FlagsRetsError = Flags(0x00004000) + FlagsPrivateData = Flags(0x00008000) ) func (f Flags) AsEffect() Effect { return Effect(f) } @@ -453,19 +454,22 @@ func NewVar(name t.ID, xType *TypeExpr) *Var { } // Field is a "name type" struct field: +// - FlagsPrivateData is the initializer need not explicitly memset to zero. // - ID2: name // - LHS: type Field Node -func (n *Field) AsNode() *Node { return (*Node)(n) } -func (n *Field) Name() t.ID { return n.id2 } -func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() } +func (n *Field) AsNode() *Node { return (*Node)(n) } +func (n *Field) PrivateData() bool { return n.flags&FlagsPrivateData != 0 } +func (n *Field) Name() t.ID { return n.id2 } +func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() } -func NewField(name t.ID, xType *TypeExpr) *Field { +func NewField(flags Flags, name t.ID, xType *TypeExpr) *Field { return &Field{ - kind: KField, - id2: name, - lhs: xType.AsNode(), + kind: KField, + flags: flags, + id2: name, + lhs: xType.AsNode(), } } diff --git a/lang/parse/parse.go b/lang/parse/parse.go index f09bf70f..b1118593 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -339,7 +339,11 @@ func (p *parser) parseFieldNode() (*a.Node, error) { if err != nil { return nil, err } - return a.NewField(name, typ).AsNode(), nil + flags := a.Flags(0) + if pkg := typ.Innermost().QID()[0]; (pkg != 0) && (pkg != t.IDBase) { + flags |= a.FlagsPrivateData + } + return a.NewField(flags, name, typ).AsNode(), nil } func (p *parser) parseTypeExpr() (*a.TypeExpr, error) { diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index e4fd3f61..5443a037 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -3297,7 +3297,6 @@ struct wuffs_gif__decoder__struct { uint64_t f_compressed_ri; uint64_t f_compressed_wi; wuffs_base__pixel_swizzler f_swizzler; - wuffs_lzw__decoder f_lzw; uint8_t f_compressed[4096]; uint8_t f_palettes[2][1024]; uint8_t f_dst_palette[1024]; @@ -3319,6 +3318,8 @@ struct wuffs_gif__decoder__struct { } private_impl; struct { + wuffs_lzw__decoder f_lzw; + struct { uint64_t scratch; } s_skip_frame[1]; @@ -3551,13 +3552,14 @@ struct wuffs_gzip__decoder__struct { uint32_t active_coroutine; bool f_ignore_checksum; - wuffs_crc32__ieee_hasher f_checksum; - wuffs_deflate__decoder f_flate; uint32_t p_decode_io_writer[1]; } private_impl; struct { + wuffs_crc32__ieee_hasher f_checksum; + wuffs_deflate__decoder f_flate; + struct { uint8_t v_flags; uint32_t v_checksum_got; @@ -3725,13 +3727,14 @@ struct wuffs_zlib__decoder__struct { uint32_t active_coroutine; bool f_ignore_checksum; - wuffs_adler32__hasher f_checksum; - wuffs_deflate__decoder f_flate; uint32_t p_decode_io_writer[1]; } private_impl; struct { + wuffs_adler32__hasher f_checksum; + wuffs_deflate__decoder f_flate; + struct { uint32_t v_checksum_got; uint64_t scratch; @@ -8605,7 +8608,7 @@ wuffs_gif__decoder__initialize(wuffs_gif__decoder* self, } { wuffs_base__status z = wuffs_lzw__decoder__initialize( - &self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw), + &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, initialize_flags); if (z) { return z; @@ -10338,9 +10341,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, .len = 1024, })); if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { - (memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), + (memset(&self->private_data.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), wuffs_base__ignore_status(wuffs_lzw__decoder__initialize( - &self->private_impl.f_lzw, sizeof((wuffs_lzw__decoder){}), + &self->private_data.f_lzw, sizeof((wuffs_lzw__decoder){}), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)), wuffs_base__return_empty_struct()); } @@ -10357,7 +10360,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, status = wuffs_gif__error__bad_literal_width; goto exit; } - wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw, + wuffs_lzw__decoder__set_literal_width(&self->private_data.f_lzw, ((uint32_t)(v_lw))); self->private_impl.f_previous_lzw_decode_ended_abruptly = true; @@ -10520,7 +10523,7 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, { u_r.meta.ri = iop_v_r - u_r.data.ptr; wuffs_base__status t_1 = wuffs_lzw__decoder__decode_io_writer( - &self->private_impl.f_lzw, + &self->private_data.f_lzw, wuffs_base__utility__null_io_writer(), v_r, wuffs_base__utility__null_slice_u8()); iop_v_r = u_r.data.ptr + u_r.meta.ri; @@ -10533,7 +10536,7 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, iop_v_r = o_0_iop_v_r; io1_v_r = o_0_io1_v_r; } - v_uncompressed = wuffs_lzw__decoder__flush(&self->private_impl.f_lzw); + v_uncompressed = wuffs_lzw__decoder__flush(&self->private_data.f_lzw); if (((uint64_t)(v_uncompressed.len)) > 0) { v_copy_status = wuffs_gif__decoder__copy_to_image_buffer( self, a_dst, v_uncompressed); @@ -10765,7 +10768,7 @@ wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, } { wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize( - &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), + &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags); if (z) { return z; @@ -10773,7 +10776,7 @@ wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self, } { wuffs_base__status z = wuffs_deflate__decoder__initialize( - &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), + &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags); if (z) { return z; @@ -11066,7 +11069,7 @@ wuffs_gzip__decoder__decode_io_writer(wuffs_gzip__decoder* self, iop_a_src - a_src.private_impl.buf->data.ptr; } wuffs_base__status t_7 = wuffs_deflate__decoder__decode_io_writer( - &self->private_impl.f_flate, a_dst, a_src, a_workbuf); + &self->private_data.f_flate, a_dst, a_src, a_workbuf); if (a_dst.private_impl.buf) { iop_a_dst = a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; @@ -11079,7 +11082,7 @@ wuffs_gzip__decoder__decode_io_writer(wuffs_gzip__decoder* self, } if (!self->private_impl.f_ignore_checksum) { v_checksum_got = wuffs_crc32__ieee_hasher__update( - &self->private_impl.f_checksum, + &self->private_data.f_checksum, ((wuffs_base__slice_u8){ .ptr = a_dst.private_impl.mark, .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), @@ -11238,7 +11241,7 @@ wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, } { wuffs_base__status z = wuffs_adler32__hasher__initialize( - &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum), + &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags); if (z) { return z; @@ -11246,7 +11249,7 @@ wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, } { wuffs_base__status z = wuffs_deflate__decoder__initialize( - &self->private_impl.f_flate, sizeof(self->private_impl.f_flate), + &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags); if (z) { return z; @@ -11424,7 +11427,7 @@ wuffs_zlib__decoder__decode_io_writer(wuffs_zlib__decoder* self, iop_a_src - a_src.private_impl.buf->data.ptr; } wuffs_base__status t_1 = wuffs_deflate__decoder__decode_io_writer( - &self->private_impl.f_flate, a_dst, a_src, a_workbuf); + &self->private_data.f_flate, a_dst, a_src, a_workbuf); if (a_dst.private_impl.buf) { iop_a_dst = a_dst.private_impl.buf->data.ptr + a_dst.private_impl.buf->meta.wi; @@ -11437,7 +11440,7 @@ wuffs_zlib__decoder__decode_io_writer(wuffs_zlib__decoder* self, } if (!self->private_impl.f_ignore_checksum) { v_checksum_got = wuffs_adler32__hasher__update( - &self->private_impl.f_checksum, + &self->private_data.f_checksum, ((wuffs_base__slice_u8){ .ptr = a_dst.private_impl.mark, .len = (size_t)(iop_a_dst - a_dst.private_impl.mark), diff --git a/test/c/std/gif.c b/test/c/std/gif.c index b38cb46c..9c170c14 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -180,9 +180,9 @@ const char* test_basic_sub_struct_initializer() { RETURN_FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "", dec.private_impl.magic, WUFFS_BASE__MAGIC); } - if (dec.private_impl.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) { + if (dec.private_data.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) { RETURN_FAIL("inner magic: got %" PRIu32 ", want %" PRIu32, - dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); + dec.private_data.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC); } return NULL; }