mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Strip the prefix from base status messages
This commit is contained in:
1 parent
7e47f4cc7a
commit
f5c6204f09
7 files changed
+80
-84
No files matched your search
@@ -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
|
||||
@@ -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<<statusCodeCodeBits-1)
|
||||
b.printf("return i < n ? a[i] : \"%s: unknown status\";\n", g.pkgName)
|
||||
b.printf("return i < n ? a[i] : \"unknown status\";\n")
|
||||
b.writes("}\n\n")
|
||||
|
||||
b.writes("// ---------------- Private Consts\n\n")
|
||||
|
||||
@@ -24,17 +24,17 @@ const baseHeader = "" +
|
||||
""
|
||||
|
||||
const baseImpl = "" +
|
||||
"#ifndef WUFFS_BASE_IMPL_H\n#define WUFFS_BASE_IMPL_H\n\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 foolproof, 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 <stdio.h>\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 <stdio.h>\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 {
|
||||
|
||||
+18
-18
@@ -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
|
||||
|
||||
+18
-18
@@ -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
|
||||
|
||||
+18
-18
@@ -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
|
||||
|
||||
+4
-4
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user