// After editing this file, run "go generate" in the parent directory. // Copyright 2017 The Wuffs Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. static inline wuffs_base__empty_struct // wuffs_base__ignore_status(wuffs_base__status z) { return wuffs_base__make_empty_struct(); } // WUFFS_BASE__MAGIC is a magic number to check that initializers are called. // It's not foolproof, given C doesn't automatically zero memory before use, // but it should catch 99.99% of cases. // // Its (non-zero) value is arbitrary, based on md5sum("wuffs"). #define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71) // WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable // error was previously encountered. // // Its (non-zero) value is arbitrary, based on md5sum("disabled"). #define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2) // Denote intentional fallthroughs for -Wimplicit-fallthrough. // // The order matters here. Clang also defines "__GNUC__". #if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L) #define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]] #elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7) #define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough)) #else #define WUFFS_BASE__FALLTHROUGH #endif // Use switch cases for coroutine suspension points, similar to the technique // in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html // // We use trivial macros instead of an explicit assignment and case statement // so that clang-format doesn't get confused by the unusual "case"s. #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:; #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \ coro_susp_point = n; \ WUFFS_BASE__FALLTHROUGH; \ case n:; #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ if (!status.repr) { \ goto ok; \ } else if (*status.repr != '$') { \ goto exit; \ } \ coro_susp_point = n; \ goto suspend; \ case n:; // Clang also defines "__GNUC__". #if defined(__GNUC__) #define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1)) #define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0)) #else #define WUFFS_BASE__LIKELY(expr) (expr) #define WUFFS_BASE__UNLIKELY(expr) (expr) #endif // The helpers below are functions, instead of macros, because their arguments // can be an expression that we shouldn't evaluate more than once. // // They are static, so that linking multiple wuffs .o files won't complain about // duplicate function definitions. // // They are explicitly marked inline, even if modern compilers don't use the // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. // ---------------- Numeric Types static inline uint8_t // wuffs_base__load_u8be(uint8_t* p) { return p[0]; } static inline uint16_t // wuffs_base__load_u16be(uint8_t* p) { return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); } static inline uint16_t // wuffs_base__load_u16le(uint8_t* p) { return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); } static inline uint32_t // wuffs_base__load_u24be(uint8_t* p) { return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 0); } static inline uint32_t // wuffs_base__load_u24le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16); } static inline uint32_t // wuffs_base__load_u32be(uint8_t* p) { return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); } static inline uint32_t // wuffs_base__load_u32le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); } static inline uint64_t // wuffs_base__load_u40be(uint8_t* p) { return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) | ((uint64_t)(p[4]) << 0); } static inline uint64_t // wuffs_base__load_u40le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32); } static inline uint64_t // wuffs_base__load_u48be(uint8_t* p) { return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) | ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) | ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0); } static inline uint64_t // wuffs_base__load_u48le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40); } static inline uint64_t // wuffs_base__load_u56be(uint8_t* p) { return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) | ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) | ((uint64_t)(p[6]) << 0); } static inline uint64_t // wuffs_base__load_u56le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | ((uint64_t)(p[6]) << 48); } static inline uint64_t // wuffs_base__load_u64be(uint8_t* p) { return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) | ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) | ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) | ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0); } static inline uint64_t // wuffs_base__load_u64le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); } // -------- static inline void // wuffs_base__store_u8be(uint8_t* p, uint8_t x) { p[0] = x; } static inline void // wuffs_base__store_u16be(uint8_t* p, uint16_t x) { p[0] = (uint8_t)(x >> 8); p[1] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u16le(uint8_t* p, uint16_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); } static inline void // wuffs_base__store_u24be(uint8_t* p, uint32_t x) { p[0] = (uint8_t)(x >> 16); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u24le(uint8_t* p, uint32_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); } static inline void // wuffs_base__store_u32be(uint8_t* p, uint32_t x) { p[0] = (uint8_t)(x >> 24); p[1] = (uint8_t)(x >> 16); p[2] = (uint8_t)(x >> 8); p[3] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u32le(uint8_t* p, uint32_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 24); } static inline void // wuffs_base__store_u40be(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 32); p[1] = (uint8_t)(x >> 24); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 8); p[4] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u40le(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 24); p[4] = (uint8_t)(x >> 32); } static inline void // wuffs_base__store_u48be(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 40); p[1] = (uint8_t)(x >> 32); p[2] = (uint8_t)(x >> 24); p[3] = (uint8_t)(x >> 16); p[4] = (uint8_t)(x >> 8); p[5] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u48le(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 24); p[4] = (uint8_t)(x >> 32); p[5] = (uint8_t)(x >> 40); } static inline void // wuffs_base__store_u56be(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 48); p[1] = (uint8_t)(x >> 40); p[2] = (uint8_t)(x >> 32); p[3] = (uint8_t)(x >> 24); p[4] = (uint8_t)(x >> 16); p[5] = (uint8_t)(x >> 8); p[6] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u56le(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 24); p[4] = (uint8_t)(x >> 32); p[5] = (uint8_t)(x >> 40); p[6] = (uint8_t)(x >> 48); } static inline void // wuffs_base__store_u64be(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 56); p[1] = (uint8_t)(x >> 48); p[2] = (uint8_t)(x >> 40); p[3] = (uint8_t)(x >> 32); p[4] = (uint8_t)(x >> 24); p[5] = (uint8_t)(x >> 16); p[6] = (uint8_t)(x >> 8); p[7] = (uint8_t)(x >> 0); } static inline void // wuffs_base__store_u64le(uint8_t* p, uint64_t x) { p[0] = (uint8_t)(x >> 0); p[1] = (uint8_t)(x >> 8); p[2] = (uint8_t)(x >> 16); p[3] = (uint8_t)(x >> 24); p[4] = (uint8_t)(x >> 32); p[5] = (uint8_t)(x >> 40); p[6] = (uint8_t)(x >> 48); p[7] = (uint8_t)(x >> 56); } // -------- extern const uint8_t wuffs_base__low_bits_mask__u8[9]; extern const uint16_t wuffs_base__low_bits_mask__u16[17]; extern const uint32_t wuffs_base__low_bits_mask__u32[33]; extern const uint64_t wuffs_base__low_bits_mask__u64[65]; #define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n]) #define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n]) #define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n]) #define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[n]) // -------- static inline void // wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_add(*x, y); } static inline void // wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_sub(*x, y); } static inline void // wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_add(*x, y); } static inline void // wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_sub(*x, y); } static inline void // wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_add(*x, y); } static inline void // wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_sub(*x, y); } static inline void // wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_add(*x, y); } static inline void // wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_sub(*x, y); } // ---------------- Slices and Tables // wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. static inline wuffs_base__slice_u8 // wuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.len = up_to; } return s; } // wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. static inline wuffs_base__slice_u8 // wuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.ptr += (uint64_t)(s.len) - up_to; s.len = up_to; } return s; } // wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len) // where len is the minimum of dst.len and src.len. // // Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty // slice) is valid and results in a no-op. static inline uint64_t // wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src) { size_t len = dst.len < src.len ? dst.len : src.len; if (len > 0) { memmove(dst.ptr, src.ptr, len); } return len; } // -------- static inline wuffs_base__slice_u8 // wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { if (y < t.height) { return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width); } return wuffs_base__make_slice_u8(NULL, 0); } // ---------------- Slices and Tables (Utility) #define wuffs_base__utility__empty_slice_u8 wuffs_base__empty_slice_u8