mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
SPDX is an ISO standard for describing licenses in a computer readable format, which is useful when applying license compliance tools and the like to source code. In addition to ensuring that the Wuffs C distribution is properly annotated to the benefit of projects using Wuffs and SPDX-supporting tools, add it everywhere else where there's a license in this repo for consistency, too.
271 lines
8.5 KiB
C
271 lines
8.5 KiB
C
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// ---------------- Fundamentals
|
|
|
|
// 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)
|
|
|
|
// Use switch cases for coroutine suspension points, similar to the technique
|
|
// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
|
|
//
|
|
// The implicit fallthrough is intentional.
|
|
//
|
|
// 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; \
|
|
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:;
|
|
|
|
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
|
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
|
#if defined(__GNUC__) || defined(__clang__)
|
|
#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
|
|
|
|
// --------
|
|
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wcast-qual"
|
|
#endif
|
|
static inline uint8_t* //
|
|
wuffs_base__strip_const_from_u8_ptr(const uint8_t* ptr) {
|
|
return (uint8_t*)ptr;
|
|
}
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
// --------
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__ignore_status(wuffs_base__status z) {
|
|
return wuffs_base__make_empty_struct();
|
|
}
|
|
|
|
static inline wuffs_base__status //
|
|
wuffs_base__status__ensure_not_a_suspension(wuffs_base__status z) {
|
|
if (z.repr && (*z.repr == '$')) {
|
|
z.repr = wuffs_base__error__cannot_return_a_suspension;
|
|
}
|
|
return z;
|
|
}
|
|
|
|
// --------
|
|
|
|
// wuffs_base__iterate_total_advance returns the exclusive pointer-offset at
|
|
// which iteration should stop. The overall slice has length total_len, each
|
|
// iteration's sub-slice has length iter_len and are placed iter_advance apart.
|
|
//
|
|
// The iter_advance may not be larger than iter_len. The iter_advance may be
|
|
// smaller than iter_len, in which case the sub-slices will overlap.
|
|
//
|
|
// The return value r satisfies ((0 <= r) && (r <= total_len)).
|
|
//
|
|
// For example, if total_len = 15, iter_len = 5 and iter_advance = 3, there are
|
|
// four iterations at offsets 0, 3, 6 and 9. This function returns 12.
|
|
//
|
|
// 0123456789012345
|
|
// [....]
|
|
// [....]
|
|
// [....]
|
|
// [....]
|
|
// $
|
|
// 0123456789012345
|
|
//
|
|
// For example, if total_len = 15, iter_len = 5 and iter_advance = 5, there are
|
|
// three iterations at offsets 0, 5 and 10. This function returns 15.
|
|
//
|
|
// 0123456789012345
|
|
// [....]
|
|
// [....]
|
|
// [....]
|
|
// $
|
|
// 0123456789012345
|
|
static inline size_t //
|
|
wuffs_base__iterate_total_advance(size_t total_len,
|
|
size_t iter_len,
|
|
size_t iter_advance) {
|
|
if (total_len >= iter_len) {
|
|
size_t n = total_len - iter_len;
|
|
return ((n / iter_advance) * iter_advance) + iter_advance;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// ---------------- Numeric Types
|
|
|
|
extern const uint8_t wuffs_base__low_bits_mask__u8[8];
|
|
extern const uint16_t wuffs_base__low_bits_mask__u16[16];
|
|
extern const uint32_t wuffs_base__low_bits_mask__u32[32];
|
|
extern const uint64_t wuffs_base__low_bits_mask__u64[64];
|
|
|
|
#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);
|
|
}
|
|
|
|
// ---------------- Numeric Types (Utility)
|
|
|
|
#define wuffs_base__utility__sign_extend_convert_u16_u32(a) \
|
|
((uint32_t)(int32_t)(int16_t)(a))
|
|
|
|
#define wuffs_base__utility__sign_extend_rshift_u32(a, n) \
|
|
((uint32_t)(((int32_t)(a)) >> (n)))
|
|
|
|
#define wuffs_base__utility__sign_extend_rshift_u64(a, n) \
|
|
((uint64_t)(((int64_t)(a)) >> (n)))
|
|
|
|
// ---------------- 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 = ((size_t)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 = ((size_t)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__empty_struct //
|
|
wuffs_base__bulk_load_host_endian(void* ptr,
|
|
size_t len,
|
|
wuffs_base__slice_u8 src) {
|
|
if (len && (len <= src.len)) {
|
|
memmove(ptr, src.ptr, len);
|
|
}
|
|
return wuffs_base__make_empty_struct();
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__bulk_memset(void* ptr, size_t len, uint8_t byte_value) {
|
|
if (len) {
|
|
memset(ptr, byte_value, len);
|
|
}
|
|
return wuffs_base__make_empty_struct();
|
|
}
|
|
|
|
static inline wuffs_base__empty_struct //
|
|
wuffs_base__bulk_save_host_endian(void* ptr,
|
|
size_t len,
|
|
wuffs_base__slice_u8 dst) {
|
|
if (len && (len <= dst.len)) {
|
|
memmove(dst.ptr, ptr, len);
|
|
}
|
|
return wuffs_base__make_empty_struct();
|
|
}
|
|
|
|
// --------
|
|
|
|
static inline wuffs_base__slice_u8 //
|
|
wuffs_base__table_u8__row_u32(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
|