mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 16:47:28 +01:00
cgen: halve the sizeof wuffs_foo__bar::unique_ptr
This commit is contained in:
1 parent
bdba035779
commit
bffbad69a4
5 files changed
+110
-81
No files matched your search
@@ -13,6 +13,7 @@
|
||||
- Changed `lzw.set_literal_width` to `lzw.set_quirk`.
|
||||
- Changed `set_quirk_enabled!(quirk: u32, enabled: bool)` to `set_quirk!(key:
|
||||
u32, value: u64) status`.
|
||||
- Halve the sizeof `wuffs_foo__bar::unique_ptr`.
|
||||
- Set image decoder pixel width and height inclusive maximum to `0xFF_FFFF`,
|
||||
down from `0x7FFF_FFFF`.
|
||||
|
||||
|
||||
@@ -106,7 +106,7 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
#endif
|
||||
}
|
||||
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr);
|
||||
}
|
||||
|
||||
std::string //
|
||||
@@ -612,7 +612,7 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
io_buf = &fallback_io_buf;
|
||||
}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
|
||||
flags.repr, pixel_blend.repr, background_color.repr,
|
||||
|
||||
@@ -348,6 +348,20 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
|
||||
// --------
|
||||
|
||||
#ifdef __cplusplus
|
||||
// Wuffs structs are just data, not resources (in the RAII sense). They don't
|
||||
// subclass anything. They don't have virtual destructors. They don't contain
|
||||
// pointers to dynamically allocated memory. They don't contain file
|
||||
// descriptors. And so on. Destroying such a struct (e.g. via a
|
||||
// wuffs_foo__bar::unique_ptr) can just call free, especially as
|
||||
// sizeof(wuffs_foo__bar) isn't supposed to be part of the public (stable) API.
|
||||
struct wuffs_unique_ptr_deleter {
|
||||
void operator()(void* p) { free(p); }
|
||||
};
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__empty_struct is used when a Wuffs function returns an empty
|
||||
// struct. In C, if a function f returns void, you can't say "x = f()", but in
|
||||
// Wuffs, if a function g returns empty, you can say "y = g()".
|
||||
|
||||
@@ -457,7 +457,7 @@ func insertInterfaceDeclarations(buf *buffer) error {
|
||||
|
||||
buf.writes("#ifdef __cplusplus\n")
|
||||
buf.writes("#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n")
|
||||
buf.printf(" using unique_ptr = std::unique_ptr<wuffs_base__%s, decltype(&free)>;\n", n)
|
||||
buf.printf(" using unique_ptr = std::unique_ptr<wuffs_base__%s, wuffs_unique_ptr_deleter>;\n", n)
|
||||
buf.writes("#endif\n\n")
|
||||
|
||||
for _, f := range builtInInterfaceMethods[qid] {
|
||||
@@ -776,7 +776,7 @@ func (g *gen) genHeader(b *buffer) error {
|
||||
b.writes("// memory allocation fails. If they return non-NULL, there is no need to call\n")
|
||||
b.writes("// wuffs_foo__bar__initialize, but the caller is responsible for eventually\n")
|
||||
b.writes("// calling free on the returned pointer. That pointer is effectively a C++\n")
|
||||
b.writes("// std::unique_ptr<T, decltype(&free)>.\n\n")
|
||||
b.writes("// std::unique_ptr<T, wuffs_unique_ptr_deleter>.\n\n")
|
||||
|
||||
for _, n := range g.structList {
|
||||
if !n.Public() {
|
||||
@@ -1240,18 +1240,18 @@ func (g *gen) writeCppMethods(b *buffer, n *a.Struct) error {
|
||||
b.writes("#ifdef __cplusplus\n")
|
||||
|
||||
b.writes("#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n")
|
||||
b.printf("using unique_ptr = std::unique_ptr<%s%s, decltype(&free)>;\n\n", g.pkgPrefix, structName)
|
||||
b.printf("using unique_ptr = std::unique_ptr<%s%s, wuffs_unique_ptr_deleter>;\n\n", g.pkgPrefix, structName)
|
||||
b.writes("// On failure, the alloc_etc functions return nullptr. They don't throw.\n\n")
|
||||
b.writes("static inline unique_ptr\n")
|
||||
b.writes("alloc() {\n")
|
||||
b.printf("return unique_ptr(%s%s__alloc(), &free);\n", g.pkgPrefix, structName)
|
||||
b.printf("return unique_ptr(%s%s__alloc());\n", g.pkgPrefix, structName)
|
||||
b.writes("}\n")
|
||||
for _, impl := range n.Implements() {
|
||||
iQID := impl.AsTypeExpr().QID()
|
||||
iName := fmt.Sprintf("wuffs_%s__%s", iQID[0].Str(g.tm), iQID[1].Str(g.tm))
|
||||
b.printf("\nstatic inline %s::unique_ptr\n", iName)
|
||||
b.printf("alloc_as__%s() {\n", iName)
|
||||
b.printf("return %s::unique_ptr(\n%s%s__alloc_as__%s(), &free);\n",
|
||||
b.printf("return %s::unique_ptr(\n%s%s__alloc_as__%s());\n",
|
||||
iName, g.pkgPrefix, structName, iName)
|
||||
b.printf("}\n")
|
||||
}
|
||||
|
||||
@@ -404,6 +404,20 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
|
||||
// --------
|
||||
|
||||
#ifdef __cplusplus
|
||||
// Wuffs structs are just data, not resources (in the RAII sense). They don't
|
||||
// subclass anything. They don't have virtual destructors. They don't contain
|
||||
// pointers to dynamically allocated memory. They don't contain file
|
||||
// descriptors. And so on. Destroying such a struct (e.g. via a
|
||||
// wuffs_foo__bar::unique_ptr) can just call free, especially as
|
||||
// sizeof(wuffs_foo__bar) isn't supposed to be part of the public (stable) API.
|
||||
struct wuffs_unique_ptr_deleter {
|
||||
void operator()(void* p) { free(p); }
|
||||
};
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__empty_struct is used when a Wuffs function returns an empty
|
||||
// struct. In C, if a function f returns void, you can't say "x = f()", but in
|
||||
// Wuffs, if a function g returns empty, you can say "y = g()".
|
||||
@@ -5932,7 +5946,7 @@ struct wuffs_base__hasher_u32__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__hasher_u32, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__hasher_u32, wuffs_unique_ptr_deleter>;
|
||||
#endif
|
||||
|
||||
inline uint64_t
|
||||
@@ -6111,7 +6125,7 @@ struct wuffs_base__image_decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__image_decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__image_decoder, wuffs_unique_ptr_deleter>;
|
||||
#endif
|
||||
|
||||
inline wuffs_base__status
|
||||
@@ -6271,7 +6285,7 @@ struct wuffs_base__io_transformer__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__io_transformer, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__io_transformer, wuffs_unique_ptr_deleter>;
|
||||
#endif
|
||||
|
||||
inline uint64_t
|
||||
@@ -6368,7 +6382,7 @@ struct wuffs_base__token_decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__token_decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_base__token_decoder, wuffs_unique_ptr_deleter>;
|
||||
#endif
|
||||
|
||||
inline uint64_t
|
||||
@@ -6449,7 +6463,7 @@ sizeof__wuffs_adler32__hasher();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_adler32__hasher*
|
||||
wuffs_adler32__hasher__alloc();
|
||||
@@ -6525,19 +6539,19 @@ struct wuffs_adler32__hasher__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_adler32__hasher, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_adler32__hasher, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_adler32__hasher__alloc(), &free);
|
||||
return unique_ptr(wuffs_adler32__hasher__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__hasher_u32::unique_ptr
|
||||
alloc_as__wuffs_base__hasher_u32() {
|
||||
return wuffs_base__hasher_u32::unique_ptr(
|
||||
wuffs_adler32__hasher__alloc_as__wuffs_base__hasher_u32(), &free);
|
||||
wuffs_adler32__hasher__alloc_as__wuffs_base__hasher_u32());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -6656,7 +6670,7 @@ sizeof__wuffs_bmp__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_bmp__decoder*
|
||||
wuffs_bmp__decoder__alloc();
|
||||
@@ -6841,19 +6855,19 @@ struct wuffs_bmp__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_bmp__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_bmp__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_bmp__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_bmp__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -7042,7 +7056,7 @@ sizeof__wuffs_bzip2__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_bzip2__decoder*
|
||||
wuffs_bzip2__decoder__alloc();
|
||||
@@ -7184,19 +7198,19 @@ struct wuffs_bzip2__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_bzip2__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_bzip2__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_bzip2__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_bzip2__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_transformer::unique_ptr
|
||||
alloc_as__wuffs_base__io_transformer() {
|
||||
return wuffs_base__io_transformer::unique_ptr(
|
||||
wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer(), &free);
|
||||
wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -7336,7 +7350,7 @@ sizeof__wuffs_cbor__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_cbor__decoder*
|
||||
wuffs_cbor__decoder__alloc();
|
||||
@@ -7428,19 +7442,19 @@ struct wuffs_cbor__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_cbor__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_cbor__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_cbor__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_cbor__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__token_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__token_decoder() {
|
||||
return wuffs_base__token_decoder::unique_ptr(
|
||||
wuffs_cbor__decoder__alloc_as__wuffs_base__token_decoder(), &free);
|
||||
wuffs_cbor__decoder__alloc_as__wuffs_base__token_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -7559,7 +7573,7 @@ sizeof__wuffs_crc32__ieee_hasher();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_crc32__ieee_hasher*
|
||||
wuffs_crc32__ieee_hasher__alloc();
|
||||
@@ -7634,19 +7648,19 @@ struct wuffs_crc32__ieee_hasher__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_crc32__ieee_hasher, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_crc32__ieee_hasher, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_crc32__ieee_hasher__alloc(), &free);
|
||||
return unique_ptr(wuffs_crc32__ieee_hasher__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__hasher_u32::unique_ptr
|
||||
alloc_as__wuffs_base__hasher_u32() {
|
||||
return wuffs_base__hasher_u32::unique_ptr(
|
||||
wuffs_crc32__ieee_hasher__alloc_as__wuffs_base__hasher_u32(), &free);
|
||||
wuffs_crc32__ieee_hasher__alloc_as__wuffs_base__hasher_u32());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -7775,7 +7789,7 @@ sizeof__wuffs_deflate__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_deflate__decoder*
|
||||
wuffs_deflate__decoder__alloc();
|
||||
@@ -7913,19 +7927,19 @@ struct wuffs_deflate__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_deflate__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_deflate__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_deflate__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_deflate__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_transformer::unique_ptr
|
||||
alloc_as__wuffs_base__io_transformer() {
|
||||
return wuffs_base__io_transformer::unique_ptr(
|
||||
wuffs_deflate__decoder__alloc_as__wuffs_base__io_transformer(), &free);
|
||||
wuffs_deflate__decoder__alloc_as__wuffs_base__io_transformer());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -8057,7 +8071,7 @@ sizeof__wuffs_lzw__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_lzw__decoder*
|
||||
wuffs_lzw__decoder__alloc();
|
||||
@@ -8161,19 +8175,19 @@ struct wuffs_lzw__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_lzw__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_lzw__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_lzw__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_lzw__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_transformer::unique_ptr
|
||||
alloc_as__wuffs_base__io_transformer() {
|
||||
return wuffs_base__io_transformer::unique_ptr(
|
||||
wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer(), &free);
|
||||
wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -8321,7 +8335,7 @@ sizeof__wuffs_gif__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_gif__decoder*
|
||||
wuffs_gif__decoder__alloc();
|
||||
@@ -8563,19 +8577,19 @@ struct wuffs_gif__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_gif__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_gif__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_gif__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_gif__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -8760,7 +8774,7 @@ sizeof__wuffs_gzip__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_gzip__decoder*
|
||||
wuffs_gzip__decoder__alloc();
|
||||
@@ -8854,19 +8868,19 @@ struct wuffs_gzip__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_gzip__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_gzip__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_gzip__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_gzip__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_transformer::unique_ptr
|
||||
alloc_as__wuffs_base__io_transformer() {
|
||||
return wuffs_base__io_transformer::unique_ptr(
|
||||
wuffs_gzip__decoder__alloc_as__wuffs_base__io_transformer(), &free);
|
||||
wuffs_gzip__decoder__alloc_as__wuffs_base__io_transformer());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -9009,7 +9023,7 @@ sizeof__wuffs_jpeg__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_jpeg__decoder*
|
||||
wuffs_jpeg__decoder__alloc();
|
||||
@@ -9290,19 +9304,19 @@ struct wuffs_jpeg__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_jpeg__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_jpeg__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_jpeg__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_jpeg__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_jpeg__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_jpeg__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -9536,7 +9550,7 @@ sizeof__wuffs_json__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_json__decoder*
|
||||
wuffs_json__decoder__alloc();
|
||||
@@ -9635,19 +9649,19 @@ struct wuffs_json__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_json__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_json__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_json__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_json__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__token_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__token_decoder() {
|
||||
return wuffs_base__token_decoder::unique_ptr(
|
||||
wuffs_json__decoder__alloc_as__wuffs_base__token_decoder(), &free);
|
||||
wuffs_json__decoder__alloc_as__wuffs_base__token_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -9772,7 +9786,7 @@ sizeof__wuffs_netpbm__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_netpbm__decoder*
|
||||
wuffs_netpbm__decoder__alloc();
|
||||
@@ -9923,19 +9937,19 @@ struct wuffs_netpbm__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_netpbm__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_netpbm__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_netpbm__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_netpbm__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_netpbm__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_netpbm__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -10118,7 +10132,7 @@ sizeof__wuffs_nie__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_nie__decoder*
|
||||
wuffs_nie__decoder__alloc();
|
||||
@@ -10273,19 +10287,19 @@ struct wuffs_nie__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_nie__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_nie__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_nie__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_nie__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -10474,7 +10488,7 @@ sizeof__wuffs_zlib__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_zlib__decoder*
|
||||
wuffs_zlib__decoder__alloc();
|
||||
@@ -10584,19 +10598,19 @@ struct wuffs_zlib__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_zlib__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_zlib__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_zlib__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_zlib__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_transformer::unique_ptr
|
||||
alloc_as__wuffs_base__io_transformer() {
|
||||
return wuffs_base__io_transformer::unique_ptr(
|
||||
wuffs_zlib__decoder__alloc_as__wuffs_base__io_transformer(), &free);
|
||||
wuffs_zlib__decoder__alloc_as__wuffs_base__io_transformer());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -10742,7 +10756,7 @@ sizeof__wuffs_png__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_png__decoder*
|
||||
wuffs_png__decoder__alloc();
|
||||
@@ -11040,19 +11054,19 @@ struct wuffs_png__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_png__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_png__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_png__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_png__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_png__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_png__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -11236,7 +11250,7 @@ sizeof__wuffs_tga__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_tga__decoder*
|
||||
wuffs_tga__decoder__alloc();
|
||||
@@ -11417,19 +11431,19 @@ struct wuffs_tga__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_tga__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_tga__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_tga__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_tga__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -11611,7 +11625,7 @@ sizeof__wuffs_wbmp__decoder();
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, decltype(&free)>.
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_wbmp__decoder*
|
||||
wuffs_wbmp__decoder__alloc();
|
||||
@@ -11772,19 +11786,19 @@ struct wuffs_wbmp__decoder__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_wbmp__decoder, decltype(&free)>;
|
||||
using unique_ptr = std::unique_ptr<wuffs_wbmp__decoder, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_wbmp__decoder__alloc(), &free);
|
||||
return unique_ptr(wuffs_wbmp__decoder__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__image_decoder::unique_ptr
|
||||
alloc_as__wuffs_base__image_decoder() {
|
||||
return wuffs_base__image_decoder::unique_ptr(
|
||||
wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder(), &free);
|
||||
wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
@@ -60346,7 +60360,7 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
#endif
|
||||
}
|
||||
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr);
|
||||
}
|
||||
|
||||
std::string //
|
||||
@@ -60852,7 +60866,7 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
io_buf = &fallback_io_buf;
|
||||
}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
|
||||
flags.repr, pixel_blend.repr, background_color.repr,
|
||||
|
||||
Reference in new issue
Block a user