diff --git a/cmd/wuffs-c/internal/cgen/base-header.h b/cmd/wuffs-c/internal/cgen/base-header.h index 66b13937..41c6c589 100644 --- a/cmd/wuffs-c/internal/cgen/base-header.h +++ b/cmd/wuffs-c/internal/cgen/base-header.h @@ -39,7 +39,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -48,42 +54,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -208,6 +178,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/cmd/wuffs-c/internal/cgen/base-impl.h b/cmd/wuffs-c/internal/cgen/base-impl.h index 918e246f..449ecc29 100644 --- a/cmd/wuffs-c/internal/cgen/base-impl.h +++ b/cmd/wuffs-c/internal/cgen/base-impl.h @@ -90,7 +90,7 @@ // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -126,6 +126,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -209,40 +243,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 3b6d21b5..7043ff19 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -18,10 +18,9 @@ package cgen const baseHeader = "" + "#ifndef WUFFS_BASE_HEADER_H\n#define WUFFS_BASE_HEADER_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#include \n#include \n#include \n\n// Wuffs assumes that:\n// - converting a uint32_t to a size_t will never overflow.\n// - converting a size_t to a uint64_t will never overflow.\n#if (__WORDSIZE != 32) && (__WORDSIZE != 64)\n#error \"Wuffs requires a word size of either 32 or 64 bits\"\n#endif\n\n// WUFFS_VERSION is the major.minor version number " + - "as a uint32_t. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION ((uint32_t)0x00001)\n\n" + + "as a uint32_t. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION ((uint32_t)0x00001)\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" + "" + - "// ---------------- Fundamentals\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\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// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; " + - " \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\n" + + "// ---------------- Numeric Types\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" + "" + "// --------\n\nstatic inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) {\n return x > y ? x : y;\n}\n\n" + "" + @@ -30,6 +29,9 @@ const baseHeader = "" + "" + "// --------\n\n// Clang also defines \"__GNUC__\".\n\nstatic inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap16(x);\n#else\n return (x >> 8) | (x << 8);\n#endif\n}\n\nstatic inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap32(x);\n#else\n static const uint32_t mask8 = 0x00FF00FF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n return (x >> 16) | (x << 16);\n#endif\n}\n\nstatic inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap64(x);\n#else\n static const uint64_t mask8 = 0x00FF00FF00FF00FF;\n static const uint64_t mask16 = 0x0000FFFF0000FFFF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n x = ((x >> 16) & mask16) | ((x & mask16) << 16);\n return (x >> 32) | (x << 32);\n#endif\n}\n\n" + "" + + "// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TAB" + + "LE(uint64_t) wuffs_base__table_u64;\n\n" + + "" + "// ---------------- Ranges and Rects\n\n// Ranges are either inclusive (\"range_ii\") or exclusive (\"range_ie\") on the\n// high end. Both the \"ii\" and \"ie\" flavors are useful in practice.\n//\n// The \"ei\" and \"ee\" flavors also exist in theory, but aren't widely used. In\n// Wuffs, the low end is always inclusive.\n//\n// The \"ii\" (closed interval) flavor is useful when refining e.g. \"the set of\n// all uint32_t values\" to a contiguous subset: \"uint32_t values in the closed\n// interval [M, N]\", for uint32_t values M and N. An unrefined type (in other\n// words, the set of all uint32_t values) is not representable in the \"ie\"\n// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.\n//\n// On the other hand, the \"ie\" (half-open interval) flavor is recommended by\n// Dijkstra's \"Why numbering should start at zero\" at\n// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further\n// discussion of motivating rationale is at\n// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-close" + "d-inclusive\n//\n// For example, with \"ie\", the number of elements in \"uint32_t values in the\n// half-open interval [M, N)\" is equal to max(0, N-M). Furthermore, that number\n// of elements (in one dimension, a length, in two dimensions, a width or\n// height) is itself representable as a uint32_t without overflow, again for\n// uint32_t values M and N. In the contrasting \"ii\" flavor, the length of the\n// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a\n// uint32_t. In Wuffs, because of this potential overflow, the \"ie\" flavor has\n// length / width / height methods, but the \"ii\" flavor does not.\n//\n// It is valid for min > max (for range_ii) or for min >= max (for range_ie),\n// in which case the range is empty. There are multiple representations of an\n// empty range.\n\ntypedef struct {\n uint32_t min_inclusive;\n uint32_t max_inclusive;\n} wuffs_base__range_ii_u32;\n\nstatic inline bool wuffs_base__range_ii_u32__is_empty(\n wuffs_base__range_ii_u32 r) {\n return r.min_inclusive > r.max_inc" + "lusive;\n}\n\nstatic inline bool wuffs_base__range_ii_u32__contains(\n wuffs_base__range_ii_u32 r,\n uint32_t x) {\n return (r.min_inclusive <= x) && (x <= r.max_inclusive);\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);\n return r;\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(s)) {\n return r;\n }\n r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);\n return r;\n}\n\n" + @@ -86,16 +88,16 @@ const baseImpl = "" + "WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; \\\n WUFFS_BASE__FALLTHROUGH; \\\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-de" + "bugging.\n// #include \n\n// The helpers below are functions, instead of macros, because their arguments\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\n" + "" + - "// ---------------- Fundamentals\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 uint64_t wuffs_base__load_u64be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u64le(uint8_t* p) {\n" + - " return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\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__pr" + - "efix(\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\n" + - "" + - "// --------\n\nstatic inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize(\n wuffs_base__table_u8 t) {\n if (t.width == t.stride) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr,\n .len = t.width * t.height,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "// ---------------- Numeric Types\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 uint64_t wuffs_base__load_u64be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u64le(uint8_t* p) {" + + "\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\n" + "" + "// --------\n\nstatic inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_sub(*x, y);\n}\n\n" + "" + + "// ---------------- Slices and Tables\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_u" + + "8 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\n" + + "" + + "// --------\n\nstatic inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize(\n wuffs_base__table_u8 t) {\n if (t.width == t.stride) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr,\n .len = t.width * t.height,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "" + "// ---------------- Ranges and Rects\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ii_u32__set_min_inclusive_x(wuffs_base__rect_ii_u32* r,\n uint32_t x) {\n r->min_inclusive_x = x;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ii_u32__set_min_inclusive_y(wuffs_base__rect_ii_u32* r,\n uint32_t y) {\n r->min_inclusive_y = y;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ii_u32__set_max_inclusive_x(wuffs_base__rect_ii_u32* r,\n uint32_t x) {\n r->max_inclusive_x = x;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ii_u32__set_max_inclusive_y(wuffs_base__rect_ii_u32* r,\n uint32_t y) {\n r->max_inclusive_y = y;\n return ((wuffs_base__empty_struct){});\n}\n\n" + "" + "// --------\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ie_u32__set_min_inclusive_x(wuffs_base__rect_ie_u32* r,\n uint32_t x) {\n r->min_inclusive_x = x;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ie_u32__set_min_inclusive_y(wuffs_base__rect_ie_u32* r,\n uint32_t y) {\n r->min_inclusive_y = y;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ie_u32__set_max_exclusive_x(wuffs_base__rect_ie_u32* r,\n uint32_t x) {\n r->max_exclusive_x = x;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct\nwuffs_base__rect_ie_u32__set_max_exclusive_y(wuffs_base__rect_ie_u32* r,\n uint32_t y) {\n r->max_exclusive_y = y;\n return ((wuffs_base__empty_struct){});\n}\n\n" + diff --git a/gen/c/std/adler32.c b/gen/c/std/adler32.c index badd1fa8..01cbc83f 100644 --- a/gen/c/std/adler32.c +++ b/gen/c/std/adler32.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1266,7 +1268,7 @@ uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1302,6 +1304,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1385,40 +1421,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/c/std/crc32.c b/gen/c/std/crc32.c index 3880e7c4..b99a6918 100644 --- a/gen/c/std/crc32.c +++ b/gen/c/std/crc32.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1265,7 +1267,7 @@ uint32_t wuffs_crc32__ieee_hasher__update(wuffs_crc32__ieee_hasher* self, // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1301,6 +1303,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1384,40 +1420,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/c/std/deflate.c b/gen/c/std/deflate.c index 5299a37b..e1fb66fc 100644 --- a/gen/c/std/deflate.c +++ b/gen/c/std/deflate.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1357,7 +1359,7 @@ wuffs_deflate__status wuffs_deflate__decoder__decode( // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1393,6 +1395,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1476,40 +1512,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 4f4358d7..eaa075a9 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1380,7 +1382,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame( // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1416,6 +1418,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1499,40 +1535,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/c/std/gzip.c b/gen/c/std/gzip.c index 23369de1..c5b53923 100644 --- a/gen/c/std/gzip.c +++ b/gen/c/std/gzip.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1560,7 +1562,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self, // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1596,6 +1598,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1679,40 +1715,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 5d208a5c..2ac24884 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the @@ -1560,7 +1562,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -// ---------------- Fundamentals +// ---------------- Numeric Types static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); @@ -1596,6 +1598,40 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- +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 + static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( wuffs_base__slice_u8 s, uint64_t i) { @@ -1679,40 +1715,6 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__linearize( return ((wuffs_base__slice_u8){}); } -// -------- - -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); -} - // ---------------- Ranges and Rects static inline wuffs_base__empty_struct diff --git a/gen/h/std/adler32.h b/gen/h/std/adler32.h index 8a42c1ba..2d1444d4 100644 --- a/gen/h/std/adler32.h +++ b/gen/h/std/adler32.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/gen/h/std/crc32.h b/gen/h/std/crc32.h index d68d53d6..0e5f2c54 100644 --- a/gen/h/std/crc32.h +++ b/gen/h/std/crc32.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/gen/h/std/deflate.h b/gen/h/std/deflate.h index 82be726b..d9e6cba5 100644 --- a/gen/h/std/deflate.h +++ b/gen/h/std/deflate.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/gen/h/std/gif.h b/gen/h/std/gif.h index 48824b71..d8b1179c 100644 --- a/gen/h/std/gif.h +++ b/gen/h/std/gif.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/gen/h/std/gzip.h b/gen/h/std/gzip.h index 0ed90aaf..0812f002 100644 --- a/gen/h/std/gzip.h +++ b/gen/h/std/gzip.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index cfae98d2..f103fafa 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -42,7 +42,13 @@ // TODO: don't hard code this in base-header.h. #define WUFFS_VERSION ((uint32_t)0x00001) -// ---------------- Fundamentals +// 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()". +typedef struct { +} wuffs_base__empty_struct; + +// ---------------- Numeric Types // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a // second. See https://github.com/OculusVR/Flicks @@ -51,42 +57,6 @@ typedef uint64_t wuffs_base__flicks; #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) -// 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()". -typedef struct { -} wuffs_base__empty_struct; - -// WUFFS_BASE__SLICE is a 1-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty slice. -#define WUFFS_BASE__SLICE(T) \ - struct { \ - T* ptr; \ - size_t len; \ - } - -// WUFFS_BASE__TABLE is a 2-dimensional buffer. -// -// A value with all fields NULL or zero is a valid, empty table. -#define WUFFS_BASE__TABLE(T) \ - struct { \ - T* ptr; \ - size_t width; \ - size_t height; \ - size_t stride; \ - } - -typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; -typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; -typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; -typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; - -typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; -typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; -typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; -typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; - // -------- static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { @@ -211,6 +181,38 @@ static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { #endif } +// ---------------- Slices and Tables + +// WUFFS_BASE__SLICE is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +#define WUFFS_BASE__SLICE(T) \ + struct { \ + T* ptr; \ + size_t len; \ + } + +// WUFFS_BASE__TABLE is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +#define WUFFS_BASE__TABLE(T) \ + struct { \ + T* ptr; \ + size_t width; \ + size_t height; \ + size_t stride; \ + } + +typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; +typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; +typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; +typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; + +typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; +typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; +typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; +typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; + // ---------------- Ranges and Rects // Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the