From f5c6204f095b31fd7bf800bfa2ee708075d516ad Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Wed, 27 Dec 2017 14:45:54 +1100 Subject: [PATCH] Strip the prefix from base status messages --- cmd/wuffs-c/internal/cgen/base-impl.h | 5 ---- cmd/wuffs-c/internal/cgen/cgen.go | 21 ++++++++-------- cmd/wuffs-c/internal/cgen/data.go | 22 ++++++++-------- gen/c/std/deflate.c | 36 +++++++++++++-------------- gen/c/std/gif.c | 36 +++++++++++++-------------- gen/c/std/zlib.c | 36 +++++++++++++-------------- test/c/std/gif.c | 8 +++--- 7 files changed, 80 insertions(+), 84 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base-impl.h b/cmd/wuffs-c/internal/cgen/base-impl.h index 21253a92..f3716c43 100644 --- a/cmd/wuffs-c/internal/cgen/base-impl.h +++ b/cmd/wuffs-c/internal/cgen/base-impl.h @@ -1,8 +1,5 @@ // After editing this file, run "go generate" in this directory. -#ifndef WUFFS_BASE_IMPL_H -#define WUFFS_BASE_IMPL_H - // Copyright 2017 The Wuffs Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -342,5 +339,3 @@ static inline wuffs_base__empty_struct wuffs_base__writer1__mark( o->private_impl.mark = mark; return ((wuffs_base__empty_struct){}); } - -#endif // WUFFS_BASE_IMPL_H diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index 0ae177c9..a128decb 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -301,19 +301,20 @@ func (g *gen) genHeader(b *buffer) error { } func (g *gen) genImpl(b *buffer) error { + b.writes("#ifndef WUFFS_BASE_IMPL_H\n#define WUFFS_BASE_IMPL_H\n\n") b.writes(baseImpl) b.writes("\n") + b.printf("static const char* wuffs_base__status__strings[%d] = {\n", len(builtin.StatusList)) + for _, z := range builtin.StatusList { + b.printf("%q,", z.Message) + } + b.writes("};\n\n") + b.writes("#endif // WUFFS_BASE_IMPL_H\n\n") b.writes("// ---------------- Status Codes Implementations\n\n") b.printf("bool %sstatus__is_error(%sstatus s) { return s < 0; }\n\n", g.pkgPrefix, g.pkgPrefix) - b.printf("const char* %sstatus__strings0[%d] = {\n", g.pkgPrefix, len(builtin.StatusList)) - for _, z := range builtin.StatusList { - b.printf("%q,", g.pkgName+": "+z.Message) - } - b.writes("};\n\n") - - b.printf("const char* %sstatus__strings1[%d] = {\n", g.pkgPrefix, len(g.statusList)) + b.printf("const char* %sstatus__strings[%d] = {\n", g.pkgPrefix, len(g.statusList)) for _, s := range g.statusList { b.printf("%q,", g.pkgName+": "+s.msg) } @@ -323,8 +324,8 @@ func (g *gen) genImpl(b *buffer) error { b.printf("const char** a = NULL;\n") b.printf("uint32_t n = 0;\n") b.printf("switch ((s >> %d) & 0x%X) {\n", statusCodeNamespaceShift, statusCodeNamespaceMask) - b.printf("case 0: a = %sstatus__strings0; n = %d; break;\n", g.pkgPrefix, len(builtin.StatusList)) - b.printf("case %spackageid: a = %sstatus__strings1; n = %d; break;\n", + b.printf("case 0: a = wuffs_base__status__strings; n = %d; break;\n", len(builtin.StatusList)) + b.printf("case %spackageid: a = %sstatus__strings; n = %d; break;\n", g.pkgPrefix, g.pkgPrefix, len(g.statusList)) for _, u := range g.usesList { // TODO: is path.Base always correct? Should we check @@ -334,7 +335,7 @@ func (g *gen) genImpl(b *buffer) error { } b.printf("}\n") b.printf("uint32_t i = s & 0x%X;\n", 1<\n\n// ---------------- Static Inline Functions\n//\n// The helpers below are functions, instead of macros, because their argume" + - "nts\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are in base-impl.h and hence copy/pasted into every generated C file,\n// instead of being in some \"base.c\" file, since a design goal is that users of\n// the generated C code can often just #include a single .c file, such as\n// \"gif.c\", without having to additionally include or otherwise build and link\n// a \"base.c\" file.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuf" + - "fs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uin" + - "t64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\ns" + - "tatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method s" + - "hould also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance != 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8" + - "_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n" + - ";\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs " + - "code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#endif // WUFFS_BASE_IMPL_H\n" + + "// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// wuffs_base__empty_struct is used when a Wuffs function returns an empty\n// struct. In C, if a function f returns void, you can't say \"x = f()\", but in\n// Wuffs, if a function g returns empty, you can say \"y = g()\".\ntypedef struct {\n} wuffs_base__empty_struct;\n\n#define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x)\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolp" + + "roof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC (0x3CCB6C71U)\n\n// WUFFS_BASE__ALREADY_ZEROED is passed from a container struct's initializer\n// to a containee struct's initializer when the container has already zeroed\n// the containee's memory.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"zeroed\").\n#define WUFFS_BASE__ALREADY_ZEROED (0x68602EF1U)\n\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_" + + "MAYBE_SUSPEND(n) \\\n if (status < 0) { \\\n goto exit; \\\n } else if (status == 0) { \\\n goto ok; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// Uncomment this #include for printf-debugging.\n// #include \n\n// ---------------- Static Inline Functions\n//\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluat" + + "e more than once.\n//\n// They are in base-impl.h and hence copy/pasted into every generated C file,\n// instead of being in some \"base.c\" file, since a design goal is that users of\n// the generated C code can often just #include a single .c file, such as\n// \"gif.c\", without having to additionally include or otherwise build and link\n// a \"base.c\" file.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t" + + ")(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <=" + + " s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from" + + "_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method should also take an unroll hint argument,\n // and the" + + " cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance != 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint3" + + "2_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy" + + "_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code, not user code. Other Wuffs test code modifies\n/" + + "/ private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" + "" type template_args_short_read struct { diff --git a/gen/c/std/deflate.c b/gen/c/std/deflate.c index 4c370465..e9f0f97a 100644 --- a/gen/c/std/deflate.c +++ b/gen/c/std/deflate.c @@ -623,6 +623,20 @@ static inline wuffs_base__empty_struct wuffs_base__writer1__mark( return ((wuffs_base__empty_struct){}); } +static const char* wuffs_base__status__strings[11] = { + "ok", + "bad wuffs version", + "bad receiver", + "bad argument", + "initializer not called", + "invalid I/O operation", + "closed for writes", + "unexpected EOF", + "short read", + "short write", + "cannot return a suspension", +}; + #endif // WUFFS_BASE_IMPL_H // ---------------- Status Codes Implementations @@ -631,21 +645,7 @@ bool wuffs_deflate__status__is_error(wuffs_deflate__status s) { return s < 0; } -const char* wuffs_deflate__status__strings0[11] = { - "deflate: ok", - "deflate: bad wuffs version", - "deflate: bad receiver", - "deflate: bad argument", - "deflate: initializer not called", - "deflate: invalid I/O operation", - "deflate: closed for writes", - "deflate: unexpected EOF", - "deflate: short read", - "deflate: short write", - "deflate: cannot return a suspension", -}; - -const char* wuffs_deflate__status__strings1[17] = { +const char* wuffs_deflate__status__strings[17] = { "deflate: bad Huffman code (over-subscribed)", "deflate: bad Huffman code (under-subscribed)", "deflate: bad Huffman code length count", @@ -670,16 +670,16 @@ const char* wuffs_deflate__status__string(wuffs_deflate__status s) { uint32_t n = 0; switch ((s >> 10) & 0x1FFFFF) { case 0: - a = wuffs_deflate__status__strings0; + a = wuffs_base__status__strings; n = 11; break; case wuffs_deflate__packageid: - a = wuffs_deflate__status__strings1; + a = wuffs_deflate__status__strings; n = 17; break; } uint32_t i = s & 0xFF; - return i < n ? a[i] : "deflate: unknown status"; + return i < n ? a[i] : "unknown status"; } // ---------------- Private Consts diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 68c45846..01a5dd05 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -611,6 +611,20 @@ static inline wuffs_base__empty_struct wuffs_base__writer1__mark( return ((wuffs_base__empty_struct){}); } +static const char* wuffs_base__status__strings[11] = { + "ok", + "bad wuffs version", + "bad receiver", + "bad argument", + "initializer not called", + "invalid I/O operation", + "closed for writes", + "unexpected EOF", + "short read", + "short write", + "cannot return a suspension", +}; + #endif // WUFFS_BASE_IMPL_H // ---------------- Status Codes Implementations @@ -619,21 +633,7 @@ bool wuffs_gif__status__is_error(wuffs_gif__status s) { return s < 0; } -const char* wuffs_gif__status__strings0[11] = { - "gif: ok", - "gif: bad wuffs version", - "gif: bad receiver", - "gif: bad argument", - "gif: initializer not called", - "gif: invalid I/O operation", - "gif: closed for writes", - "gif: unexpected EOF", - "gif: short read", - "gif: short write", - "gif: cannot return a suspension", -}; - -const char* wuffs_gif__status__strings1[8] = { +const char* wuffs_gif__status__strings[8] = { "gif: bad GIF block", "gif: bad GIF extension label", "gif: bad GIF header", @@ -649,16 +649,16 @@ const char* wuffs_gif__status__string(wuffs_gif__status s) { uint32_t n = 0; switch ((s >> 10) & 0x1FFFFF) { case 0: - a = wuffs_gif__status__strings0; + a = wuffs_base__status__strings; n = 11; break; case wuffs_gif__packageid: - a = wuffs_gif__status__strings1; + a = wuffs_gif__status__strings; n = 8; break; } uint32_t i = s & 0xFF; - return i < n ? a[i] : "gif: unknown status"; + return i < n ? a[i] : "unknown status"; } // ---------------- Private Consts diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 8846601b..5ad4b434 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -746,6 +746,20 @@ static inline wuffs_base__empty_struct wuffs_base__writer1__mark( return ((wuffs_base__empty_struct){}); } +static const char* wuffs_base__status__strings[11] = { + "ok", + "bad wuffs version", + "bad receiver", + "bad argument", + "initializer not called", + "invalid I/O operation", + "closed for writes", + "unexpected EOF", + "short read", + "short write", + "cannot return a suspension", +}; + #endif // WUFFS_BASE_IMPL_H // ---------------- Status Codes Implementations @@ -754,21 +768,7 @@ bool wuffs_zlib__status__is_error(wuffs_zlib__status s) { return s < 0; } -const char* wuffs_zlib__status__strings0[11] = { - "zlib: ok", - "zlib: bad wuffs version", - "zlib: bad receiver", - "zlib: bad argument", - "zlib: initializer not called", - "zlib: invalid I/O operation", - "zlib: closed for writes", - "zlib: unexpected EOF", - "zlib: short read", - "zlib: short write", - "zlib: cannot return a suspension", -}; - -const char* wuffs_zlib__status__strings1[5] = { +const char* wuffs_zlib__status__strings[5] = { "zlib: checksum mismatch", "zlib: invalid zlib compression method", "zlib: invalid zlib compression window size", @@ -781,18 +781,18 @@ const char* wuffs_zlib__status__string(wuffs_zlib__status s) { uint32_t n = 0; switch ((s >> 10) & 0x1FFFFF) { case 0: - a = wuffs_zlib__status__strings0; + a = wuffs_base__status__strings; n = 11; break; case wuffs_zlib__packageid: - a = wuffs_zlib__status__strings1; + a = wuffs_zlib__status__strings; n = 5; break; case wuffs_deflate__packageid: return wuffs_deflate__status__string(s); } uint32_t i = s & 0xFF; - return i < n ? a[i] : "zlib: unknown status"; + return i < n ? a[i] : "unknown status"; } // ---------------- Private Consts diff --git a/test/c/std/gif.c b/test/c/std/gif.c index d63dbfec..8842eade 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -119,20 +119,20 @@ void test_basic_status_is_error() { void test_basic_status_strings() { CHECK_FOCUS(__func__); const char* s0 = wuffs_gif__status__string(WUFFS_GIF__STATUS_OK); - const char* t0 = "gif: ok"; + const char* t0 = "ok"; if (strcmp(s0, t0)) { FAIL("got \"%s\", want \"%s\"", s0, t0); return; } const char* s1 = wuffs_gif__status__string(WUFFS_GIF__ERROR_BAD_WUFFS_VERSION); - const char* t1 = "gif: bad wuffs version"; + const char* t1 = "bad wuffs version"; if (strcmp(s1, t1)) { FAIL("got \"%s\", want \"%s\"", s1, t1); return; } const char* s2 = wuffs_gif__status__string(WUFFS_GIF__SUSPENSION_SHORT_WRITE); - const char* t2 = "gif: short write"; + const char* t2 = "short write"; if (strcmp(s2, t2)) { FAIL("got \"%s\", want \"%s\"", s2, t2); return; @@ -145,7 +145,7 @@ void test_basic_status_strings() { return; } const char* s4 = wuffs_gif__status__string(-254); - const char* t4 = "gif: unknown status"; + const char* t4 = "unknown status"; if (strcmp(s4, t4)) { FAIL("got \"%s\", want \"%s\"", s4, t4); return;