From cd4a5122918aeb3f3dd34c4463d3f6f19a882851 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 14 Aug 2023 20:00:04 +0800 Subject: [PATCH 01/37] Chore: embed yyjson source code Ref: https://github.com/fastfetch-cli/fastfetch/discussions/523 --- CMakeLists.txt | 24 +- src/3rdparty/yyjson/repo.json | 6 + src/3rdparty/yyjson/yyjson.c | 9281 +++++++++++++++++++++ src/3rdparty/yyjson/yyjson.h | 7846 +++++++++++++++++ src/detection/terminalfont/terminalfont.c | 1 - src/fastfetch.h | 3 +- 6 files changed, 17137 insertions(+), 24 deletions(-) create mode 100644 src/3rdparty/yyjson/repo.json create mode 100644 src/3rdparty/yyjson/yyjson.c create mode 100644 src/3rdparty/yyjson/yyjson.h diff --git a/CMakeLists.txt b/CMakeLists.txt index a4e49c373a..63b6df913e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url & FetchContent +cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url project(fastfetch VERSION 2.0.0 @@ -36,24 +36,6 @@ endif() include(CheckIncludeFile) -include(FetchContent) -function(ff_fetch_dep package repo tag) - FetchContent_Declare( - "${package}" - GIT_REPOSITORY "${repo}" - GIT_TAG "${tag}" - GIT_PROGRESS TRUE - ) - FetchContent_GetProperties("${package}") - if(NOT ${package}_POPULATED) - message("-- Fetching dependency ${package}@${tag} from ${repo}") - FetchContent_Populate(${package}) - add_subdirectory(${${package}_SOURCE_DIR} ${${package}_BINARY_DIR} EXCLUDE_FROM_ALL) - endif() -endfunction() - -ff_fetch_dep(yyjson "https://github.com/ibireme/yyjson" "0.7.0") - ##################### # Configure options # ##################### @@ -269,6 +251,7 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}") ####################### set(LIBFASTFETCH_SRC + src/3rdparty/yyjson/yyjson.c src/common/bar.c src/common/font.c src/common/format.c @@ -847,7 +830,6 @@ target_include_directories(libfastfetch target_link_libraries(libfastfetch PRIVATE ${CMAKE_DL_LIBS} - PRIVATE yyjson ) ###################### @@ -862,7 +844,6 @@ target_compile_definitions(fastfetch ) target_link_libraries(fastfetch PRIVATE libfastfetch - PRIVATE yyjson ) add_executable(flashfetch @@ -873,7 +854,6 @@ target_compile_definitions(flashfetch ) target_link_libraries(flashfetch PRIVATE libfastfetch - PRIVATE yyjson ) if(WIN32) diff --git a/src/3rdparty/yyjson/repo.json b/src/3rdparty/yyjson/repo.json new file mode 100644 index 0000000000..d9edbde014 --- /dev/null +++ b/src/3rdparty/yyjson/repo.json @@ -0,0 +1,6 @@ +{ + "home": "https://github.com/ibireme/yyjson", + "license": "MIT ( embed in source )", + "version": "5e3b26d2659287d31e2f8e10f95f95feb7e5ab3a", + "author": "ibireme" +} diff --git a/src/3rdparty/yyjson/yyjson.c b/src/3rdparty/yyjson/yyjson.c new file mode 100644 index 0000000000..c669bab9bc --- /dev/null +++ b/src/3rdparty/yyjson/yyjson.c @@ -0,0 +1,9281 @@ +/*============================================================================== + Copyright (c) 2020 YaoYuan + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + *============================================================================*/ + +#include "yyjson.h" +#include + + + +/*============================================================================== + * Warning Suppress + *============================================================================*/ + +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunused-function" +# pragma clang diagnostic ignored "-Wunused-parameter" +# pragma clang diagnostic ignored "-Wunused-label" +# pragma clang diagnostic ignored "-Wunused-macros" +# pragma clang diagnostic ignored "-Wunused-variable" +#elif defined(__GNUC__) +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunused-parameter" +# pragma GCC diagnostic ignored "-Wunused-label" +# pragma GCC diagnostic ignored "-Wunused-macros" +# pragma GCC diagnostic ignored "-Wunused-variable" +#elif defined(_MSC_VER) +# pragma warning(disable:4100) /* unreferenced formal parameter */ +# pragma warning(disable:4101) /* unreferenced variable */ +# pragma warning(disable:4102) /* unreferenced label */ +# pragma warning(disable:4127) /* conditional expression is constant */ +# pragma warning(disable:4706) /* assignment within conditional expression */ +#endif + + + +/*============================================================================== + * Version + *============================================================================*/ + +uint32_t yyjson_version(void) { + return YYJSON_VERSION_HEX; +} + + + +/*============================================================================== + * Flags + *============================================================================*/ + +/* msvc intrinsic */ +#if YYJSON_MSC_VER >= 1400 +# include +# if defined(_M_AMD64) || defined(_M_ARM64) +# define MSC_HAS_BIT_SCAN_64 1 +# pragma intrinsic(_BitScanForward64) +# pragma intrinsic(_BitScanReverse64) +# else +# define MSC_HAS_BIT_SCAN_64 0 +# endif +# if defined(_M_AMD64) || defined(_M_ARM64) || \ + defined(_M_IX86) || defined(_M_ARM) +# define MSC_HAS_BIT_SCAN 1 +# pragma intrinsic(_BitScanForward) +# pragma intrinsic(_BitScanReverse) +# else +# define MSC_HAS_BIT_SCAN 0 +# endif +# if defined(_M_AMD64) +# define MSC_HAS_UMUL128 1 +# pragma intrinsic(_umul128) +# else +# define MSC_HAS_UMUL128 0 +# endif +#else +# define MSC_HAS_BIT_SCAN_64 0 +# define MSC_HAS_BIT_SCAN 0 +# define MSC_HAS_UMUL128 0 +#endif + +/* gcc builtin */ +#if yyjson_has_builtin(__builtin_clzll) || yyjson_gcc_available(3, 4, 0) +# define GCC_HAS_CLZLL 1 +#else +# define GCC_HAS_CLZLL 0 +#endif + +#if yyjson_has_builtin(__builtin_ctzll) || yyjson_gcc_available(3, 4, 0) +# define GCC_HAS_CTZLL 1 +#else +# define GCC_HAS_CTZLL 0 +#endif + +/* int128 type */ +#if defined(__SIZEOF_INT128__) && (__SIZEOF_INT128__ == 16) && \ + (defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER)) +# define YYJSON_HAS_INT128 1 +#else +# define YYJSON_HAS_INT128 0 +#endif + +/* IEEE 754 floating-point binary representation */ +#if defined(__STDC_IEC_559__) || defined(__STDC_IEC_60559_BFP__) +# define YYJSON_HAS_IEEE_754 1 +#elif (FLT_RADIX == 2) && (DBL_MANT_DIG == 53) && (DBL_DIG == 15) && \ + (DBL_MIN_EXP == -1021) && (DBL_MAX_EXP == 1024) && \ + (DBL_MIN_10_EXP == -307) && (DBL_MAX_10_EXP == 308) +# define YYJSON_HAS_IEEE_754 1 +#else +# define YYJSON_HAS_IEEE_754 0 +#endif + +/* + Correct rounding in double number computations. + + On the x86 architecture, some compilers may use x87 FPU instructions for + floating-point arithmetic. The x87 FPU loads all floating point number as + 80-bit double-extended precision internally, then rounds the result to original + precision, which may produce inaccurate results. For a more detailed + explanation, see the paper: https://arxiv.org/abs/cs/0701192 + + Here are some examples of double precision calculation error: + + 2877.0 / 1e6 == 0.002877, but x87 returns 0.0028770000000000002 + 43683.0 * 1e21 == 4.3683e25, but x87 returns 4.3683000000000004e25 + + Here are some examples of compiler flags to generate x87 instructions on x86: + + clang -m32 -mno-sse + gcc/icc -m32 -mfpmath=387 + msvc /arch:SSE or /arch:IA32 + + If we are sure that there's no similar error described above, we can define the + YYJSON_DOUBLE_MATH_CORRECT as 1 to enable the fast path calculation. This is + not an accurate detection, it's just try to avoid the error at compile-time. + An accurate detection can be done at run-time: + + bool is_double_math_correct(void) { + volatile double r = 43683.0; + r *= 1e21; + return r == 4.3683e25; + } + + See also: utils.h in https://github.com/google/double-conversion/ + */ +#if !defined(FLT_EVAL_METHOD) && defined(__FLT_EVAL_METHOD__) +# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ +#endif + +#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0 && FLT_EVAL_METHOD != 1 +# define YYJSON_DOUBLE_MATH_CORRECT 0 +#elif defined(i386) || defined(__i386) || defined(__i386__) || \ + defined(_X86_) || defined(__X86__) || defined(_M_IX86) || \ + defined(__I86__) || defined(__IA32__) || defined(__THW_INTEL) +# if (defined(_MSC_VER) && defined(_M_IX86_FP) && _M_IX86_FP == 2) || \ + (defined(__SSE2_MATH__) && __SSE2_MATH__) +# define YYJSON_DOUBLE_MATH_CORRECT 1 +# else +# define YYJSON_DOUBLE_MATH_CORRECT 0 +# endif +#elif defined(__mc68000__) || defined(__pnacl__) || defined(__native_client__) +# define YYJSON_DOUBLE_MATH_CORRECT 0 +#else +# define YYJSON_DOUBLE_MATH_CORRECT 1 +#endif + +/* endian */ +#if yyjson_has_include() +# include /* POSIX */ +#endif +#if yyjson_has_include() +# include /* Linux */ +#elif yyjson_has_include() +# include /* BSD, Android */ +#elif yyjson_has_include() +# include /* BSD, Darwin */ +#endif + +#define YYJSON_BIG_ENDIAN 4321 +#define YYJSON_LITTLE_ENDIAN 1234 + +#if defined(BYTE_ORDER) && BYTE_ORDER +# if defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN) +# define YYJSON_ENDIAN YYJSON_BIG_ENDIAN +# elif defined(LITTLE_ENDIAN) && (BYTE_ORDER == LITTLE_ENDIAN) +# define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN +# endif + +#elif defined(__BYTE_ORDER) && __BYTE_ORDER +# if defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) +# define YYJSON_ENDIAN YYJSON_BIG_ENDIAN +# elif defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) +# define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN +# endif + +#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ +# if defined(__ORDER_BIG_ENDIAN__) && \ + (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +# define YYJSON_ENDIAN YYJSON_BIG_ENDIAN +# elif defined(__ORDER_LITTLE_ENDIAN__) && \ + (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) +# define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN +# endif + +#elif (defined(__LITTLE_ENDIAN__) && __LITTLE_ENDIAN__ == 1) || \ + defined(__i386) || defined(__i386__) || \ + defined(_X86_) || defined(__X86__) || \ + defined(_M_IX86) || defined(__THW_INTEL__) || \ + defined(__x86_64) || defined(__x86_64__) || \ + defined(__amd64) || defined(__amd64__) || \ + defined(_M_AMD64) || defined(_M_X64) || \ + defined(_M_ARM) || defined(_M_ARM64) || \ + defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \ + defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \ + defined(__EMSCRIPTEN__) || defined(__wasm__) || \ + defined(__loongarch__) +# define YYJSON_ENDIAN YYJSON_LITTLE_ENDIAN + +#elif (defined(__BIG_ENDIAN__) && __BIG_ENDIAN__ == 1) || \ + defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \ + defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || \ + defined(__or1k__) || defined(__OR1K__) +# define YYJSON_ENDIAN YYJSON_BIG_ENDIAN + +#else +# define YYJSON_ENDIAN 0 /* unknown endian, detect at run-time */ +#endif + +/* + This macro controls how yyjson handles unaligned memory accesses. + + By default, yyjson uses `memcpy()` for memory copying. This takes advantage of + the compiler's automatic optimizations to generate unaligned memory access + instructions when the target architecture supports it. + + However, for some older compilers or architectures where `memcpy()` isn't + optimized well and may generate unnecessary function calls, consider defining + this macro as 1. In such cases, yyjson switches to manual byte-by-byte access, + potentially improving performance. An example of the generated assembly code on + the ARM platform can be found here: https://godbolt.org/z/334jjhxPT + + As this flag has already been enabled for some common architectures in the + following code, users typically don't need to manually specify it. If users are + unsure about it, please review the generated assembly code or perform actual + benchmark to make an informed decision. + */ +#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS +# if defined(__ia64) || defined(_IA64) || defined(__IA64__) || \ + defined(__ia64__) || defined(_M_IA64) || defined(__itanium__) +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* Itanium */ +# elif (defined(__arm__) || defined(__arm64__) || defined(__aarch64__)) && \ + (defined(__GNUC__) || defined(__clang__)) && \ + (!defined(__ARM_FEATURE_UNALIGNED) || !__ARM_FEATURE_UNALIGNED) +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* ARM */ +# elif defined(__sparc) || defined(__sparc__) +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* SPARC */ +# elif defined(__mips) || defined(__mips__) || defined(__MIPS__) +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* MIPS */ +# elif defined(__m68k__) || defined(M68000) +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 1 /* M68K */ +# else +# define YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS 0 +# endif +#endif + +/* + Estimated initial ratio of the JSON data (data_size / value_count). + For example: + + data: {"id":12345678,"name":"Harry"} + data_size: 30 + value_count: 5 + ratio: 6 + + yyjson uses dynamic memory with a growth factor of 1.5 when reading and writing + JSON, the ratios below are used to determine the initial memory size. + + A too large ratio will waste memory, and a too small ratio will cause multiple + memory growths and degrade performance. Currently, these ratios are generated + with some commonly used JSON datasets. + */ +#define YYJSON_READER_ESTIMATED_PRETTY_RATIO 16 +#define YYJSON_READER_ESTIMATED_MINIFY_RATIO 6 +#define YYJSON_WRITER_ESTIMATED_PRETTY_RATIO 32 +#define YYJSON_WRITER_ESTIMATED_MINIFY_RATIO 18 + +/* The initial and maximum size of the memory pool's chunk in yyjson_mut_doc. */ +#define YYJSON_MUT_DOC_STR_POOL_INIT_SIZE 0x100 +#define YYJSON_MUT_DOC_STR_POOL_MAX_SIZE 0x10000000 +#define YYJSON_MUT_DOC_VAL_POOL_INIT_SIZE (0x10 * sizeof(yyjson_mut_val)) +#define YYJSON_MUT_DOC_VAL_POOL_MAX_SIZE (0x1000000 * sizeof(yyjson_mut_val)) + +/* Default value for compile-time options. */ +#ifndef YYJSON_DISABLE_READER +#define YYJSON_DISABLE_READER 0 +#endif +#ifndef YYJSON_DISABLE_WRITER +#define YYJSON_DISABLE_WRITER 0 +#endif +#ifndef YYJSON_DISABLE_UTILS +#define YYJSON_DISABLE_UTILS 0 +#endif +#ifndef YYJSON_DISABLE_FAST_FP_CONV +#define YYJSON_DISABLE_FAST_FP_CONV 0 +#endif +#ifndef YYJSON_DISABLE_NON_STANDARD +#define YYJSON_DISABLE_NON_STANDARD 0 +#endif +#ifndef YYJSON_DISABLE_UTF8_VALIDATION +#define YYJSON_DISABLE_UTF8_VALIDATION 0 +#endif + + + +/*============================================================================== + * Macros + *============================================================================*/ + +/* Macros used for loop unrolling and other purpose. */ +#define repeat2(x) { x x } +#define repeat3(x) { x x x } +#define repeat4(x) { x x x x } +#define repeat8(x) { x x x x x x x x } +#define repeat16(x) { x x x x x x x x x x x x x x x x } + +#define repeat2_incr(x) { x(0) x(1) } +#define repeat4_incr(x) { x(0) x(1) x(2) x(3) } +#define repeat8_incr(x) { x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) } +#define repeat16_incr(x) { x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \ + x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) } + +#define repeat_in_1_18(x) { x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) \ + x(9) x(10) x(11) x(12) x(13) x(14) x(15) x(16) \ + x(17) x(18) } + +/* Macros used to provide branch prediction information for compiler. */ +#undef likely +#define likely(x) yyjson_likely(x) +#undef unlikely +#define unlikely(x) yyjson_unlikely(x) + +/* Macros used to provide inline information for compiler. */ +#undef static_inline +#define static_inline static yyjson_inline +#undef static_noinline +#define static_noinline static yyjson_noinline + +/* Macros for min and max. */ +#undef yyjson_min +#define yyjson_min(x, y) ((x) < (y) ? (x) : (y)) +#undef yyjson_max +#define yyjson_max(x, y) ((x) > (y) ? (x) : (y)) + +/* Used to write u64 literal for C89 which doesn't support "ULL" suffix. */ +#undef U64 +#define U64(hi, lo) ((((u64)hi##UL) << 32U) + lo##UL) + +/* Used to cast away (remove) const qualifier. */ +#define constcast(type) (type)(void *)(size_t)(const void *) + +/* flag test */ +#define has_read_flag(_flag) unlikely(read_flag_eq(flg, YYJSON_READ_##_flag)) +#define has_write_flag(_flag) unlikely(write_flag_eq(flg, YYJSON_WRITE_##_flag)) + +static_inline bool read_flag_eq(yyjson_read_flag flg, yyjson_read_flag chk) { +#if YYJSON_DISABLE_NON_STANDARD + if (chk == YYJSON_READ_ALLOW_INF_AND_NAN || + chk == YYJSON_READ_ALLOW_COMMENTS || + chk == YYJSON_READ_ALLOW_TRAILING_COMMAS || + chk == YYJSON_READ_ALLOW_INVALID_UNICODE) + return false; /* this should be evaluated at compile-time */ +#endif + return (flg & chk) != 0; +} + +static_inline bool write_flag_eq(yyjson_write_flag flg, yyjson_write_flag chk) { +#if YYJSON_DISABLE_NON_STANDARD + if (chk == YYJSON_WRITE_ALLOW_INF_AND_NAN || + chk == YYJSON_WRITE_ALLOW_INVALID_UNICODE) + return false; /* this should be evaluated at compile-time */ +#endif + return (flg & chk) != 0; +} + + + +/*============================================================================== + * Integer Constants + *============================================================================*/ + +/* U64 constant values */ +#undef U64_MAX +#define U64_MAX U64(0xFFFFFFFF, 0xFFFFFFFF) +#undef I64_MAX +#define I64_MAX U64(0x7FFFFFFF, 0xFFFFFFFF) +#undef USIZE_MAX +#define USIZE_MAX ((usize)(~(usize)0)) + +/* Maximum number of digits for reading u32/u64/usize safety (not overflow). */ +#undef U32_SAFE_DIG +#define U32_SAFE_DIG 9 /* u32 max is 4294967295, 10 digits */ +#undef U64_SAFE_DIG +#define U64_SAFE_DIG 19 /* u64 max is 18446744073709551615, 20 digits */ +#undef USIZE_SAFE_DIG +#define USIZE_SAFE_DIG (sizeof(usize) == 8 ? U64_SAFE_DIG : U32_SAFE_DIG) + + + +/*============================================================================== + * IEEE-754 Double Number Constants + *============================================================================*/ + +/* Inf raw value (positive) */ +#define F64_RAW_INF U64(0x7FF00000, 0x00000000) + +/* NaN raw value (quiet NaN, no payload, no sign) */ +#if defined(__hppa__) || (defined(__mips__) && !defined(__mips_nan2008)) +#define F64_RAW_NAN U64(0x7FF7FFFF, 0xFFFFFFFF) +#else +#define F64_RAW_NAN U64(0x7FF80000, 0x00000000) +#endif + +/* double number bits */ +#define F64_BITS 64 + +/* double number exponent part bits */ +#define F64_EXP_BITS 11 + +/* double number significand part bits */ +#define F64_SIG_BITS 52 + +/* double number significand part bits (with 1 hidden bit) */ +#define F64_SIG_FULL_BITS 53 + +/* double number significand bit mask */ +#define F64_SIG_MASK U64(0x000FFFFF, 0xFFFFFFFF) + +/* double number exponent bit mask */ +#define F64_EXP_MASK U64(0x7FF00000, 0x00000000) + +/* double number exponent bias */ +#define F64_EXP_BIAS 1023 + +/* double number significant digits count in decimal */ +#define F64_DEC_DIG 17 + +/* max significant digits count in decimal when reading double number */ +#define F64_MAX_DEC_DIG 768 + +/* maximum decimal power of double number (1.7976931348623157e308) */ +#define F64_MAX_DEC_EXP 308 + +/* minimum decimal power of double number (4.9406564584124654e-324) */ +#define F64_MIN_DEC_EXP (-324) + +/* maximum binary power of double number */ +#define F64_MAX_BIN_EXP 1024 + +/* minimum binary power of double number */ +#define F64_MIN_BIN_EXP (-1021) + + + +/*============================================================================== + * Types + *============================================================================*/ + +/** Type define for primitive types. */ +typedef float f32; +typedef double f64; +typedef int8_t i8; +typedef uint8_t u8; +typedef int16_t i16; +typedef uint16_t u16; +typedef int32_t i32; +typedef uint32_t u32; +typedef int64_t i64; +typedef uint64_t u64; +typedef size_t usize; + +/** 128-bit integer, used by floating-point number reader and writer. */ +#if YYJSON_HAS_INT128 +__extension__ typedef __int128 i128; +__extension__ typedef unsigned __int128 u128; +#endif + +/** 16/32/64-bit vector */ +typedef struct v16 { char c[2]; } v16; +typedef struct v32 { char c[4]; } v32; +typedef struct v64 { char c[8]; } v64; + +/** 16/32/64-bit vector union */ +typedef union v16_uni { v16 v; u16 u; } v16_uni; +typedef union v32_uni { v32 v; u32 u; } v32_uni; +typedef union v64_uni { v64 v; u64 u; } v64_uni; + + + +/*============================================================================== + * Load/Store Utils + *============================================================================*/ + +#if YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS + +#define byte_move_idx(x) ((char *)dst)[x] = ((const char *)src)[x]; + +static_inline void byte_copy_2(void *dst, const void *src) { + repeat2_incr(byte_move_idx) +} + +static_inline void byte_copy_4(void *dst, const void *src) { + repeat4_incr(byte_move_idx) +} + +static_inline void byte_copy_8(void *dst, const void *src) { + repeat8_incr(byte_move_idx) +} + +static_inline void byte_copy_16(void *dst, const void *src) { + repeat16_incr(byte_move_idx) +} + +static_inline void byte_move_2(void *dst, const void *src) { + repeat2_incr(byte_move_idx) +} + +static_inline void byte_move_4(void *dst, const void *src) { + repeat4_incr(byte_move_idx) +} + +static_inline void byte_move_8(void *dst, const void *src) { + repeat8_incr(byte_move_idx) +} + +static_inline void byte_move_16(void *dst, const void *src) { + repeat16_incr(byte_move_idx) +} + +static_inline bool byte_match_2(void *buf, const char *pat) { + return + ((char *)buf)[0] == ((const char *)pat)[0] && + ((char *)buf)[1] == ((const char *)pat)[1]; +} + +static_inline bool byte_match_4(void *buf, const char *pat) { + return + ((char *)buf)[0] == ((const char *)pat)[0] && + ((char *)buf)[1] == ((const char *)pat)[1] && + ((char *)buf)[2] == ((const char *)pat)[2] && + ((char *)buf)[3] == ((const char *)pat)[3]; +} + +static_inline u16 byte_load_2(const void *src) { + v16_uni uni; + uni.v.c[0] = ((const char *)src)[0]; + uni.v.c[1] = ((const char *)src)[1]; + return uni.u; +} + +static_inline u32 byte_load_3(const void *src) { + v32_uni uni; + uni.v.c[0] = ((const char *)src)[0]; + uni.v.c[1] = ((const char *)src)[1]; + uni.v.c[2] = ((const char *)src)[2]; + uni.v.c[3] = 0; + return uni.u; +} + +static_inline u32 byte_load_4(const void *src) { + v32_uni uni; + uni.v.c[0] = ((const char *)src)[0]; + uni.v.c[1] = ((const char *)src)[1]; + uni.v.c[2] = ((const char *)src)[2]; + uni.v.c[3] = ((const char *)src)[3]; + return uni.u; +} + +#undef byte_move_expr + +#else + +static_inline void byte_copy_2(void *dst, const void *src) { + memcpy(dst, src, 2); +} + +static_inline void byte_copy_4(void *dst, const void *src) { + memcpy(dst, src, 4); +} + +static_inline void byte_copy_8(void *dst, const void *src) { + memcpy(dst, src, 8); +} + +static_inline void byte_copy_16(void *dst, const void *src) { + memcpy(dst, src, 16); +} + +static_inline void byte_move_2(void *dst, const void *src) { + u16 tmp; + memcpy(&tmp, src, 2); + memcpy(dst, &tmp, 2); +} + +static_inline void byte_move_4(void *dst, const void *src) { + u32 tmp; + memcpy(&tmp, src, 4); + memcpy(dst, &tmp, 4); +} + +static_inline void byte_move_8(void *dst, const void *src) { + u64 tmp; + memcpy(&tmp, src, 8); + memcpy(dst, &tmp, 8); +} + +static_inline void byte_move_16(void *dst, const void *src) { + char *pdst = (char *)dst; + const char *psrc = (const char *)src; + u64 tmp1, tmp2; + memcpy(&tmp1, psrc, 8); + memcpy(&tmp2, psrc + 8, 8); + memcpy(pdst, &tmp1, 8); + memcpy(pdst + 8, &tmp2, 8); +} + +static_inline bool byte_match_2(void *buf, const char *pat) { + v16_uni u1, u2; + memcpy(&u1, buf, 2); + memcpy(&u2, pat, 2); + return u1.u == u2.u; +} + +static_inline bool byte_match_4(void *buf, const char *pat) { + v32_uni u1, u2; + memcpy(&u1, buf, 4); + memcpy(&u2, pat, 4); + return u1.u == u2.u; +} + +static_inline u16 byte_load_2(const void *src) { + v16_uni uni; + memcpy(&uni, src, 2); + return uni.u; +} + +static_inline u32 byte_load_3(const void *src) { + v32_uni uni; + memcpy(&uni, src, 2); + uni.v.c[2] = ((const char *)src)[2]; + uni.v.c[3] = 0; + return uni.u; +} + +static_inline u32 byte_load_4(const void *src) { + v32_uni uni; + memcpy(&uni, src, 4); + return uni.u; +} + +#endif + + + +/*============================================================================== + * Number Utils + * These functions are used to detect and convert NaN and Inf numbers. + *============================================================================*/ + +/** Convert raw binary to double. */ +static_inline f64 f64_from_raw(u64 u) { + /* use memcpy to avoid violating the strict aliasing rule */ + f64 f; + memcpy(&f, &u, 8); + return f; +} + +/** Convert double to raw binary. */ +static_inline u64 f64_to_raw(f64 f) { + /* use memcpy to avoid violating the strict aliasing rule */ + u64 u; + memcpy(&u, &f, 8); + return u; +} + +/** Get raw 'infinity' with sign. */ +static_inline u64 f64_raw_get_inf(bool sign) { +#if YYJSON_HAS_IEEE_754 + return F64_RAW_INF | ((u64)sign << 63); +#elif defined(INFINITY) + return f64_to_raw(sign ? -INFINITY : INFINITY); +#else + return f64_to_raw(sign ? -HUGE_VAL : HUGE_VAL); +#endif +} + +/** Get raw 'nan' with sign. */ +static_inline u64 f64_raw_get_nan(bool sign) { +#if YYJSON_HAS_IEEE_754 + return F64_RAW_NAN | ((u64)sign << 63); +#elif defined(NAN) + return f64_to_raw(sign ? (f64)-NAN : (f64)NAN); +#else + return f64_to_raw((sign ? -0.0 : 0.0) / 0.0); +#endif +} + +/** + Convert normalized u64 (highest bit is 1) to f64. + + Some compiler (such as Microsoft Visual C++ 6.0) do not support converting + number from u64 to f64. This function will first convert u64 to i64 and then + to f64, with `to nearest` rounding mode. + */ +static_inline f64 normalized_u64_to_f64(u64 val) { +#if YYJSON_U64_TO_F64_NO_IMPL + i64 sig = (i64)((val >> 1) | (val & 1)); + return ((f64)sig) * (f64)2.0; +#else + return (f64)val; +#endif +} + + + +/*============================================================================== + * Size Utils + * These functions are used for memory allocation. + *============================================================================*/ + +/** Returns whether the size is overflow after increment. */ +static_inline bool size_add_is_overflow(usize size, usize add) { + return size > (size + add); +} + +/** Returns whether the size is power of 2 (size should not be 0). */ +static_inline bool size_is_pow2(usize size) { + return (size & (size - 1)) == 0; +} + +/** Align size upwards (may overflow). */ +static_inline usize size_align_up(usize size, usize align) { + if (size_is_pow2(align)) { + return (size + (align - 1)) & ~(align - 1); + } else { + return size + align - (size + align - 1) % align - 1; + } +} + +/** Align size downwards. */ +static_inline usize size_align_down(usize size, usize align) { + if (size_is_pow2(align)) { + return size & ~(align - 1); + } else { + return size - (size % align); + } +} + +/** Align address upwards (may overflow). */ +static_inline void *mem_align_up(void *mem, usize align) { + usize size; + memcpy(&size, &mem, sizeof(usize)); + size = size_align_up(size, align); + memcpy(&mem, &size, sizeof(usize)); + return mem; +} + + + +/*============================================================================== + * Bits Utils + * These functions are used by the floating-point number reader and writer. + *============================================================================*/ + +/** Returns the number of leading 0-bits in value (input should not be 0). */ +static_inline u32 u64_lz_bits(u64 v) { +#if GCC_HAS_CLZLL + return (u32)__builtin_clzll(v); +#elif MSC_HAS_BIT_SCAN_64 + unsigned long r; + _BitScanReverse64(&r, v); + return (u32)63 - (u32)r; +#elif MSC_HAS_BIT_SCAN + unsigned long hi, lo; + bool hi_set = _BitScanReverse(&hi, (u32)(v >> 32)) != 0; + _BitScanReverse(&lo, (u32)v); + hi |= 32; + return (u32)63 - (u32)(hi_set ? hi : lo); +#else + /* + branchless, use de Bruijn sequences + see: https://www.chessprogramming.org/BitScan + */ + const u8 table[64] = { + 63, 16, 62, 7, 15, 36, 61, 3, 6, 14, 22, 26, 35, 47, 60, 2, + 9, 5, 28, 11, 13, 21, 42, 19, 25, 31, 34, 40, 46, 52, 59, 1, + 17, 8, 37, 4, 23, 27, 48, 10, 29, 12, 43, 20, 32, 41, 53, 18, + 38, 24, 49, 30, 44, 33, 54, 39, 50, 45, 55, 51, 56, 57, 58, 0 + }; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v |= v >> 32; + return table[(v * U64(0x03F79D71, 0xB4CB0A89)) >> 58]; +#endif +} + +/** Returns the number of trailing 0-bits in value (input should not be 0). */ +static_inline u32 u64_tz_bits(u64 v) { +#if GCC_HAS_CTZLL + return (u32)__builtin_ctzll(v); +#elif MSC_HAS_BIT_SCAN_64 + unsigned long r; + _BitScanForward64(&r, v); + return (u32)r; +#elif MSC_HAS_BIT_SCAN + unsigned long lo, hi; + bool lo_set = _BitScanForward(&lo, (u32)(v)) != 0; + _BitScanForward(&hi, (u32)(v >> 32)); + hi += 32; + return lo_set ? lo : hi; +#else + /* + branchless, use de Bruijn sequences + see: https://www.chessprogramming.org/BitScan + */ + const u8 table[64] = { + 0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28, + 62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11, + 63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10, + 51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12 + }; + return table[((v & (~v + 1)) * U64(0x022FDD63, 0xCC95386D)) >> 58]; +#endif +} + + + +/*============================================================================== + * 128-bit Integer Utils + * These functions are used by the floating-point number reader and writer. + *============================================================================*/ + +/** Multiplies two 64-bit unsigned integers (a * b), + returns the 128-bit result as 'hi' and 'lo'. */ +static_inline void u128_mul(u64 a, u64 b, u64 *hi, u64 *lo) { +#if YYJSON_HAS_INT128 + u128 m = (u128)a * b; + *hi = (u64)(m >> 64); + *lo = (u64)(m); +#elif MSC_HAS_UMUL128 + *lo = _umul128(a, b, hi); +#else + u32 a0 = (u32)(a), a1 = (u32)(a >> 32); + u32 b0 = (u32)(b), b1 = (u32)(b >> 32); + u64 p00 = (u64)a0 * b0, p01 = (u64)a0 * b1; + u64 p10 = (u64)a1 * b0, p11 = (u64)a1 * b1; + u64 m0 = p01 + (p00 >> 32); + u32 m00 = (u32)(m0), m01 = (u32)(m0 >> 32); + u64 m1 = p10 + m00; + u32 m10 = (u32)(m1), m11 = (u32)(m1 >> 32); + *hi = p11 + m01 + m11; + *lo = ((u64)m10 << 32) | (u32)p00; +#endif +} + +/** Multiplies two 64-bit unsigned integers and add a value (a * b + c), + returns the 128-bit result as 'hi' and 'lo'. */ +static_inline void u128_mul_add(u64 a, u64 b, u64 c, u64 *hi, u64 *lo) { +#if YYJSON_HAS_INT128 + u128 m = (u128)a * b + c; + *hi = (u64)(m >> 64); + *lo = (u64)(m); +#else + u64 h, l, t; + u128_mul(a, b, &h, &l); + t = l + c; + h += (u64)(((t < l) | (t < c))); + *hi = h; + *lo = t; +#endif +} + + + +/*============================================================================== + * File Utils + * These functions are used to read and write JSON files. + *============================================================================*/ + +#define YYJSON_FOPEN_EXT +#if !defined(_MSC_VER) && defined(__GLIBC__) && defined(__GLIBC_PREREQ) +# if __GLIBC_PREREQ(2, 7) +# undef YYJSON_FOPEN_EXT +# define YYJSON_FOPEN_EXT "e" /* glibc extension to enable O_CLOEXEC */ +# endif +#endif + +static_inline FILE *fopen_safe(const char *path, const char *mode) { +#if YYJSON_MSC_VER >= 1400 + FILE *file = NULL; + if (fopen_s(&file, path, mode) != 0) return NULL; + return file; +#else + return fopen(path, mode); +#endif +} + +static_inline FILE *fopen_readonly(const char *path) { + return fopen_safe(path, "rb" YYJSON_FOPEN_EXT); +} + +static_inline FILE *fopen_writeonly(const char *path) { + return fopen_safe(path, "wb" YYJSON_FOPEN_EXT); +} + +static_inline usize fread_safe(void *buf, usize size, FILE *file) { +#if YYJSON_MSC_VER >= 1400 + return fread_s(buf, size, 1, size, file); +#else + return fread(buf, 1, size, file); +#endif +} + + + +/*============================================================================== + * Default Memory Allocator + * This is a simple libc memory allocator wrapper. + *============================================================================*/ + +static void *default_malloc(void *ctx, usize size) { + return malloc(size); +} + +static void *default_realloc(void *ctx, void *ptr, usize old_size, usize size) { + return realloc(ptr, size); +} + +static void default_free(void *ctx, void *ptr) { + free(ptr); +} + +static const yyjson_alc YYJSON_DEFAULT_ALC = { + default_malloc, + default_realloc, + default_free, + NULL +}; + +static void *null_malloc(void *ctx, usize size) { + return NULL; +} + +static void *null_realloc(void *ctx, void *ptr, usize old_size, usize size) { + return NULL; +} + +static void null_free(void *ctx, void *ptr) { + return; +} + +static const yyjson_alc YYJSON_NULL_ALC = { + null_malloc, + null_realloc, + null_free, + NULL +}; + + + +/*============================================================================== + * Pool Memory Allocator + * This is a simple memory allocator that uses linked list memory chunk. + * The following code will be executed only when the library user creates + * this allocator manually. + *============================================================================*/ + +/** chunk header */ +typedef struct pool_chunk { + usize size; /* chunk memory size (include chunk header) */ + struct pool_chunk *next; +} pool_chunk; + +/** ctx header */ +typedef struct pool_ctx { + usize size; /* total memory size (include ctx header) */ + pool_chunk *free_list; +} pool_ctx; + +static void *pool_malloc(void *ctx_ptr, usize size) { + pool_ctx *ctx = (pool_ctx *)ctx_ptr; + pool_chunk *next, *prev = NULL, *cur = ctx->free_list; + + if (unlikely(size == 0 || size >= ctx->size)) return NULL; + size = size_align_up(size, sizeof(pool_chunk)) + sizeof(pool_chunk); + + while (cur) { + if (cur->size < size) { + /* not enough space, try next chunk */ + prev = cur; + cur = cur->next; + continue; + } + if (cur->size >= size + sizeof(pool_chunk) * 2) { + /* too much space, split this chunk */ + next = (pool_chunk *)(void *)((u8 *)cur + size); + next->size = cur->size - size; + next->next = cur->next; + cur->size = size; + } else { + /* just enough space, use whole chunk */ + next = cur->next; + } + if (prev) prev->next = next; + else ctx->free_list = next; + return (void *)(cur + 1); + } + return NULL; +} + +static void pool_free(void *ctx_ptr, void *ptr) { + pool_ctx *ctx = (pool_ctx *)ctx_ptr; + pool_chunk *cur = ((pool_chunk *)ptr) - 1; + pool_chunk *prev = NULL, *next = ctx->free_list; + + while (next && next < cur) { + prev = next; + next = next->next; + } + if (prev) prev->next = cur; + else ctx->free_list = cur; + cur->next = next; + + if (next && ((u8 *)cur + cur->size) == (u8 *)next) { + /* merge cur to higher chunk */ + cur->size += next->size; + cur->next = next->next; + } + if (prev && ((u8 *)prev + prev->size) == (u8 *)cur) { + /* merge cur to lower chunk */ + prev->size += cur->size; + prev->next = cur->next; + } +} + +static void *pool_realloc(void *ctx_ptr, void *ptr, + usize old_size, usize size) { + pool_ctx *ctx = (pool_ctx *)ctx_ptr; + pool_chunk *cur = ((pool_chunk *)ptr) - 1, *prev, *next, *tmp; + usize free_size; + void *new_ptr; + + if (unlikely(size == 0 || size >= ctx->size)) return NULL; + size = size_align_up(size, sizeof(pool_chunk)) + sizeof(pool_chunk); + + /* reduce size */ + if (unlikely(size <= cur->size)) { + free_size = cur->size - size; + if (free_size >= sizeof(pool_chunk) * 2) { + tmp = (pool_chunk *)(void *)((u8 *)cur + cur->size - free_size); + tmp->size = free_size; + pool_free(ctx_ptr, (void *)(tmp + 1)); + cur->size -= free_size; + } + return ptr; + } + + /* find next and prev chunk */ + prev = NULL; + next = ctx->free_list; + while (next && next < cur) { + prev = next; + next = next->next; + } + + /* merge to higher chunk if they are contiguous */ + if ((u8 *)cur + cur->size == (u8 *)next && + cur->size + next->size >= size) { + free_size = cur->size + next->size - size; + if (free_size > sizeof(pool_chunk) * 2) { + tmp = (pool_chunk *)(void *)((u8 *)cur + size); + if (prev) prev->next = tmp; + else ctx->free_list = tmp; + tmp->next = next->next; + tmp->size = free_size; + cur->size = size; + } else { + if (prev) prev->next = next->next; + else ctx->free_list = next->next; + cur->size += next->size; + } + return ptr; + } + + /* fallback to malloc and memcpy */ + new_ptr = pool_malloc(ctx_ptr, size - sizeof(pool_chunk)); + if (new_ptr) { + memcpy(new_ptr, ptr, cur->size - sizeof(pool_chunk)); + pool_free(ctx_ptr, ptr); + } + return new_ptr; +} + +bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, usize size) { + pool_chunk *chunk; + pool_ctx *ctx; + + if (unlikely(!alc)) return false; + *alc = YYJSON_NULL_ALC; + if (size < sizeof(pool_ctx) * 4) return false; + ctx = (pool_ctx *)mem_align_up(buf, sizeof(pool_ctx)); + if (unlikely(!ctx)) return false; + size -= (usize)((u8 *)ctx - (u8 *)buf); + size = size_align_down(size, sizeof(pool_ctx)); + + chunk = (pool_chunk *)(ctx + 1); + chunk->size = size - sizeof(pool_ctx); + chunk->next = NULL; + ctx->size = size; + ctx->free_list = chunk; + + alc->malloc = pool_malloc; + alc->realloc = pool_realloc; + alc->free = pool_free; + alc->ctx = (void *)ctx; + return true; +} + + + +/*============================================================================== + * JSON document and value + *============================================================================*/ + +static_inline void unsafe_yyjson_str_pool_release(yyjson_str_pool *pool, + yyjson_alc *alc) { + yyjson_str_chunk *chunk = pool->chunks, *next; + while (chunk) { + next = chunk->next; + alc->free(alc->ctx, chunk); + chunk = next; + } +} + +static_inline void unsafe_yyjson_val_pool_release(yyjson_val_pool *pool, + yyjson_alc *alc) { + yyjson_val_chunk *chunk = pool->chunks, *next; + while (chunk) { + next = chunk->next; + alc->free(alc->ctx, chunk); + chunk = next; + } +} + +bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool, + const yyjson_alc *alc, usize len) { + yyjson_str_chunk *chunk; + usize size, max_len; + + /* create a new chunk */ + max_len = USIZE_MAX - sizeof(yyjson_str_chunk); + if (unlikely(len > max_len)) return false; + size = len + sizeof(yyjson_str_chunk); + size = yyjson_max(pool->chunk_size, size); + chunk = (yyjson_str_chunk *)alc->malloc(alc->ctx, size); + if (unlikely(!chunk)) return false; + + /* insert the new chunk as the head of the linked list */ + chunk->next = pool->chunks; + chunk->chunk_size = size; + pool->chunks = chunk; + pool->cur = (char *)chunk + sizeof(yyjson_str_chunk); + pool->end = (char *)chunk + size; + + /* the next chunk is twice the size of the current one */ + size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max); + if (size < pool->chunk_size) size = pool->chunk_size_max; /* overflow */ + pool->chunk_size = size; + return true; +} + +bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool, + const yyjson_alc *alc, usize count) { + yyjson_val_chunk *chunk; + usize size, max_count; + + /* create a new chunk */ + max_count = USIZE_MAX / sizeof(yyjson_mut_val) - 1; + if (unlikely(count > max_count)) return false; + size = (count + 1) * sizeof(yyjson_mut_val); + size = yyjson_max(pool->chunk_size, size); + chunk = (yyjson_val_chunk *)alc->malloc(alc->ctx, size); + if (unlikely(!chunk)) return false; + + /* insert the new chunk as the head of the linked list */ + chunk->next = pool->chunks; + chunk->chunk_size = size; + pool->chunks = chunk; + pool->cur = (yyjson_mut_val *)(void *)((u8 *)chunk) + 1; + pool->end = (yyjson_mut_val *)(void *)((u8 *)chunk + size); + + /* the next chunk is twice the size of the current one */ + size = yyjson_min(pool->chunk_size * 2, pool->chunk_size_max); + if (size < pool->chunk_size) size = pool->chunk_size_max; /* overflow */ + pool->chunk_size = size; + return true; +} + +bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc *doc, size_t len) { + usize max_size = USIZE_MAX - sizeof(yyjson_str_chunk); + if (!doc || !len || len > max_size) return false; + doc->str_pool.chunk_size = len + sizeof(yyjson_str_chunk); + return true; +} + +bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc, size_t count) { + usize max_count = USIZE_MAX / sizeof(yyjson_mut_val) - 1; + if (!doc || !count || count > max_count) return false; + doc->val_pool.chunk_size = (count + 1) * sizeof(yyjson_mut_val); + return true; +} + +void yyjson_mut_doc_free(yyjson_mut_doc *doc) { + if (doc) { + yyjson_alc alc = doc->alc; + unsafe_yyjson_str_pool_release(&doc->str_pool, &alc); + unsafe_yyjson_val_pool_release(&doc->val_pool, &alc); + alc.free(alc.ctx, doc); + } +} + +yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc) { + yyjson_mut_doc *doc; + if (!alc) alc = &YYJSON_DEFAULT_ALC; + doc = (yyjson_mut_doc *)alc->malloc(alc->ctx, sizeof(yyjson_mut_doc)); + if (!doc) return NULL; + memset(doc, 0, sizeof(yyjson_mut_doc)); + + doc->alc = *alc; + doc->str_pool.chunk_size = YYJSON_MUT_DOC_STR_POOL_INIT_SIZE; + doc->str_pool.chunk_size_max = YYJSON_MUT_DOC_STR_POOL_MAX_SIZE; + doc->val_pool.chunk_size = YYJSON_MUT_DOC_VAL_POOL_INIT_SIZE; + doc->val_pool.chunk_size_max = YYJSON_MUT_DOC_VAL_POOL_MAX_SIZE; + return doc; +} + +yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc, const yyjson_alc *alc) { + yyjson_mut_doc *m_doc; + yyjson_mut_val *m_val; + + if (!doc || !doc->root) return NULL; + m_doc = yyjson_mut_doc_new(alc); + if (!m_doc) return NULL; + m_val = yyjson_val_mut_copy(m_doc, doc->root); + if (!m_val) { + yyjson_mut_doc_free(m_doc); + return NULL; + } + yyjson_mut_doc_set_root(m_doc, m_val); + return m_doc; +} + +yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc, + const yyjson_alc *alc) { + yyjson_mut_doc *m_doc; + yyjson_mut_val *m_val; + + if (!doc) return NULL; + if (!doc->root) return yyjson_mut_doc_new(alc); + + m_doc = yyjson_mut_doc_new(alc); + if (!m_doc) return NULL; + m_val = yyjson_mut_val_mut_copy(m_doc, doc->root); + if (!m_val) { + yyjson_mut_doc_free(m_doc); + return NULL; + } + yyjson_mut_doc_set_root(m_doc, m_val); + return m_doc; +} + +yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *m_doc, + yyjson_val *i_vals) { + /* + The immutable object or array stores all sub-values in a contiguous memory, + We copy them to another contiguous memory as mutable values, + then reconnect the mutable values with the original relationship. + */ + + usize i_vals_len; + yyjson_mut_val *m_vals, *m_val; + yyjson_val *i_val, *i_end; + + if (!m_doc || !i_vals) return NULL; + i_end = unsafe_yyjson_get_next(i_vals); + i_vals_len = (usize)(unsafe_yyjson_get_next(i_vals) - i_vals); + m_vals = unsafe_yyjson_mut_val(m_doc, i_vals_len); + if (!m_vals) return NULL; + i_val = i_vals; + m_val = m_vals; + + for (; i_val < i_end; i_val++, m_val++) { + yyjson_type type = unsafe_yyjson_get_type(i_val); + m_val->tag = i_val->tag; + m_val->uni.u64 = i_val->uni.u64; + if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) { + const char *str = i_val->uni.str; + usize str_len = unsafe_yyjson_get_len(i_val); + m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len); + if (!m_val->uni.str) return NULL; + } else if (type == YYJSON_TYPE_ARR) { + usize len = unsafe_yyjson_get_len(i_val); + if (len > 0) { + yyjson_val *ii_val = i_val + 1, *ii_next; + yyjson_mut_val *mm_val = m_val + 1, *mm_ctn = m_val, *mm_next; + while (len-- > 1) { + ii_next = unsafe_yyjson_get_next(ii_val); + mm_next = mm_val + (ii_next - ii_val); + mm_val->next = mm_next; + ii_val = ii_next; + mm_val = mm_next; + } + mm_val->next = mm_ctn + 1; + mm_ctn->uni.ptr = mm_val; + } + } else if (type == YYJSON_TYPE_OBJ) { + usize len = unsafe_yyjson_get_len(i_val); + if (len > 0) { + yyjson_val *ii_key = i_val + 1, *ii_nextkey; + yyjson_mut_val *mm_key = m_val + 1, *mm_ctn = m_val; + yyjson_mut_val *mm_nextkey; + while (len-- > 1) { + ii_nextkey = unsafe_yyjson_get_next(ii_key + 1); + mm_nextkey = mm_key + (ii_nextkey - ii_key); + mm_key->next = mm_key + 1; + mm_key->next->next = mm_nextkey; + ii_key = ii_nextkey; + mm_key = mm_nextkey; + } + mm_key->next = mm_key + 1; + mm_key->next->next = mm_ctn + 1; + mm_ctn->uni.ptr = mm_key; + } + } + } + + return m_vals; +} + +static yyjson_mut_val *unsafe_yyjson_mut_val_mut_copy(yyjson_mut_doc *m_doc, + yyjson_mut_val *m_vals) { + /* + The mutable object or array stores all sub-values in a circular linked + list, so we can traverse them in the same loop. The traversal starts from + the last item, continues with the first item in a list, and ends with the + second to last item, which needs to be linked to the last item to close the + circle. + */ + + yyjson_mut_val *m_val = unsafe_yyjson_mut_val(m_doc, 1); + if (unlikely(!m_val)) return NULL; + m_val->tag = m_vals->tag; + + switch (unsafe_yyjson_get_type(m_vals)) { + case YYJSON_TYPE_OBJ: + case YYJSON_TYPE_ARR: + if (unsafe_yyjson_get_len(m_vals) > 0) { + yyjson_mut_val *last = (yyjson_mut_val *)m_vals->uni.ptr; + yyjson_mut_val *next = last->next, *prev; + prev = unsafe_yyjson_mut_val_mut_copy(m_doc, last); + if (!prev) return NULL; + m_val->uni.ptr = (void *)prev; + while (next != last) { + prev->next = unsafe_yyjson_mut_val_mut_copy(m_doc, next); + if (!prev->next) return NULL; + prev = prev->next; + next = next->next; + } + prev->next = (yyjson_mut_val *)m_val->uni.ptr; + } + break; + + case YYJSON_TYPE_RAW: + case YYJSON_TYPE_STR: { + const char *str = m_vals->uni.str; + usize str_len = unsafe_yyjson_get_len(m_vals); + m_val->uni.str = unsafe_yyjson_mut_strncpy(m_doc, str, str_len); + if (!m_val->uni.str) return NULL; + break; + } + + default: + m_val->uni = m_vals->uni; + break; + } + + return m_val; +} + +yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc, + yyjson_mut_val *val) { + if (doc && val) return unsafe_yyjson_mut_val_mut_copy(doc, val); + return NULL; +} + +/* Count the number of values and the total length of the strings. */ +static void yyjson_mut_stat(yyjson_mut_val *val, + usize *val_sum, usize *str_sum) { + yyjson_type type = unsafe_yyjson_get_type(val); + *val_sum += 1; + if (type == YYJSON_TYPE_ARR || type == YYJSON_TYPE_OBJ) { + yyjson_mut_val *child = (yyjson_mut_val *)val->uni.ptr; + usize len = unsafe_yyjson_get_len(val), i; + len <<= (u8)(type == YYJSON_TYPE_OBJ); + *val_sum += len; + for (i = 0; i < len; i++) { + yyjson_type stype = unsafe_yyjson_get_type(child); + if (stype == YYJSON_TYPE_STR || stype == YYJSON_TYPE_RAW) { + *str_sum += unsafe_yyjson_get_len(child) + 1; + } else if (stype == YYJSON_TYPE_ARR || stype == YYJSON_TYPE_OBJ) { + yyjson_mut_stat(child, val_sum, str_sum); + *val_sum -= 1; + } + child = child->next; + } + } else if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) { + *str_sum += unsafe_yyjson_get_len(val) + 1; + } +} + +/* Copy mutable values to immutable value pool. */ +static usize yyjson_imut_copy(yyjson_val **val_ptr, char **buf_ptr, + yyjson_mut_val *mval) { + yyjson_val *val = *val_ptr; + yyjson_type type = unsafe_yyjson_get_type(mval); + if (type == YYJSON_TYPE_ARR || type == YYJSON_TYPE_OBJ) { + yyjson_mut_val *child = (yyjson_mut_val *)mval->uni.ptr; + usize len = unsafe_yyjson_get_len(mval), i; + usize val_sum = 1; + if (type == YYJSON_TYPE_OBJ) { + if (len) child = child->next->next; + len <<= 1; + } else { + if (len) child = child->next; + } + *val_ptr = val + 1; + for (i = 0; i < len; i++) { + val_sum += yyjson_imut_copy(val_ptr, buf_ptr, child); + child = child->next; + } + val->tag = mval->tag; + val->uni.ofs = val_sum * sizeof(yyjson_val); + return val_sum; + } else if (type == YYJSON_TYPE_STR || type == YYJSON_TYPE_RAW) { + char *buf = *buf_ptr; + usize len = unsafe_yyjson_get_len(mval); + memcpy((void *)buf, (const void *)mval->uni.str, len); + buf[len] = '\0'; + val->tag = mval->tag; + val->uni.str = buf; + *val_ptr = val + 1; + *buf_ptr = buf + len + 1; + return 1; + } else { + val->tag = mval->tag; + val->uni = mval->uni; + *val_ptr = val + 1; + return 1; + } +} + +yyjson_doc *yyjson_mut_doc_imut_copy(yyjson_mut_doc *mdoc, + const yyjson_alc *alc) { + if (!mdoc) return NULL; + return yyjson_mut_val_imut_copy(mdoc->root, alc); +} + +yyjson_doc *yyjson_mut_val_imut_copy(yyjson_mut_val *mval, + const yyjson_alc *alc) { + usize val_num = 0, str_sum = 0, hdr_size, buf_size; + yyjson_doc *doc = NULL; + yyjson_val *val_hdr = NULL; + + /* This value should be NULL here. Setting a non-null value suppresses + warning from the clang analyzer. */ + char *str_hdr = (char *)(void *)&str_sum; + if (!mval) return NULL; + if (!alc) alc = &YYJSON_DEFAULT_ALC; + + /* traverse the input value to get pool size */ + yyjson_mut_stat(mval, &val_num, &str_sum); + + /* create doc and val pool */ + hdr_size = size_align_up(sizeof(yyjson_doc), sizeof(yyjson_val)); + buf_size = hdr_size + val_num * sizeof(yyjson_val); + doc = (yyjson_doc *)alc->malloc(alc->ctx, buf_size); + if (!doc) return NULL; + memset(doc, 0, sizeof(yyjson_doc)); + val_hdr = (yyjson_val *)(void *)((char *)(void *)doc + hdr_size); + doc->root = val_hdr; + doc->alc = *alc; + + /* create str pool */ + if (str_sum > 0) { + str_hdr = (char *)alc->malloc(alc->ctx, str_sum); + doc->str_pool = str_hdr; + if (!str_hdr) { + alc->free(alc->ctx, (void *)doc); + return NULL; + } + } + + /* copy vals and strs */ + doc->val_read = yyjson_imut_copy(&val_hdr, &str_hdr, mval); + doc->dat_read = str_sum + 1; + return doc; +} + +static_inline bool unsafe_yyjson_num_equals(void *lhs, void *rhs) { + yyjson_val_uni *luni = &((yyjson_val *)lhs)->uni; + yyjson_val_uni *runi = &((yyjson_val *)rhs)->uni; + yyjson_subtype lt = unsafe_yyjson_get_subtype(lhs); + yyjson_subtype rt = unsafe_yyjson_get_subtype(rhs); + if (lt == rt) + return luni->u64 == runi->u64; + if (lt == YYJSON_SUBTYPE_SINT && rt == YYJSON_SUBTYPE_UINT) + return luni->i64 >= 0 && luni->u64 == runi->u64; + if (lt == YYJSON_SUBTYPE_UINT && rt == YYJSON_SUBTYPE_SINT) + return runi->i64 >= 0 && luni->u64 == runi->u64; + return false; +} + +static_inline bool unsafe_yyjson_str_equals(void *lhs, void *rhs) { + usize len = unsafe_yyjson_get_len(lhs); + if (len != unsafe_yyjson_get_len(rhs)) return false; + return !memcmp(unsafe_yyjson_get_str(lhs), + unsafe_yyjson_get_str(rhs), len); +} + +bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) { + yyjson_type type = unsafe_yyjson_get_type(lhs); + if (type != unsafe_yyjson_get_type(rhs)) return false; + + switch (type) { + case YYJSON_TYPE_OBJ: { + usize len = unsafe_yyjson_get_len(lhs); + if (len != unsafe_yyjson_get_len(rhs)) return false; + if (len > 0) { + yyjson_obj_iter iter; + yyjson_obj_iter_init(rhs, &iter); + lhs = unsafe_yyjson_get_first(lhs); + while (len-- > 0) { + rhs = yyjson_obj_iter_getn(&iter, lhs->uni.str, + unsafe_yyjson_get_len(lhs)); + if (!rhs || !unsafe_yyjson_equals(lhs + 1, rhs)) + return false; + lhs = unsafe_yyjson_get_next(lhs + 1); + } + } + /* yyjson allows duplicate keys, so the check may be inaccurate */ + return true; + } + + case YYJSON_TYPE_ARR: { + usize len = unsafe_yyjson_get_len(lhs); + if (len != unsafe_yyjson_get_len(rhs)) return false; + if (len > 0) { + lhs = unsafe_yyjson_get_first(lhs); + rhs = unsafe_yyjson_get_first(rhs); + while (len-- > 0) { + if (!unsafe_yyjson_equals(lhs, rhs)) return false; + lhs = unsafe_yyjson_get_next(lhs); + rhs = unsafe_yyjson_get_next(rhs); + } + } + return true; + } + + case YYJSON_TYPE_NUM: + return unsafe_yyjson_num_equals(lhs, rhs); + + case YYJSON_TYPE_RAW: + case YYJSON_TYPE_STR: + return unsafe_yyjson_str_equals(lhs, rhs); + + case YYJSON_TYPE_NULL: + case YYJSON_TYPE_BOOL: + return lhs->tag == rhs->tag; + + default: + return false; + } +} + +bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs, yyjson_mut_val *rhs) { + yyjson_type type = unsafe_yyjson_get_type(lhs); + if (type != unsafe_yyjson_get_type(rhs)) return false; + + switch (type) { + case YYJSON_TYPE_OBJ: { + usize len = unsafe_yyjson_get_len(lhs); + if (len != unsafe_yyjson_get_len(rhs)) return false; + if (len > 0) { + yyjson_mut_obj_iter iter; + yyjson_mut_obj_iter_init(rhs, &iter); + lhs = (yyjson_mut_val *)lhs->uni.ptr; + while (len-- > 0) { + rhs = yyjson_mut_obj_iter_getn(&iter, lhs->uni.str, + unsafe_yyjson_get_len(lhs)); + if (!rhs || !unsafe_yyjson_mut_equals(lhs->next, rhs)) + return false; + lhs = lhs->next->next; + } + } + /* yyjson allows duplicate keys, so the check may be inaccurate */ + return true; + } + + case YYJSON_TYPE_ARR: { + usize len = unsafe_yyjson_get_len(lhs); + if (len != unsafe_yyjson_get_len(rhs)) return false; + if (len > 0) { + lhs = (yyjson_mut_val *)lhs->uni.ptr; + rhs = (yyjson_mut_val *)rhs->uni.ptr; + while (len-- > 0) { + if (!unsafe_yyjson_mut_equals(lhs, rhs)) return false; + lhs = lhs->next; + rhs = rhs->next; + } + } + return true; + } + + case YYJSON_TYPE_NUM: + return unsafe_yyjson_num_equals(lhs, rhs); + + case YYJSON_TYPE_RAW: + case YYJSON_TYPE_STR: + return unsafe_yyjson_str_equals(lhs, rhs); + + case YYJSON_TYPE_NULL: + case YYJSON_TYPE_BOOL: + return lhs->tag == rhs->tag; + + default: + return false; + } +} + + + +#if !YYJSON_DISABLE_UTILS + +/*============================================================================== + * JSON Pointer API (RFC 6901) + *============================================================================*/ + +/** + Get a token from JSON pointer string. + @param ptr [in,out] + in: string that points to current token prefix `/` + out: string that points to next token prefix `/`, or string end + @param end [in] end of the entire JSON Pointer string + @param len [out] unescaped token length + @param esc [out] number of escaped characters in this token + @return head of the token, or NULL if syntax error + */ +static_inline const char *ptr_next_token(const char **ptr, const char *end, + usize *len, usize *esc) { + const char *hdr = *ptr + 1; + const char *cur = hdr; + /* skip unescaped characters */ + while (cur < end && *cur != '/' && *cur != '~') cur++; + if (likely(cur == end || *cur != '~')) { + /* no escaped characters, return */ + *ptr = cur; + *len = (usize)(cur - hdr); + *esc = 0; + return hdr; + } else { + /* handle escaped characters */ + usize esc_num = 0; + while (cur < end && *cur != '/') { + if (*cur++ == '~') { + if (cur == end || (*cur != '0' && *cur != '1')) { + *ptr = cur - 1; + return NULL; + } + esc_num++; + } + } + *ptr = cur; + *len = (usize)(cur - hdr) - esc_num; + *esc = esc_num; + return hdr; + } +} + +/** + Convert token string to index. + @param cur [in] token head + @param len [in] token length + @param idx [out] the index number, or USIZE_MAX if token is '-' + @return true if token is a valid array index + */ +static_inline bool ptr_token_to_idx(const char *cur, usize len, usize *idx) { + const char *end = cur + len; + usize num = 0, add; + if (unlikely(len == 0 || len > USIZE_SAFE_DIG)) return false; + if (*cur == '0') { + if (unlikely(len > 1)) return false; + *idx = 0; + return true; + } + if (*cur == '-') { + if (unlikely(len > 1)) return false; + *idx = USIZE_MAX; + return true; + } + for (; cur < end && (add = (usize)((u8)*cur - (u8)'0')) <= 9; cur++) { + num = num * 10 + add; + } + if (unlikely(num == 0 || cur < end)) return false; + *idx = num; + return true; +} + +/** + Compare JSON key with token. + @param key a string key (yyjson_val or yyjson_mut_val) + @param token a JSON pointer token + @param len unescaped token length + @param esc number of escaped characters in this token + @return true if `str` is equals to `token` + */ +static_inline bool ptr_token_eq(void *key, + const char *token, usize len, usize esc) { + yyjson_val *val = (yyjson_val *)key; + if (unsafe_yyjson_get_len(val) != len) return false; + if (likely(!esc)) { + return memcmp(val->uni.str, token, len) == 0; + } else { + const char *str = val->uni.str; + for (; len-- > 0; token++, str++) { + if (*token == '~') { + if (*str != (*++token == '0' ? '~' : '/')) return false; + } else { + if (*str != *token) return false; + } + } + return true; + } +} + +/** + Get a value from array by token. + @param arr an array, should not be NULL or non-array type + @param token a JSON pointer token + @param len unescaped token length + @param esc number of escaped characters in this token + @return value at index, or NULL if token is not index or index is out of range + */ +static_inline yyjson_val *ptr_arr_get(yyjson_val *arr, const char *token, + usize len, usize esc) { + yyjson_val *val = unsafe_yyjson_get_first(arr); + usize num = unsafe_yyjson_get_len(arr), idx = 0; + if (unlikely(num == 0)) return NULL; + if (unlikely(!ptr_token_to_idx(token, len, &idx))) return NULL; + if (unlikely(idx >= num)) return NULL; + if (unsafe_yyjson_arr_is_flat(arr)) { + return val + idx; + } else { + while (idx-- > 0) val = unsafe_yyjson_get_next(val); + return val; + } +} + +/** + Get a value from object by token. + @param obj [in] an object, should not be NULL or non-object type + @param token [in] a JSON pointer token + @param len [in] unescaped token length + @param esc [in] number of escaped characters in this token + @return value associated with the token, or NULL if no value + */ +static_inline yyjson_val *ptr_obj_get(yyjson_val *obj, const char *token, + usize len, usize esc) { + yyjson_val *key = unsafe_yyjson_get_first(obj); + usize num = unsafe_yyjson_get_len(obj); + if (unlikely(num == 0)) return NULL; + for (; num > 0; num--, key = unsafe_yyjson_get_next(key + 1)) { + if (ptr_token_eq(key, token, len, esc)) return key + 1; + } + return NULL; +} + +/** + Get a value from array by token. + @param arr [in] an array, should not be NULL or non-array type + @param token [in] a JSON pointer token + @param len [in] unescaped token length + @param esc [in] number of escaped characters in this token + @param pre [out] previous (sibling) value of the returned value + @param last [out] whether index is last + @return value at index, or NULL if token is not index or index is out of range + */ +static_inline yyjson_mut_val *ptr_mut_arr_get(yyjson_mut_val *arr, + const char *token, + usize len, usize esc, + yyjson_mut_val **pre, + bool *last) { + yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr; /* last (tail) */ + usize num = unsafe_yyjson_get_len(arr), idx; + if (last) *last = false; + if (pre) *pre = NULL; + if (unlikely(num == 0)) { + if (last && len == 1 && (*token == '0' || *token == '-')) *last = true; + return NULL; + } + if (unlikely(!ptr_token_to_idx(token, len, &idx))) return NULL; + if (last) *last = (idx == num || idx == USIZE_MAX); + if (unlikely(idx >= num)) return NULL; + while (idx-- > 0) val = val->next; + *pre = val; + return val->next; +} + +/** + Get a value from object by token. + @param obj [in] an object, should not be NULL or non-object type + @param token [in] a JSON pointer token + @param len [in] unescaped token length + @param esc [in] number of escaped characters in this token + @param pre [out] previous (sibling) key of the returned value's key + @return value associated with the token, or NULL if no value + */ +static_inline yyjson_mut_val *ptr_mut_obj_get(yyjson_mut_val *obj, + const char *token, + usize len, usize esc, + yyjson_mut_val **pre) { + yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr, *key; + usize num = unsafe_yyjson_get_len(obj); + if (pre) *pre = NULL; + if (unlikely(num == 0)) return NULL; + for (; num > 0; num--, pre_key = key) { + key = pre_key->next->next; + if (ptr_token_eq(key, token, len, esc)) { + *pre = pre_key; + return key->next; + } + } + return NULL; +} + +/** + Create a string value with JSON pointer token. + @param token [in] a JSON pointer token + @param len [in] unescaped token length + @param esc [in] number of escaped characters in this token + @param doc [in] used for memory allocation when creating value + @return new string value, or NULL if memory allocation failed + */ +static_inline yyjson_mut_val *ptr_new_key(const char *token, + usize len, usize esc, + yyjson_mut_doc *doc) { + const char *src = token; + if (likely(!esc)) { + return yyjson_mut_strncpy(doc, src, len); + } else { + const char *end = src + len + esc; + char *dst = unsafe_yyjson_mut_str_alc(doc, len + esc); + char *str = dst; + if (unlikely(!dst)) return NULL; + for (; src < end; src++, dst++) { + if (*src != '~') *dst = *src; + else *dst = (*++src == '0' ? '~' : '/'); + } + *dst = '\0'; + return yyjson_mut_strn(doc, str, len); + } +} + +/* macros for yyjson_ptr */ +#define return_err(_ret, _code, _pos, _msg) do { \ + if (err) { \ + err->code = YYJSON_PTR_ERR_##_code; \ + err->msg = _msg; \ + err->pos = (usize)(_pos); \ + } \ + return _ret; \ +} while (false) + +#define return_err_resolve(_ret, _pos) \ + return_err(_ret, RESOLVE, _pos, "JSON pointer cannot be resolved") +#define return_err_syntax(_ret, _pos) \ + return_err(_ret, SYNTAX, _pos, "invalid escaped character") +#define return_err_alloc(_ret) \ + return_err(_ret, MEMORY_ALLOCATION, 0, "failed to create value") + +yyjson_val *unsafe_yyjson_ptr_getx(yyjson_val *val, + const char *ptr, size_t ptr_len, + yyjson_ptr_err *err) { + + const char *hdr = ptr, *end = ptr + ptr_len, *token; + usize len, esc; + yyjson_type type; + + while (true) { + token = ptr_next_token(&ptr, end, &len, &esc); + if (unlikely(!token)) return_err_syntax(NULL, ptr - hdr); + type = unsafe_yyjson_get_type(val); + if (type == YYJSON_TYPE_OBJ) { + val = ptr_obj_get(val, token, len, esc); + } else if (type == YYJSON_TYPE_ARR) { + val = ptr_arr_get(val, token, len, esc); + } else { + val = NULL; + } + if (!val) return_err_resolve(NULL, token - hdr); + if (ptr == end) return val; + } +} + +yyjson_mut_val *unsafe_yyjson_mut_ptr_getx(yyjson_mut_val *val, + const char *ptr, + size_t ptr_len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + + const char *hdr = ptr, *end = ptr + ptr_len, *token; + usize len, esc; + yyjson_mut_val *ctn, *pre = NULL; + yyjson_type type; + bool idx_is_last = false; + + while (true) { + token = ptr_next_token(&ptr, end, &len, &esc); + if (unlikely(!token)) return_err_syntax(NULL, ptr - hdr); + ctn = val; + type = unsafe_yyjson_get_type(val); + if (type == YYJSON_TYPE_OBJ) { + val = ptr_mut_obj_get(val, token, len, esc, &pre); + } else if (type == YYJSON_TYPE_ARR) { + val = ptr_mut_arr_get(val, token, len, esc, &pre, &idx_is_last); + } else { + val = NULL; + } + if (ctx && (ptr == end)) { + if (type == YYJSON_TYPE_OBJ || + (type == YYJSON_TYPE_ARR && (val || idx_is_last))) { + ctx->ctn = ctn; + ctx->pre = pre; + } + } + if (!val) return_err_resolve(NULL, token - hdr); + if (ptr == end) return val; + } +} + +bool unsafe_yyjson_mut_ptr_putx(yyjson_mut_val *val, + const char *ptr, size_t ptr_len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, bool insert_new, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + + const char *hdr = ptr, *end = ptr + ptr_len, *token; + usize token_len, esc, ctn_len; + yyjson_mut_val *ctn, *key, *pre = NULL; + yyjson_mut_val *sep_ctn = NULL, *sep_key = NULL, *sep_val = NULL; + yyjson_type ctn_type; + bool idx_is_last = false; + + /* skip exist parent nodes */ + while (true) { + token = ptr_next_token(&ptr, end, &token_len, &esc); + if (unlikely(!token)) return_err_syntax(false, ptr - hdr); + ctn = val; + ctn_type = unsafe_yyjson_get_type(ctn); + if (ctn_type == YYJSON_TYPE_OBJ) { + val = ptr_mut_obj_get(ctn, token, token_len, esc, &pre); + } else if (ctn_type == YYJSON_TYPE_ARR) { + val = ptr_mut_arr_get(ctn, token, token_len, esc, &pre, + &idx_is_last); + } else return_err_resolve(false, token - hdr); + if (!val) break; + if (ptr == end) break; /* is last token */ + } + + /* create parent nodes if not exist */ + if (unlikely(ptr != end)) { /* not last token */ + if (!create_parent) return_err_resolve(false, token - hdr); + + /* add value at last index if container is array */ + if (ctn_type == YYJSON_TYPE_ARR) { + if (!idx_is_last || !insert_new) { + return_err_resolve(false, token - hdr); + } + val = yyjson_mut_obj(doc); + if (!val) return_err_alloc(false); + + /* delay attaching until all operations are completed */ + sep_ctn = ctn; + sep_key = NULL; + sep_val = val; + + /* move to next token */ + ctn = val; + val = NULL; + ctn_type = YYJSON_TYPE_OBJ; + token = ptr_next_token(&ptr, end, &token_len, &esc); + if (unlikely(!token)) return_err_resolve(false, token - hdr); + } + + /* container is object, create parent nodes */ + while (ptr != end) { /* not last token */ + key = ptr_new_key(token, token_len, esc, doc); + if (!key) return_err_alloc(false); + val = yyjson_mut_obj(doc); + if (!val) return_err_alloc(false); + + /* delay attaching until all operations are completed */ + if (!sep_ctn) { + sep_ctn = ctn; + sep_key = key; + sep_val = val; + } else { + yyjson_mut_obj_add(ctn, key, val); + } + + /* move to next token */ + ctn = val; + val = NULL; + token = ptr_next_token(&ptr, end, &token_len, &esc); + if (unlikely(!token)) return_err_syntax(false, ptr - hdr); + } + } + + /* JSON pointer is resolved, insert or replace target value */ + ctn_len = unsafe_yyjson_get_len(ctn); + if (ctn_type == YYJSON_TYPE_OBJ) { + if (ctx) ctx->ctn = ctn; + if (!val || insert_new) { + /* insert new key-value pair */ + key = ptr_new_key(token, token_len, esc, doc); + if (unlikely(!key)) return_err_alloc(false); + if (ctx) ctx->pre = ctn_len ? (yyjson_mut_val *)ctn->uni.ptr : key; + unsafe_yyjson_mut_obj_add(ctn, key, new_val, ctn_len); + } else { + /* replace exist value */ + key = pre->next->next; + if (ctx) ctx->pre = pre; + if (ctx) ctx->old = val; + yyjson_mut_obj_put(ctn, key, new_val); + } + } else { + /* array */ + if (ctx && (val || idx_is_last)) ctx->ctn = ctn; + if (insert_new) { + /* append new value */ + if (val) { + pre->next = new_val; + new_val->next = val; + if (ctx) ctx->pre = pre; + unsafe_yyjson_set_len(ctn, ctn_len + 1); + } else if (idx_is_last) { + if (ctx) ctx->pre = ctn_len ? + (yyjson_mut_val *)ctn->uni.ptr : new_val; + yyjson_mut_arr_append(ctn, new_val); + } else { + return_err_resolve(false, token - hdr); + } + } else { + /* replace exist value */ + if (!val) return_err_resolve(false, token - hdr); + if (ctn_len > 1) { + new_val->next = val->next; + pre->next = new_val; + if (ctn->uni.ptr == val) ctn->uni.ptr = new_val; + } else { + new_val->next = new_val; + ctn->uni.ptr = new_val; + pre = new_val; + } + if (ctx) ctx->pre = pre; + if (ctx) ctx->old = val; + } + } + + /* all operations are completed, attach the new components to the target */ + if (unlikely(sep_ctn)) { + if (sep_key) yyjson_mut_obj_add(sep_ctn, sep_key, sep_val); + else yyjson_mut_arr_append(sep_ctn, sep_val); + } + return true; +} + +yyjson_mut_val *unsafe_yyjson_mut_ptr_replacex( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) { + + yyjson_mut_val *cur_val; + yyjson_ptr_ctx cur_ctx; + memset(&cur_ctx, 0, sizeof(cur_ctx)); + if (!ctx) ctx = &cur_ctx; + cur_val = unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err); + if (!cur_val) return NULL; + + if (yyjson_mut_is_obj(ctx->ctn)) { + yyjson_mut_val *key = ctx->pre->next->next; + yyjson_mut_obj_put(ctx->ctn, key, new_val); + } else { + yyjson_ptr_ctx_replace(ctx, new_val); + } + ctx->old = cur_val; + return cur_val; +} + +yyjson_mut_val *unsafe_yyjson_mut_ptr_removex(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_mut_val *cur_val; + yyjson_ptr_ctx cur_ctx; + memset(&cur_ctx, 0, sizeof(cur_ctx)); + if (!ctx) ctx = &cur_ctx; + cur_val = unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err); + if (cur_val) { + if (yyjson_mut_is_obj(ctx->ctn)) { + yyjson_mut_val *key = ctx->pre->next->next; + yyjson_mut_obj_put(ctx->ctn, key, NULL); + } else { + yyjson_ptr_ctx_remove(ctx); + } + ctx->pre = NULL; + ctx->old = cur_val; + } + return cur_val; +} + +/* macros for yyjson_ptr */ +#undef return_err +#undef return_err_resolve +#undef return_err_syntax +#undef return_err_alloc + + + +/*============================================================================== + * JSON Patch API (RFC 6902) + *============================================================================*/ + +/* JSON Patch operation */ +typedef enum patch_op { + PATCH_OP_ADD, /* path, value */ + PATCH_OP_REMOVE, /* path */ + PATCH_OP_REPLACE, /* path, value */ + PATCH_OP_MOVE, /* from, path */ + PATCH_OP_COPY, /* from, path */ + PATCH_OP_TEST, /* path, value */ + PATCH_OP_NONE /* invalid */ +} patch_op; + +static patch_op patch_op_get(yyjson_val *op) { + const char *str = op->uni.str; + switch (unsafe_yyjson_get_len(op)) { + case 3: + if (!memcmp(str, "add", 3)) return PATCH_OP_ADD; + return PATCH_OP_NONE; + case 4: + if (!memcmp(str, "move", 4)) return PATCH_OP_MOVE; + if (!memcmp(str, "copy", 4)) return PATCH_OP_COPY; + if (!memcmp(str, "test", 4)) return PATCH_OP_TEST; + return PATCH_OP_NONE; + case 6: + if (!memcmp(str, "remove", 6)) return PATCH_OP_REMOVE; + return PATCH_OP_NONE; + case 7: + if (!memcmp(str, "replace", 7)) return PATCH_OP_REPLACE; + return PATCH_OP_NONE; + default: + return PATCH_OP_NONE; + } +} + +/* macros for yyjson_patch */ +#define return_err(_code, _msg) do { \ + if (err->ptr.code == YYJSON_PTR_ERR_MEMORY_ALLOCATION) { \ + err->code = YYJSON_PATCH_ERROR_MEMORY_ALLOCATION; \ + err->msg = _msg; \ + memset(&err->ptr, 0, sizeof(yyjson_ptr_err)); \ + } else { \ + err->code = YYJSON_PATCH_ERROR_##_code; \ + err->msg = _msg; \ + err->idx = iter.idx ? iter.idx - 1 : 0; \ + } \ + return NULL; \ +} while (false) + +#define return_err_copy() \ + return_err(MEMORY_ALLOCATION, "failed to copy value") +#define return_err_key(_key) \ + return_err(MISSING_KEY, "missing key " _key) +#define return_err_val(_key) \ + return_err(INVALID_MEMBER, "invalid member " _key) + +#define ptr_get(_ptr) yyjson_mut_ptr_getx( \ + root, _ptr->uni.str, _ptr##_len, NULL, &err->ptr) +#define ptr_add(_ptr, _val) yyjson_mut_ptr_addx( \ + root, _ptr->uni.str, _ptr##_len, _val, doc, false, NULL, &err->ptr) +#define ptr_remove(_ptr) yyjson_mut_ptr_removex( \ + root, _ptr->uni.str, _ptr##_len, NULL, &err->ptr) +#define ptr_replace(_ptr, _val)yyjson_mut_ptr_replacex( \ + root, _ptr->uni.str, _ptr##_len, _val, NULL, &err->ptr) + +yyjson_mut_val *yyjson_patch(yyjson_mut_doc *doc, + yyjson_val *orig, + yyjson_val *patch, + yyjson_patch_err *err) { + + yyjson_mut_val *root; + yyjson_val *obj; + yyjson_arr_iter iter; + yyjson_patch_err err_tmp; + if (!err) err = &err_tmp; + memset(err, 0, sizeof(*err)); + memset(&iter, 0, sizeof(iter)); + + if (unlikely(!doc || !orig || !patch)) { + return_err(INVALID_PARAMETER, "input parameter is NULL"); + } + if (unlikely(!yyjson_is_arr(patch))) { + return_err(INVALID_PARAMETER, "input patch is not array"); + } + root = yyjson_val_mut_copy(doc, orig); + if (unlikely(!root)) return_err_copy(); + + /* iterate through the patch array */ + yyjson_arr_iter_init(patch, &iter); + while ((obj = yyjson_arr_iter_next(&iter))) { + patch_op op_enum; + yyjson_val *op, *path, *from = NULL, *value; + yyjson_mut_val *val = NULL, *test; + usize path_len, from_len = 0; + if (unlikely(!unsafe_yyjson_is_obj(obj))) { + return_err(INVALID_OPERATION, "JSON patch operation is not object"); + } + + /* get required member: op */ + op = yyjson_obj_get(obj, "op"); + if (unlikely(!op)) return_err_key("`op`"); + if (unlikely(!yyjson_is_str(op))) return_err_val("`op`"); + op_enum = patch_op_get(op); + + /* get required member: path */ + path = yyjson_obj_get(obj, "path"); + if (unlikely(!path)) return_err_key("`path`"); + if (unlikely(!yyjson_is_str(path))) return_err_val("`path`"); + path_len = unsafe_yyjson_get_len(path); + + /* get required member: value, from */ + switch ((int)op_enum) { + case PATCH_OP_ADD: case PATCH_OP_REPLACE: case PATCH_OP_TEST: + value = yyjson_obj_get(obj, "value"); + if (unlikely(!value)) return_err_key("`value`"); + val = yyjson_val_mut_copy(doc, value); + if (unlikely(!val)) return_err_copy(); + break; + case PATCH_OP_MOVE: case PATCH_OP_COPY: + from = yyjson_obj_get(obj, "from"); + if (unlikely(!from)) return_err_key("`from`"); + if (unlikely(!yyjson_is_str(from))) return_err_val("`from`"); + from_len = unsafe_yyjson_get_len(from); + break; + default: + break; + } + + /* perform an operation */ + switch ((int)op_enum) { + case PATCH_OP_ADD: /* add(path, val) */ + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_REMOVE: /* remove(path) */ + if (unlikely(!ptr_remove(path))) { + return_err(POINTER, "failed to remove `path`"); + } + break; + case PATCH_OP_REPLACE: /* replace(path, val) */ + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_replace(path, val))) { + return_err(POINTER, "failed to replace `path`"); + } + break; + case PATCH_OP_MOVE: /* val = remove(from), add(path, val) */ + if (unlikely(from_len == 0 && path_len == 0)) break; + val = ptr_remove(from); + if (unlikely(!val)) { + return_err(POINTER, "failed to remove `from`"); + } + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_COPY: /* val = get(from).copy, add(path, val) */ + val = ptr_get(from); + if (unlikely(!val)) { + return_err(POINTER, "failed to get `from`"); + } + if (unlikely(path_len == 0)) { root = val; break; } + val = yyjson_mut_val_mut_copy(doc, val); + if (unlikely(!val)) return_err_copy(); + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_TEST: /* test = get(path), test.eq(val) */ + test = ptr_get(path); + if (unlikely(!test)) { + return_err(POINTER, "failed to get `path`"); + } + if (unlikely(!yyjson_mut_equals(val, test))) { + return_err(EQUAL, "failed to test equal"); + } + break; + default: + return_err(INVALID_MEMBER, "unsupported `op`"); + } + } + return root; +} + +yyjson_mut_val *yyjson_mut_patch(yyjson_mut_doc *doc, + yyjson_mut_val *orig, + yyjson_mut_val *patch, + yyjson_patch_err *err) { + yyjson_mut_val *root, *obj; + yyjson_mut_arr_iter iter; + yyjson_patch_err err_tmp; + if (!err) err = &err_tmp; + memset(err, 0, sizeof(*err)); + memset(&iter, 0, sizeof(iter)); + + if (unlikely(!doc || !orig || !patch)) { + return_err(INVALID_PARAMETER, "input parameter is NULL"); + } + if (unlikely(!yyjson_mut_is_arr(patch))) { + return_err(INVALID_PARAMETER, "input patch is not array"); + } + root = yyjson_mut_val_mut_copy(doc, orig); + if (unlikely(!root)) return_err_copy(); + + /* iterate through the patch array */ + yyjson_mut_arr_iter_init(patch, &iter); + while ((obj = yyjson_mut_arr_iter_next(&iter))) { + patch_op op_enum; + yyjson_mut_val *op, *path, *from = NULL, *value; + yyjson_mut_val *val = NULL, *test; + usize path_len, from_len = 0; + if (!unsafe_yyjson_is_obj(obj)) { + return_err(INVALID_OPERATION, "JSON patch operation is not object"); + } + + /* get required member: op */ + op = yyjson_mut_obj_get(obj, "op"); + if (unlikely(!op)) return_err_key("`op`"); + if (unlikely(!yyjson_mut_is_str(op))) return_err_val("`op`"); + op_enum = patch_op_get((yyjson_val *)(void *)op); + + /* get required member: path */ + path = yyjson_mut_obj_get(obj, "path"); + if (unlikely(!path)) return_err_key("`path`"); + if (unlikely(!yyjson_mut_is_str(path))) return_err_val("`path`"); + path_len = unsafe_yyjson_get_len(path); + + /* get required member: value, from */ + switch ((int)op_enum) { + case PATCH_OP_ADD: case PATCH_OP_REPLACE: case PATCH_OP_TEST: + value = yyjson_mut_obj_get(obj, "value"); + if (unlikely(!value)) return_err_key("`value`"); + val = yyjson_mut_val_mut_copy(doc, value); + if (unlikely(!val)) return_err_copy(); + break; + case PATCH_OP_MOVE: case PATCH_OP_COPY: + from = yyjson_mut_obj_get(obj, "from"); + if (unlikely(!from)) return_err_key("`from`"); + if (unlikely(!yyjson_mut_is_str(from))) { + return_err_val("`from`"); + } + from_len = unsafe_yyjson_get_len(from); + break; + default: + break; + } + + /* perform an operation */ + switch ((int)op_enum) { + case PATCH_OP_ADD: /* add(path, val) */ + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_REMOVE: /* remove(path) */ + if (unlikely(!ptr_remove(path))) { + return_err(POINTER, "failed to remove `path`"); + } + break; + case PATCH_OP_REPLACE: /* replace(path, val) */ + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_replace(path, val))) { + return_err(POINTER, "failed to replace `path`"); + } + break; + case PATCH_OP_MOVE: /* val = remove(from), add(path, val) */ + if (unlikely(from_len == 0 && path_len == 0)) break; + val = ptr_remove(from); + if (unlikely(!val)) { + return_err(POINTER, "failed to remove `from`"); + } + if (unlikely(path_len == 0)) { root = val; break; } + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_COPY: /* val = get(from).copy, add(path, val) */ + val = ptr_get(from); + if (unlikely(!val)) { + return_err(POINTER, "failed to get `from`"); + } + if (unlikely(path_len == 0)) { root = val; break; } + val = yyjson_mut_val_mut_copy(doc, val); + if (unlikely(!val)) return_err_copy(); + if (unlikely(!ptr_add(path, val))) { + return_err(POINTER, "failed to add `path`"); + } + break; + case PATCH_OP_TEST: /* test = get(path), test.eq(val) */ + test = ptr_get(path); + if (unlikely(!test)) { + return_err(POINTER, "failed to get `path`"); + } + if (unlikely(!yyjson_mut_equals(val, test))) { + return_err(EQUAL, "failed to test equal"); + } + break; + default: + return_err(INVALID_MEMBER, "unsupported `op`"); + } + } + return root; +} + +/* macros for yyjson_patch */ +#undef return_err +#undef return_err_copy +#undef return_err_key +#undef return_err_val +#undef ptr_get +#undef ptr_add +#undef ptr_remove +#undef ptr_replace + + + +/*============================================================================== + * JSON Merge-Patch API (RFC 7386) + *============================================================================*/ + +yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc, + yyjson_val *orig, + yyjson_val *patch) { + usize idx, max; + yyjson_val *key, *orig_val, *patch_val, local_orig; + yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val; + + if (unlikely(!yyjson_is_obj(patch))) { + return yyjson_val_mut_copy(doc, patch); + } + + builder = yyjson_mut_obj(doc); + if (unlikely(!builder)) return NULL; + + if (!yyjson_is_obj(orig)) { + orig = &local_orig; + orig->tag = builder->tag; + orig->uni = builder->uni; + } + + /* If orig is contributing, copy any items not modified by the patch */ + if (orig != &local_orig) { + yyjson_obj_foreach(orig, idx, max, key, orig_val) { + patch_val = yyjson_obj_getn(patch, + unsafe_yyjson_get_str(key), + unsafe_yyjson_get_len(key)); + if (!patch_val) { + mut_key = yyjson_val_mut_copy(doc, key); + mut_val = yyjson_val_mut_copy(doc, orig_val); + if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL; + } + } + } + + /* Merge items modified by the patch. */ + yyjson_obj_foreach(patch, idx, max, key, patch_val) { + /* null indicates the field is removed. */ + if (unsafe_yyjson_is_null(patch_val)) { + continue; + } + mut_key = yyjson_val_mut_copy(doc, key); + orig_val = yyjson_obj_getn(orig, + unsafe_yyjson_get_str(key), + unsafe_yyjson_get_len(key)); + merged_val = yyjson_merge_patch(doc, orig_val, patch_val); + if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL; + } + + return builder; +} + +yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc, + yyjson_mut_val *orig, + yyjson_mut_val *patch) { + usize idx, max; + yyjson_mut_val *key, *orig_val, *patch_val, local_orig; + yyjson_mut_val *builder, *mut_key, *mut_val, *merged_val; + + if (unlikely(!yyjson_mut_is_obj(patch))) { + return yyjson_mut_val_mut_copy(doc, patch); + } + + builder = yyjson_mut_obj(doc); + if (unlikely(!builder)) return NULL; + + if (!yyjson_mut_is_obj(orig)) { + orig = &local_orig; + orig->tag = builder->tag; + orig->uni = builder->uni; + } + + /* If orig is contributing, copy any items not modified by the patch */ + if (orig != &local_orig) { + yyjson_mut_obj_foreach(orig, idx, max, key, orig_val) { + patch_val = yyjson_mut_obj_getn(patch, + unsafe_yyjson_get_str(key), + unsafe_yyjson_get_len(key)); + if (!patch_val) { + mut_key = yyjson_mut_val_mut_copy(doc, key); + mut_val = yyjson_mut_val_mut_copy(doc, orig_val); + if (!yyjson_mut_obj_add(builder, mut_key, mut_val)) return NULL; + } + } + } + + /* Merge items modified by the patch. */ + yyjson_mut_obj_foreach(patch, idx, max, key, patch_val) { + /* null indicates the field is removed. */ + if (unsafe_yyjson_is_null(patch_val)) { + continue; + } + mut_key = yyjson_mut_val_mut_copy(doc, key); + orig_val = yyjson_mut_obj_getn(orig, + unsafe_yyjson_get_str(key), + unsafe_yyjson_get_len(key)); + merged_val = yyjson_mut_merge_patch(doc, orig_val, patch_val); + if (!yyjson_mut_obj_add(builder, mut_key, merged_val)) return NULL; + } + + return builder; +} + +#endif /* YYJSON_DISABLE_UTILS */ + + + +/*============================================================================== + * Power10 Lookup Table + * These data are used by the floating-point number reader and writer. + *============================================================================*/ + +#if (!YYJSON_DISABLE_READER || !YYJSON_DISABLE_WRITER) && \ + (!YYJSON_DISABLE_FAST_FP_CONV) + +/** Minimum decimal exponent in pow10_sig_table. */ +#define POW10_SIG_TABLE_MIN_EXP -343 + +/** Maximum decimal exponent in pow10_sig_table. */ +#define POW10_SIG_TABLE_MAX_EXP 324 + +/** Minimum exact decimal exponent in pow10_sig_table */ +#define POW10_SIG_TABLE_MIN_EXACT_EXP 0 + +/** Maximum exact decimal exponent in pow10_sig_table */ +#define POW10_SIG_TABLE_MAX_EXACT_EXP 55 + +/** Normalized significant 128 bits of pow10, no rounded up (size: 10.4KB). + This lookup table is used by both the double number reader and writer. + (generate with misc/make_tables.c) */ +static const u64 pow10_sig_table[] = { + U64(0xBF29DCAB, 0xA82FDEAE), U64(0x7432EE87, 0x3880FC33), /* ~= 10^-343 */ + U64(0xEEF453D6, 0x923BD65A), U64(0x113FAA29, 0x06A13B3F), /* ~= 10^-342 */ + U64(0x9558B466, 0x1B6565F8), U64(0x4AC7CA59, 0xA424C507), /* ~= 10^-341 */ + U64(0xBAAEE17F, 0xA23EBF76), U64(0x5D79BCF0, 0x0D2DF649), /* ~= 10^-340 */ + U64(0xE95A99DF, 0x8ACE6F53), U64(0xF4D82C2C, 0x107973DC), /* ~= 10^-339 */ + U64(0x91D8A02B, 0xB6C10594), U64(0x79071B9B, 0x8A4BE869), /* ~= 10^-338 */ + U64(0xB64EC836, 0xA47146F9), U64(0x9748E282, 0x6CDEE284), /* ~= 10^-337 */ + U64(0xE3E27A44, 0x4D8D98B7), U64(0xFD1B1B23, 0x08169B25), /* ~= 10^-336 */ + U64(0x8E6D8C6A, 0xB0787F72), U64(0xFE30F0F5, 0xE50E20F7), /* ~= 10^-335 */ + U64(0xB208EF85, 0x5C969F4F), U64(0xBDBD2D33, 0x5E51A935), /* ~= 10^-334 */ + U64(0xDE8B2B66, 0xB3BC4723), U64(0xAD2C7880, 0x35E61382), /* ~= 10^-333 */ + U64(0x8B16FB20, 0x3055AC76), U64(0x4C3BCB50, 0x21AFCC31), /* ~= 10^-332 */ + U64(0xADDCB9E8, 0x3C6B1793), U64(0xDF4ABE24, 0x2A1BBF3D), /* ~= 10^-331 */ + U64(0xD953E862, 0x4B85DD78), U64(0xD71D6DAD, 0x34A2AF0D), /* ~= 10^-330 */ + U64(0x87D4713D, 0x6F33AA6B), U64(0x8672648C, 0x40E5AD68), /* ~= 10^-329 */ + U64(0xA9C98D8C, 0xCB009506), U64(0x680EFDAF, 0x511F18C2), /* ~= 10^-328 */ + U64(0xD43BF0EF, 0xFDC0BA48), U64(0x0212BD1B, 0x2566DEF2), /* ~= 10^-327 */ + U64(0x84A57695, 0xFE98746D), U64(0x014BB630, 0xF7604B57), /* ~= 10^-326 */ + U64(0xA5CED43B, 0x7E3E9188), U64(0x419EA3BD, 0x35385E2D), /* ~= 10^-325 */ + U64(0xCF42894A, 0x5DCE35EA), U64(0x52064CAC, 0x828675B9), /* ~= 10^-324 */ + U64(0x818995CE, 0x7AA0E1B2), U64(0x7343EFEB, 0xD1940993), /* ~= 10^-323 */ + U64(0xA1EBFB42, 0x19491A1F), U64(0x1014EBE6, 0xC5F90BF8), /* ~= 10^-322 */ + U64(0xCA66FA12, 0x9F9B60A6), U64(0xD41A26E0, 0x77774EF6), /* ~= 10^-321 */ + U64(0xFD00B897, 0x478238D0), U64(0x8920B098, 0x955522B4), /* ~= 10^-320 */ + U64(0x9E20735E, 0x8CB16382), U64(0x55B46E5F, 0x5D5535B0), /* ~= 10^-319 */ + U64(0xC5A89036, 0x2FDDBC62), U64(0xEB2189F7, 0x34AA831D), /* ~= 10^-318 */ + U64(0xF712B443, 0xBBD52B7B), U64(0xA5E9EC75, 0x01D523E4), /* ~= 10^-317 */ + U64(0x9A6BB0AA, 0x55653B2D), U64(0x47B233C9, 0x2125366E), /* ~= 10^-316 */ + U64(0xC1069CD4, 0xEABE89F8), U64(0x999EC0BB, 0x696E840A), /* ~= 10^-315 */ + U64(0xF148440A, 0x256E2C76), U64(0xC00670EA, 0x43CA250D), /* ~= 10^-314 */ + U64(0x96CD2A86, 0x5764DBCA), U64(0x38040692, 0x6A5E5728), /* ~= 10^-313 */ + U64(0xBC807527, 0xED3E12BC), U64(0xC6050837, 0x04F5ECF2), /* ~= 10^-312 */ + U64(0xEBA09271, 0xE88D976B), U64(0xF7864A44, 0xC633682E), /* ~= 10^-311 */ + U64(0x93445B87, 0x31587EA3), U64(0x7AB3EE6A, 0xFBE0211D), /* ~= 10^-310 */ + U64(0xB8157268, 0xFDAE9E4C), U64(0x5960EA05, 0xBAD82964), /* ~= 10^-309 */ + U64(0xE61ACF03, 0x3D1A45DF), U64(0x6FB92487, 0x298E33BD), /* ~= 10^-308 */ + U64(0x8FD0C162, 0x06306BAB), U64(0xA5D3B6D4, 0x79F8E056), /* ~= 10^-307 */ + U64(0xB3C4F1BA, 0x87BC8696), U64(0x8F48A489, 0x9877186C), /* ~= 10^-306 */ + U64(0xE0B62E29, 0x29ABA83C), U64(0x331ACDAB, 0xFE94DE87), /* ~= 10^-305 */ + U64(0x8C71DCD9, 0xBA0B4925), U64(0x9FF0C08B, 0x7F1D0B14), /* ~= 10^-304 */ + U64(0xAF8E5410, 0x288E1B6F), U64(0x07ECF0AE, 0x5EE44DD9), /* ~= 10^-303 */ + U64(0xDB71E914, 0x32B1A24A), U64(0xC9E82CD9, 0xF69D6150), /* ~= 10^-302 */ + U64(0x892731AC, 0x9FAF056E), U64(0xBE311C08, 0x3A225CD2), /* ~= 10^-301 */ + U64(0xAB70FE17, 0xC79AC6CA), U64(0x6DBD630A, 0x48AAF406), /* ~= 10^-300 */ + U64(0xD64D3D9D, 0xB981787D), U64(0x092CBBCC, 0xDAD5B108), /* ~= 10^-299 */ + U64(0x85F04682, 0x93F0EB4E), U64(0x25BBF560, 0x08C58EA5), /* ~= 10^-298 */ + U64(0xA76C5823, 0x38ED2621), U64(0xAF2AF2B8, 0x0AF6F24E), /* ~= 10^-297 */ + U64(0xD1476E2C, 0x07286FAA), U64(0x1AF5AF66, 0x0DB4AEE1), /* ~= 10^-296 */ + U64(0x82CCA4DB, 0x847945CA), U64(0x50D98D9F, 0xC890ED4D), /* ~= 10^-295 */ + U64(0xA37FCE12, 0x6597973C), U64(0xE50FF107, 0xBAB528A0), /* ~= 10^-294 */ + U64(0xCC5FC196, 0xFEFD7D0C), U64(0x1E53ED49, 0xA96272C8), /* ~= 10^-293 */ + U64(0xFF77B1FC, 0xBEBCDC4F), U64(0x25E8E89C, 0x13BB0F7A), /* ~= 10^-292 */ + U64(0x9FAACF3D, 0xF73609B1), U64(0x77B19161, 0x8C54E9AC), /* ~= 10^-291 */ + U64(0xC795830D, 0x75038C1D), U64(0xD59DF5B9, 0xEF6A2417), /* ~= 10^-290 */ + U64(0xF97AE3D0, 0xD2446F25), U64(0x4B057328, 0x6B44AD1D), /* ~= 10^-289 */ + U64(0x9BECCE62, 0x836AC577), U64(0x4EE367F9, 0x430AEC32), /* ~= 10^-288 */ + U64(0xC2E801FB, 0x244576D5), U64(0x229C41F7, 0x93CDA73F), /* ~= 10^-287 */ + U64(0xF3A20279, 0xED56D48A), U64(0x6B435275, 0x78C1110F), /* ~= 10^-286 */ + U64(0x9845418C, 0x345644D6), U64(0x830A1389, 0x6B78AAA9), /* ~= 10^-285 */ + U64(0xBE5691EF, 0x416BD60C), U64(0x23CC986B, 0xC656D553), /* ~= 10^-284 */ + U64(0xEDEC366B, 0x11C6CB8F), U64(0x2CBFBE86, 0xB7EC8AA8), /* ~= 10^-283 */ + U64(0x94B3A202, 0xEB1C3F39), U64(0x7BF7D714, 0x32F3D6A9), /* ~= 10^-282 */ + U64(0xB9E08A83, 0xA5E34F07), U64(0xDAF5CCD9, 0x3FB0CC53), /* ~= 10^-281 */ + U64(0xE858AD24, 0x8F5C22C9), U64(0xD1B3400F, 0x8F9CFF68), /* ~= 10^-280 */ + U64(0x91376C36, 0xD99995BE), U64(0x23100809, 0xB9C21FA1), /* ~= 10^-279 */ + U64(0xB5854744, 0x8FFFFB2D), U64(0xABD40A0C, 0x2832A78A), /* ~= 10^-278 */ + U64(0xE2E69915, 0xB3FFF9F9), U64(0x16C90C8F, 0x323F516C), /* ~= 10^-277 */ + U64(0x8DD01FAD, 0x907FFC3B), U64(0xAE3DA7D9, 0x7F6792E3), /* ~= 10^-276 */ + U64(0xB1442798, 0xF49FFB4A), U64(0x99CD11CF, 0xDF41779C), /* ~= 10^-275 */ + U64(0xDD95317F, 0x31C7FA1D), U64(0x40405643, 0xD711D583), /* ~= 10^-274 */ + U64(0x8A7D3EEF, 0x7F1CFC52), U64(0x482835EA, 0x666B2572), /* ~= 10^-273 */ + U64(0xAD1C8EAB, 0x5EE43B66), U64(0xDA324365, 0x0005EECF), /* ~= 10^-272 */ + U64(0xD863B256, 0x369D4A40), U64(0x90BED43E, 0x40076A82), /* ~= 10^-271 */ + U64(0x873E4F75, 0xE2224E68), U64(0x5A7744A6, 0xE804A291), /* ~= 10^-270 */ + U64(0xA90DE353, 0x5AAAE202), U64(0x711515D0, 0xA205CB36), /* ~= 10^-269 */ + U64(0xD3515C28, 0x31559A83), U64(0x0D5A5B44, 0xCA873E03), /* ~= 10^-268 */ + U64(0x8412D999, 0x1ED58091), U64(0xE858790A, 0xFE9486C2), /* ~= 10^-267 */ + U64(0xA5178FFF, 0x668AE0B6), U64(0x626E974D, 0xBE39A872), /* ~= 10^-266 */ + U64(0xCE5D73FF, 0x402D98E3), U64(0xFB0A3D21, 0x2DC8128F), /* ~= 10^-265 */ + U64(0x80FA687F, 0x881C7F8E), U64(0x7CE66634, 0xBC9D0B99), /* ~= 10^-264 */ + U64(0xA139029F, 0x6A239F72), U64(0x1C1FFFC1, 0xEBC44E80), /* ~= 10^-263 */ + U64(0xC9874347, 0x44AC874E), U64(0xA327FFB2, 0x66B56220), /* ~= 10^-262 */ + U64(0xFBE91419, 0x15D7A922), U64(0x4BF1FF9F, 0x0062BAA8), /* ~= 10^-261 */ + U64(0x9D71AC8F, 0xADA6C9B5), U64(0x6F773FC3, 0x603DB4A9), /* ~= 10^-260 */ + U64(0xC4CE17B3, 0x99107C22), U64(0xCB550FB4, 0x384D21D3), /* ~= 10^-259 */ + U64(0xF6019DA0, 0x7F549B2B), U64(0x7E2A53A1, 0x46606A48), /* ~= 10^-258 */ + U64(0x99C10284, 0x4F94E0FB), U64(0x2EDA7444, 0xCBFC426D), /* ~= 10^-257 */ + U64(0xC0314325, 0x637A1939), U64(0xFA911155, 0xFEFB5308), /* ~= 10^-256 */ + U64(0xF03D93EE, 0xBC589F88), U64(0x793555AB, 0x7EBA27CA), /* ~= 10^-255 */ + U64(0x96267C75, 0x35B763B5), U64(0x4BC1558B, 0x2F3458DE), /* ~= 10^-254 */ + U64(0xBBB01B92, 0x83253CA2), U64(0x9EB1AAED, 0xFB016F16), /* ~= 10^-253 */ + U64(0xEA9C2277, 0x23EE8BCB), U64(0x465E15A9, 0x79C1CADC), /* ~= 10^-252 */ + U64(0x92A1958A, 0x7675175F), U64(0x0BFACD89, 0xEC191EC9), /* ~= 10^-251 */ + U64(0xB749FAED, 0x14125D36), U64(0xCEF980EC, 0x671F667B), /* ~= 10^-250 */ + U64(0xE51C79A8, 0x5916F484), U64(0x82B7E127, 0x80E7401A), /* ~= 10^-249 */ + U64(0x8F31CC09, 0x37AE58D2), U64(0xD1B2ECB8, 0xB0908810), /* ~= 10^-248 */ + U64(0xB2FE3F0B, 0x8599EF07), U64(0x861FA7E6, 0xDCB4AA15), /* ~= 10^-247 */ + U64(0xDFBDCECE, 0x67006AC9), U64(0x67A791E0, 0x93E1D49A), /* ~= 10^-246 */ + U64(0x8BD6A141, 0x006042BD), U64(0xE0C8BB2C, 0x5C6D24E0), /* ~= 10^-245 */ + U64(0xAECC4991, 0x4078536D), U64(0x58FAE9F7, 0x73886E18), /* ~= 10^-244 */ + U64(0xDA7F5BF5, 0x90966848), U64(0xAF39A475, 0x506A899E), /* ~= 10^-243 */ + U64(0x888F9979, 0x7A5E012D), U64(0x6D8406C9, 0x52429603), /* ~= 10^-242 */ + U64(0xAAB37FD7, 0xD8F58178), U64(0xC8E5087B, 0xA6D33B83), /* ~= 10^-241 */ + U64(0xD5605FCD, 0xCF32E1D6), U64(0xFB1E4A9A, 0x90880A64), /* ~= 10^-240 */ + U64(0x855C3BE0, 0xA17FCD26), U64(0x5CF2EEA0, 0x9A55067F), /* ~= 10^-239 */ + U64(0xA6B34AD8, 0xC9DFC06F), U64(0xF42FAA48, 0xC0EA481E), /* ~= 10^-238 */ + U64(0xD0601D8E, 0xFC57B08B), U64(0xF13B94DA, 0xF124DA26), /* ~= 10^-237 */ + U64(0x823C1279, 0x5DB6CE57), U64(0x76C53D08, 0xD6B70858), /* ~= 10^-236 */ + U64(0xA2CB1717, 0xB52481ED), U64(0x54768C4B, 0x0C64CA6E), /* ~= 10^-235 */ + U64(0xCB7DDCDD, 0xA26DA268), U64(0xA9942F5D, 0xCF7DFD09), /* ~= 10^-234 */ + U64(0xFE5D5415, 0x0B090B02), U64(0xD3F93B35, 0x435D7C4C), /* ~= 10^-233 */ + U64(0x9EFA548D, 0x26E5A6E1), U64(0xC47BC501, 0x4A1A6DAF), /* ~= 10^-232 */ + U64(0xC6B8E9B0, 0x709F109A), U64(0x359AB641, 0x9CA1091B), /* ~= 10^-231 */ + U64(0xF867241C, 0x8CC6D4C0), U64(0xC30163D2, 0x03C94B62), /* ~= 10^-230 */ + U64(0x9B407691, 0xD7FC44F8), U64(0x79E0DE63, 0x425DCF1D), /* ~= 10^-229 */ + U64(0xC2109436, 0x4DFB5636), U64(0x985915FC, 0x12F542E4), /* ~= 10^-228 */ + U64(0xF294B943, 0xE17A2BC4), U64(0x3E6F5B7B, 0x17B2939D), /* ~= 10^-227 */ + U64(0x979CF3CA, 0x6CEC5B5A), U64(0xA705992C, 0xEECF9C42), /* ~= 10^-226 */ + U64(0xBD8430BD, 0x08277231), U64(0x50C6FF78, 0x2A838353), /* ~= 10^-225 */ + U64(0xECE53CEC, 0x4A314EBD), U64(0xA4F8BF56, 0x35246428), /* ~= 10^-224 */ + U64(0x940F4613, 0xAE5ED136), U64(0x871B7795, 0xE136BE99), /* ~= 10^-223 */ + U64(0xB9131798, 0x99F68584), U64(0x28E2557B, 0x59846E3F), /* ~= 10^-222 */ + U64(0xE757DD7E, 0xC07426E5), U64(0x331AEADA, 0x2FE589CF), /* ~= 10^-221 */ + U64(0x9096EA6F, 0x3848984F), U64(0x3FF0D2C8, 0x5DEF7621), /* ~= 10^-220 */ + U64(0xB4BCA50B, 0x065ABE63), U64(0x0FED077A, 0x756B53A9), /* ~= 10^-219 */ + U64(0xE1EBCE4D, 0xC7F16DFB), U64(0xD3E84959, 0x12C62894), /* ~= 10^-218 */ + U64(0x8D3360F0, 0x9CF6E4BD), U64(0x64712DD7, 0xABBBD95C), /* ~= 10^-217 */ + U64(0xB080392C, 0xC4349DEC), U64(0xBD8D794D, 0x96AACFB3), /* ~= 10^-216 */ + U64(0xDCA04777, 0xF541C567), U64(0xECF0D7A0, 0xFC5583A0), /* ~= 10^-215 */ + U64(0x89E42CAA, 0xF9491B60), U64(0xF41686C4, 0x9DB57244), /* ~= 10^-214 */ + U64(0xAC5D37D5, 0xB79B6239), U64(0x311C2875, 0xC522CED5), /* ~= 10^-213 */ + U64(0xD77485CB, 0x25823AC7), U64(0x7D633293, 0x366B828B), /* ~= 10^-212 */ + U64(0x86A8D39E, 0xF77164BC), U64(0xAE5DFF9C, 0x02033197), /* ~= 10^-211 */ + U64(0xA8530886, 0xB54DBDEB), U64(0xD9F57F83, 0x0283FDFC), /* ~= 10^-210 */ + U64(0xD267CAA8, 0x62A12D66), U64(0xD072DF63, 0xC324FD7B), /* ~= 10^-209 */ + U64(0x8380DEA9, 0x3DA4BC60), U64(0x4247CB9E, 0x59F71E6D), /* ~= 10^-208 */ + U64(0xA4611653, 0x8D0DEB78), U64(0x52D9BE85, 0xF074E608), /* ~= 10^-207 */ + U64(0xCD795BE8, 0x70516656), U64(0x67902E27, 0x6C921F8B), /* ~= 10^-206 */ + U64(0x806BD971, 0x4632DFF6), U64(0x00BA1CD8, 0xA3DB53B6), /* ~= 10^-205 */ + U64(0xA086CFCD, 0x97BF97F3), U64(0x80E8A40E, 0xCCD228A4), /* ~= 10^-204 */ + U64(0xC8A883C0, 0xFDAF7DF0), U64(0x6122CD12, 0x8006B2CD), /* ~= 10^-203 */ + U64(0xFAD2A4B1, 0x3D1B5D6C), U64(0x796B8057, 0x20085F81), /* ~= 10^-202 */ + U64(0x9CC3A6EE, 0xC6311A63), U64(0xCBE33036, 0x74053BB0), /* ~= 10^-201 */ + U64(0xC3F490AA, 0x77BD60FC), U64(0xBEDBFC44, 0x11068A9C), /* ~= 10^-200 */ + U64(0xF4F1B4D5, 0x15ACB93B), U64(0xEE92FB55, 0x15482D44), /* ~= 10^-199 */ + U64(0x99171105, 0x2D8BF3C5), U64(0x751BDD15, 0x2D4D1C4A), /* ~= 10^-198 */ + U64(0xBF5CD546, 0x78EEF0B6), U64(0xD262D45A, 0x78A0635D), /* ~= 10^-197 */ + U64(0xEF340A98, 0x172AACE4), U64(0x86FB8971, 0x16C87C34), /* ~= 10^-196 */ + U64(0x9580869F, 0x0E7AAC0E), U64(0xD45D35E6, 0xAE3D4DA0), /* ~= 10^-195 */ + U64(0xBAE0A846, 0xD2195712), U64(0x89748360, 0x59CCA109), /* ~= 10^-194 */ + U64(0xE998D258, 0x869FACD7), U64(0x2BD1A438, 0x703FC94B), /* ~= 10^-193 */ + U64(0x91FF8377, 0x5423CC06), U64(0x7B6306A3, 0x4627DDCF), /* ~= 10^-192 */ + U64(0xB67F6455, 0x292CBF08), U64(0x1A3BC84C, 0x17B1D542), /* ~= 10^-191 */ + U64(0xE41F3D6A, 0x7377EECA), U64(0x20CABA5F, 0x1D9E4A93), /* ~= 10^-190 */ + U64(0x8E938662, 0x882AF53E), U64(0x547EB47B, 0x7282EE9C), /* ~= 10^-189 */ + U64(0xB23867FB, 0x2A35B28D), U64(0xE99E619A, 0x4F23AA43), /* ~= 10^-188 */ + U64(0xDEC681F9, 0xF4C31F31), U64(0x6405FA00, 0xE2EC94D4), /* ~= 10^-187 */ + U64(0x8B3C113C, 0x38F9F37E), U64(0xDE83BC40, 0x8DD3DD04), /* ~= 10^-186 */ + U64(0xAE0B158B, 0x4738705E), U64(0x9624AB50, 0xB148D445), /* ~= 10^-185 */ + U64(0xD98DDAEE, 0x19068C76), U64(0x3BADD624, 0xDD9B0957), /* ~= 10^-184 */ + U64(0x87F8A8D4, 0xCFA417C9), U64(0xE54CA5D7, 0x0A80E5D6), /* ~= 10^-183 */ + U64(0xA9F6D30A, 0x038D1DBC), U64(0x5E9FCF4C, 0xCD211F4C), /* ~= 10^-182 */ + U64(0xD47487CC, 0x8470652B), U64(0x7647C320, 0x0069671F), /* ~= 10^-181 */ + U64(0x84C8D4DF, 0xD2C63F3B), U64(0x29ECD9F4, 0x0041E073), /* ~= 10^-180 */ + U64(0xA5FB0A17, 0xC777CF09), U64(0xF4681071, 0x00525890), /* ~= 10^-179 */ + U64(0xCF79CC9D, 0xB955C2CC), U64(0x7182148D, 0x4066EEB4), /* ~= 10^-178 */ + U64(0x81AC1FE2, 0x93D599BF), U64(0xC6F14CD8, 0x48405530), /* ~= 10^-177 */ + U64(0xA21727DB, 0x38CB002F), U64(0xB8ADA00E, 0x5A506A7C), /* ~= 10^-176 */ + U64(0xCA9CF1D2, 0x06FDC03B), U64(0xA6D90811, 0xF0E4851C), /* ~= 10^-175 */ + U64(0xFD442E46, 0x88BD304A), U64(0x908F4A16, 0x6D1DA663), /* ~= 10^-174 */ + U64(0x9E4A9CEC, 0x15763E2E), U64(0x9A598E4E, 0x043287FE), /* ~= 10^-173 */ + U64(0xC5DD4427, 0x1AD3CDBA), U64(0x40EFF1E1, 0x853F29FD), /* ~= 10^-172 */ + U64(0xF7549530, 0xE188C128), U64(0xD12BEE59, 0xE68EF47C), /* ~= 10^-171 */ + U64(0x9A94DD3E, 0x8CF578B9), U64(0x82BB74F8, 0x301958CE), /* ~= 10^-170 */ + U64(0xC13A148E, 0x3032D6E7), U64(0xE36A5236, 0x3C1FAF01), /* ~= 10^-169 */ + U64(0xF18899B1, 0xBC3F8CA1), U64(0xDC44E6C3, 0xCB279AC1), /* ~= 10^-168 */ + U64(0x96F5600F, 0x15A7B7E5), U64(0x29AB103A, 0x5EF8C0B9), /* ~= 10^-167 */ + U64(0xBCB2B812, 0xDB11A5DE), U64(0x7415D448, 0xF6B6F0E7), /* ~= 10^-166 */ + U64(0xEBDF6617, 0x91D60F56), U64(0x111B495B, 0x3464AD21), /* ~= 10^-165 */ + U64(0x936B9FCE, 0xBB25C995), U64(0xCAB10DD9, 0x00BEEC34), /* ~= 10^-164 */ + U64(0xB84687C2, 0x69EF3BFB), U64(0x3D5D514F, 0x40EEA742), /* ~= 10^-163 */ + U64(0xE65829B3, 0x046B0AFA), U64(0x0CB4A5A3, 0x112A5112), /* ~= 10^-162 */ + U64(0x8FF71A0F, 0xE2C2E6DC), U64(0x47F0E785, 0xEABA72AB), /* ~= 10^-161 */ + U64(0xB3F4E093, 0xDB73A093), U64(0x59ED2167, 0x65690F56), /* ~= 10^-160 */ + U64(0xE0F218B8, 0xD25088B8), U64(0x306869C1, 0x3EC3532C), /* ~= 10^-159 */ + U64(0x8C974F73, 0x83725573), U64(0x1E414218, 0xC73A13FB), /* ~= 10^-158 */ + U64(0xAFBD2350, 0x644EEACF), U64(0xE5D1929E, 0xF90898FA), /* ~= 10^-157 */ + U64(0xDBAC6C24, 0x7D62A583), U64(0xDF45F746, 0xB74ABF39), /* ~= 10^-156 */ + U64(0x894BC396, 0xCE5DA772), U64(0x6B8BBA8C, 0x328EB783), /* ~= 10^-155 */ + U64(0xAB9EB47C, 0x81F5114F), U64(0x066EA92F, 0x3F326564), /* ~= 10^-154 */ + U64(0xD686619B, 0xA27255A2), U64(0xC80A537B, 0x0EFEFEBD), /* ~= 10^-153 */ + U64(0x8613FD01, 0x45877585), U64(0xBD06742C, 0xE95F5F36), /* ~= 10^-152 */ + U64(0xA798FC41, 0x96E952E7), U64(0x2C481138, 0x23B73704), /* ~= 10^-151 */ + U64(0xD17F3B51, 0xFCA3A7A0), U64(0xF75A1586, 0x2CA504C5), /* ~= 10^-150 */ + U64(0x82EF8513, 0x3DE648C4), U64(0x9A984D73, 0xDBE722FB), /* ~= 10^-149 */ + U64(0xA3AB6658, 0x0D5FDAF5), U64(0xC13E60D0, 0xD2E0EBBA), /* ~= 10^-148 */ + U64(0xCC963FEE, 0x10B7D1B3), U64(0x318DF905, 0x079926A8), /* ~= 10^-147 */ + U64(0xFFBBCFE9, 0x94E5C61F), U64(0xFDF17746, 0x497F7052), /* ~= 10^-146 */ + U64(0x9FD561F1, 0xFD0F9BD3), U64(0xFEB6EA8B, 0xEDEFA633), /* ~= 10^-145 */ + U64(0xC7CABA6E, 0x7C5382C8), U64(0xFE64A52E, 0xE96B8FC0), /* ~= 10^-144 */ + U64(0xF9BD690A, 0x1B68637B), U64(0x3DFDCE7A, 0xA3C673B0), /* ~= 10^-143 */ + U64(0x9C1661A6, 0x51213E2D), U64(0x06BEA10C, 0xA65C084E), /* ~= 10^-142 */ + U64(0xC31BFA0F, 0xE5698DB8), U64(0x486E494F, 0xCFF30A62), /* ~= 10^-141 */ + U64(0xF3E2F893, 0xDEC3F126), U64(0x5A89DBA3, 0xC3EFCCFA), /* ~= 10^-140 */ + U64(0x986DDB5C, 0x6B3A76B7), U64(0xF8962946, 0x5A75E01C), /* ~= 10^-139 */ + U64(0xBE895233, 0x86091465), U64(0xF6BBB397, 0xF1135823), /* ~= 10^-138 */ + U64(0xEE2BA6C0, 0x678B597F), U64(0x746AA07D, 0xED582E2C), /* ~= 10^-137 */ + U64(0x94DB4838, 0x40B717EF), U64(0xA8C2A44E, 0xB4571CDC), /* ~= 10^-136 */ + U64(0xBA121A46, 0x50E4DDEB), U64(0x92F34D62, 0x616CE413), /* ~= 10^-135 */ + U64(0xE896A0D7, 0xE51E1566), U64(0x77B020BA, 0xF9C81D17), /* ~= 10^-134 */ + U64(0x915E2486, 0xEF32CD60), U64(0x0ACE1474, 0xDC1D122E), /* ~= 10^-133 */ + U64(0xB5B5ADA8, 0xAAFF80B8), U64(0x0D819992, 0x132456BA), /* ~= 10^-132 */ + U64(0xE3231912, 0xD5BF60E6), U64(0x10E1FFF6, 0x97ED6C69), /* ~= 10^-131 */ + U64(0x8DF5EFAB, 0xC5979C8F), U64(0xCA8D3FFA, 0x1EF463C1), /* ~= 10^-130 */ + U64(0xB1736B96, 0xB6FD83B3), U64(0xBD308FF8, 0xA6B17CB2), /* ~= 10^-129 */ + U64(0xDDD0467C, 0x64BCE4A0), U64(0xAC7CB3F6, 0xD05DDBDE), /* ~= 10^-128 */ + U64(0x8AA22C0D, 0xBEF60EE4), U64(0x6BCDF07A, 0x423AA96B), /* ~= 10^-127 */ + U64(0xAD4AB711, 0x2EB3929D), U64(0x86C16C98, 0xD2C953C6), /* ~= 10^-126 */ + U64(0xD89D64D5, 0x7A607744), U64(0xE871C7BF, 0x077BA8B7), /* ~= 10^-125 */ + U64(0x87625F05, 0x6C7C4A8B), U64(0x11471CD7, 0x64AD4972), /* ~= 10^-124 */ + U64(0xA93AF6C6, 0xC79B5D2D), U64(0xD598E40D, 0x3DD89BCF), /* ~= 10^-123 */ + U64(0xD389B478, 0x79823479), U64(0x4AFF1D10, 0x8D4EC2C3), /* ~= 10^-122 */ + U64(0x843610CB, 0x4BF160CB), U64(0xCEDF722A, 0x585139BA), /* ~= 10^-121 */ + U64(0xA54394FE, 0x1EEDB8FE), U64(0xC2974EB4, 0xEE658828), /* ~= 10^-120 */ + U64(0xCE947A3D, 0xA6A9273E), U64(0x733D2262, 0x29FEEA32), /* ~= 10^-119 */ + U64(0x811CCC66, 0x8829B887), U64(0x0806357D, 0x5A3F525F), /* ~= 10^-118 */ + U64(0xA163FF80, 0x2A3426A8), U64(0xCA07C2DC, 0xB0CF26F7), /* ~= 10^-117 */ + U64(0xC9BCFF60, 0x34C13052), U64(0xFC89B393, 0xDD02F0B5), /* ~= 10^-116 */ + U64(0xFC2C3F38, 0x41F17C67), U64(0xBBAC2078, 0xD443ACE2), /* ~= 10^-115 */ + U64(0x9D9BA783, 0x2936EDC0), U64(0xD54B944B, 0x84AA4C0D), /* ~= 10^-114 */ + U64(0xC5029163, 0xF384A931), U64(0x0A9E795E, 0x65D4DF11), /* ~= 10^-113 */ + U64(0xF64335BC, 0xF065D37D), U64(0x4D4617B5, 0xFF4A16D5), /* ~= 10^-112 */ + U64(0x99EA0196, 0x163FA42E), U64(0x504BCED1, 0xBF8E4E45), /* ~= 10^-111 */ + U64(0xC06481FB, 0x9BCF8D39), U64(0xE45EC286, 0x2F71E1D6), /* ~= 10^-110 */ + U64(0xF07DA27A, 0x82C37088), U64(0x5D767327, 0xBB4E5A4C), /* ~= 10^-109 */ + U64(0x964E858C, 0x91BA2655), U64(0x3A6A07F8, 0xD510F86F), /* ~= 10^-108 */ + U64(0xBBE226EF, 0xB628AFEA), U64(0x890489F7, 0x0A55368B), /* ~= 10^-107 */ + U64(0xEADAB0AB, 0xA3B2DBE5), U64(0x2B45AC74, 0xCCEA842E), /* ~= 10^-106 */ + U64(0x92C8AE6B, 0x464FC96F), U64(0x3B0B8BC9, 0x0012929D), /* ~= 10^-105 */ + U64(0xB77ADA06, 0x17E3BBCB), U64(0x09CE6EBB, 0x40173744), /* ~= 10^-104 */ + U64(0xE5599087, 0x9DDCAABD), U64(0xCC420A6A, 0x101D0515), /* ~= 10^-103 */ + U64(0x8F57FA54, 0xC2A9EAB6), U64(0x9FA94682, 0x4A12232D), /* ~= 10^-102 */ + U64(0xB32DF8E9, 0xF3546564), U64(0x47939822, 0xDC96ABF9), /* ~= 10^-101 */ + U64(0xDFF97724, 0x70297EBD), U64(0x59787E2B, 0x93BC56F7), /* ~= 10^-100 */ + U64(0x8BFBEA76, 0xC619EF36), U64(0x57EB4EDB, 0x3C55B65A), /* ~= 10^-99 */ + U64(0xAEFAE514, 0x77A06B03), U64(0xEDE62292, 0x0B6B23F1), /* ~= 10^-98 */ + U64(0xDAB99E59, 0x958885C4), U64(0xE95FAB36, 0x8E45ECED), /* ~= 10^-97 */ + U64(0x88B402F7, 0xFD75539B), U64(0x11DBCB02, 0x18EBB414), /* ~= 10^-96 */ + U64(0xAAE103B5, 0xFCD2A881), U64(0xD652BDC2, 0x9F26A119), /* ~= 10^-95 */ + U64(0xD59944A3, 0x7C0752A2), U64(0x4BE76D33, 0x46F0495F), /* ~= 10^-94 */ + U64(0x857FCAE6, 0x2D8493A5), U64(0x6F70A440, 0x0C562DDB), /* ~= 10^-93 */ + U64(0xA6DFBD9F, 0xB8E5B88E), U64(0xCB4CCD50, 0x0F6BB952), /* ~= 10^-92 */ + U64(0xD097AD07, 0xA71F26B2), U64(0x7E2000A4, 0x1346A7A7), /* ~= 10^-91 */ + U64(0x825ECC24, 0xC873782F), U64(0x8ED40066, 0x8C0C28C8), /* ~= 10^-90 */ + U64(0xA2F67F2D, 0xFA90563B), U64(0x72890080, 0x2F0F32FA), /* ~= 10^-89 */ + U64(0xCBB41EF9, 0x79346BCA), U64(0x4F2B40A0, 0x3AD2FFB9), /* ~= 10^-88 */ + U64(0xFEA126B7, 0xD78186BC), U64(0xE2F610C8, 0x4987BFA8), /* ~= 10^-87 */ + U64(0x9F24B832, 0xE6B0F436), U64(0x0DD9CA7D, 0x2DF4D7C9), /* ~= 10^-86 */ + U64(0xC6EDE63F, 0xA05D3143), U64(0x91503D1C, 0x79720DBB), /* ~= 10^-85 */ + U64(0xF8A95FCF, 0x88747D94), U64(0x75A44C63, 0x97CE912A), /* ~= 10^-84 */ + U64(0x9B69DBE1, 0xB548CE7C), U64(0xC986AFBE, 0x3EE11ABA), /* ~= 10^-83 */ + U64(0xC24452DA, 0x229B021B), U64(0xFBE85BAD, 0xCE996168), /* ~= 10^-82 */ + U64(0xF2D56790, 0xAB41C2A2), U64(0xFAE27299, 0x423FB9C3), /* ~= 10^-81 */ + U64(0x97C560BA, 0x6B0919A5), U64(0xDCCD879F, 0xC967D41A), /* ~= 10^-80 */ + U64(0xBDB6B8E9, 0x05CB600F), U64(0x5400E987, 0xBBC1C920), /* ~= 10^-79 */ + U64(0xED246723, 0x473E3813), U64(0x290123E9, 0xAAB23B68), /* ~= 10^-78 */ + U64(0x9436C076, 0x0C86E30B), U64(0xF9A0B672, 0x0AAF6521), /* ~= 10^-77 */ + U64(0xB9447093, 0x8FA89BCE), U64(0xF808E40E, 0x8D5B3E69), /* ~= 10^-76 */ + U64(0xE7958CB8, 0x7392C2C2), U64(0xB60B1D12, 0x30B20E04), /* ~= 10^-75 */ + U64(0x90BD77F3, 0x483BB9B9), U64(0xB1C6F22B, 0x5E6F48C2), /* ~= 10^-74 */ + U64(0xB4ECD5F0, 0x1A4AA828), U64(0x1E38AEB6, 0x360B1AF3), /* ~= 10^-73 */ + U64(0xE2280B6C, 0x20DD5232), U64(0x25C6DA63, 0xC38DE1B0), /* ~= 10^-72 */ + U64(0x8D590723, 0x948A535F), U64(0x579C487E, 0x5A38AD0E), /* ~= 10^-71 */ + U64(0xB0AF48EC, 0x79ACE837), U64(0x2D835A9D, 0xF0C6D851), /* ~= 10^-70 */ + U64(0xDCDB1B27, 0x98182244), U64(0xF8E43145, 0x6CF88E65), /* ~= 10^-69 */ + U64(0x8A08F0F8, 0xBF0F156B), U64(0x1B8E9ECB, 0x641B58FF), /* ~= 10^-68 */ + U64(0xAC8B2D36, 0xEED2DAC5), U64(0xE272467E, 0x3D222F3F), /* ~= 10^-67 */ + U64(0xD7ADF884, 0xAA879177), U64(0x5B0ED81D, 0xCC6ABB0F), /* ~= 10^-66 */ + U64(0x86CCBB52, 0xEA94BAEA), U64(0x98E94712, 0x9FC2B4E9), /* ~= 10^-65 */ + U64(0xA87FEA27, 0xA539E9A5), U64(0x3F2398D7, 0x47B36224), /* ~= 10^-64 */ + U64(0xD29FE4B1, 0x8E88640E), U64(0x8EEC7F0D, 0x19A03AAD), /* ~= 10^-63 */ + U64(0x83A3EEEE, 0xF9153E89), U64(0x1953CF68, 0x300424AC), /* ~= 10^-62 */ + U64(0xA48CEAAA, 0xB75A8E2B), U64(0x5FA8C342, 0x3C052DD7), /* ~= 10^-61 */ + U64(0xCDB02555, 0x653131B6), U64(0x3792F412, 0xCB06794D), /* ~= 10^-60 */ + U64(0x808E1755, 0x5F3EBF11), U64(0xE2BBD88B, 0xBEE40BD0), /* ~= 10^-59 */ + U64(0xA0B19D2A, 0xB70E6ED6), U64(0x5B6ACEAE, 0xAE9D0EC4), /* ~= 10^-58 */ + U64(0xC8DE0475, 0x64D20A8B), U64(0xF245825A, 0x5A445275), /* ~= 10^-57 */ + U64(0xFB158592, 0xBE068D2E), U64(0xEED6E2F0, 0xF0D56712), /* ~= 10^-56 */ + U64(0x9CED737B, 0xB6C4183D), U64(0x55464DD6, 0x9685606B), /* ~= 10^-55 */ + U64(0xC428D05A, 0xA4751E4C), U64(0xAA97E14C, 0x3C26B886), /* ~= 10^-54 */ + U64(0xF5330471, 0x4D9265DF), U64(0xD53DD99F, 0x4B3066A8), /* ~= 10^-53 */ + U64(0x993FE2C6, 0xD07B7FAB), U64(0xE546A803, 0x8EFE4029), /* ~= 10^-52 */ + U64(0xBF8FDB78, 0x849A5F96), U64(0xDE985204, 0x72BDD033), /* ~= 10^-51 */ + U64(0xEF73D256, 0xA5C0F77C), U64(0x963E6685, 0x8F6D4440), /* ~= 10^-50 */ + U64(0x95A86376, 0x27989AAD), U64(0xDDE70013, 0x79A44AA8), /* ~= 10^-49 */ + U64(0xBB127C53, 0xB17EC159), U64(0x5560C018, 0x580D5D52), /* ~= 10^-48 */ + U64(0xE9D71B68, 0x9DDE71AF), U64(0xAAB8F01E, 0x6E10B4A6), /* ~= 10^-47 */ + U64(0x92267121, 0x62AB070D), U64(0xCAB39613, 0x04CA70E8), /* ~= 10^-46 */ + U64(0xB6B00D69, 0xBB55C8D1), U64(0x3D607B97, 0xC5FD0D22), /* ~= 10^-45 */ + U64(0xE45C10C4, 0x2A2B3B05), U64(0x8CB89A7D, 0xB77C506A), /* ~= 10^-44 */ + U64(0x8EB98A7A, 0x9A5B04E3), U64(0x77F3608E, 0x92ADB242), /* ~= 10^-43 */ + U64(0xB267ED19, 0x40F1C61C), U64(0x55F038B2, 0x37591ED3), /* ~= 10^-42 */ + U64(0xDF01E85F, 0x912E37A3), U64(0x6B6C46DE, 0xC52F6688), /* ~= 10^-41 */ + U64(0x8B61313B, 0xBABCE2C6), U64(0x2323AC4B, 0x3B3DA015), /* ~= 10^-40 */ + U64(0xAE397D8A, 0xA96C1B77), U64(0xABEC975E, 0x0A0D081A), /* ~= 10^-39 */ + U64(0xD9C7DCED, 0x53C72255), U64(0x96E7BD35, 0x8C904A21), /* ~= 10^-38 */ + U64(0x881CEA14, 0x545C7575), U64(0x7E50D641, 0x77DA2E54), /* ~= 10^-37 */ + U64(0xAA242499, 0x697392D2), U64(0xDDE50BD1, 0xD5D0B9E9), /* ~= 10^-36 */ + U64(0xD4AD2DBF, 0xC3D07787), U64(0x955E4EC6, 0x4B44E864), /* ~= 10^-35 */ + U64(0x84EC3C97, 0xDA624AB4), U64(0xBD5AF13B, 0xEF0B113E), /* ~= 10^-34 */ + U64(0xA6274BBD, 0xD0FADD61), U64(0xECB1AD8A, 0xEACDD58E), /* ~= 10^-33 */ + U64(0xCFB11EAD, 0x453994BA), U64(0x67DE18ED, 0xA5814AF2), /* ~= 10^-32 */ + U64(0x81CEB32C, 0x4B43FCF4), U64(0x80EACF94, 0x8770CED7), /* ~= 10^-31 */ + U64(0xA2425FF7, 0x5E14FC31), U64(0xA1258379, 0xA94D028D), /* ~= 10^-30 */ + U64(0xCAD2F7F5, 0x359A3B3E), U64(0x096EE458, 0x13A04330), /* ~= 10^-29 */ + U64(0xFD87B5F2, 0x8300CA0D), U64(0x8BCA9D6E, 0x188853FC), /* ~= 10^-28 */ + U64(0x9E74D1B7, 0x91E07E48), U64(0x775EA264, 0xCF55347D), /* ~= 10^-27 */ + U64(0xC6120625, 0x76589DDA), U64(0x95364AFE, 0x032A819D), /* ~= 10^-26 */ + U64(0xF79687AE, 0xD3EEC551), U64(0x3A83DDBD, 0x83F52204), /* ~= 10^-25 */ + U64(0x9ABE14CD, 0x44753B52), U64(0xC4926A96, 0x72793542), /* ~= 10^-24 */ + U64(0xC16D9A00, 0x95928A27), U64(0x75B7053C, 0x0F178293), /* ~= 10^-23 */ + U64(0xF1C90080, 0xBAF72CB1), U64(0x5324C68B, 0x12DD6338), /* ~= 10^-22 */ + U64(0x971DA050, 0x74DA7BEE), U64(0xD3F6FC16, 0xEBCA5E03), /* ~= 10^-21 */ + U64(0xBCE50864, 0x92111AEA), U64(0x88F4BB1C, 0xA6BCF584), /* ~= 10^-20 */ + U64(0xEC1E4A7D, 0xB69561A5), U64(0x2B31E9E3, 0xD06C32E5), /* ~= 10^-19 */ + U64(0x9392EE8E, 0x921D5D07), U64(0x3AFF322E, 0x62439FCF), /* ~= 10^-18 */ + U64(0xB877AA32, 0x36A4B449), U64(0x09BEFEB9, 0xFAD487C2), /* ~= 10^-17 */ + U64(0xE69594BE, 0xC44DE15B), U64(0x4C2EBE68, 0x7989A9B3), /* ~= 10^-16 */ + U64(0x901D7CF7, 0x3AB0ACD9), U64(0x0F9D3701, 0x4BF60A10), /* ~= 10^-15 */ + U64(0xB424DC35, 0x095CD80F), U64(0x538484C1, 0x9EF38C94), /* ~= 10^-14 */ + U64(0xE12E1342, 0x4BB40E13), U64(0x2865A5F2, 0x06B06FB9), /* ~= 10^-13 */ + U64(0x8CBCCC09, 0x6F5088CB), U64(0xF93F87B7, 0x442E45D3), /* ~= 10^-12 */ + U64(0xAFEBFF0B, 0xCB24AAFE), U64(0xF78F69A5, 0x1539D748), /* ~= 10^-11 */ + U64(0xDBE6FECE, 0xBDEDD5BE), U64(0xB573440E, 0x5A884D1B), /* ~= 10^-10 */ + U64(0x89705F41, 0x36B4A597), U64(0x31680A88, 0xF8953030), /* ~= 10^-9 */ + U64(0xABCC7711, 0x8461CEFC), U64(0xFDC20D2B, 0x36BA7C3D), /* ~= 10^-8 */ + U64(0xD6BF94D5, 0xE57A42BC), U64(0x3D329076, 0x04691B4C), /* ~= 10^-7 */ + U64(0x8637BD05, 0xAF6C69B5), U64(0xA63F9A49, 0xC2C1B10F), /* ~= 10^-6 */ + U64(0xA7C5AC47, 0x1B478423), U64(0x0FCF80DC, 0x33721D53), /* ~= 10^-5 */ + U64(0xD1B71758, 0xE219652B), U64(0xD3C36113, 0x404EA4A8), /* ~= 10^-4 */ + U64(0x83126E97, 0x8D4FDF3B), U64(0x645A1CAC, 0x083126E9), /* ~= 10^-3 */ + U64(0xA3D70A3D, 0x70A3D70A), U64(0x3D70A3D7, 0x0A3D70A3), /* ~= 10^-2 */ + U64(0xCCCCCCCC, 0xCCCCCCCC), U64(0xCCCCCCCC, 0xCCCCCCCC), /* ~= 10^-1 */ + U64(0x80000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^0 */ + U64(0xA0000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^1 */ + U64(0xC8000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^2 */ + U64(0xFA000000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^3 */ + U64(0x9C400000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^4 */ + U64(0xC3500000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^5 */ + U64(0xF4240000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^6 */ + U64(0x98968000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^7 */ + U64(0xBEBC2000, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^8 */ + U64(0xEE6B2800, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^9 */ + U64(0x9502F900, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^10 */ + U64(0xBA43B740, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^11 */ + U64(0xE8D4A510, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^12 */ + U64(0x9184E72A, 0x00000000), U64(0x00000000, 0x00000000), /* == 10^13 */ + U64(0xB5E620F4, 0x80000000), U64(0x00000000, 0x00000000), /* == 10^14 */ + U64(0xE35FA931, 0xA0000000), U64(0x00000000, 0x00000000), /* == 10^15 */ + U64(0x8E1BC9BF, 0x04000000), U64(0x00000000, 0x00000000), /* == 10^16 */ + U64(0xB1A2BC2E, 0xC5000000), U64(0x00000000, 0x00000000), /* == 10^17 */ + U64(0xDE0B6B3A, 0x76400000), U64(0x00000000, 0x00000000), /* == 10^18 */ + U64(0x8AC72304, 0x89E80000), U64(0x00000000, 0x00000000), /* == 10^19 */ + U64(0xAD78EBC5, 0xAC620000), U64(0x00000000, 0x00000000), /* == 10^20 */ + U64(0xD8D726B7, 0x177A8000), U64(0x00000000, 0x00000000), /* == 10^21 */ + U64(0x87867832, 0x6EAC9000), U64(0x00000000, 0x00000000), /* == 10^22 */ + U64(0xA968163F, 0x0A57B400), U64(0x00000000, 0x00000000), /* == 10^23 */ + U64(0xD3C21BCE, 0xCCEDA100), U64(0x00000000, 0x00000000), /* == 10^24 */ + U64(0x84595161, 0x401484A0), U64(0x00000000, 0x00000000), /* == 10^25 */ + U64(0xA56FA5B9, 0x9019A5C8), U64(0x00000000, 0x00000000), /* == 10^26 */ + U64(0xCECB8F27, 0xF4200F3A), U64(0x00000000, 0x00000000), /* == 10^27 */ + U64(0x813F3978, 0xF8940984), U64(0x40000000, 0x00000000), /* == 10^28 */ + U64(0xA18F07D7, 0x36B90BE5), U64(0x50000000, 0x00000000), /* == 10^29 */ + U64(0xC9F2C9CD, 0x04674EDE), U64(0xA4000000, 0x00000000), /* == 10^30 */ + U64(0xFC6F7C40, 0x45812296), U64(0x4D000000, 0x00000000), /* == 10^31 */ + U64(0x9DC5ADA8, 0x2B70B59D), U64(0xF0200000, 0x00000000), /* == 10^32 */ + U64(0xC5371912, 0x364CE305), U64(0x6C280000, 0x00000000), /* == 10^33 */ + U64(0xF684DF56, 0xC3E01BC6), U64(0xC7320000, 0x00000000), /* == 10^34 */ + U64(0x9A130B96, 0x3A6C115C), U64(0x3C7F4000, 0x00000000), /* == 10^35 */ + U64(0xC097CE7B, 0xC90715B3), U64(0x4B9F1000, 0x00000000), /* == 10^36 */ + U64(0xF0BDC21A, 0xBB48DB20), U64(0x1E86D400, 0x00000000), /* == 10^37 */ + U64(0x96769950, 0xB50D88F4), U64(0x13144480, 0x00000000), /* == 10^38 */ + U64(0xBC143FA4, 0xE250EB31), U64(0x17D955A0, 0x00000000), /* == 10^39 */ + U64(0xEB194F8E, 0x1AE525FD), U64(0x5DCFAB08, 0x00000000), /* == 10^40 */ + U64(0x92EFD1B8, 0xD0CF37BE), U64(0x5AA1CAE5, 0x00000000), /* == 10^41 */ + U64(0xB7ABC627, 0x050305AD), U64(0xF14A3D9E, 0x40000000), /* == 10^42 */ + U64(0xE596B7B0, 0xC643C719), U64(0x6D9CCD05, 0xD0000000), /* == 10^43 */ + U64(0x8F7E32CE, 0x7BEA5C6F), U64(0xE4820023, 0xA2000000), /* == 10^44 */ + U64(0xB35DBF82, 0x1AE4F38B), U64(0xDDA2802C, 0x8A800000), /* == 10^45 */ + U64(0xE0352F62, 0xA19E306E), U64(0xD50B2037, 0xAD200000), /* == 10^46 */ + U64(0x8C213D9D, 0xA502DE45), U64(0x4526F422, 0xCC340000), /* == 10^47 */ + U64(0xAF298D05, 0x0E4395D6), U64(0x9670B12B, 0x7F410000), /* == 10^48 */ + U64(0xDAF3F046, 0x51D47B4C), U64(0x3C0CDD76, 0x5F114000), /* == 10^49 */ + U64(0x88D8762B, 0xF324CD0F), U64(0xA5880A69, 0xFB6AC800), /* == 10^50 */ + U64(0xAB0E93B6, 0xEFEE0053), U64(0x8EEA0D04, 0x7A457A00), /* == 10^51 */ + U64(0xD5D238A4, 0xABE98068), U64(0x72A49045, 0x98D6D880), /* == 10^52 */ + U64(0x85A36366, 0xEB71F041), U64(0x47A6DA2B, 0x7F864750), /* == 10^53 */ + U64(0xA70C3C40, 0xA64E6C51), U64(0x999090B6, 0x5F67D924), /* == 10^54 */ + U64(0xD0CF4B50, 0xCFE20765), U64(0xFFF4B4E3, 0xF741CF6D), /* == 10^55 */ + U64(0x82818F12, 0x81ED449F), U64(0xBFF8F10E, 0x7A8921A4), /* ~= 10^56 */ + U64(0xA321F2D7, 0x226895C7), U64(0xAFF72D52, 0x192B6A0D), /* ~= 10^57 */ + U64(0xCBEA6F8C, 0xEB02BB39), U64(0x9BF4F8A6, 0x9F764490), /* ~= 10^58 */ + U64(0xFEE50B70, 0x25C36A08), U64(0x02F236D0, 0x4753D5B4), /* ~= 10^59 */ + U64(0x9F4F2726, 0x179A2245), U64(0x01D76242, 0x2C946590), /* ~= 10^60 */ + U64(0xC722F0EF, 0x9D80AAD6), U64(0x424D3AD2, 0xB7B97EF5), /* ~= 10^61 */ + U64(0xF8EBAD2B, 0x84E0D58B), U64(0xD2E08987, 0x65A7DEB2), /* ~= 10^62 */ + U64(0x9B934C3B, 0x330C8577), U64(0x63CC55F4, 0x9F88EB2F), /* ~= 10^63 */ + U64(0xC2781F49, 0xFFCFA6D5), U64(0x3CBF6B71, 0xC76B25FB), /* ~= 10^64 */ + U64(0xF316271C, 0x7FC3908A), U64(0x8BEF464E, 0x3945EF7A), /* ~= 10^65 */ + U64(0x97EDD871, 0xCFDA3A56), U64(0x97758BF0, 0xE3CBB5AC), /* ~= 10^66 */ + U64(0xBDE94E8E, 0x43D0C8EC), U64(0x3D52EEED, 0x1CBEA317), /* ~= 10^67 */ + U64(0xED63A231, 0xD4C4FB27), U64(0x4CA7AAA8, 0x63EE4BDD), /* ~= 10^68 */ + U64(0x945E455F, 0x24FB1CF8), U64(0x8FE8CAA9, 0x3E74EF6A), /* ~= 10^69 */ + U64(0xB975D6B6, 0xEE39E436), U64(0xB3E2FD53, 0x8E122B44), /* ~= 10^70 */ + U64(0xE7D34C64, 0xA9C85D44), U64(0x60DBBCA8, 0x7196B616), /* ~= 10^71 */ + U64(0x90E40FBE, 0xEA1D3A4A), U64(0xBC8955E9, 0x46FE31CD), /* ~= 10^72 */ + U64(0xB51D13AE, 0xA4A488DD), U64(0x6BABAB63, 0x98BDBE41), /* ~= 10^73 */ + U64(0xE264589A, 0x4DCDAB14), U64(0xC696963C, 0x7EED2DD1), /* ~= 10^74 */ + U64(0x8D7EB760, 0x70A08AEC), U64(0xFC1E1DE5, 0xCF543CA2), /* ~= 10^75 */ + U64(0xB0DE6538, 0x8CC8ADA8), U64(0x3B25A55F, 0x43294BCB), /* ~= 10^76 */ + U64(0xDD15FE86, 0xAFFAD912), U64(0x49EF0EB7, 0x13F39EBE), /* ~= 10^77 */ + U64(0x8A2DBF14, 0x2DFCC7AB), U64(0x6E356932, 0x6C784337), /* ~= 10^78 */ + U64(0xACB92ED9, 0x397BF996), U64(0x49C2C37F, 0x07965404), /* ~= 10^79 */ + U64(0xD7E77A8F, 0x87DAF7FB), U64(0xDC33745E, 0xC97BE906), /* ~= 10^80 */ + U64(0x86F0AC99, 0xB4E8DAFD), U64(0x69A028BB, 0x3DED71A3), /* ~= 10^81 */ + U64(0xA8ACD7C0, 0x222311BC), U64(0xC40832EA, 0x0D68CE0C), /* ~= 10^82 */ + U64(0xD2D80DB0, 0x2AABD62B), U64(0xF50A3FA4, 0x90C30190), /* ~= 10^83 */ + U64(0x83C7088E, 0x1AAB65DB), U64(0x792667C6, 0xDA79E0FA), /* ~= 10^84 */ + U64(0xA4B8CAB1, 0xA1563F52), U64(0x577001B8, 0x91185938), /* ~= 10^85 */ + U64(0xCDE6FD5E, 0x09ABCF26), U64(0xED4C0226, 0xB55E6F86), /* ~= 10^86 */ + U64(0x80B05E5A, 0xC60B6178), U64(0x544F8158, 0x315B05B4), /* ~= 10^87 */ + U64(0xA0DC75F1, 0x778E39D6), U64(0x696361AE, 0x3DB1C721), /* ~= 10^88 */ + U64(0xC913936D, 0xD571C84C), U64(0x03BC3A19, 0xCD1E38E9), /* ~= 10^89 */ + U64(0xFB587849, 0x4ACE3A5F), U64(0x04AB48A0, 0x4065C723), /* ~= 10^90 */ + U64(0x9D174B2D, 0xCEC0E47B), U64(0x62EB0D64, 0x283F9C76), /* ~= 10^91 */ + U64(0xC45D1DF9, 0x42711D9A), U64(0x3BA5D0BD, 0x324F8394), /* ~= 10^92 */ + U64(0xF5746577, 0x930D6500), U64(0xCA8F44EC, 0x7EE36479), /* ~= 10^93 */ + U64(0x9968BF6A, 0xBBE85F20), U64(0x7E998B13, 0xCF4E1ECB), /* ~= 10^94 */ + U64(0xBFC2EF45, 0x6AE276E8), U64(0x9E3FEDD8, 0xC321A67E), /* ~= 10^95 */ + U64(0xEFB3AB16, 0xC59B14A2), U64(0xC5CFE94E, 0xF3EA101E), /* ~= 10^96 */ + U64(0x95D04AEE, 0x3B80ECE5), U64(0xBBA1F1D1, 0x58724A12), /* ~= 10^97 */ + U64(0xBB445DA9, 0xCA61281F), U64(0x2A8A6E45, 0xAE8EDC97), /* ~= 10^98 */ + U64(0xEA157514, 0x3CF97226), U64(0xF52D09D7, 0x1A3293BD), /* ~= 10^99 */ + U64(0x924D692C, 0xA61BE758), U64(0x593C2626, 0x705F9C56), /* ~= 10^100 */ + U64(0xB6E0C377, 0xCFA2E12E), U64(0x6F8B2FB0, 0x0C77836C), /* ~= 10^101 */ + U64(0xE498F455, 0xC38B997A), U64(0x0B6DFB9C, 0x0F956447), /* ~= 10^102 */ + U64(0x8EDF98B5, 0x9A373FEC), U64(0x4724BD41, 0x89BD5EAC), /* ~= 10^103 */ + U64(0xB2977EE3, 0x00C50FE7), U64(0x58EDEC91, 0xEC2CB657), /* ~= 10^104 */ + U64(0xDF3D5E9B, 0xC0F653E1), U64(0x2F2967B6, 0x6737E3ED), /* ~= 10^105 */ + U64(0x8B865B21, 0x5899F46C), U64(0xBD79E0D2, 0x0082EE74), /* ~= 10^106 */ + U64(0xAE67F1E9, 0xAEC07187), U64(0xECD85906, 0x80A3AA11), /* ~= 10^107 */ + U64(0xDA01EE64, 0x1A708DE9), U64(0xE80E6F48, 0x20CC9495), /* ~= 10^108 */ + U64(0x884134FE, 0x908658B2), U64(0x3109058D, 0x147FDCDD), /* ~= 10^109 */ + U64(0xAA51823E, 0x34A7EEDE), U64(0xBD4B46F0, 0x599FD415), /* ~= 10^110 */ + U64(0xD4E5E2CD, 0xC1D1EA96), U64(0x6C9E18AC, 0x7007C91A), /* ~= 10^111 */ + U64(0x850FADC0, 0x9923329E), U64(0x03E2CF6B, 0xC604DDB0), /* ~= 10^112 */ + U64(0xA6539930, 0xBF6BFF45), U64(0x84DB8346, 0xB786151C), /* ~= 10^113 */ + U64(0xCFE87F7C, 0xEF46FF16), U64(0xE6126418, 0x65679A63), /* ~= 10^114 */ + U64(0x81F14FAE, 0x158C5F6E), U64(0x4FCB7E8F, 0x3F60C07E), /* ~= 10^115 */ + U64(0xA26DA399, 0x9AEF7749), U64(0xE3BE5E33, 0x0F38F09D), /* ~= 10^116 */ + U64(0xCB090C80, 0x01AB551C), U64(0x5CADF5BF, 0xD3072CC5), /* ~= 10^117 */ + U64(0xFDCB4FA0, 0x02162A63), U64(0x73D9732F, 0xC7C8F7F6), /* ~= 10^118 */ + U64(0x9E9F11C4, 0x014DDA7E), U64(0x2867E7FD, 0xDCDD9AFA), /* ~= 10^119 */ + U64(0xC646D635, 0x01A1511D), U64(0xB281E1FD, 0x541501B8), /* ~= 10^120 */ + U64(0xF7D88BC2, 0x4209A565), U64(0x1F225A7C, 0xA91A4226), /* ~= 10^121 */ + U64(0x9AE75759, 0x6946075F), U64(0x3375788D, 0xE9B06958), /* ~= 10^122 */ + U64(0xC1A12D2F, 0xC3978937), U64(0x0052D6B1, 0x641C83AE), /* ~= 10^123 */ + U64(0xF209787B, 0xB47D6B84), U64(0xC0678C5D, 0xBD23A49A), /* ~= 10^124 */ + U64(0x9745EB4D, 0x50CE6332), U64(0xF840B7BA, 0x963646E0), /* ~= 10^125 */ + U64(0xBD176620, 0xA501FBFF), U64(0xB650E5A9, 0x3BC3D898), /* ~= 10^126 */ + U64(0xEC5D3FA8, 0xCE427AFF), U64(0xA3E51F13, 0x8AB4CEBE), /* ~= 10^127 */ + U64(0x93BA47C9, 0x80E98CDF), U64(0xC66F336C, 0x36B10137), /* ~= 10^128 */ + U64(0xB8A8D9BB, 0xE123F017), U64(0xB80B0047, 0x445D4184), /* ~= 10^129 */ + U64(0xE6D3102A, 0xD96CEC1D), U64(0xA60DC059, 0x157491E5), /* ~= 10^130 */ + U64(0x9043EA1A, 0xC7E41392), U64(0x87C89837, 0xAD68DB2F), /* ~= 10^131 */ + U64(0xB454E4A1, 0x79DD1877), U64(0x29BABE45, 0x98C311FB), /* ~= 10^132 */ + U64(0xE16A1DC9, 0xD8545E94), U64(0xF4296DD6, 0xFEF3D67A), /* ~= 10^133 */ + U64(0x8CE2529E, 0x2734BB1D), U64(0x1899E4A6, 0x5F58660C), /* ~= 10^134 */ + U64(0xB01AE745, 0xB101E9E4), U64(0x5EC05DCF, 0xF72E7F8F), /* ~= 10^135 */ + U64(0xDC21A117, 0x1D42645D), U64(0x76707543, 0xF4FA1F73), /* ~= 10^136 */ + U64(0x899504AE, 0x72497EBA), U64(0x6A06494A, 0x791C53A8), /* ~= 10^137 */ + U64(0xABFA45DA, 0x0EDBDE69), U64(0x0487DB9D, 0x17636892), /* ~= 10^138 */ + U64(0xD6F8D750, 0x9292D603), U64(0x45A9D284, 0x5D3C42B6), /* ~= 10^139 */ + U64(0x865B8692, 0x5B9BC5C2), U64(0x0B8A2392, 0xBA45A9B2), /* ~= 10^140 */ + U64(0xA7F26836, 0xF282B732), U64(0x8E6CAC77, 0x68D7141E), /* ~= 10^141 */ + U64(0xD1EF0244, 0xAF2364FF), U64(0x3207D795, 0x430CD926), /* ~= 10^142 */ + U64(0x8335616A, 0xED761F1F), U64(0x7F44E6BD, 0x49E807B8), /* ~= 10^143 */ + U64(0xA402B9C5, 0xA8D3A6E7), U64(0x5F16206C, 0x9C6209A6), /* ~= 10^144 */ + U64(0xCD036837, 0x130890A1), U64(0x36DBA887, 0xC37A8C0F), /* ~= 10^145 */ + U64(0x80222122, 0x6BE55A64), U64(0xC2494954, 0xDA2C9789), /* ~= 10^146 */ + U64(0xA02AA96B, 0x06DEB0FD), U64(0xF2DB9BAA, 0x10B7BD6C), /* ~= 10^147 */ + U64(0xC83553C5, 0xC8965D3D), U64(0x6F928294, 0x94E5ACC7), /* ~= 10^148 */ + U64(0xFA42A8B7, 0x3ABBF48C), U64(0xCB772339, 0xBA1F17F9), /* ~= 10^149 */ + U64(0x9C69A972, 0x84B578D7), U64(0xFF2A7604, 0x14536EFB), /* ~= 10^150 */ + U64(0xC38413CF, 0x25E2D70D), U64(0xFEF51385, 0x19684ABA), /* ~= 10^151 */ + U64(0xF46518C2, 0xEF5B8CD1), U64(0x7EB25866, 0x5FC25D69), /* ~= 10^152 */ + U64(0x98BF2F79, 0xD5993802), U64(0xEF2F773F, 0xFBD97A61), /* ~= 10^153 */ + U64(0xBEEEFB58, 0x4AFF8603), U64(0xAAFB550F, 0xFACFD8FA), /* ~= 10^154 */ + U64(0xEEAABA2E, 0x5DBF6784), U64(0x95BA2A53, 0xF983CF38), /* ~= 10^155 */ + U64(0x952AB45C, 0xFA97A0B2), U64(0xDD945A74, 0x7BF26183), /* ~= 10^156 */ + U64(0xBA756174, 0x393D88DF), U64(0x94F97111, 0x9AEEF9E4), /* ~= 10^157 */ + U64(0xE912B9D1, 0x478CEB17), U64(0x7A37CD56, 0x01AAB85D), /* ~= 10^158 */ + U64(0x91ABB422, 0xCCB812EE), U64(0xAC62E055, 0xC10AB33A), /* ~= 10^159 */ + U64(0xB616A12B, 0x7FE617AA), U64(0x577B986B, 0x314D6009), /* ~= 10^160 */ + U64(0xE39C4976, 0x5FDF9D94), U64(0xED5A7E85, 0xFDA0B80B), /* ~= 10^161 */ + U64(0x8E41ADE9, 0xFBEBC27D), U64(0x14588F13, 0xBE847307), /* ~= 10^162 */ + U64(0xB1D21964, 0x7AE6B31C), U64(0x596EB2D8, 0xAE258FC8), /* ~= 10^163 */ + U64(0xDE469FBD, 0x99A05FE3), U64(0x6FCA5F8E, 0xD9AEF3BB), /* ~= 10^164 */ + U64(0x8AEC23D6, 0x80043BEE), U64(0x25DE7BB9, 0x480D5854), /* ~= 10^165 */ + U64(0xADA72CCC, 0x20054AE9), U64(0xAF561AA7, 0x9A10AE6A), /* ~= 10^166 */ + U64(0xD910F7FF, 0x28069DA4), U64(0x1B2BA151, 0x8094DA04), /* ~= 10^167 */ + U64(0x87AA9AFF, 0x79042286), U64(0x90FB44D2, 0xF05D0842), /* ~= 10^168 */ + U64(0xA99541BF, 0x57452B28), U64(0x353A1607, 0xAC744A53), /* ~= 10^169 */ + U64(0xD3FA922F, 0x2D1675F2), U64(0x42889B89, 0x97915CE8), /* ~= 10^170 */ + U64(0x847C9B5D, 0x7C2E09B7), U64(0x69956135, 0xFEBADA11), /* ~= 10^171 */ + U64(0xA59BC234, 0xDB398C25), U64(0x43FAB983, 0x7E699095), /* ~= 10^172 */ + U64(0xCF02B2C2, 0x1207EF2E), U64(0x94F967E4, 0x5E03F4BB), /* ~= 10^173 */ + U64(0x8161AFB9, 0x4B44F57D), U64(0x1D1BE0EE, 0xBAC278F5), /* ~= 10^174 */ + U64(0xA1BA1BA7, 0x9E1632DC), U64(0x6462D92A, 0x69731732), /* ~= 10^175 */ + U64(0xCA28A291, 0x859BBF93), U64(0x7D7B8F75, 0x03CFDCFE), /* ~= 10^176 */ + U64(0xFCB2CB35, 0xE702AF78), U64(0x5CDA7352, 0x44C3D43E), /* ~= 10^177 */ + U64(0x9DEFBF01, 0xB061ADAB), U64(0x3A088813, 0x6AFA64A7), /* ~= 10^178 */ + U64(0xC56BAEC2, 0x1C7A1916), U64(0x088AAA18, 0x45B8FDD0), /* ~= 10^179 */ + U64(0xF6C69A72, 0xA3989F5B), U64(0x8AAD549E, 0x57273D45), /* ~= 10^180 */ + U64(0x9A3C2087, 0xA63F6399), U64(0x36AC54E2, 0xF678864B), /* ~= 10^181 */ + U64(0xC0CB28A9, 0x8FCF3C7F), U64(0x84576A1B, 0xB416A7DD), /* ~= 10^182 */ + U64(0xF0FDF2D3, 0xF3C30B9F), U64(0x656D44A2, 0xA11C51D5), /* ~= 10^183 */ + U64(0x969EB7C4, 0x7859E743), U64(0x9F644AE5, 0xA4B1B325), /* ~= 10^184 */ + U64(0xBC4665B5, 0x96706114), U64(0x873D5D9F, 0x0DDE1FEE), /* ~= 10^185 */ + U64(0xEB57FF22, 0xFC0C7959), U64(0xA90CB506, 0xD155A7EA), /* ~= 10^186 */ + U64(0x9316FF75, 0xDD87CBD8), U64(0x09A7F124, 0x42D588F2), /* ~= 10^187 */ + U64(0xB7DCBF53, 0x54E9BECE), U64(0x0C11ED6D, 0x538AEB2F), /* ~= 10^188 */ + U64(0xE5D3EF28, 0x2A242E81), U64(0x8F1668C8, 0xA86DA5FA), /* ~= 10^189 */ + U64(0x8FA47579, 0x1A569D10), U64(0xF96E017D, 0x694487BC), /* ~= 10^190 */ + U64(0xB38D92D7, 0x60EC4455), U64(0x37C981DC, 0xC395A9AC), /* ~= 10^191 */ + U64(0xE070F78D, 0x3927556A), U64(0x85BBE253, 0xF47B1417), /* ~= 10^192 */ + U64(0x8C469AB8, 0x43B89562), U64(0x93956D74, 0x78CCEC8E), /* ~= 10^193 */ + U64(0xAF584166, 0x54A6BABB), U64(0x387AC8D1, 0x970027B2), /* ~= 10^194 */ + U64(0xDB2E51BF, 0xE9D0696A), U64(0x06997B05, 0xFCC0319E), /* ~= 10^195 */ + U64(0x88FCF317, 0xF22241E2), U64(0x441FECE3, 0xBDF81F03), /* ~= 10^196 */ + U64(0xAB3C2FDD, 0xEEAAD25A), U64(0xD527E81C, 0xAD7626C3), /* ~= 10^197 */ + U64(0xD60B3BD5, 0x6A5586F1), U64(0x8A71E223, 0xD8D3B074), /* ~= 10^198 */ + U64(0x85C70565, 0x62757456), U64(0xF6872D56, 0x67844E49), /* ~= 10^199 */ + U64(0xA738C6BE, 0xBB12D16C), U64(0xB428F8AC, 0x016561DB), /* ~= 10^200 */ + U64(0xD106F86E, 0x69D785C7), U64(0xE13336D7, 0x01BEBA52), /* ~= 10^201 */ + U64(0x82A45B45, 0x0226B39C), U64(0xECC00246, 0x61173473), /* ~= 10^202 */ + U64(0xA34D7216, 0x42B06084), U64(0x27F002D7, 0xF95D0190), /* ~= 10^203 */ + U64(0xCC20CE9B, 0xD35C78A5), U64(0x31EC038D, 0xF7B441F4), /* ~= 10^204 */ + U64(0xFF290242, 0xC83396CE), U64(0x7E670471, 0x75A15271), /* ~= 10^205 */ + U64(0x9F79A169, 0xBD203E41), U64(0x0F0062C6, 0xE984D386), /* ~= 10^206 */ + U64(0xC75809C4, 0x2C684DD1), U64(0x52C07B78, 0xA3E60868), /* ~= 10^207 */ + U64(0xF92E0C35, 0x37826145), U64(0xA7709A56, 0xCCDF8A82), /* ~= 10^208 */ + U64(0x9BBCC7A1, 0x42B17CCB), U64(0x88A66076, 0x400BB691), /* ~= 10^209 */ + U64(0xC2ABF989, 0x935DDBFE), U64(0x6ACFF893, 0xD00EA435), /* ~= 10^210 */ + U64(0xF356F7EB, 0xF83552FE), U64(0x0583F6B8, 0xC4124D43), /* ~= 10^211 */ + U64(0x98165AF3, 0x7B2153DE), U64(0xC3727A33, 0x7A8B704A), /* ~= 10^212 */ + U64(0xBE1BF1B0, 0x59E9A8D6), U64(0x744F18C0, 0x592E4C5C), /* ~= 10^213 */ + U64(0xEDA2EE1C, 0x7064130C), U64(0x1162DEF0, 0x6F79DF73), /* ~= 10^214 */ + U64(0x9485D4D1, 0xC63E8BE7), U64(0x8ADDCB56, 0x45AC2BA8), /* ~= 10^215 */ + U64(0xB9A74A06, 0x37CE2EE1), U64(0x6D953E2B, 0xD7173692), /* ~= 10^216 */ + U64(0xE8111C87, 0xC5C1BA99), U64(0xC8FA8DB6, 0xCCDD0437), /* ~= 10^217 */ + U64(0x910AB1D4, 0xDB9914A0), U64(0x1D9C9892, 0x400A22A2), /* ~= 10^218 */ + U64(0xB54D5E4A, 0x127F59C8), U64(0x2503BEB6, 0xD00CAB4B), /* ~= 10^219 */ + U64(0xE2A0B5DC, 0x971F303A), U64(0x2E44AE64, 0x840FD61D), /* ~= 10^220 */ + U64(0x8DA471A9, 0xDE737E24), U64(0x5CEAECFE, 0xD289E5D2), /* ~= 10^221 */ + U64(0xB10D8E14, 0x56105DAD), U64(0x7425A83E, 0x872C5F47), /* ~= 10^222 */ + U64(0xDD50F199, 0x6B947518), U64(0xD12F124E, 0x28F77719), /* ~= 10^223 */ + U64(0x8A5296FF, 0xE33CC92F), U64(0x82BD6B70, 0xD99AAA6F), /* ~= 10^224 */ + U64(0xACE73CBF, 0xDC0BFB7B), U64(0x636CC64D, 0x1001550B), /* ~= 10^225 */ + U64(0xD8210BEF, 0xD30EFA5A), U64(0x3C47F7E0, 0x5401AA4E), /* ~= 10^226 */ + U64(0x8714A775, 0xE3E95C78), U64(0x65ACFAEC, 0x34810A71), /* ~= 10^227 */ + U64(0xA8D9D153, 0x5CE3B396), U64(0x7F1839A7, 0x41A14D0D), /* ~= 10^228 */ + U64(0xD31045A8, 0x341CA07C), U64(0x1EDE4811, 0x1209A050), /* ~= 10^229 */ + U64(0x83EA2B89, 0x2091E44D), U64(0x934AED0A, 0xAB460432), /* ~= 10^230 */ + U64(0xA4E4B66B, 0x68B65D60), U64(0xF81DA84D, 0x5617853F), /* ~= 10^231 */ + U64(0xCE1DE406, 0x42E3F4B9), U64(0x36251260, 0xAB9D668E), /* ~= 10^232 */ + U64(0x80D2AE83, 0xE9CE78F3), U64(0xC1D72B7C, 0x6B426019), /* ~= 10^233 */ + U64(0xA1075A24, 0xE4421730), U64(0xB24CF65B, 0x8612F81F), /* ~= 10^234 */ + U64(0xC94930AE, 0x1D529CFC), U64(0xDEE033F2, 0x6797B627), /* ~= 10^235 */ + U64(0xFB9B7CD9, 0xA4A7443C), U64(0x169840EF, 0x017DA3B1), /* ~= 10^236 */ + U64(0x9D412E08, 0x06E88AA5), U64(0x8E1F2895, 0x60EE864E), /* ~= 10^237 */ + U64(0xC491798A, 0x08A2AD4E), U64(0xF1A6F2BA, 0xB92A27E2), /* ~= 10^238 */ + U64(0xF5B5D7EC, 0x8ACB58A2), U64(0xAE10AF69, 0x6774B1DB), /* ~= 10^239 */ + U64(0x9991A6F3, 0xD6BF1765), U64(0xACCA6DA1, 0xE0A8EF29), /* ~= 10^240 */ + U64(0xBFF610B0, 0xCC6EDD3F), U64(0x17FD090A, 0x58D32AF3), /* ~= 10^241 */ + U64(0xEFF394DC, 0xFF8A948E), U64(0xDDFC4B4C, 0xEF07F5B0), /* ~= 10^242 */ + U64(0x95F83D0A, 0x1FB69CD9), U64(0x4ABDAF10, 0x1564F98E), /* ~= 10^243 */ + U64(0xBB764C4C, 0xA7A4440F), U64(0x9D6D1AD4, 0x1ABE37F1), /* ~= 10^244 */ + U64(0xEA53DF5F, 0xD18D5513), U64(0x84C86189, 0x216DC5ED), /* ~= 10^245 */ + U64(0x92746B9B, 0xE2F8552C), U64(0x32FD3CF5, 0xB4E49BB4), /* ~= 10^246 */ + U64(0xB7118682, 0xDBB66A77), U64(0x3FBC8C33, 0x221DC2A1), /* ~= 10^247 */ + U64(0xE4D5E823, 0x92A40515), U64(0x0FABAF3F, 0xEAA5334A), /* ~= 10^248 */ + U64(0x8F05B116, 0x3BA6832D), U64(0x29CB4D87, 0xF2A7400E), /* ~= 10^249 */ + U64(0xB2C71D5B, 0xCA9023F8), U64(0x743E20E9, 0xEF511012), /* ~= 10^250 */ + U64(0xDF78E4B2, 0xBD342CF6), U64(0x914DA924, 0x6B255416), /* ~= 10^251 */ + U64(0x8BAB8EEF, 0xB6409C1A), U64(0x1AD089B6, 0xC2F7548E), /* ~= 10^252 */ + U64(0xAE9672AB, 0xA3D0C320), U64(0xA184AC24, 0x73B529B1), /* ~= 10^253 */ + U64(0xDA3C0F56, 0x8CC4F3E8), U64(0xC9E5D72D, 0x90A2741E), /* ~= 10^254 */ + U64(0x88658996, 0x17FB1871), U64(0x7E2FA67C, 0x7A658892), /* ~= 10^255 */ + U64(0xAA7EEBFB, 0x9DF9DE8D), U64(0xDDBB901B, 0x98FEEAB7), /* ~= 10^256 */ + U64(0xD51EA6FA, 0x85785631), U64(0x552A7422, 0x7F3EA565), /* ~= 10^257 */ + U64(0x8533285C, 0x936B35DE), U64(0xD53A8895, 0x8F87275F), /* ~= 10^258 */ + U64(0xA67FF273, 0xB8460356), U64(0x8A892ABA, 0xF368F137), /* ~= 10^259 */ + U64(0xD01FEF10, 0xA657842C), U64(0x2D2B7569, 0xB0432D85), /* ~= 10^260 */ + U64(0x8213F56A, 0x67F6B29B), U64(0x9C3B2962, 0x0E29FC73), /* ~= 10^261 */ + U64(0xA298F2C5, 0x01F45F42), U64(0x8349F3BA, 0x91B47B8F), /* ~= 10^262 */ + U64(0xCB3F2F76, 0x42717713), U64(0x241C70A9, 0x36219A73), /* ~= 10^263 */ + U64(0xFE0EFB53, 0xD30DD4D7), U64(0xED238CD3, 0x83AA0110), /* ~= 10^264 */ + U64(0x9EC95D14, 0x63E8A506), U64(0xF4363804, 0x324A40AA), /* ~= 10^265 */ + U64(0xC67BB459, 0x7CE2CE48), U64(0xB143C605, 0x3EDCD0D5), /* ~= 10^266 */ + U64(0xF81AA16F, 0xDC1B81DA), U64(0xDD94B786, 0x8E94050A), /* ~= 10^267 */ + U64(0x9B10A4E5, 0xE9913128), U64(0xCA7CF2B4, 0x191C8326), /* ~= 10^268 */ + U64(0xC1D4CE1F, 0x63F57D72), U64(0xFD1C2F61, 0x1F63A3F0), /* ~= 10^269 */ + U64(0xF24A01A7, 0x3CF2DCCF), U64(0xBC633B39, 0x673C8CEC), /* ~= 10^270 */ + U64(0x976E4108, 0x8617CA01), U64(0xD5BE0503, 0xE085D813), /* ~= 10^271 */ + U64(0xBD49D14A, 0xA79DBC82), U64(0x4B2D8644, 0xD8A74E18), /* ~= 10^272 */ + U64(0xEC9C459D, 0x51852BA2), U64(0xDDF8E7D6, 0x0ED1219E), /* ~= 10^273 */ + U64(0x93E1AB82, 0x52F33B45), U64(0xCABB90E5, 0xC942B503), /* ~= 10^274 */ + U64(0xB8DA1662, 0xE7B00A17), U64(0x3D6A751F, 0x3B936243), /* ~= 10^275 */ + U64(0xE7109BFB, 0xA19C0C9D), U64(0x0CC51267, 0x0A783AD4), /* ~= 10^276 */ + U64(0x906A617D, 0x450187E2), U64(0x27FB2B80, 0x668B24C5), /* ~= 10^277 */ + U64(0xB484F9DC, 0x9641E9DA), U64(0xB1F9F660, 0x802DEDF6), /* ~= 10^278 */ + U64(0xE1A63853, 0xBBD26451), U64(0x5E7873F8, 0xA0396973), /* ~= 10^279 */ + U64(0x8D07E334, 0x55637EB2), U64(0xDB0B487B, 0x6423E1E8), /* ~= 10^280 */ + U64(0xB049DC01, 0x6ABC5E5F), U64(0x91CE1A9A, 0x3D2CDA62), /* ~= 10^281 */ + U64(0xDC5C5301, 0xC56B75F7), U64(0x7641A140, 0xCC7810FB), /* ~= 10^282 */ + U64(0x89B9B3E1, 0x1B6329BA), U64(0xA9E904C8, 0x7FCB0A9D), /* ~= 10^283 */ + U64(0xAC2820D9, 0x623BF429), U64(0x546345FA, 0x9FBDCD44), /* ~= 10^284 */ + U64(0xD732290F, 0xBACAF133), U64(0xA97C1779, 0x47AD4095), /* ~= 10^285 */ + U64(0x867F59A9, 0xD4BED6C0), U64(0x49ED8EAB, 0xCCCC485D), /* ~= 10^286 */ + U64(0xA81F3014, 0x49EE8C70), U64(0x5C68F256, 0xBFFF5A74), /* ~= 10^287 */ + U64(0xD226FC19, 0x5C6A2F8C), U64(0x73832EEC, 0x6FFF3111), /* ~= 10^288 */ + U64(0x83585D8F, 0xD9C25DB7), U64(0xC831FD53, 0xC5FF7EAB), /* ~= 10^289 */ + U64(0xA42E74F3, 0xD032F525), U64(0xBA3E7CA8, 0xB77F5E55), /* ~= 10^290 */ + U64(0xCD3A1230, 0xC43FB26F), U64(0x28CE1BD2, 0xE55F35EB), /* ~= 10^291 */ + U64(0x80444B5E, 0x7AA7CF85), U64(0x7980D163, 0xCF5B81B3), /* ~= 10^292 */ + U64(0xA0555E36, 0x1951C366), U64(0xD7E105BC, 0xC332621F), /* ~= 10^293 */ + U64(0xC86AB5C3, 0x9FA63440), U64(0x8DD9472B, 0xF3FEFAA7), /* ~= 10^294 */ + U64(0xFA856334, 0x878FC150), U64(0xB14F98F6, 0xF0FEB951), /* ~= 10^295 */ + U64(0x9C935E00, 0xD4B9D8D2), U64(0x6ED1BF9A, 0x569F33D3), /* ~= 10^296 */ + U64(0xC3B83581, 0x09E84F07), U64(0x0A862F80, 0xEC4700C8), /* ~= 10^297 */ + U64(0xF4A642E1, 0x4C6262C8), U64(0xCD27BB61, 0x2758C0FA), /* ~= 10^298 */ + U64(0x98E7E9CC, 0xCFBD7DBD), U64(0x8038D51C, 0xB897789C), /* ~= 10^299 */ + U64(0xBF21E440, 0x03ACDD2C), U64(0xE0470A63, 0xE6BD56C3), /* ~= 10^300 */ + U64(0xEEEA5D50, 0x04981478), U64(0x1858CCFC, 0xE06CAC74), /* ~= 10^301 */ + U64(0x95527A52, 0x02DF0CCB), U64(0x0F37801E, 0x0C43EBC8), /* ~= 10^302 */ + U64(0xBAA718E6, 0x8396CFFD), U64(0xD3056025, 0x8F54E6BA), /* ~= 10^303 */ + U64(0xE950DF20, 0x247C83FD), U64(0x47C6B82E, 0xF32A2069), /* ~= 10^304 */ + U64(0x91D28B74, 0x16CDD27E), U64(0x4CDC331D, 0x57FA5441), /* ~= 10^305 */ + U64(0xB6472E51, 0x1C81471D), U64(0xE0133FE4, 0xADF8E952), /* ~= 10^306 */ + U64(0xE3D8F9E5, 0x63A198E5), U64(0x58180FDD, 0xD97723A6), /* ~= 10^307 */ + U64(0x8E679C2F, 0x5E44FF8F), U64(0x570F09EA, 0xA7EA7648), /* ~= 10^308 */ + U64(0xB201833B, 0x35D63F73), U64(0x2CD2CC65, 0x51E513DA), /* ~= 10^309 */ + U64(0xDE81E40A, 0x034BCF4F), U64(0xF8077F7E, 0xA65E58D1), /* ~= 10^310 */ + U64(0x8B112E86, 0x420F6191), U64(0xFB04AFAF, 0x27FAF782), /* ~= 10^311 */ + U64(0xADD57A27, 0xD29339F6), U64(0x79C5DB9A, 0xF1F9B563), /* ~= 10^312 */ + U64(0xD94AD8B1, 0xC7380874), U64(0x18375281, 0xAE7822BC), /* ~= 10^313 */ + U64(0x87CEC76F, 0x1C830548), U64(0x8F229391, 0x0D0B15B5), /* ~= 10^314 */ + U64(0xA9C2794A, 0xE3A3C69A), U64(0xB2EB3875, 0x504DDB22), /* ~= 10^315 */ + U64(0xD433179D, 0x9C8CB841), U64(0x5FA60692, 0xA46151EB), /* ~= 10^316 */ + U64(0x849FEEC2, 0x81D7F328), U64(0xDBC7C41B, 0xA6BCD333), /* ~= 10^317 */ + U64(0xA5C7EA73, 0x224DEFF3), U64(0x12B9B522, 0x906C0800), /* ~= 10^318 */ + U64(0xCF39E50F, 0xEAE16BEF), U64(0xD768226B, 0x34870A00), /* ~= 10^319 */ + U64(0x81842F29, 0xF2CCE375), U64(0xE6A11583, 0x00D46640), /* ~= 10^320 */ + U64(0xA1E53AF4, 0x6F801C53), U64(0x60495AE3, 0xC1097FD0), /* ~= 10^321 */ + U64(0xCA5E89B1, 0x8B602368), U64(0x385BB19C, 0xB14BDFC4), /* ~= 10^322 */ + U64(0xFCF62C1D, 0xEE382C42), U64(0x46729E03, 0xDD9ED7B5), /* ~= 10^323 */ + U64(0x9E19DB92, 0xB4E31BA9), U64(0x6C07A2C2, 0x6A8346D1) /* ~= 10^324 */ +}; + +/** + Get the cached pow10 value from pow10_sig_table. + @param exp10 The exponent of pow(10, e). This value must in range + POW10_SIG_TABLE_MIN_EXP to POW10_SIG_TABLE_MAX_EXP. + @param hi The highest 64 bits of pow(10, e). + @param lo The lower 64 bits after `hi`. + */ +static_inline void pow10_table_get_sig(i32 exp10, u64 *hi, u64 *lo) { + i32 idx = exp10 - (POW10_SIG_TABLE_MIN_EXP); + *hi = pow10_sig_table[idx * 2]; + *lo = pow10_sig_table[idx * 2 + 1]; +} + +/** + Get the exponent (base 2) for highest 64 bits significand in pow10_sig_table. + */ +static_inline void pow10_table_get_exp(i32 exp10, i32 *exp2) { + /* e2 = floor(log2(pow(10, e))) - 64 + 1 */ + /* = floor(e * log2(10) - 63) */ + *exp2 = (exp10 * 217706 - 4128768) >> 16; +} + +#endif + + + +#if !YYJSON_DISABLE_READER + +/*============================================================================== + * JSON Character Matcher + *============================================================================*/ + +/** Character type */ +typedef u8 char_type; + +/** Whitespace character: ' ', '\\t', '\\n', '\\r'. */ +static const char_type CHAR_TYPE_SPACE = 1 << 0; + +/** Number character: '-', [0-9]. */ +static const char_type CHAR_TYPE_NUMBER = 1 << 1; + +/** JSON Escaped character: '"', '\', [0x00-0x1F]. */ +static const char_type CHAR_TYPE_ESC_ASCII = 1 << 2; + +/** Non-ASCII character: [0x80-0xFF]. */ +static const char_type CHAR_TYPE_NON_ASCII = 1 << 3; + +/** JSON container character: '{', '['. */ +static const char_type CHAR_TYPE_CONTAINER = 1 << 4; + +/** Comment character: '/'. */ +static const char_type CHAR_TYPE_COMMENT = 1 << 5; + +/** Line end character: '\\n', '\\r', '\0'. */ +static const char_type CHAR_TYPE_LINE_END = 1 << 6; + +/** Hexadecimal numeric character: [0-9a-fA-F]. */ +static const char_type CHAR_TYPE_HEX = 1 << 7; + +/** Character type table (generate with misc/make_tables.c) */ +static const char_type char_table[256] = { + 0x44, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x05, 0x45, 0x04, 0x04, 0x45, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x20, + 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, + 0x82, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 +}; + +/** Match a character with specified type. */ +static_inline bool char_is_type(u8 c, char_type type) { + return (char_table[c] & type) != 0; +} + +/** Match a whitespace: ' ', '\\t', '\\n', '\\r'. */ +static_inline bool char_is_space(u8 c) { + return char_is_type(c, (char_type)CHAR_TYPE_SPACE); +} + +/** Match a whitespace or comment: ' ', '\\t', '\\n', '\\r', '/'. */ +static_inline bool char_is_space_or_comment(u8 c) { + return char_is_type(c, (char_type)(CHAR_TYPE_SPACE | CHAR_TYPE_COMMENT)); +} + +/** Match a JSON number: '-', [0-9]. */ +static_inline bool char_is_number(u8 c) { + return char_is_type(c, (char_type)CHAR_TYPE_NUMBER); +} + +/** Match a JSON container: '{', '['. */ +static_inline bool char_is_container(u8 c) { + return char_is_type(c, (char_type)CHAR_TYPE_CONTAINER); +} + +/** Match a stop character in ASCII string: '"', '\', [0x00-0x1F,0x80-0xFF]. */ +static_inline bool char_is_ascii_stop(u8 c) { + return char_is_type(c, (char_type)(CHAR_TYPE_ESC_ASCII | + CHAR_TYPE_NON_ASCII)); +} + +/** Match a line end character: '\\n', '\\r', '\0'. */ +static_inline bool char_is_line_end(u8 c) { + return char_is_type(c, (char_type)CHAR_TYPE_LINE_END); +} + +/** Match a hexadecimal numeric character: [0-9a-fA-F]. */ +static_inline bool char_is_hex(u8 c) { + return char_is_type(c, (char_type)CHAR_TYPE_HEX); +} + + + +/*============================================================================== + * Digit Character Matcher + *============================================================================*/ + +/** Digit type */ +typedef u8 digi_type; + +/** Digit: '0'. */ +static const digi_type DIGI_TYPE_ZERO = 1 << 0; + +/** Digit: [1-9]. */ +static const digi_type DIGI_TYPE_NONZERO = 1 << 1; + +/** Plus sign (positive): '+'. */ +static const digi_type DIGI_TYPE_POS = 1 << 2; + +/** Minus sign (negative): '-'. */ +static const digi_type DIGI_TYPE_NEG = 1 << 3; + +/** Decimal point: '.' */ +static const digi_type DIGI_TYPE_DOT = 1 << 4; + +/** Exponent sign: 'e, 'E'. */ +static const digi_type DIGI_TYPE_EXP = 1 << 5; + +/** Digit type table (generate with misc/make_tables.c) */ +static const digi_type digi_table[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x10, 0x00, + 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +/** Match a character with specified type. */ +static_inline bool digi_is_type(u8 d, digi_type type) { + return (digi_table[d] & type) != 0; +} + +/** Match a sign: '+', '-' */ +static_inline bool digi_is_sign(u8 d) { + return digi_is_type(d, (digi_type)(DIGI_TYPE_POS | DIGI_TYPE_NEG)); +} + +/** Match a none zero digit: [1-9] */ +static_inline bool digi_is_nonzero(u8 d) { + return digi_is_type(d, (digi_type)DIGI_TYPE_NONZERO); +} + +/** Match a digit: [0-9] */ +static_inline bool digi_is_digit(u8 d) { + return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO)); +} + +/** Match an exponent sign: 'e', 'E'. */ +static_inline bool digi_is_exp(u8 d) { + return digi_is_type(d, (digi_type)DIGI_TYPE_EXP); +} + +/** Match a floating point indicator: '.', 'e', 'E'. */ +static_inline bool digi_is_fp(u8 d) { + return digi_is_type(d, (digi_type)(DIGI_TYPE_DOT | DIGI_TYPE_EXP)); +} + +/** Match a digit or floating point indicator: [0-9], '.', 'e', 'E'. */ +static_inline bool digi_is_digit_or_fp(u8 d) { + return digi_is_type(d, (digi_type)(DIGI_TYPE_ZERO | DIGI_TYPE_NONZERO | + DIGI_TYPE_DOT | DIGI_TYPE_EXP)); +} + + + +/*============================================================================== + * Hex Character Reader + * This function is used by JSON reader to read escaped characters. + *============================================================================*/ + +/** + This table is used to convert 4 hex character sequence to a number. + A valid hex character [0-9A-Fa-f] will mapped to it's raw number [0x00, 0x0F], + an invalid hex character will mapped to [0xF0]. + (generate with misc/make_tables.c) + */ +static const u8 hex_conv_table[256] = { + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0 +}; + +/** + Scans an escaped character sequence as a UTF-16 code unit (branchless). + e.g. "\\u005C" should pass "005C" as `cur`. + + This requires the string has 4-byte zero padding. + */ +static_inline bool read_hex_u16(const u8 *cur, u16 *val) { + u16 c0, c1, c2, c3, t0, t1; + c0 = hex_conv_table[cur[0]]; + c1 = hex_conv_table[cur[1]]; + c2 = hex_conv_table[cur[2]]; + c3 = hex_conv_table[cur[3]]; + t0 = (u16)((c0 << 8) | c2); + t1 = (u16)((c1 << 8) | c3); + *val = (u16)((t0 << 4) | t1); + return ((t0 | t1) & (u16)0xF0F0) == 0; +} + + + +/*============================================================================== + * JSON Reader Utils + * These functions are used by JSON reader to read literals and comments. + *============================================================================*/ + +/** Read 'true' literal, '*cur' should be 't'. */ +static_inline bool read_true(u8 **ptr, yyjson_val *val) { + u8 *cur = *ptr; + u8 **end = ptr; + if (likely(byte_match_4(cur, "true"))) { + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE; + *end = cur + 4; + return true; + } + return false; +} + +/** Read 'false' literal, '*cur' should be 'f'. */ +static_inline bool read_false(u8 **ptr, yyjson_val *val) { + u8 *cur = *ptr; + u8 **end = ptr; + if (likely(byte_match_4(cur + 1, "alse"))) { + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE; + *end = cur + 5; + return true; + } + return false; +} + +/** Read 'null' literal, '*cur' should be 'n'. */ +static_inline bool read_null(u8 **ptr, yyjson_val *val) { + u8 *cur = *ptr; + u8 **end = ptr; + if (likely(byte_match_4(cur, "null"))) { + val->tag = YYJSON_TYPE_NULL; + *end = cur + 4; + return true; + } + return false; +} + +/** Read 'Inf' or 'Infinity' literal (ignoring case). */ +static_inline bool read_inf(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) { + u8 *hdr = *ptr - sign; + u8 *cur = *ptr; + u8 **end = ptr; + if ((cur[0] == 'I' || cur[0] == 'i') && + (cur[1] == 'N' || cur[1] == 'n') && + (cur[2] == 'F' || cur[2] == 'f')) { + if ((cur[3] == 'I' || cur[3] == 'i') && + (cur[4] == 'N' || cur[4] == 'n') && + (cur[5] == 'I' || cur[5] == 'i') && + (cur[6] == 'T' || cur[6] == 't') && + (cur[7] == 'Y' || cur[7] == 'y')) { + cur += 8; + } else { + cur += 3; + } + *end = cur; + if (pre) { + /* add null-terminator for previous raw string */ + if (*pre) **pre = '\0'; + *pre = cur; + val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; + val->uni.str = (const char *)hdr; + } else { + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.u64 = f64_raw_get_inf(sign); + } + return true; + } + return false; +} + +/** Read 'NaN' literal (ignoring case). */ +static_inline bool read_nan(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) { + u8 *hdr = *ptr - sign; + u8 *cur = *ptr; + u8 **end = ptr; + if ((cur[0] == 'N' || cur[0] == 'n') && + (cur[1] == 'A' || cur[1] == 'a') && + (cur[2] == 'N' || cur[2] == 'n')) { + cur += 3; + *end = cur; + if (pre) { + /* add null-terminator for previous raw string */ + if (*pre) **pre = '\0'; + *pre = cur; + val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; + val->uni.str = (const char *)hdr; + } else { + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.u64 = f64_raw_get_nan(sign); + } + return true; + } + return false; +} + +/** Read 'Inf', 'Infinity' or 'NaN' literal (ignoring case). */ +static_inline bool read_inf_or_nan(bool sign, u8 **ptr, u8 **pre, + yyjson_val *val) { + if (read_inf(sign, ptr, pre, val)) return true; + if (read_nan(sign, ptr, pre, val)) return true; + return false; +} + +/** Read a JSON number as raw string. */ +static_noinline bool read_number_raw(u8 **ptr, + u8 **pre, + yyjson_read_flag flg, + yyjson_val *val, + const char **msg) { + +#define return_err(_pos, _msg) do { \ + *msg = _msg; \ + *end = _pos; \ + return false; \ +} while (false) + +#define return_raw() do { \ + val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \ + val->uni.str = (const char *)hdr; \ + *pre = cur; *end = cur; return true; \ +} while (false) + + u8 *hdr = *ptr; + u8 *cur = *ptr; + u8 **end = ptr; + + /* add null-terminator for previous raw string */ + if (*pre) **pre = '\0'; + + /* skip sign */ + cur += (*cur == '-'); + + /* read first digit, check leading zero */ + if (unlikely(!digi_is_digit(*cur))) { + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_inf_or_nan(*hdr == '-', &cur, pre, val)) return_raw(); + } + return_err(cur, "no digit after minus sign"); + } + + /* read integral part */ + if (*cur == '0') { + cur++; + if (unlikely(digi_is_digit(*cur))) { + return_err(cur - 1, "number with leading zero is not allowed"); + } + if (!digi_is_fp(*cur)) return_raw(); + } else { + while (digi_is_digit(*cur)) cur++; + if (!digi_is_fp(*cur)) return_raw(); + } + + /* read fraction part */ + if (*cur == '.') { + cur++; + if (!digi_is_digit(*cur++)) { + return_err(cur, "no digit after decimal point"); + } + while (digi_is_digit(*cur)) cur++; + } + + /* read exponent part */ + if (digi_is_exp(*cur)) { + cur += 1 + digi_is_sign(cur[1]); + if (!digi_is_digit(*cur++)) { + return_err(cur, "no digit after exponent sign"); + } + while (digi_is_digit(*cur)) cur++; + } + + return_raw(); + +#undef return_err +#undef return_raw +} + +/** + Skips spaces and comments as many as possible. + + It will return false in these cases: + 1. No character is skipped. The 'end' pointer is set as input cursor. + 2. A multiline comment is not closed. The 'end' pointer is set as the head + of this comment block. + */ +static_noinline bool skip_spaces_and_comments(u8 **ptr) { + u8 *hdr = *ptr; + u8 *cur = *ptr; + u8 **end = ptr; + while (true) { + if (byte_match_2(cur, "/*")) { + hdr = cur; + cur += 2; + while (true) { + if (byte_match_2(cur, "*/")) { + cur += 2; + break; + } + if (*cur == 0) { + *end = hdr; + return false; + } + cur++; + } + continue; + } + if (byte_match_2(cur, "//")) { + cur += 2; + while (!char_is_line_end(*cur)) cur++; + continue; + } + if (char_is_space(*cur)) { + cur += 1; + while (char_is_space(*cur)) cur++; + continue; + } + break; + } + *end = cur; + return hdr != cur; +} + +/** + Check truncated string. + Returns true if `cur` match `str` but is truncated. + */ +static_inline bool is_truncated_str(u8 *cur, u8 *end, + const char *str, + bool case_sensitive) { + usize len = strlen(str); + if (cur + len <= end || end <= cur) return false; + if (case_sensitive) { + return memcmp(cur, str, (usize)(end - cur)) == 0; + } + for (; cur < end; cur++, str++) { + if ((*cur != (u8)*str) && (*cur != (u8)*str - 'a' + 'A')) { + return false; + } + } + return true; +} + +/** + Check truncated JSON on parsing errors. + Returns true if the input is valid but truncated. + */ +static_noinline bool is_truncated_end(u8 *hdr, u8 *cur, u8 *end, + yyjson_read_code code, + yyjson_read_flag flg) { + if (cur >= end) return true; + if (code == YYJSON_READ_ERROR_LITERAL) { + if (is_truncated_str(cur, end, "true", true) || + is_truncated_str(cur, end, "false", true) || + is_truncated_str(cur, end, "null", true)) { + return true; + } + } + if (code == YYJSON_READ_ERROR_UNEXPECTED_CHARACTER || + code == YYJSON_READ_ERROR_INVALID_NUMBER || + code == YYJSON_READ_ERROR_LITERAL) { + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (*cur == '-') cur++; + if (is_truncated_str(cur, end, "infinity", false) || + is_truncated_str(cur, end, "nan", false)) { + return true; + } + } + } + if (code == YYJSON_READ_ERROR_UNEXPECTED_CONTENT) { + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (hdr + 3 <= cur && + is_truncated_str(cur - 3, end, "infinity", false)) { + return true; /* e.g. infin would be read as inf + in */ + } + } + } + if (code == YYJSON_READ_ERROR_INVALID_STRING) { + usize len = (usize)(end - cur); + + /* unicode escape sequence */ + if (*cur == '\\') { + if (len == 1) return true; + if (len <= 5) { + if (*++cur != 'u') return false; + for (++cur; cur < end; cur++) { + if (!char_is_hex(*cur)) return false; + } + return true; + } + return false; + } + + /* 2 to 4 bytes UTF-8, see `read_string()` for details. */ + if (*cur & 0x80) { + u8 c0 = cur[0], c1 = cur[1], c2 = cur[2]; + if (len == 1) { + /* 2 bytes UTF-8, truncated */ + if ((c0 & 0xE0) == 0xC0 && (c0 & 0x1E) != 0x00) return true; + /* 3 bytes UTF-8, truncated */ + if ((c0 & 0xF0) == 0xE0) return true; + /* 4 bytes UTF-8, truncated */ + if ((c0 & 0xF8) == 0xF0 && (c0 & 0x07) <= 0x04) return true; + } + if (len == 2) { + /* 3 bytes UTF-8, truncated */ + if ((c0 & 0xF0) == 0xE0 && + (c1 & 0xC0) == 0x80) { + u8 pat = (u8)(((c0 & 0x0F) << 1) | ((c1 & 0x20) >> 5)); + return 0x01 <= pat && pat != 0x1B; + } + /* 4 bytes UTF-8, truncated */ + if ((c0 & 0xF8) == 0xF0 && + (c1 & 0xC0) == 0x80) { + u8 pat = (u8)(((c0 & 0x07) << 2) | ((c1 & 0x30) >> 4)); + return 0x01 <= pat && pat <= 0x10; + } + } + if (len == 3) { + /* 4 bytes UTF-8, truncated */ + if ((c0 & 0xF8) == 0xF0 && + (c1 & 0xC0) == 0x80 && + (c2 & 0xC0) == 0x80) { + u8 pat = (u8)(((c0 & 0x07) << 2) | ((c1 & 0x30) >> 4)); + return 0x01 <= pat && pat <= 0x10; + } + } + } + } + return false; +} + + + +#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV /* FP_READER */ + +/*============================================================================== + * BigInt For Floating Point Number Reader + * + * The bigint algorithm is used by floating-point number reader to get correctly + * rounded result for numbers with lots of digits. This part of code is rarely + * used for common numbers. + *============================================================================*/ + +/** Maximum exponent of exact pow10 */ +#define U64_POW10_MAX_EXP 19 + +/** Table: [ 10^0, ..., 10^19 ] (generate with misc/make_tables.c) */ +static const u64 u64_pow10_table[U64_POW10_MAX_EXP + 1] = { + U64(0x00000000, 0x00000001), U64(0x00000000, 0x0000000A), + U64(0x00000000, 0x00000064), U64(0x00000000, 0x000003E8), + U64(0x00000000, 0x00002710), U64(0x00000000, 0x000186A0), + U64(0x00000000, 0x000F4240), U64(0x00000000, 0x00989680), + U64(0x00000000, 0x05F5E100), U64(0x00000000, 0x3B9ACA00), + U64(0x00000002, 0x540BE400), U64(0x00000017, 0x4876E800), + U64(0x000000E8, 0xD4A51000), U64(0x00000918, 0x4E72A000), + U64(0x00005AF3, 0x107A4000), U64(0x00038D7E, 0xA4C68000), + U64(0x002386F2, 0x6FC10000), U64(0x01634578, 0x5D8A0000), + U64(0x0DE0B6B3, 0xA7640000), U64(0x8AC72304, 0x89E80000) +}; + +/** Maximum numbers of chunks used by a bigint (58 is enough here). */ +#define BIGINT_MAX_CHUNKS 64 + +/** Unsigned arbitrarily large integer */ +typedef struct bigint { + u32 used; /* used chunks count, should not be 0 */ + u64 bits[BIGINT_MAX_CHUNKS]; /* chunks */ +} bigint; + +/** + Evaluate 'big += val'. + @param big A big number (can be 0). + @param val An unsigned integer (can be 0). + */ +static_inline void bigint_add_u64(bigint *big, u64 val) { + u32 idx, max; + u64 num = big->bits[0]; + u64 add = num + val; + big->bits[0] = add; + if (likely((add >= num) || (add >= val))) return; + for ((void)(idx = 1), max = big->used; idx < max; idx++) { + if (likely(big->bits[idx] != U64_MAX)) { + big->bits[idx] += 1; + return; + } + big->bits[idx] = 0; + } + big->bits[big->used++] = 1; +} + +/** + Evaluate 'big *= val'. + @param big A big number (can be 0). + @param val An unsigned integer (cannot be 0). + */ +static_inline void bigint_mul_u64(bigint *big, u64 val) { + u32 idx = 0, max = big->used; + u64 hi, lo, carry = 0; + for (; idx < max; idx++) { + if (big->bits[idx]) break; + } + for (; idx < max; idx++) { + u128_mul_add(big->bits[idx], val, carry, &hi, &lo); + big->bits[idx] = lo; + carry = hi; + } + if (carry) big->bits[big->used++] = carry; +} + +/** + Evaluate 'big *= 2^exp'. + @param big A big number (can be 0). + @param exp An exponent integer (can be 0). + */ +static_inline void bigint_mul_pow2(bigint *big, u32 exp) { + u32 shft = exp % 64; + u32 move = exp / 64; + u32 idx = big->used; + if (unlikely(shft == 0)) { + for (; idx > 0; idx--) { + big->bits[idx + move - 1] = big->bits[idx - 1]; + } + big->used += move; + while (move) big->bits[--move] = 0; + } else { + big->bits[idx] = 0; + for (; idx > 0; idx--) { + u64 num = big->bits[idx] << shft; + num |= big->bits[idx - 1] >> (64 - shft); + big->bits[idx + move] = num; + } + big->bits[move] = big->bits[0] << shft; + big->used += move + (big->bits[big->used + move] > 0); + while (move) big->bits[--move] = 0; + } +} + +/** + Evaluate 'big *= 10^exp'. + @param big A big number (can be 0). + @param exp An exponent integer (cannot be 0). + */ +static_inline void bigint_mul_pow10(bigint *big, i32 exp) { + for (; exp >= U64_POW10_MAX_EXP; exp -= U64_POW10_MAX_EXP) { + bigint_mul_u64(big, u64_pow10_table[U64_POW10_MAX_EXP]); + } + if (exp) { + bigint_mul_u64(big, u64_pow10_table[exp]); + } +} + +/** + Compare two bigint. + @return -1 if 'a < b', +1 if 'a > b', 0 if 'a == b'. + */ +static_inline i32 bigint_cmp(bigint *a, bigint *b) { + u32 idx = a->used; + if (a->used < b->used) return -1; + if (a->used > b->used) return +1; + while (idx-- > 0) { + u64 av = a->bits[idx]; + u64 bv = b->bits[idx]; + if (av < bv) return -1; + if (av > bv) return +1; + } + return 0; +} + +/** + Evaluate 'big = val'. + @param big A big number (can be 0). + @param val An unsigned integer (can be 0). + */ +static_inline void bigint_set_u64(bigint *big, u64 val) { + big->used = 1; + big->bits[0] = val; +} + +/** Set a bigint with floating point number string. */ +static_noinline void bigint_set_buf(bigint *big, u64 sig, i32 *exp, + u8 *sig_cut, u8 *sig_end, u8 *dot_pos) { + + if (unlikely(!sig_cut)) { + /* no digit cut, set significant part only */ + bigint_set_u64(big, sig); + return; + + } else { + /* some digits were cut, read them from 'sig_cut' to 'sig_end' */ + u8 *hdr = sig_cut; + u8 *cur = hdr; + u32 len = 0; + u64 val = 0; + bool dig_big_cut = false; + bool has_dot = (hdr < dot_pos) & (dot_pos < sig_end); + u32 dig_len_total = U64_SAFE_DIG + (u32)(sig_end - hdr) - has_dot; + + sig -= (*sig_cut >= '5'); /* sig was rounded before */ + if (dig_len_total > F64_MAX_DEC_DIG) { + dig_big_cut = true; + sig_end -= dig_len_total - (F64_MAX_DEC_DIG + 1); + sig_end -= (dot_pos + 1 == sig_end); + dig_len_total = (F64_MAX_DEC_DIG + 1); + } + *exp -= (i32)dig_len_total - U64_SAFE_DIG; + + big->used = 1; + big->bits[0] = sig; + while (cur < sig_end) { + if (likely(cur != dot_pos)) { + val = val * 10 + (u8)(*cur++ - '0'); + len++; + if (unlikely(cur == sig_end && dig_big_cut)) { + /* The last digit must be non-zero, */ + /* set it to '1' for correct rounding. */ + val = val - (val % 10) + 1; + } + if (len == U64_SAFE_DIG || cur == sig_end) { + bigint_mul_pow10(big, (i32)len); + bigint_add_u64(big, val); + val = 0; + len = 0; + } + } else { + cur++; + } + } + } +} + + + +/*============================================================================== + * Diy Floating Point + *============================================================================*/ + +/** "Do It Yourself Floating Point" struct. */ +typedef struct diy_fp { + u64 sig; /* significand */ + i32 exp; /* exponent, base 2 */ + i32 pad; /* padding, useless */ +} diy_fp; + +/** Get cached rounded diy_fp with pow(10, e) The input value must in range + [POW10_SIG_TABLE_MIN_EXP, POW10_SIG_TABLE_MAX_EXP]. */ +static_inline diy_fp diy_fp_get_cached_pow10(i32 exp10) { + diy_fp fp; + u64 sig_ext; + pow10_table_get_sig(exp10, &fp.sig, &sig_ext); + pow10_table_get_exp(exp10, &fp.exp); + fp.sig += (sig_ext >> 63); + return fp; +} + +/** Returns fp * fp2. */ +static_inline diy_fp diy_fp_mul(diy_fp fp, diy_fp fp2) { + u64 hi, lo; + u128_mul(fp.sig, fp2.sig, &hi, &lo); + fp.sig = hi + (lo >> 63); + fp.exp += fp2.exp + 64; + return fp; +} + +/** Convert diy_fp to IEEE-754 raw value. */ +static_inline u64 diy_fp_to_ieee_raw(diy_fp fp) { + u64 sig = fp.sig; + i32 exp = fp.exp; + u32 lz_bits; + if (unlikely(fp.sig == 0)) return 0; + + lz_bits = u64_lz_bits(sig); + sig <<= lz_bits; + sig >>= F64_BITS - F64_SIG_FULL_BITS; + exp -= (i32)lz_bits; + exp += F64_BITS - F64_SIG_FULL_BITS; + exp += F64_SIG_BITS; + + if (unlikely(exp >= F64_MAX_BIN_EXP)) { + /* overflow */ + return F64_RAW_INF; + } else if (likely(exp >= F64_MIN_BIN_EXP - 1)) { + /* normal */ + exp += F64_EXP_BIAS; + return ((u64)exp << F64_SIG_BITS) | (sig & F64_SIG_MASK); + } else if (likely(exp >= F64_MIN_BIN_EXP - F64_SIG_FULL_BITS)) { + /* subnormal */ + return sig >> (F64_MIN_BIN_EXP - exp - 1); + } else { + /* underflow */ + return 0; + } +} + + + +/*============================================================================== + * JSON Number Reader (IEEE-754) + *============================================================================*/ + +/** Maximum exact pow10 exponent for double value. */ +#define F64_POW10_EXP_MAX_EXACT 22 + +/** Cached pow10 table. */ +static const f64 f64_pow10_table[] = { + 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, + 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22 +}; + +/** + Read a JSON number. + + 1. This function assume that the floating-point number is in IEEE-754 format. + 2. This function support uint64/int64/double number. If an integer number + cannot fit in uint64/int64, it will returns as a double number. If a double + number is infinite, the return value is based on flag. + 3. This function (with inline attribute) may generate a lot of instructions. + */ +static_inline bool read_number(u8 **ptr, + u8 **pre, + yyjson_read_flag flg, + yyjson_val *val, + const char **msg) { + +#define return_err(_pos, _msg) do { \ + *msg = _msg; \ + *end = _pos; \ + return false; \ +} while (false) + +#define return_0() do { \ + val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); \ + val->uni.u64 = 0; \ + *end = cur; return true; \ +} while (false) + +#define return_i64(_v) do { \ + val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); \ + val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \ + *end = cur; return true; \ +} while (false) + +#define return_f64(_v) do { \ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \ + val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \ + *end = cur; return true; \ +} while (false) + +#define return_f64_bin(_v) do { \ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \ + val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \ + *end = cur; return true; \ +} while (false) + +#define return_inf() do { \ + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); \ + if (has_read_flag(ALLOW_INF_AND_NAN)) return_f64_bin(F64_RAW_INF); \ + else return_err(hdr, "number is infinity when parsed as double"); \ +} while (false) + +#define return_raw() do { \ + if (*pre) **pre = '\0'; /* add null-terminator for previous raw string */ \ + val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \ + val->uni.str = (const char *)hdr; \ + *pre = cur; *end = cur; return true; \ +} while (false) + + u8 *sig_cut = NULL; /* significant part cutting position for long number */ + u8 *sig_end = NULL; /* significant part ending position */ + u8 *dot_pos = NULL; /* decimal point position */ + + u64 sig = 0; /* significant part of the number */ + i32 exp = 0; /* exponent part of the number */ + + bool exp_sign; /* temporary exponent sign from literal part */ + i64 exp_sig = 0; /* temporary exponent number from significant part */ + i64 exp_lit = 0; /* temporary exponent number from exponent literal part */ + u64 num; /* temporary number for reading */ + u8 *tmp; /* temporary cursor for reading */ + + u8 *hdr = *ptr; + u8 *cur = *ptr; + u8 **end = ptr; + bool sign; + + /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */ + if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) { + return read_number_raw(ptr, pre, flg, val, msg); + } + + sign = (*hdr == '-'); + cur += sign; + + /* begin with a leading zero or non-digit */ + if (unlikely(!digi_is_nonzero(*cur))) { /* 0 or non-digit char */ + if (unlikely(*cur != '0')) { /* non-digit char */ + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_inf_or_nan(sign, &cur, pre, val)) { + *end = cur; + return true; + } + } + return_err(cur, "no digit after minus sign"); + } + /* begin with 0 */ + if (likely(!digi_is_digit_or_fp(*++cur))) return_0(); + if (likely(*cur == '.')) { + dot_pos = cur++; + if (unlikely(!digi_is_digit(*cur))) { + return_err(cur, "no digit after decimal point"); + } + while (unlikely(*cur == '0')) cur++; + if (likely(digi_is_digit(*cur))) { + /* first non-zero digit after decimal point */ + sig = (u64)(*cur - '0'); /* read first digit */ + cur--; + goto digi_frac_1; /* continue read fraction part */ + } + } + if (unlikely(digi_is_digit(*cur))) { + return_err(cur - 1, "number with leading zero is not allowed"); + } + if (unlikely(digi_is_exp(*cur))) { /* 0 with any exponent is still 0 */ + cur += (usize)1 + digi_is_sign(cur[1]); + if (unlikely(!digi_is_digit(*cur))) { + return_err(cur, "no digit after exponent sign"); + } + while (digi_is_digit(*++cur)); + } + return_f64_bin(0); + } + + /* begin with non-zero digit */ + sig = (u64)(*cur - '0'); + + /* + Read integral part, same as the following code. + + for (int i = 1; i <= 18; i++) { + num = cur[i] - '0'; + if (num <= 9) sig = num + sig * 10; + else goto digi_sepr_i; + } + */ +#define expr_intg(i) \ + if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \ + else { goto digi_sepr_##i; } + repeat_in_1_18(expr_intg) +#undef expr_intg + + + cur += 19; /* skip continuous 19 digits */ + if (!digi_is_digit_or_fp(*cur)) { + /* this number is an integer consisting of 19 digits */ + if (sign && (sig > ((u64)1 << 63))) { /* overflow */ + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); + return_f64(normalized_u64_to_f64(sig)); + } + return_i64(sig); + } + goto digi_intg_more; /* read more digits in integral part */ + + + /* process first non-digit character */ +#define expr_sepr(i) \ + digi_sepr_##i: \ + if (likely(!digi_is_fp(cur[i]))) { cur += i; return_i64(sig); } \ + dot_pos = cur + i; \ + if (likely(cur[i] == '.')) goto digi_frac_##i; \ + cur += i; sig_end = cur; goto digi_exp_more; + repeat_in_1_18(expr_sepr) +#undef expr_sepr + + + /* read fraction part */ +#define expr_frac(i) \ + digi_frac_##i: \ + if (likely((num = (u64)(cur[i + 1] - (u8)'0')) <= 9)) \ + sig = num + sig * 10; \ + else { goto digi_stop_##i; } + repeat_in_1_18(expr_frac) +#undef expr_frac + + cur += 20; /* skip 19 digits and 1 decimal point */ + if (!digi_is_digit(*cur)) goto digi_frac_end; /* fraction part end */ + goto digi_frac_more; /* read more digits in fraction part */ + + + /* significant part end */ +#define expr_stop(i) \ + digi_stop_##i: \ + cur += i + 1; \ + goto digi_frac_end; + repeat_in_1_18(expr_stop) +#undef expr_stop + + + /* read more digits in integral part */ +digi_intg_more: + if (digi_is_digit(*cur)) { + if (!digi_is_digit_or_fp(cur[1])) { + /* this number is an integer consisting of 20 digits */ + num = (u64)(*cur - '0'); + if ((sig < (U64_MAX / 10)) || + (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) { + sig = num + sig * 10; + cur++; + /* convert to double if overflow */ + if (sign) { + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); + return_f64(normalized_u64_to_f64(sig)); + } + return_i64(sig); + } + } + } + + if (digi_is_exp(*cur)) { + dot_pos = cur; + goto digi_exp_more; + } + + if (*cur == '.') { + dot_pos = cur++; + if (!digi_is_digit(*cur)) { + return_err(cur, "no digit after decimal point"); + } + } + + + /* read more digits in fraction part */ +digi_frac_more: + sig_cut = cur; /* too large to fit in u64, excess digits need to be cut */ + sig += (*cur >= '5'); /* round */ + while (digi_is_digit(*++cur)); + if (!dot_pos) { + if (!digi_is_fp(*cur) && has_read_flag(BIGNUM_AS_RAW)) { + return_raw(); /* it's a large integer */ + } + dot_pos = cur; + if (*cur == '.') { + if (!digi_is_digit(*++cur)) { + return_err(cur, "no digit after decimal point"); + } + while (digi_is_digit(*cur)) cur++; + } + } + exp_sig = (i64)(dot_pos - sig_cut); + exp_sig += (dot_pos < sig_cut); + + /* ignore trailing zeros */ + tmp = cur - 1; + while (*tmp == '0' || *tmp == '.') tmp--; + if (tmp < sig_cut) { + sig_cut = NULL; + } else { + sig_end = cur; + } + + if (digi_is_exp(*cur)) goto digi_exp_more; + goto digi_exp_finish; + + + /* fraction part end */ +digi_frac_end: + if (unlikely(dot_pos + 1 == cur)) { + return_err(cur, "no digit after decimal point"); + } + sig_end = cur; + exp_sig = -(i64)((u64)(cur - dot_pos) - 1); + if (likely(!digi_is_exp(*cur))) { + if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) { + return_f64_bin(0); /* underflow */ + } + exp = (i32)exp_sig; + goto digi_finish; + } else { + goto digi_exp_more; + } + + + /* read exponent part */ +digi_exp_more: + exp_sign = (*++cur == '-'); + cur += digi_is_sign(*cur); + if (unlikely(!digi_is_digit(*cur))) { + return_err(cur, "no digit after exponent sign"); + } + while (*cur == '0') cur++; + + /* read exponent literal */ + tmp = cur; + while (digi_is_digit(*cur)) { + exp_lit = (i64)((u8)(*cur++ - '0') + (u64)exp_lit * 10); + } + if (unlikely(cur - tmp >= U64_SAFE_DIG)) { + if (exp_sign) { + return_f64_bin(0); /* underflow */ + } else { + return_inf(); /* overflow */ + } + } + exp_sig += exp_sign ? -exp_lit : exp_lit; + + + /* validate exponent value */ +digi_exp_finish: + if (unlikely(exp_sig < F64_MIN_DEC_EXP - 19)) { + return_f64_bin(0); /* underflow */ + } + if (unlikely(exp_sig > F64_MAX_DEC_EXP)) { + return_inf(); /* overflow */ + } + exp = (i32)exp_sig; + + + /* all digit read finished */ +digi_finish: + + /* + Fast path 1: + + 1. The floating-point number calculation should be accurate, see the + comments of macro `YYJSON_DOUBLE_MATH_CORRECT`. + 2. Correct rounding should be performed (fegetround() == FE_TONEAREST). + 3. The input of floating point number calculation does not lose precision, + which means: 64 - leading_zero(input) - trailing_zero(input) < 53. + + We don't check all available inputs here, because that would make the code + more complicated, and not friendly to branch predictor. + */ +#if YYJSON_DOUBLE_MATH_CORRECT + if (sig < ((u64)1 << 53) && + exp >= -F64_POW10_EXP_MAX_EXACT && + exp <= +F64_POW10_EXP_MAX_EXACT) { + f64 dbl = (f64)sig; + if (exp < 0) { + dbl /= f64_pow10_table[-exp]; + } else { + dbl *= f64_pow10_table[+exp]; + } + return_f64(dbl); + } +#endif + + /* + Fast path 2: + + To keep it simple, we only accept normal number here, + let the slow path to handle subnormal and infinity number. + */ + if (likely(!sig_cut && + exp > -F64_MAX_DEC_EXP + 1 && + exp < +F64_MAX_DEC_EXP - 20)) { + /* + The result value is exactly equal to (sig * 10^exp), + the exponent part (10^exp) can be converted to (sig2 * 2^exp2). + + The sig2 can be an infinite length number, only the highest 128 bits + is cached in the pow10_sig_table. + + Now we have these bits: + sig1 (normalized 64bit) : aaaaaaaa + sig2 (higher 64bit) : bbbbbbbb + sig2_ext (lower 64bit) : cccccccc + sig2_cut (extra unknown bits) : dddddddddddd.... + + And the calculation process is: + ---------------------------------------- + aaaaaaaa * + bbbbbbbbccccccccdddddddddddd.... + ---------------------------------------- + abababababababab + + acacacacacacacac + + adadadadadadadadadad.... + ---------------------------------------- + [hi____][lo____] + + [hi2___][lo2___] + + [unknown___________....] + ---------------------------------------- + + The addition with carry may affect higher bits, but if there is a 0 + in higher bits, the bits higher than 0 will not be affected. + + `lo2` + `unknown` may get a carry bit and may affect `hi2`, the max + value of `hi2` is 0xFFFFFFFFFFFFFFFE, so `hi2` will not overflow. + + `lo` + `hi2` may also get a carry bit and may affect `hi`, but only + the highest significant 53 bits of `hi` is needed. If there is a 0 + in the lower bits of `hi`, then all the following bits can be dropped. + + To convert the result to IEEE-754 double number, we need to perform + correct rounding: + 1. if bit 54 is 0, round down, + 2. if bit 54 is 1 and any bit beyond bit 54 is 1, round up, + 3. if bit 54 is 1 and all bits beyond bit 54 are 0, round to even, + as the extra bits is unknown, this case will not be handled here. + */ + + u64 raw; + u64 sig1, sig2, sig2_ext, hi, lo, hi2, lo2, add, bits; + i32 exp2; + u32 lz; + bool exact = false, carry, round_up; + + /* convert (10^exp) to (sig2 * 2^exp2) */ + pow10_table_get_sig(exp, &sig2, &sig2_ext); + pow10_table_get_exp(exp, &exp2); + + /* normalize and multiply */ + lz = u64_lz_bits(sig); + sig1 = sig << lz; + exp2 -= (i32)lz; + u128_mul(sig1, sig2, &hi, &lo); + + /* + The `hi` is in range [0x4000000000000000, 0xFFFFFFFFFFFFFFFE], + To get normalized value, `hi` should be shifted to the left by 0 or 1. + + The highest significant 53 bits is used by IEEE-754 double number, + and the bit 54 is used to detect rounding direction. + + The lowest (64 - 54 - 1) bits is used to check whether it contains 0. + */ + bits = hi & (((u64)1 << (64 - 54 - 1)) - 1); + if (bits - 1 < (((u64)1 << (64 - 54 - 1)) - 2)) { + /* + (bits != 0 && bits != 0x1FF) => (bits - 1 < 0x1FF - 1) + The `bits` is not zero, so we don't need to check `round to even` + case. The `bits` contains bit `0`, so we can drop the extra bits + after `0`. + */ + exact = true; + + } else { + /* + (bits == 0 || bits == 0x1FF) + The `bits` is filled with all `0` or all `1`, so we need to check + lower bits with another 64-bit multiplication. + */ + u128_mul(sig1, sig2_ext, &hi2, &lo2); + + add = lo + hi2; + if (add + 1 > (u64)1) { + /* + (add != 0 && add != U64_MAX) => (add + 1 > 1) + The `add` is not zero, so we don't need to check `round to + even` case. The `add` contains bit `0`, so we can drop the + extra bits after `0`. The `hi` cannot be U64_MAX, so it will + not overflow. + */ + carry = add < lo || add < hi2; + hi += carry; + exact = true; + } + } + + if (exact) { + /* normalize */ + lz = hi < ((u64)1 << 63); + hi <<= lz; + exp2 -= (i32)lz; + exp2 += 64; + + /* test the bit 54 and get rounding direction */ + round_up = (hi & ((u64)1 << (64 - 54))) > (u64)0; + hi += (round_up ? ((u64)1 << (64 - 54)) : (u64)0); + + /* test overflow */ + if (hi < ((u64)1 << (64 - 54))) { + hi = ((u64)1 << 63); + exp2 += 1; + } + + /* This is a normal number, convert it to IEEE-754 format. */ + hi >>= F64_BITS - F64_SIG_FULL_BITS; + exp2 += F64_BITS - F64_SIG_FULL_BITS + F64_SIG_BITS; + exp2 += F64_EXP_BIAS; + raw = ((u64)exp2 << F64_SIG_BITS) | (hi & F64_SIG_MASK); + return_f64_bin(raw); + } + } + + /* + Slow path: read double number exactly with diyfp. + 1. Use cached diyfp to get an approximation value. + 2. Use bigcomp to check the approximation value if needed. + + This algorithm refers to google's double-conversion project: + https://github.com/google/double-conversion + */ + { + const i32 ERR_ULP_LOG = 3; + const i32 ERR_ULP = 1 << ERR_ULP_LOG; + const i32 ERR_CACHED_POW = ERR_ULP / 2; + const i32 ERR_MUL_FIXED = ERR_ULP / 2; + const i32 DIY_SIG_BITS = 64; + const i32 EXP_BIAS = F64_EXP_BIAS + F64_SIG_BITS; + const i32 EXP_SUBNORMAL = -EXP_BIAS + 1; + + u64 fp_err; + u32 bits; + i32 order_of_magnitude; + i32 effective_significand_size; + i32 precision_digits_count; + u64 precision_bits; + u64 half_way; + + u64 raw; + diy_fp fp, fp_upper; + bigint big_full, big_comp; + i32 cmp; + + fp.sig = sig; + fp.exp = 0; + fp_err = sig_cut ? (u64)(ERR_ULP / 2) : (u64)0; + + /* normalize */ + bits = u64_lz_bits(fp.sig); + fp.sig <<= bits; + fp.exp -= (i32)bits; + fp_err <<= bits; + + /* multiply and add error */ + fp = diy_fp_mul(fp, diy_fp_get_cached_pow10(exp)); + fp_err += (u64)ERR_CACHED_POW + (fp_err != 0) + (u64)ERR_MUL_FIXED; + + /* normalize */ + bits = u64_lz_bits(fp.sig); + fp.sig <<= bits; + fp.exp -= (i32)bits; + fp_err <<= bits; + + /* effective significand */ + order_of_magnitude = DIY_SIG_BITS + fp.exp; + if (likely(order_of_magnitude >= EXP_SUBNORMAL + F64_SIG_FULL_BITS)) { + effective_significand_size = F64_SIG_FULL_BITS; + } else if (order_of_magnitude <= EXP_SUBNORMAL) { + effective_significand_size = 0; + } else { + effective_significand_size = order_of_magnitude - EXP_SUBNORMAL; + } + + /* precision digits count */ + precision_digits_count = DIY_SIG_BITS - effective_significand_size; + if (unlikely(precision_digits_count + ERR_ULP_LOG >= DIY_SIG_BITS)) { + i32 shr = (precision_digits_count + ERR_ULP_LOG) - DIY_SIG_BITS + 1; + fp.sig >>= shr; + fp.exp += shr; + fp_err = (fp_err >> shr) + 1 + (u32)ERR_ULP; + precision_digits_count -= shr; + } + + /* half way */ + precision_bits = fp.sig & (((u64)1 << precision_digits_count) - 1); + precision_bits *= (u32)ERR_ULP; + half_way = (u64)1 << (precision_digits_count - 1); + half_way *= (u32)ERR_ULP; + + /* rounding */ + fp.sig >>= precision_digits_count; + fp.sig += (precision_bits >= half_way + fp_err); + fp.exp += precision_digits_count; + + /* get IEEE double raw value */ + raw = diy_fp_to_ieee_raw(fp); + if (unlikely(raw == F64_RAW_INF)) return_inf(); + if (likely(precision_bits <= half_way - fp_err || + precision_bits >= half_way + fp_err)) { + return_f64_bin(raw); /* number is accurate */ + } + /* now the number is the correct value, or the next lower value */ + + /* upper boundary */ + if (raw & F64_EXP_MASK) { + fp_upper.sig = (raw & F64_SIG_MASK) + ((u64)1 << F64_SIG_BITS); + fp_upper.exp = (i32)((raw & F64_EXP_MASK) >> F64_SIG_BITS); + } else { + fp_upper.sig = (raw & F64_SIG_MASK); + fp_upper.exp = 1; + } + fp_upper.exp -= F64_EXP_BIAS + F64_SIG_BITS; + fp_upper.sig <<= 1; + fp_upper.exp -= 1; + fp_upper.sig += 1; /* add half ulp */ + + /* compare with bigint */ + bigint_set_buf(&big_full, sig, &exp, sig_cut, sig_end, dot_pos); + bigint_set_u64(&big_comp, fp_upper.sig); + if (exp >= 0) { + bigint_mul_pow10(&big_full, +exp); + } else { + bigint_mul_pow10(&big_comp, -exp); + } + if (fp_upper.exp > 0) { + bigint_mul_pow2(&big_comp, (u32)+fp_upper.exp); + } else { + bigint_mul_pow2(&big_full, (u32)-fp_upper.exp); + } + cmp = bigint_cmp(&big_full, &big_comp); + if (likely(cmp != 0)) { + /* round down or round up */ + raw += (cmp > 0); + } else { + /* falls midway, round to even */ + raw += (raw & 1); + } + + if (unlikely(raw == F64_RAW_INF)) return_inf(); + return_f64_bin(raw); + } + +#undef return_err +#undef return_inf +#undef return_0 +#undef return_i64 +#undef return_f64 +#undef return_f64_bin +#undef return_raw +} + + + +#else /* FP_READER */ + +/** + Read a JSON number. + This is a fallback function if the custom number reader is disabled. + This function use libc's strtod() to read floating-point number. + */ +static_inline bool read_number(u8 **ptr, + u8 **pre, + yyjson_read_flag flg, + yyjson_val *val, + const char **msg) { + +#define return_err(_pos, _msg) do { \ + *msg = _msg; \ + *end = _pos; \ + return false; \ +} while (false) + +#define return_0() do { \ + val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); \ + val->uni.u64 = 0; \ + *end = cur; return true; \ +} while (false) + +#define return_i64(_v) do { \ + val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); \ + val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); \ + *end = cur; return true; \ +} while (false) + +#define return_f64(_v) do { \ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \ + val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); \ + *end = cur; return true; \ +} while (false) + +#define return_f64_bin(_v) do { \ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; \ + val->uni.u64 = ((u64)sign << 63) | (u64)(_v); \ + *end = cur; return true; \ +} while (false) + +#define return_inf() do { \ + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); \ + if (has_read_flag(ALLOW_INF_AND_NAN)) return_f64_bin(F64_RAW_INF); \ + else return_err(hdr, "number is infinity when parsed as double"); \ +} while (false) + +#define return_raw() do { \ + if (*pre) **pre = '\0'; /* add null-terminator for previous raw string */ \ + val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; \ + val->uni.str = (const char *)hdr; \ + *pre = cur; *end = cur; return true; \ +} while (false) + + u64 sig, num; + u8 *hdr = *ptr; + u8 *cur = *ptr; + u8 **end = ptr; + u8 *dot = NULL; + u8 *f64_end = NULL; + bool sign; + + /* read number as raw string if has `YYJSON_READ_NUMBER_AS_RAW` flag */ + if (unlikely(pre && !has_read_flag(BIGNUM_AS_RAW))) { + return read_number_raw(ptr, pre, flg, val, msg); + } + + sign = (*hdr == '-'); + cur += sign; + sig = (u8)(*cur - '0'); + + /* read first digit, check leading zero */ + if (unlikely(!digi_is_digit(*cur))) { + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_inf_or_nan(sign, &cur, pre, val)) { + *end = cur; + return true; + } + } + return_err(cur, "no digit after minus sign"); + } + if (*cur == '0') { + cur++; + if (unlikely(digi_is_digit(*cur))) { + return_err(cur - 1, "number with leading zero is not allowed"); + } + if (!digi_is_fp(*cur)) return_0(); + goto read_double; + } + + /* read continuous digits, up to 19 characters */ +#define expr_intg(i) \ + if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; \ + else { cur += i; goto intg_end; } + repeat_in_1_18(expr_intg) +#undef expr_intg + + /* here are 19 continuous digits, skip them */ + cur += 19; + if (digi_is_digit(cur[0]) && !digi_is_digit_or_fp(cur[1])) { + /* this number is an integer consisting of 20 digits */ + num = (u8)(*cur - '0'); + if ((sig < (U64_MAX / 10)) || + (sig == (U64_MAX / 10) && num <= (U64_MAX % 10))) { + sig = num + sig * 10; + cur++; + if (sign) { + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); + return_f64(normalized_u64_to_f64(sig)); + } + return_i64(sig); + } + } + +intg_end: + /* continuous digits ended */ + if (!digi_is_digit_or_fp(*cur)) { + /* this number is an integer consisting of 1 to 19 digits */ + if (sign && (sig > ((u64)1 << 63))) { + if (has_read_flag(BIGNUM_AS_RAW)) return_raw(); + return_f64(normalized_u64_to_f64(sig)); + } + return_i64(sig); + } + +read_double: + /* this number should be read as double */ + while (digi_is_digit(*cur)) cur++; + if (!digi_is_fp(*cur) && has_read_flag(BIGNUM_AS_RAW)) { + return_raw(); /* it's a large integer */ + } + if (*cur == '.') { + /* skip fraction part */ + dot = cur; + cur++; + if (!digi_is_digit(*cur)) { + return_err(cur, "no digit after decimal point"); + } + cur++; + while (digi_is_digit(*cur)) cur++; + } + if (digi_is_exp(*cur)) { + /* skip exponent part */ + cur += 1 + digi_is_sign(cur[1]); + if (!digi_is_digit(*cur)) { + return_err(cur, "no digit after exponent sign"); + } + cur++; + while (digi_is_digit(*cur)) cur++; + } + + /* + libc's strtod() is used to parse the floating-point number. + + Note that the decimal point character used by strtod() is locale-dependent, + and the rounding direction may affected by fesetround(). + + For currently known locales, (en, zh, ja, ko, am, he, hi) use '.' as the + decimal point, while other locales use ',' as the decimal point. + + Here strtod() is called twice for different locales, but if another thread + happens calls setlocale() between two strtod(), parsing may still fail. + */ + val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end); + if (unlikely(f64_end != cur)) { + /* replace '.' with ',' for locale */ + bool cut = (*cur == ','); + if (cut) *cur = ' '; + if (dot) *dot = ','; + val->uni.f64 = strtod((const char *)hdr, (char **)&f64_end); + /* restore ',' to '.' */ + if (cut) *cur = ','; + if (dot) *dot = '.'; + if (unlikely(f64_end != cur)) { + return_err(hdr, "strtod() failed to parse the number"); + } + } + if (unlikely(val->uni.f64 >= HUGE_VAL || val->uni.f64 <= -HUGE_VAL)) { + return_inf(); + } + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + *end = cur; + return true; + +#undef return_err +#undef return_0 +#undef return_i64 +#undef return_f64 +#undef return_f64_bin +#undef return_inf +#undef return_raw +} + +#endif /* FP_READER */ + + + +/*============================================================================== + * JSON String Reader + *============================================================================*/ + +/** + Read a JSON string. + @param ptr The head pointer of string before '"' prefix (inout). + @param lst JSON last position. + @param inv Allow invalid unicode. + @param val The string value to be written. + @param msg The error message pointer. + @return Whether success. + */ +static_inline bool read_string(u8 **ptr, + u8 *lst, + bool inv, + yyjson_val *val, + const char **msg) { + /* + Each unicode code point is encoded as 1 to 4 bytes in UTF-8 encoding, + we use 4-byte mask and pattern value to validate UTF-8 byte sequence, + this requires the input data to have 4-byte zero padding. + --------------------------------------------------- + 1 byte + unicode range [U+0000, U+007F] + unicode min [.......0] + unicode max [.1111111] + bit pattern [0.......] + --------------------------------------------------- + 2 byte + unicode range [U+0080, U+07FF] + unicode min [......10 ..000000] + unicode max [...11111 ..111111] + bit require [...xxxx. ........] (1E 00) + bit mask [xxx..... xx......] (E0 C0) + bit pattern [110..... 10......] (C0 80) + --------------------------------------------------- + 3 byte + unicode range [U+0800, U+FFFF] + unicode min [........ ..100000 ..000000] + unicode max [....1111 ..111111 ..111111] + bit require [....xxxx ..x..... ........] (0F 20 00) + bit mask [xxxx.... xx...... xx......] (F0 C0 C0) + bit pattern [1110.... 10...... 10......] (E0 80 80) + --------------------------------------------------- + 3 byte invalid (reserved for surrogate halves) + unicode range [U+D800, U+DFFF] + unicode min [....1101 ..100000 ..000000] + unicode max [....1101 ..111111 ..111111] + bit mask [....xxxx ..x..... ........] (0F 20 00) + bit pattern [....1101 ..1..... ........] (0D 20 00) + --------------------------------------------------- + 4 byte + unicode range [U+10000, U+10FFFF] + unicode min [........ ...10000 ..000000 ..000000] + unicode max [.....100 ..001111 ..111111 ..111111] + bit require [.....xxx ..xx.... ........ ........] (07 30 00 00) + bit mask [xxxxx... xx...... xx...... xx......] (F8 C0 C0 C0) + bit pattern [11110... 10...... 10...... 10......] (F0 80 80 80) + --------------------------------------------------- + */ +#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN + const u32 b1_mask = 0x80000000UL; + const u32 b1_patt = 0x00000000UL; + const u32 b2_mask = 0xE0C00000UL; + const u32 b2_patt = 0xC0800000UL; + const u32 b2_requ = 0x1E000000UL; + const u32 b3_mask = 0xF0C0C000UL; + const u32 b3_patt = 0xE0808000UL; + const u32 b3_requ = 0x0F200000UL; + const u32 b3_erro = 0x0D200000UL; + const u32 b4_mask = 0xF8C0C0C0UL; + const u32 b4_patt = 0xF0808080UL; + const u32 b4_requ = 0x07300000UL; + const u32 b4_err0 = 0x04000000UL; + const u32 b4_err1 = 0x03300000UL; +#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN + const u32 b1_mask = 0x00000080UL; + const u32 b1_patt = 0x00000000UL; + const u32 b2_mask = 0x0000C0E0UL; + const u32 b2_patt = 0x000080C0UL; + const u32 b2_requ = 0x0000001EUL; + const u32 b3_mask = 0x00C0C0F0UL; + const u32 b3_patt = 0x008080E0UL; + const u32 b3_requ = 0x0000200FUL; + const u32 b3_erro = 0x0000200DUL; + const u32 b4_mask = 0xC0C0C0F8UL; + const u32 b4_patt = 0x808080F0UL; + const u32 b4_requ = 0x00003007UL; + const u32 b4_err0 = 0x00000004UL; + const u32 b4_err1 = 0x00003003UL; +#else + /* this should be evaluated at compile-time */ + v32_uni b1_mask_uni = {{ 0x80, 0x00, 0x00, 0x00 }}; + v32_uni b1_patt_uni = {{ 0x00, 0x00, 0x00, 0x00 }}; + v32_uni b2_mask_uni = {{ 0xE0, 0xC0, 0x00, 0x00 }}; + v32_uni b2_patt_uni = {{ 0xC0, 0x80, 0x00, 0x00 }}; + v32_uni b2_requ_uni = {{ 0x1E, 0x00, 0x00, 0x00 }}; + v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }}; + v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }}; + v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }}; + v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }}; + v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }}; + v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }}; + v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }}; + v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }}; + v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }}; + u32 b1_mask = b1_mask_uni.u; + u32 b1_patt = b1_patt_uni.u; + u32 b2_mask = b2_mask_uni.u; + u32 b2_patt = b2_patt_uni.u; + u32 b2_requ = b2_requ_uni.u; + u32 b3_mask = b3_mask_uni.u; + u32 b3_patt = b3_patt_uni.u; + u32 b3_requ = b3_requ_uni.u; + u32 b3_erro = b3_erro_uni.u; + u32 b4_mask = b4_mask_uni.u; + u32 b4_patt = b4_patt_uni.u; + u32 b4_requ = b4_requ_uni.u; + u32 b4_err0 = b4_err0_uni.u; + u32 b4_err1 = b4_err1_uni.u; +#endif + +#define is_valid_seq_1(uni) ( \ + ((uni & b1_mask) == b1_patt) \ +) + +#define is_valid_seq_2(uni) ( \ + ((uni & b2_mask) == b2_patt) && \ + ((uni & b2_requ)) \ +) + +#define is_valid_seq_3(uni) ( \ + ((uni & b3_mask) == b3_patt) && \ + ((tmp = (uni & b3_requ))) && \ + ((tmp != b3_erro)) \ +) + +#define is_valid_seq_4(uni) ( \ + ((uni & b4_mask) == b4_patt) && \ + ((tmp = (uni & b4_requ))) && \ + ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \ +) + +#define return_err(_end, _msg) do { \ + *msg = _msg; \ + *end = _end; \ + return false; \ +} while (false) + + u8 *cur = *ptr; + u8 **end = ptr; + u8 *src = ++cur, *dst, *pos; + u16 hi, lo; + u32 uni, tmp; + +skip_ascii: + /* Most strings have no escaped characters, so we can jump them quickly. */ + +skip_ascii_begin: + /* + We want to make loop unrolling, as shown in the following code. Some + compiler may not generate instructions as expected, so we rewrite it with + explicit goto statements. We hope the compiler can generate instructions + like this: https://godbolt.org/z/8vjsYq + + while (true) repeat16({ + if (likely(!(char_is_ascii_stop(*src)))) src++; + else break; + }) + */ +#define expr_jump(i) \ + if (likely(!char_is_ascii_stop(src[i]))) {} \ + else goto skip_ascii_stop##i; + +#define expr_stop(i) \ + skip_ascii_stop##i: \ + src += i; \ + goto skip_ascii_end; + + repeat16_incr(expr_jump) + src += 16; + goto skip_ascii_begin; + repeat16_incr(expr_stop) + +#undef expr_jump +#undef expr_stop + +skip_ascii_end: + + /* + GCC may store src[i] in a register at each line of expr_jump(i) above. + These instructions are useless and will degrade performance. + This inline asm is a hint for gcc: "the memory has been modified, + do not cache it". + + MSVC, Clang, ICC can generate expected instructions without this hint. + */ +#if YYJSON_IS_REAL_GCC + __asm__ volatile("":"=m"(*src)); +#endif + if (likely(*src == '"')) { + val->tag = ((u64)(src - cur) << YYJSON_TAG_BIT) | + (u64)(YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC); + val->uni.str = (const char *)cur; + *src = '\0'; + *end = src + 1; + return true; + } + +skip_utf8: + if (*src & 0x80) { /* non-ASCII character */ + /* + Non-ASCII character appears here, which means that the text is likely + to be written in non-English or emoticons. According to some common + data set statistics, byte sequences of the same length may appear + consecutively. We process the byte sequences of the same length in each + loop, which is more friendly to branch prediction. + */ + pos = src; +#if YYJSON_DISABLE_UTF8_VALIDATION + while (true) repeat8({ + if (likely((*src & 0xF0) == 0xE0)) src += 3; + else break; + }) + if (*src < 0x80) goto skip_ascii; + while (true) repeat8({ + if (likely((*src & 0xE0) == 0xC0)) src += 2; + else break; + }) + while (true) repeat8({ + if (likely((*src & 0xF8) == 0xF0)) src += 4; + else break; + }) +#else + uni = byte_load_4(src); + while (is_valid_seq_3(uni)) { + src += 3; + uni = byte_load_4(src); + } + if (is_valid_seq_1(uni)) goto skip_ascii; + while (is_valid_seq_2(uni)) { + src += 2; + uni = byte_load_4(src); + } + while (is_valid_seq_4(uni)) { + src += 4; + uni = byte_load_4(src); + } +#endif + if (unlikely(pos == src)) { + if (!inv) return_err(src, "invalid UTF-8 encoding in string"); + ++src; + } + goto skip_ascii; + } + + /* The escape character appears, we need to copy it. */ + dst = src; +copy_escape: + if (likely(*src == '\\')) { + switch (*++src) { + case '"': *dst++ = '"'; src++; break; + case '\\': *dst++ = '\\'; src++; break; + case '/': *dst++ = '/'; src++; break; + case 'b': *dst++ = '\b'; src++; break; + case 'f': *dst++ = '\f'; src++; break; + case 'n': *dst++ = '\n'; src++; break; + case 'r': *dst++ = '\r'; src++; break; + case 't': *dst++ = '\t'; src++; break; + case 'u': + if (unlikely(!read_hex_u16(++src, &hi))) { + return_err(src - 2, "invalid escaped sequence in string"); + } + src += 4; + if (likely((hi & 0xF800) != 0xD800)) { + /* a BMP character */ + if (hi >= 0x800) { + *dst++ = (u8)(0xE0 | (hi >> 12)); + *dst++ = (u8)(0x80 | ((hi >> 6) & 0x3F)); + *dst++ = (u8)(0x80 | (hi & 0x3F)); + } else if (hi >= 0x80) { + *dst++ = (u8)(0xC0 | (hi >> 6)); + *dst++ = (u8)(0x80 | (hi & 0x3F)); + } else { + *dst++ = (u8)hi; + } + } else { + /* a non-BMP character, represented as a surrogate pair */ + if (unlikely((hi & 0xFC00) != 0xD800)) { + return_err(src - 6, "invalid high surrogate in string"); + } + if (unlikely(!byte_match_2(src, "\\u"))) { + return_err(src, "no low surrogate in string"); + } + if (unlikely(!read_hex_u16(src + 2, &lo))) { + return_err(src, "invalid escaped sequence in string"); + } + if (unlikely((lo & 0xFC00) != 0xDC00)) { + return_err(src, "invalid low surrogate in string"); + } + uni = ((((u32)hi - 0xD800) << 10) | + ((u32)lo - 0xDC00)) + 0x10000; + *dst++ = (u8)(0xF0 | (uni >> 18)); + *dst++ = (u8)(0x80 | ((uni >> 12) & 0x3F)); + *dst++ = (u8)(0x80 | ((uni >> 6) & 0x3F)); + *dst++ = (u8)(0x80 | (uni & 0x3F)); + src += 6; + } + break; + default: return_err(src, "invalid escaped character in string"); + } + } else if (likely(*src == '"')) { + val->tag = ((u64)(dst - cur) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = (const char *)cur; + *dst = '\0'; + *end = src + 1; + return true; + } else { + if (!inv) return_err(src, "unexpected control character in string"); + if (src >= lst) return_err(src, "unclosed string"); + *dst++ = *src++; + } + +copy_ascii: + /* + Copy continuous ASCII, loop unrolling, same as the following code: + + while (true) repeat16({ + if (unlikely(char_is_ascii_stop(*src))) break; + *dst++ = *src++; + }) + */ +#if YYJSON_IS_REAL_GCC +# define expr_jump(i) \ + if (likely(!(char_is_ascii_stop(src[i])))) {} \ + else { __asm__ volatile("":"=m"(src[i])); goto copy_ascii_stop_##i; } +#else +# define expr_jump(i) \ + if (likely(!(char_is_ascii_stop(src[i])))) {} \ + else { goto copy_ascii_stop_##i; } +#endif + repeat16_incr(expr_jump) +#undef expr_jump + + byte_move_16(dst, src); + src += 16; + dst += 16; + goto copy_ascii; + + /* + The memory will be moved forward by at least 1 byte. So the `byte_move` + can be one byte more than needed to reduce the number of instructions. + */ +copy_ascii_stop_0: + goto copy_utf8; +copy_ascii_stop_1: + byte_move_2(dst, src); + src += 1; + dst += 1; + goto copy_utf8; +copy_ascii_stop_2: + byte_move_2(dst, src); + src += 2; + dst += 2; + goto copy_utf8; +copy_ascii_stop_3: + byte_move_4(dst, src); + src += 3; + dst += 3; + goto copy_utf8; +copy_ascii_stop_4: + byte_move_4(dst, src); + src += 4; + dst += 4; + goto copy_utf8; +copy_ascii_stop_5: + byte_move_4(dst, src); + byte_move_2(dst + 4, src + 4); + src += 5; + dst += 5; + goto copy_utf8; +copy_ascii_stop_6: + byte_move_4(dst, src); + byte_move_2(dst + 4, src + 4); + src += 6; + dst += 6; + goto copy_utf8; +copy_ascii_stop_7: + byte_move_8(dst, src); + src += 7; + dst += 7; + goto copy_utf8; +copy_ascii_stop_8: + byte_move_8(dst, src); + src += 8; + dst += 8; + goto copy_utf8; +copy_ascii_stop_9: + byte_move_8(dst, src); + byte_move_2(dst + 8, src + 8); + src += 9; + dst += 9; + goto copy_utf8; +copy_ascii_stop_10: + byte_move_8(dst, src); + byte_move_2(dst + 8, src + 8); + src += 10; + dst += 10; + goto copy_utf8; +copy_ascii_stop_11: + byte_move_8(dst, src); + byte_move_4(dst + 8, src + 8); + src += 11; + dst += 11; + goto copy_utf8; +copy_ascii_stop_12: + byte_move_8(dst, src); + byte_move_4(dst + 8, src + 8); + src += 12; + dst += 12; + goto copy_utf8; +copy_ascii_stop_13: + byte_move_8(dst, src); + byte_move_4(dst + 8, src + 8); + byte_move_2(dst + 12, src + 12); + src += 13; + dst += 13; + goto copy_utf8; +copy_ascii_stop_14: + byte_move_8(dst, src); + byte_move_4(dst + 8, src + 8); + byte_move_2(dst + 12, src + 12); + src += 14; + dst += 14; + goto copy_utf8; +copy_ascii_stop_15: + byte_move_16(dst, src); + src += 15; + dst += 15; + goto copy_utf8; + +copy_utf8: + if (*src & 0x80) { /* non-ASCII character */ + pos = src; + uni = byte_load_4(src); +#if YYJSON_DISABLE_UTF8_VALIDATION + while (true) repeat4({ + if ((uni & b3_mask) == b3_patt) { + byte_copy_4(dst, &uni); + dst += 3; + src += 3; + uni = byte_load_4(src); + } else break; + }) + if ((uni & b1_mask) == b1_patt) goto copy_ascii; + while (true) repeat4({ + if ((uni & b2_mask) == b2_patt) { + byte_copy_2(dst, &uni); + dst += 2; + src += 2; + uni = byte_load_4(src); + } else break; + }) + while (true) repeat4({ + if ((uni & b4_mask) == b4_patt) { + byte_copy_4(dst, &uni); + dst += 4; + src += 4; + uni = byte_load_4(src); + } else break; + }) +#else + while (is_valid_seq_3(uni)) { + byte_copy_4(dst, &uni); + dst += 3; + src += 3; + uni = byte_load_4(src); + } + if (is_valid_seq_1(uni)) goto copy_ascii; + while (is_valid_seq_2(uni)) { + byte_copy_2(dst, &uni); + dst += 2; + src += 2; + uni = byte_load_4(src); + } + while (is_valid_seq_4(uni)) { + byte_copy_4(dst, &uni); + dst += 4; + src += 4; + uni = byte_load_4(src); + } +#endif + if (unlikely(pos == src)) { + if (!inv) return_err(src, "invalid UTF-8 encoding in string"); + goto copy_ascii_stop_1; + } + goto copy_ascii; + } + goto copy_escape; + +#undef return_err +#undef is_valid_seq_1 +#undef is_valid_seq_2 +#undef is_valid_seq_3 +#undef is_valid_seq_4 +} + + + +/*============================================================================== + * JSON Reader Implementation + * + * We use goto statements to build the finite state machine (FSM). + * The FSM's state was held by program counter (PC) and the 'goto' make the + * state transitions. + *============================================================================*/ + +/** Read single value JSON document. */ +static_noinline yyjson_doc *read_root_single(u8 *hdr, + u8 *cur, + u8 *end, + yyjson_alc alc, + yyjson_read_flag flg, + yyjson_read_err *err) { + +#define return_err(_pos, _code, _msg) do { \ + if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \ + err->pos = (usize)(end - hdr); \ + err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \ + err->msg = "unexpected end of data"; \ + } else { \ + err->pos = (usize)(_pos - hdr); \ + err->code = YYJSON_READ_ERROR_##_code; \ + err->msg = _msg; \ + } \ + if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \ + return NULL; \ +} while (false) + + usize hdr_len; /* value count used by doc */ + usize alc_num; /* value count capacity */ + yyjson_val *val_hdr; /* the head of allocated values */ + yyjson_val *val; /* current value */ + yyjson_doc *doc; /* the JSON document, equals to val_hdr */ + const char *msg; /* error message */ + + bool raw; /* read number as raw */ + bool inv; /* allow invalid unicode */ + u8 *raw_end; /* raw end for null-terminator */ + u8 **pre; /* previous raw end pointer */ + + hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val); + hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0; + alc_num = hdr_len + 1; /* single value */ + + val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_num * sizeof(yyjson_val)); + if (unlikely(!val_hdr)) goto fail_alloc; + val = val_hdr + hdr_len; + raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW); + inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0; + raw_end = NULL; + pre = raw ? &raw_end : NULL; + + if (char_is_number(*cur)) { + if (likely(read_number(&cur, pre, flg, val, &msg))) goto doc_end; + goto fail_number; + } + if (*cur == '"') { + if (likely(read_string(&cur, end, inv, val, &msg))) goto doc_end; + goto fail_string; + } + if (*cur == 't') { + if (likely(read_true(&cur, val))) goto doc_end; + goto fail_literal; + } + if (*cur == 'f') { + if (likely(read_false(&cur, val))) goto doc_end; + goto fail_literal; + } + if (*cur == 'n') { + if (likely(read_null(&cur, val))) goto doc_end; + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_nan(false, &cur, pre, val)) goto doc_end; + } + goto fail_literal; + } + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_inf_or_nan(false, &cur, pre, val)) goto doc_end; + } + goto fail_character; + +doc_end: + /* check invalid contents after json document */ + if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) { + if (has_read_flag(ALLOW_COMMENTS)) { + if (!skip_spaces_and_comments(&cur)) { + if (byte_match_2(cur, "/*")) goto fail_comment; + } + } else { + while (char_is_space(*cur)) cur++; + } + if (unlikely(cur < end)) goto fail_garbage; + } + + if (pre && *pre) **pre = '\0'; + doc = (yyjson_doc *)val_hdr; + doc->root = val_hdr + hdr_len; + doc->alc = alc; + doc->dat_read = (usize)(cur - hdr); + doc->val_read = 1; + doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr; + return doc; + +fail_string: + return_err(cur, INVALID_STRING, msg); +fail_number: + return_err(cur, INVALID_NUMBER, msg); +fail_alloc: + return_err(cur, MEMORY_ALLOCATION, "memory allocation failed"); +fail_literal: + return_err(cur, LITERAL, "invalid literal"); +fail_comment: + return_err(cur, INVALID_COMMENT, "unclosed multiline comment"); +fail_character: + return_err(cur, UNEXPECTED_CHARACTER, "unexpected character"); +fail_garbage: + return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document"); + +#undef return_err +} + +/** Read JSON document (accept all style, but optimized for minify). */ +static_inline yyjson_doc *read_root_minify(u8 *hdr, + u8 *cur, + u8 *end, + yyjson_alc alc, + yyjson_read_flag flg, + yyjson_read_err *err) { + +#define return_err(_pos, _code, _msg) do { \ + if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \ + err->pos = (usize)(end - hdr); \ + err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \ + err->msg = "unexpected end of data"; \ + } else { \ + err->pos = (usize)(_pos - hdr); \ + err->code = YYJSON_READ_ERROR_##_code; \ + err->msg = _msg; \ + } \ + if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \ + return NULL; \ +} while (false) + +#define val_incr() do { \ + val++; \ + if (unlikely(val >= val_end)) { \ + usize alc_old = alc_len; \ + alc_len += alc_len / 2; \ + if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; \ + val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \ + alc_old * sizeof(yyjson_val), \ + alc_len * sizeof(yyjson_val)); \ + if ((!val_tmp)) goto fail_alloc; \ + val = val_tmp + (usize)(val - val_hdr); \ + ctn = val_tmp + (usize)(ctn - val_hdr); \ + val_hdr = val_tmp; \ + val_end = val_tmp + (alc_len - 2); \ + } \ +} while (false) + + usize dat_len; /* data length in bytes, hint for allocator */ + usize hdr_len; /* value count used by yyjson_doc */ + usize alc_len; /* value count allocated */ + usize alc_max; /* maximum value count for allocator */ + usize ctn_len; /* the number of elements in current container */ + yyjson_val *val_hdr; /* the head of allocated values */ + yyjson_val *val_end; /* the end of allocated values */ + yyjson_val *val_tmp; /* temporary pointer for realloc */ + yyjson_val *val; /* current JSON value */ + yyjson_val *ctn; /* current container */ + yyjson_val *ctn_parent; /* parent of current container */ + yyjson_doc *doc; /* the JSON document, equals to val_hdr */ + const char *msg; /* error message */ + + bool raw; /* read number as raw */ + bool inv; /* allow invalid unicode */ + u8 *raw_end; /* raw end for null-terminator */ + u8 **pre; /* previous raw end pointer */ + + dat_len = has_read_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur); + hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val); + hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0; + alc_max = USIZE_MAX / sizeof(yyjson_val); + alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_MINIFY_RATIO) + 4; + alc_len = yyjson_min(alc_len, alc_max); + + val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val)); + if (unlikely(!val_hdr)) goto fail_alloc; + val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */ + val = val_hdr + hdr_len; + ctn = val; + ctn_len = 0; + raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW); + inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0; + raw_end = NULL; + pre = raw ? &raw_end : NULL; + + if (*cur++ == '{') { + ctn->tag = YYJSON_TYPE_OBJ; + ctn->uni.ofs = 0; + goto obj_key_begin; + } else { + ctn->tag = YYJSON_TYPE_ARR; + ctn->uni.ofs = 0; + goto arr_val_begin; + } + +arr_begin: + /* save current container */ + ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) | + (ctn->tag & YYJSON_TAG_MASK); + + /* create a new array value, save parent container offset */ + val_incr(); + val->tag = YYJSON_TYPE_ARR; + val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn); + + /* push the new array value as current container */ + ctn = val; + ctn_len = 0; + +arr_val_begin: + if (*cur == '{') { + cur++; + goto obj_begin; + } + if (*cur == '[') { + cur++; + goto arr_begin; + } + if (char_is_number(*cur)) { + val_incr(); + ctn_len++; + if (likely(read_number(&cur, pre, flg, val, &msg))) goto arr_val_end; + goto fail_number; + } + if (*cur == '"') { + val_incr(); + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end; + goto fail_string; + } + if (*cur == 't') { + val_incr(); + ctn_len++; + if (likely(read_true(&cur, val))) goto arr_val_end; + goto fail_literal; + } + if (*cur == 'f') { + val_incr(); + ctn_len++; + if (likely(read_false(&cur, val))) goto arr_val_end; + goto fail_literal; + } + if (*cur == 'n') { + val_incr(); + ctn_len++; + if (likely(read_null(&cur, val))) goto arr_val_end; + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_nan(false, &cur, pre, val)) goto arr_val_end; + } + goto fail_literal; + } + if (*cur == ']') { + cur++; + if (likely(ctn_len == 0)) goto arr_end; + if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto arr_end; + while (*cur != ',') cur--; + goto fail_trailing_comma; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto arr_val_begin; + } + if (has_read_flag(ALLOW_INF_AND_NAN) && + (*cur == 'i' || *cur == 'I' || *cur == 'N')) { + val_incr(); + ctn_len++; + if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end; + goto fail_character; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto arr_val_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +arr_val_end: + if (*cur == ',') { + cur++; + goto arr_val_begin; + } + if (*cur == ']') { + cur++; + goto arr_end; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto arr_val_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto arr_val_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +arr_end: + /* get parent container */ + ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs); + + /* save the next sibling value offset */ + ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val); + ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; + if (unlikely(ctn == ctn_parent)) goto doc_end; + + /* pop parent as current container */ + ctn = ctn_parent; + ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT); + if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) { + goto obj_val_end; + } else { + goto arr_val_end; + } + +obj_begin: + /* push container */ + ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) | + (ctn->tag & YYJSON_TAG_MASK); + val_incr(); + val->tag = YYJSON_TYPE_OBJ; + /* offset to the parent */ + val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn); + ctn = val; + ctn_len = 0; + +obj_key_begin: + if (likely(*cur == '"')) { + val_incr(); + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end; + goto fail_string; + } + if (likely(*cur == '}')) { + cur++; + if (likely(ctn_len == 0)) goto obj_end; + if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto obj_end; + while (*cur != ',') cur--; + goto fail_trailing_comma; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_key_begin; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_key_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_key_end: + if (*cur == ':') { + cur++; + goto obj_val_begin; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_key_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_key_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_val_begin: + if (*cur == '"') { + val++; + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end; + goto fail_string; + } + if (char_is_number(*cur)) { + val++; + ctn_len++; + if (likely(read_number(&cur, pre, flg, val, &msg))) goto obj_val_end; + goto fail_number; + } + if (*cur == '{') { + cur++; + goto obj_begin; + } + if (*cur == '[') { + cur++; + goto arr_begin; + } + if (*cur == 't') { + val++; + ctn_len++; + if (likely(read_true(&cur, val))) goto obj_val_end; + goto fail_literal; + } + if (*cur == 'f') { + val++; + ctn_len++; + if (likely(read_false(&cur, val))) goto obj_val_end; + goto fail_literal; + } + if (*cur == 'n') { + val++; + ctn_len++; + if (likely(read_null(&cur, val))) goto obj_val_end; + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_nan(false, &cur, pre, val)) goto obj_val_end; + } + goto fail_literal; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_val_begin; + } + if (has_read_flag(ALLOW_INF_AND_NAN) && + (*cur == 'i' || *cur == 'I' || *cur == 'N')) { + val++; + ctn_len++; + if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end; + goto fail_character; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_val_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_val_end: + if (likely(*cur == ',')) { + cur++; + goto obj_key_begin; + } + if (likely(*cur == '}')) { + cur++; + goto obj_end; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_val_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_val_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_end: + /* pop container */ + ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs); + /* point to the next value */ + ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val); + ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ; + if (unlikely(ctn == ctn_parent)) goto doc_end; + ctn = ctn_parent; + ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT); + if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) { + goto obj_val_end; + } else { + goto arr_val_end; + } + +doc_end: + /* check invalid contents after json document */ + if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) { + if (has_read_flag(ALLOW_COMMENTS)) { + skip_spaces_and_comments(&cur); + if (byte_match_2(cur, "/*")) goto fail_comment; + } else { + while (char_is_space(*cur)) cur++; + } + if (unlikely(cur < end)) goto fail_garbage; + } + + if (pre && *pre) **pre = '\0'; + doc = (yyjson_doc *)val_hdr; + doc->root = val_hdr + hdr_len; + doc->alc = alc; + doc->dat_read = (usize)(cur - hdr); + doc->val_read = (usize)((val - doc->root) + 1); + doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr; + return doc; + +fail_string: + return_err(cur, INVALID_STRING, msg); +fail_number: + return_err(cur, INVALID_NUMBER, msg); +fail_alloc: + return_err(cur, MEMORY_ALLOCATION, "memory allocation failed"); +fail_trailing_comma: + return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed"); +fail_literal: + return_err(cur, LITERAL, "invalid literal"); +fail_comment: + return_err(cur, INVALID_COMMENT, "unclosed multiline comment"); +fail_character: + return_err(cur, UNEXPECTED_CHARACTER, "unexpected character"); +fail_garbage: + return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document"); + +#undef val_incr +#undef return_err +} + +/** Read JSON document (accept all style, but optimized for pretty). */ +static_inline yyjson_doc *read_root_pretty(u8 *hdr, + u8 *cur, + u8 *end, + yyjson_alc alc, + yyjson_read_flag flg, + yyjson_read_err *err) { + +#define return_err(_pos, _code, _msg) do { \ + if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { \ + err->pos = (usize)(end - hdr); \ + err->code = YYJSON_READ_ERROR_UNEXPECTED_END; \ + err->msg = "unexpected end of data"; \ + } else { \ + err->pos = (usize)(_pos - hdr); \ + err->code = YYJSON_READ_ERROR_##_code; \ + err->msg = _msg; \ + } \ + if (val_hdr) alc.free(alc.ctx, (void *)val_hdr); \ + return NULL; \ +} while (false) + +#define val_incr() do { \ + val++; \ + if (unlikely(val >= val_end)) { \ + usize alc_old = alc_len; \ + alc_len += alc_len / 2; \ + if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; \ + val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, \ + alc_old * sizeof(yyjson_val), \ + alc_len * sizeof(yyjson_val)); \ + if ((!val_tmp)) goto fail_alloc; \ + val = val_tmp + (usize)(val - val_hdr); \ + ctn = val_tmp + (usize)(ctn - val_hdr); \ + val_hdr = val_tmp; \ + val_end = val_tmp + (alc_len - 2); \ + } \ +} while (false) + + usize dat_len; /* data length in bytes, hint for allocator */ + usize hdr_len; /* value count used by yyjson_doc */ + usize alc_len; /* value count allocated */ + usize alc_max; /* maximum value count for allocator */ + usize ctn_len; /* the number of elements in current container */ + yyjson_val *val_hdr; /* the head of allocated values */ + yyjson_val *val_end; /* the end of allocated values */ + yyjson_val *val_tmp; /* temporary pointer for realloc */ + yyjson_val *val; /* current JSON value */ + yyjson_val *ctn; /* current container */ + yyjson_val *ctn_parent; /* parent of current container */ + yyjson_doc *doc; /* the JSON document, equals to val_hdr */ + const char *msg; /* error message */ + + bool raw; /* read number as raw */ + bool inv; /* allow invalid unicode */ + u8 *raw_end; /* raw end for null-terminator */ + u8 **pre; /* previous raw end pointer */ + + dat_len = has_read_flag(STOP_WHEN_DONE) ? 256 : (usize)(end - cur); + hdr_len = sizeof(yyjson_doc) / sizeof(yyjson_val); + hdr_len += (sizeof(yyjson_doc) % sizeof(yyjson_val)) > 0; + alc_max = USIZE_MAX / sizeof(yyjson_val); + alc_len = hdr_len + (dat_len / YYJSON_READER_ESTIMATED_PRETTY_RATIO) + 4; + alc_len = yyjson_min(alc_len, alc_max); + + val_hdr = (yyjson_val *)alc.malloc(alc.ctx, alc_len * sizeof(yyjson_val)); + if (unlikely(!val_hdr)) goto fail_alloc; + val_end = val_hdr + (alc_len - 2); /* padding for key-value pair reading */ + val = val_hdr + hdr_len; + ctn = val; + ctn_len = 0; + raw = has_read_flag(NUMBER_AS_RAW) || has_read_flag(BIGNUM_AS_RAW); + inv = has_read_flag(ALLOW_INVALID_UNICODE) != 0; + raw_end = NULL; + pre = raw ? &raw_end : NULL; + + if (*cur++ == '{') { + ctn->tag = YYJSON_TYPE_OBJ; + ctn->uni.ofs = 0; + if (*cur == '\n') cur++; + goto obj_key_begin; + } else { + ctn->tag = YYJSON_TYPE_ARR; + ctn->uni.ofs = 0; + if (*cur == '\n') cur++; + goto arr_val_begin; + } + +arr_begin: + /* save current container */ + ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) | + (ctn->tag & YYJSON_TAG_MASK); + + /* create a new array value, save parent container offset */ + val_incr(); + val->tag = YYJSON_TYPE_ARR; + val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn); + + /* push the new array value as current container */ + ctn = val; + ctn_len = 0; + if (*cur == '\n') cur++; + +arr_val_begin: +#if YYJSON_IS_REAL_GCC + while (true) repeat16({ + if (byte_match_2(cur, " ")) cur += 2; + else break; + }) +#else + while (true) repeat16({ + if (likely(byte_match_2(cur, " "))) cur += 2; + else break; + }) +#endif + + if (*cur == '{') { + cur++; + goto obj_begin; + } + if (*cur == '[') { + cur++; + goto arr_begin; + } + if (char_is_number(*cur)) { + val_incr(); + ctn_len++; + if (likely(read_number(&cur, pre, flg, val, &msg))) goto arr_val_end; + goto fail_number; + } + if (*cur == '"') { + val_incr(); + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto arr_val_end; + goto fail_string; + } + if (*cur == 't') { + val_incr(); + ctn_len++; + if (likely(read_true(&cur, val))) goto arr_val_end; + goto fail_literal; + } + if (*cur == 'f') { + val_incr(); + ctn_len++; + if (likely(read_false(&cur, val))) goto arr_val_end; + goto fail_literal; + } + if (*cur == 'n') { + val_incr(); + ctn_len++; + if (likely(read_null(&cur, val))) goto arr_val_end; + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_nan(false, &cur, pre, val)) goto arr_val_end; + } + goto fail_literal; + } + if (*cur == ']') { + cur++; + if (likely(ctn_len == 0)) goto arr_end; + if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto arr_end; + while (*cur != ',') cur--; + goto fail_trailing_comma; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto arr_val_begin; + } + if (has_read_flag(ALLOW_INF_AND_NAN) && + (*cur == 'i' || *cur == 'I' || *cur == 'N')) { + val_incr(); + ctn_len++; + if (read_inf_or_nan(false, &cur, pre, val)) goto arr_val_end; + goto fail_character; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto arr_val_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +arr_val_end: + if (byte_match_2(cur, ",\n")) { + cur += 2; + goto arr_val_begin; + } + if (*cur == ',') { + cur++; + goto arr_val_begin; + } + if (*cur == ']') { + cur++; + goto arr_end; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto arr_val_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto arr_val_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +arr_end: + /* get parent container */ + ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs); + + /* save the next sibling value offset */ + ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val); + ctn->tag = ((ctn_len) << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; + if (unlikely(ctn == ctn_parent)) goto doc_end; + + /* pop parent as current container */ + ctn = ctn_parent; + ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT); + if (*cur == '\n') cur++; + if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) { + goto obj_val_end; + } else { + goto arr_val_end; + } + +obj_begin: + /* push container */ + ctn->tag = (((u64)ctn_len + 1) << YYJSON_TAG_BIT) | + (ctn->tag & YYJSON_TAG_MASK); + val_incr(); + val->tag = YYJSON_TYPE_OBJ; + /* offset to the parent */ + val->uni.ofs = (usize)((u8 *)val - (u8 *)ctn); + ctn = val; + ctn_len = 0; + if (*cur == '\n') cur++; + +obj_key_begin: +#if YYJSON_IS_REAL_GCC + while (true) repeat16({ + if (byte_match_2(cur, " ")) cur += 2; + else break; + }) +#else + while (true) repeat16({ + if (likely(byte_match_2(cur, " "))) cur += 2; + else break; + }) +#endif + if (likely(*cur == '"')) { + val_incr(); + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_key_end; + goto fail_string; + } + if (likely(*cur == '}')) { + cur++; + if (likely(ctn_len == 0)) goto obj_end; + if (has_read_flag(ALLOW_TRAILING_COMMAS)) goto obj_end; + while (*cur != ',') cur--; + goto fail_trailing_comma; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_key_begin; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_key_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_key_end: + if (byte_match_2(cur, ": ")) { + cur += 2; + goto obj_val_begin; + } + if (*cur == ':') { + cur++; + goto obj_val_begin; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_key_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_key_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_val_begin: + if (*cur == '"') { + val++; + ctn_len++; + if (likely(read_string(&cur, end, inv, val, &msg))) goto obj_val_end; + goto fail_string; + } + if (char_is_number(*cur)) { + val++; + ctn_len++; + if (likely(read_number(&cur, pre, flg, val, &msg))) goto obj_val_end; + goto fail_number; + } + if (*cur == '{') { + cur++; + goto obj_begin; + } + if (*cur == '[') { + cur++; + goto arr_begin; + } + if (*cur == 't') { + val++; + ctn_len++; + if (likely(read_true(&cur, val))) goto obj_val_end; + goto fail_literal; + } + if (*cur == 'f') { + val++; + ctn_len++; + if (likely(read_false(&cur, val))) goto obj_val_end; + goto fail_literal; + } + if (*cur == 'n') { + val++; + ctn_len++; + if (likely(read_null(&cur, val))) goto obj_val_end; + if (has_read_flag(ALLOW_INF_AND_NAN)) { + if (read_nan(false, &cur, pre, val)) goto obj_val_end; + } + goto fail_literal; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_val_begin; + } + if (has_read_flag(ALLOW_INF_AND_NAN) && + (*cur == 'i' || *cur == 'I' || *cur == 'N')) { + val++; + ctn_len++; + if (read_inf_or_nan(false, &cur, pre, val)) goto obj_val_end; + goto fail_character; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_val_begin; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_val_end: + if (byte_match_2(cur, ",\n")) { + cur += 2; + goto obj_key_begin; + } + if (likely(*cur == ',')) { + cur++; + goto obj_key_begin; + } + if (likely(*cur == '}')) { + cur++; + goto obj_end; + } + if (char_is_space(*cur)) { + while (char_is_space(*++cur)); + goto obj_val_end; + } + if (has_read_flag(ALLOW_COMMENTS)) { + if (skip_spaces_and_comments(&cur)) goto obj_val_end; + if (byte_match_2(cur, "/*")) goto fail_comment; + } + goto fail_character; + +obj_end: + /* pop container */ + ctn_parent = (yyjson_val *)(void *)((u8 *)ctn - ctn->uni.ofs); + /* point to the next value */ + ctn->uni.ofs = (usize)((u8 *)val - (u8 *)ctn) + sizeof(yyjson_val); + ctn->tag = (ctn_len << (YYJSON_TAG_BIT - 1)) | YYJSON_TYPE_OBJ; + if (unlikely(ctn == ctn_parent)) goto doc_end; + ctn = ctn_parent; + ctn_len = (usize)(ctn->tag >> YYJSON_TAG_BIT); + if (*cur == '\n') cur++; + if ((ctn->tag & YYJSON_TYPE_MASK) == YYJSON_TYPE_OBJ) { + goto obj_val_end; + } else { + goto arr_val_end; + } + +doc_end: + /* check invalid contents after json document */ + if (unlikely(cur < end) && !has_read_flag(STOP_WHEN_DONE)) { + if (has_read_flag(ALLOW_COMMENTS)) { + skip_spaces_and_comments(&cur); + if (byte_match_2(cur, "/*")) goto fail_comment; + } else { + while (char_is_space(*cur)) cur++; + } + if (unlikely(cur < end)) goto fail_garbage; + } + + if (pre && *pre) **pre = '\0'; + doc = (yyjson_doc *)val_hdr; + doc->root = val_hdr + hdr_len; + doc->alc = alc; + doc->dat_read = (usize)(cur - hdr); + doc->val_read = (usize)((val - val_hdr)) - hdr_len + 1; + doc->str_pool = has_read_flag(INSITU) ? NULL : (char *)hdr; + return doc; + +fail_string: + return_err(cur, INVALID_STRING, msg); +fail_number: + return_err(cur, INVALID_NUMBER, msg); +fail_alloc: + return_err(cur, MEMORY_ALLOCATION, "memory allocation failed"); +fail_trailing_comma: + return_err(cur, JSON_STRUCTURE, "trailing comma is not allowed"); +fail_literal: + return_err(cur, LITERAL, "invalid literal"); +fail_comment: + return_err(cur, INVALID_COMMENT, "unclosed multiline comment"); +fail_character: + return_err(cur, UNEXPECTED_CHARACTER, "unexpected character"); +fail_garbage: + return_err(cur, UNEXPECTED_CONTENT, "unexpected content after document"); + +#undef val_incr +#undef return_err +} + + + +/*============================================================================== + * JSON Reader Entrance + *============================================================================*/ + +yyjson_doc *yyjson_read_opts(char *dat, + usize len, + yyjson_read_flag flg, + const yyjson_alc *alc_ptr, + yyjson_read_err *err) { + +#define return_err(_pos, _code, _msg) do { \ + err->pos = (usize)(_pos); \ + err->msg = _msg; \ + err->code = YYJSON_READ_ERROR_##_code; \ + if (!has_read_flag(INSITU) && hdr) alc.free(alc.ctx, (void *)hdr); \ + return NULL; \ +} while (false) + + yyjson_read_err dummy_err; + yyjson_alc alc; + yyjson_doc *doc; + u8 *hdr = NULL, *end, *cur; + + /* validate input parameters */ + if (!err) err = &dummy_err; + if (likely(!alc_ptr)) { + alc = YYJSON_DEFAULT_ALC; + } else { + alc = *alc_ptr; + } + if (unlikely(!dat)) { + return_err(0, INVALID_PARAMETER, "input data is NULL"); + } + if (unlikely(!len)) { + return_err(0, INVALID_PARAMETER, "input length is 0"); + } + + /* add 4-byte zero padding for input data if necessary */ + if (has_read_flag(INSITU)) { + hdr = (u8 *)dat; + end = (u8 *)dat + len; + cur = (u8 *)dat; + } else { + if (unlikely(len >= USIZE_MAX - YYJSON_PADDING_SIZE)) { + return_err(0, MEMORY_ALLOCATION, "memory allocation failed"); + } + hdr = (u8 *)alc.malloc(alc.ctx, len + YYJSON_PADDING_SIZE); + if (unlikely(!hdr)) { + return_err(0, MEMORY_ALLOCATION, "memory allocation failed"); + } + end = hdr + len; + cur = hdr; + memcpy(hdr, dat, len); + memset(end, 0, YYJSON_PADDING_SIZE); + } + + /* skip empty contents before json document */ + if (unlikely(char_is_space_or_comment(*cur))) { + if (has_read_flag(ALLOW_COMMENTS)) { + if (!skip_spaces_and_comments(&cur)) { + return_err(cur - hdr, INVALID_COMMENT, + "unclosed multiline comment"); + } + } else { + if (likely(char_is_space(*cur))) { + while (char_is_space(*++cur)); + } + } + if (unlikely(cur >= end)) { + return_err(0, EMPTY_CONTENT, "input data is empty"); + } + } + + /* read json document */ + if (likely(char_is_container(*cur))) { + if (char_is_space(cur[1]) && char_is_space(cur[2])) { + doc = read_root_pretty(hdr, cur, end, alc, flg, err); + } else { + doc = read_root_minify(hdr, cur, end, alc, flg, err); + } + } else { + doc = read_root_single(hdr, cur, end, alc, flg, err); + } + + /* check result */ + if (likely(doc)) { + memset(err, 0, sizeof(yyjson_read_err)); + } else { + /* RFC 8259: JSON text MUST be encoded using UTF-8 */ + if (err->pos == 0 && err->code != YYJSON_READ_ERROR_MEMORY_ALLOCATION) { + if ((hdr[0] == 0xEF && hdr[1] == 0xBB && hdr[2] == 0xBF)) { + err->msg = "byte order mark (BOM) is not supported"; + } else if (len >= 4 && + ((hdr[0] == 0x00 && hdr[1] == 0x00 && + hdr[2] == 0xFE && hdr[3] == 0xFF) || + (hdr[0] == 0xFF && hdr[1] == 0xFE && + hdr[2] == 0x00 && hdr[3] == 0x00))) { + err->msg = "UTF-32 encoding is not supported"; + } else if (len >= 2 && + ((hdr[0] == 0xFE && hdr[1] == 0xFF) || + (hdr[0] == 0xFF && hdr[1] == 0xFE))) { + err->msg = "UTF-16 encoding is not supported"; + } + } + if (!has_read_flag(INSITU)) alc.free(alc.ctx, (void *)hdr); + } + return doc; + +#undef return_err +} + +yyjson_doc *yyjson_read_file(const char *path, + yyjson_read_flag flg, + const yyjson_alc *alc_ptr, + yyjson_read_err *err) { +#define return_err(_code, _msg) do { \ + err->pos = 0; \ + err->msg = _msg; \ + err->code = YYJSON_READ_ERROR_##_code; \ + return NULL; \ +} while (false) + + yyjson_read_err dummy_err; + yyjson_doc *doc; + FILE *file; + + if (!err) err = &dummy_err; + if (unlikely(!path)) return_err(INVALID_PARAMETER, "input path is NULL"); + + file = fopen_readonly(path); + if (unlikely(!file)) return_err(FILE_OPEN, "file opening failed"); + + doc = yyjson_read_fp(file, flg, alc_ptr, err); + fclose(file); + return doc; + +#undef return_err +} + +yyjson_doc *yyjson_read_fp(FILE *file, + yyjson_read_flag flg, + const yyjson_alc *alc_ptr, + yyjson_read_err *err) { +#define return_err(_code, _msg) do { \ + err->pos = 0; \ + err->msg = _msg; \ + err->code = YYJSON_READ_ERROR_##_code; \ + if (buf) alc.free(alc.ctx, buf); \ + return NULL; \ +} while (false) + + yyjson_read_err dummy_err; + yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC; + yyjson_doc *doc; + + long file_size = 0, file_pos; + void *buf = NULL; + usize buf_size = 0; + + /* validate input parameters */ + if (!err) err = &dummy_err; + if (unlikely(!file)) return_err(INVALID_PARAMETER, "input file is NULL"); + + /* get current position */ + file_pos = ftell(file); + if (file_pos != -1) { + /* get total file size, may fail */ + if (fseek(file, 0, SEEK_END) == 0) file_size = ftell(file); + /* reset to original position, may fail */ + if (fseek(file, file_pos, SEEK_SET) != 0) file_size = 0; + /* get file size from current postion to end */ + if (file_size > 0) file_size -= file_pos; + } + + /* read file */ + if (file_size > 0) { + /* read the entire file in one call */ + buf_size = (usize)file_size + YYJSON_PADDING_SIZE; + buf = alc.malloc(alc.ctx, buf_size); + if (buf == NULL) { + return_err(MEMORY_ALLOCATION, "fail to alloc memory"); + } + if (fread_safe(buf, (usize)file_size, file) != (usize)file_size) { + return_err(FILE_READ, "file reading failed"); + } + } else { + /* failed to get file size, read it as a stream */ + usize chunk_min = (usize)64; + usize chunk_max = (usize)512 * 1024 * 1024; + usize chunk_now = chunk_min; + usize read_size; + void *tmp; + + buf_size = YYJSON_PADDING_SIZE; + while (true) { + if (buf_size + chunk_now < buf_size) { /* overflow */ + return_err(MEMORY_ALLOCATION, "fail to alloc memory"); + } + buf_size += chunk_now; + if (!buf) { + buf = alc.malloc(alc.ctx, buf_size); + if (!buf) return_err(MEMORY_ALLOCATION, "fail to alloc memory"); + } else { + tmp = alc.realloc(alc.ctx, buf, buf_size - chunk_now, buf_size); + if (!tmp) return_err(MEMORY_ALLOCATION, "fail to alloc memory"); + buf = tmp; + } + tmp = ((u8 *)buf) + buf_size - YYJSON_PADDING_SIZE - chunk_now; + read_size = fread_safe(tmp, chunk_now, file); + file_size += (long)read_size; + if (read_size != chunk_now) break; + + chunk_now *= 2; + if (chunk_now > chunk_max) chunk_now = chunk_max; + } + } + + /* read JSON */ + memset((u8 *)buf + file_size, 0, YYJSON_PADDING_SIZE); + flg |= YYJSON_READ_INSITU; + doc = yyjson_read_opts((char *)buf, (usize)file_size, flg, &alc, err); + if (doc) { + doc->str_pool = (char *)buf; + return doc; + } else { + alc.free(alc.ctx, buf); + return NULL; + } + +#undef return_err +} + +const char *yyjson_read_number(const char *dat, + yyjson_val *val, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err) { +#define return_err(_pos, _code, _msg) do { \ + err->pos = _pos > hdr ? (usize)(_pos - hdr) : 0; \ + err->msg = _msg; \ + err->code = YYJSON_READ_ERROR_##_code; \ + return NULL; \ +} while (false) + + u8 *hdr = constcast(u8 *)dat, *cur = hdr; + bool raw; /* read number as raw */ + u8 *raw_end; /* raw end for null-terminator */ + u8 **pre; /* previous raw end pointer */ + const char *msg; + yyjson_read_err dummy_err; + +#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV + u8 buf[128]; + usize dat_len; +#endif + + if (!err) err = &dummy_err; + if (unlikely(!dat)) { + return_err(cur, INVALID_PARAMETER, "input data is NULL"); + } + if (unlikely(!val)) { + return_err(cur, INVALID_PARAMETER, "output value is NULL"); + } + +#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV + if (!alc) alc = &YYJSON_DEFAULT_ALC; + dat_len = strlen(dat); + if (dat_len < sizeof(buf)) { + memcpy(buf, dat, dat_len + 1); + hdr = buf; + cur = hdr; + } else { + hdr = (u8 *)alc->malloc(alc->ctx, dat_len + 1); + cur = hdr; + if (unlikely(!hdr)) { + return_err(cur, MEMORY_ALLOCATION, "memory allocation failed"); + } + memcpy(hdr, dat, dat_len + 1); + } + hdr[dat_len] = 0; +#endif + + raw = (flg & (YYJSON_READ_NUMBER_AS_RAW | YYJSON_READ_BIGNUM_AS_RAW)) != 0; + raw_end = NULL; + pre = raw ? &raw_end : NULL; + +#if !YYJSON_HAS_IEEE_754 || YYJSON_DISABLE_FAST_FP_CONV + if (!read_number(&cur, pre, flg, val, &msg)) { + if (dat_len >= sizeof(buf)) alc->free(alc->ctx, hdr); + return_err(cur, INVALID_NUMBER, msg); + } + if (dat_len >= sizeof(buf)) alc->free(alc->ctx, hdr); + if (yyjson_is_raw(val)) val->uni.str = dat; + return dat + (cur - hdr); +#else + if (!read_number(&cur, pre, flg, val, &msg)) { + return_err(cur, INVALID_NUMBER, msg); + } + return (const char *)cur; +#endif + +#undef return_err +} + +#endif /* YYJSON_DISABLE_READER */ + + + +#if !YYJSON_DISABLE_WRITER + +/*============================================================================== + * Integer Writer + * + * The maximum value of uint32_t is 4294967295 (10 digits), + * these digits are named as 'aabbccddee' here. + * + * Although most compilers may convert the "division by constant value" into + * "multiply and shift", manual conversion can still help some compilers + * generate fewer and better instructions. + * + * Reference: + * Division by Invariant Integers using Multiplication, 1994. + * https://gmplib.org/~tege/divcnst-pldi94.pdf + * Improved division by invariant integers, 2011. + * https://gmplib.org/~tege/division-paper.pdf + *============================================================================*/ + +/** Digit table from 00 to 99. */ +yyjson_align(2) +static const char digit_table[200] = { + '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', + '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', + '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', + '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', + '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', + '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', + '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', + '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', + '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', + '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', + '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', + '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', + '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', + '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', + '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', + '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', + '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', + '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', + '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', + '9', '5', '9', '6', '9', '7', '9', '8', '9', '9' +}; + +static_inline u8 *write_u32_len_8(u32 val, u8 *buf) { + u32 aa, bb, cc, dd, aabb, ccdd; /* 8 digits: aabbccdd */ + aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */ + ccdd = val - aabb * 10000; /* (val % 10000) */ + aa = (aabb * 5243) >> 19; /* (aabb / 100) */ + cc = (ccdd * 5243) >> 19; /* (ccdd / 100) */ + bb = aabb - aa * 100; /* (aabb % 100) */ + dd = ccdd - cc * 100; /* (ccdd % 100) */ + byte_copy_2(buf + 0, digit_table + aa * 2); + byte_copy_2(buf + 2, digit_table + bb * 2); + byte_copy_2(buf + 4, digit_table + cc * 2); + byte_copy_2(buf + 6, digit_table + dd * 2); + return buf + 8; +} + +static_inline u8 *write_u32_len_4(u32 val, u8 *buf) { + u32 aa, bb; /* 4 digits: aabb */ + aa = (val * 5243) >> 19; /* (val / 100) */ + bb = val - aa * 100; /* (val % 100) */ + byte_copy_2(buf + 0, digit_table + aa * 2); + byte_copy_2(buf + 2, digit_table + bb * 2); + return buf + 4; +} + +static_inline u8 *write_u32_len_1_8(u32 val, u8 *buf) { + u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz; + + if (val < 100) { /* 1-2 digits: aa */ + lz = val < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + val * 2 + lz); + buf -= lz; + return buf + 2; + + } else if (val < 10000) { /* 3-4 digits: aabb */ + aa = (val * 5243) >> 19; /* (val / 100) */ + bb = val - aa * 100; /* (val % 100) */ + lz = aa < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + aa * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + bb * 2); + return buf + 4; + + } else if (val < 1000000) { /* 5-6 digits: aabbcc */ + aa = (u32)(((u64)val * 429497) >> 32); /* (val / 10000) */ + bbcc = val - aa * 10000; /* (val % 10000) */ + bb = (bbcc * 5243) >> 19; /* (bbcc / 100) */ + cc = bbcc - bb * 100; /* (bbcc % 100) */ + lz = aa < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + aa * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + bb * 2); + byte_copy_2(buf + 4, digit_table + cc * 2); + return buf + 6; + + } else { /* 7-8 digits: aabbccdd */ + aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */ + ccdd = val - aabb * 10000; /* (val % 10000) */ + aa = (aabb * 5243) >> 19; /* (aabb / 100) */ + cc = (ccdd * 5243) >> 19; /* (ccdd / 100) */ + bb = aabb - aa * 100; /* (aabb % 100) */ + dd = ccdd - cc * 100; /* (ccdd % 100) */ + lz = aa < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + aa * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + bb * 2); + byte_copy_2(buf + 4, digit_table + cc * 2); + byte_copy_2(buf + 6, digit_table + dd * 2); + return buf + 8; + } +} + +static_inline u8 *write_u64_len_5_8(u32 val, u8 *buf) { + u32 aa, bb, cc, dd, aabb, bbcc, ccdd, lz; + + if (val < 1000000) { /* 5-6 digits: aabbcc */ + aa = (u32)(((u64)val * 429497) >> 32); /* (val / 10000) */ + bbcc = val - aa * 10000; /* (val % 10000) */ + bb = (bbcc * 5243) >> 19; /* (bbcc / 100) */ + cc = bbcc - bb * 100; /* (bbcc % 100) */ + lz = aa < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + aa * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + bb * 2); + byte_copy_2(buf + 4, digit_table + cc * 2); + return buf + 6; + + } else { /* 7-8 digits: aabbccdd */ + aabb = (u32)(((u64)val * 109951163) >> 40); /* (val / 10000) */ + ccdd = val - aabb * 10000; /* (val % 10000) */ + aa = (aabb * 5243) >> 19; /* (aabb / 100) */ + cc = (ccdd * 5243) >> 19; /* (ccdd / 100) */ + bb = aabb - aa * 100; /* (aabb % 100) */ + dd = ccdd - cc * 100; /* (ccdd % 100) */ + lz = aa < 10; /* leading zero: 0 or 1 */ + byte_copy_2(buf + 0, digit_table + aa * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + bb * 2); + byte_copy_2(buf + 4, digit_table + cc * 2); + byte_copy_2(buf + 6, digit_table + dd * 2); + return buf + 8; + } +} + +static_inline u8 *write_u64(u64 val, u8 *buf) { + u64 tmp, hgh; + u32 mid, low; + + if (val < 100000000) { /* 1-8 digits */ + buf = write_u32_len_1_8((u32)val, buf); + return buf; + + } else if (val < (u64)100000000 * 100000000) { /* 9-16 digits */ + hgh = val / 100000000; /* (val / 100000000) */ + low = (u32)(val - hgh * 100000000); /* (val % 100000000) */ + buf = write_u32_len_1_8((u32)hgh, buf); + buf = write_u32_len_8(low, buf); + return buf; + + } else { /* 17-20 digits */ + tmp = val / 100000000; /* (val / 100000000) */ + low = (u32)(val - tmp * 100000000); /* (val % 100000000) */ + hgh = (u32)(tmp / 10000); /* (tmp / 10000) */ + mid = (u32)(tmp - hgh * 10000); /* (tmp % 10000) */ + buf = write_u64_len_5_8((u32)hgh, buf); + buf = write_u32_len_4(mid, buf); + buf = write_u32_len_8(low, buf); + return buf; + } +} + + + +/*============================================================================== + * Number Writer + *============================================================================*/ + +#if YYJSON_HAS_IEEE_754 && !YYJSON_DISABLE_FAST_FP_CONV /* FP_WRITER */ + +/** Trailing zero count table for number 0 to 99. + (generate with misc/make_tables.c) */ +static const u8 dec_trailing_zero_table[] = { + 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/** Write an unsigned integer with a length of 1 to 16. */ +static_inline u8 *write_u64_len_1_to_16(u64 val, u8 *buf) { + u64 hgh; + u32 low; + if (val < 100000000) { /* 1-8 digits */ + buf = write_u32_len_1_8((u32)val, buf); + return buf; + } else { /* 9-16 digits */ + hgh = val / 100000000; /* (val / 100000000) */ + low = (u32)(val - hgh * 100000000); /* (val % 100000000) */ + buf = write_u32_len_1_8((u32)hgh, buf); + buf = write_u32_len_8(low, buf); + return buf; + } +} + +/** Write an unsigned integer with a length of 1 to 17. */ +static_inline u8 *write_u64_len_1_to_17(u64 val, u8 *buf) { + u64 hgh; + u32 mid, low, one; + if (val >= (u64)100000000 * 10000000) { /* len: 16 to 17 */ + hgh = val / 100000000; /* (val / 100000000) */ + low = (u32)(val - hgh * 100000000); /* (val % 100000000) */ + one = (u32)(hgh / 100000000); /* (hgh / 100000000) */ + mid = (u32)(hgh - (u64)one * 100000000); /* (hgh % 100000000) */ + *buf = (u8)((u8)one + (u8)'0'); + buf += one > 0; + buf = write_u32_len_8(mid, buf); + buf = write_u32_len_8(low, buf); + return buf; + } else if (val >= (u64)100000000){ /* len: 9 to 15 */ + hgh = val / 100000000; /* (val / 100000000) */ + low = (u32)(val - hgh * 100000000); /* (val % 100000000) */ + buf = write_u32_len_1_8((u32)hgh, buf); + buf = write_u32_len_8(low, buf); + return buf; + } else { /* len: 1 to 8 */ + buf = write_u32_len_1_8((u32)val, buf); + return buf; + } +} + +/** + Write an unsigned integer with a length of 15 to 17 with trailing zero trimmed. + These digits are named as "aabbccddeeffgghhii" here. + For example, input 1234567890123000, output "1234567890123". + */ +static_inline u8 *write_u64_len_15_to_17_trim(u8 *buf, u64 sig) { + bool lz; /* leading zero */ + u32 tz1, tz2, tz; /* trailing zero */ + + u32 abbccddee = (u32)(sig / 100000000); + u32 ffgghhii = (u32)(sig - (u64)abbccddee * 100000000); + u32 abbcc = abbccddee / 10000; /* (abbccddee / 10000) */ + u32 ddee = abbccddee - abbcc * 10000; /* (abbccddee % 10000) */ + u32 abb = (u32)(((u64)abbcc * 167773) >> 24); /* (abbcc / 100) */ + u32 a = (abb * 41) >> 12; /* (abb / 100) */ + u32 bb = abb - a * 100; /* (abb % 100) */ + u32 cc = abbcc - abb * 100; /* (abbcc % 100) */ + + /* write abbcc */ + buf[0] = (u8)(a + '0'); + buf += a > 0; + lz = bb < 10 && a == 0; + byte_copy_2(buf + 0, digit_table + bb * 2 + lz); + buf -= lz; + byte_copy_2(buf + 2, digit_table + cc * 2); + + if (ffgghhii) { + u32 dd = (ddee * 5243) >> 19; /* (ddee / 100) */ + u32 ee = ddee - dd * 100; /* (ddee % 100) */ + u32 ffgg = (u32)(((u64)ffgghhii * 109951163) >> 40); /* (val / 10000) */ + u32 hhii = ffgghhii - ffgg * 10000; /* (val % 10000) */ + u32 ff = (ffgg * 5243) >> 19; /* (aabb / 100) */ + u32 gg = ffgg - ff * 100; /* (aabb % 100) */ + byte_copy_2(buf + 4, digit_table + dd * 2); + byte_copy_2(buf + 6, digit_table + ee * 2); + byte_copy_2(buf + 8, digit_table + ff * 2); + byte_copy_2(buf + 10, digit_table + gg * 2); + if (hhii) { + u32 hh = (hhii * 5243) >> 19; /* (ccdd / 100) */ + u32 ii = hhii - hh * 100; /* (ccdd % 100) */ + byte_copy_2(buf + 12, digit_table + hh * 2); + byte_copy_2(buf + 14, digit_table + ii * 2); + tz1 = dec_trailing_zero_table[hh]; + tz2 = dec_trailing_zero_table[ii]; + tz = ii ? tz2 : (tz1 + 2); + buf += 16 - tz; + return buf; + } else { + tz1 = dec_trailing_zero_table[ff]; + tz2 = dec_trailing_zero_table[gg]; + tz = gg ? tz2 : (tz1 + 2); + buf += 12 - tz; + return buf; + } + } else { + if (ddee) { + u32 dd = (ddee * 5243) >> 19; /* (ddee / 100) */ + u32 ee = ddee - dd * 100; /* (ddee % 100) */ + byte_copy_2(buf + 4, digit_table + dd * 2); + byte_copy_2(buf + 6, digit_table + ee * 2); + tz1 = dec_trailing_zero_table[dd]; + tz2 = dec_trailing_zero_table[ee]; + tz = ee ? tz2 : (tz1 + 2); + buf += 8 - tz; + return buf; + } else { + tz1 = dec_trailing_zero_table[bb]; + tz2 = dec_trailing_zero_table[cc]; + tz = cc ? tz2 : (tz1 + tz2); + buf += 4 - tz; + return buf; + } + } +} + +/** Write a signed integer in the range -324 to 308. */ +static_inline u8 *write_f64_exp(i32 exp, u8 *buf) { + buf[0] = '-'; + buf += exp < 0; + exp = exp < 0 ? -exp : exp; + if (exp < 100) { + u32 lz = exp < 10; + byte_copy_2(buf + 0, digit_table + (u32)exp * 2 + lz); + return buf + 2 - lz; + } else { + u32 hi = ((u32)exp * 656) >> 16; /* exp / 100 */ + u32 lo = (u32)exp - hi * 100; /* exp % 100 */ + buf[0] = (u8)((u8)hi + (u8)'0'); + byte_copy_2(buf + 1, digit_table + lo * 2); + return buf + 3; + } +} + +/** Multiplies 128-bit integer and returns highest 64-bit rounded value. */ +static_inline u64 round_to_odd(u64 hi, u64 lo, u64 cp) { + u64 x_hi, x_lo, y_hi, y_lo; + u128_mul(cp, lo, &x_hi, &x_lo); + u128_mul_add(cp, hi, x_hi, &y_hi, &y_lo); + return y_hi | (y_lo > 1); +} + +/** + Convert double number from binary to decimal. + The output significand is shortest decimal but may have trailing zeros. + + This function use the Schubfach algorithm: + Raffaello Giulietti, The Schubfach way to render doubles (5th version), 2022. + https://drive.google.com/file/d/1gp5xv4CAa78SVgCeWfGqqI4FfYYYuNFb + https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-November/083536.html + https://github.com/openjdk/jdk/pull/3402 (Java implementation) + https://github.com/abolz/Drachennest (C++ implementation) + + See also: + Dragonbox: A New Floating-Point Binary-to-Decimal Conversion Algorithm, 2022. + https://github.com/jk-jeon/dragonbox/blob/master/other_files/Dragonbox.pdf + https://github.com/jk-jeon/dragonbox + + @param sig_raw The raw value of significand in IEEE 754 format. + @param exp_raw The raw value of exponent in IEEE 754 format. + @param sig_bin The decoded value of significand in binary. + @param exp_bin The decoded value of exponent in binary. + @param sig_dec The output value of significand in decimal. + @param exp_dec The output value of exponent in decimal. + @warning The input double number should not be 0, inf, nan. + */ +static_inline void f64_bin_to_dec(u64 sig_raw, u32 exp_raw, + u64 sig_bin, i32 exp_bin, + u64 *sig_dec, i32 *exp_dec) { + + bool is_even, regular_spacing, u_inside, w_inside, round_up; + u64 s, sp, cb, cbl, cbr, vb, vbl, vbr, pow10hi, pow10lo, upper, lower, mid; + i32 k, h, exp10; + + is_even = !(sig_bin & 1); + regular_spacing = (sig_raw == 0 && exp_raw > 1); + + cbl = 4 * sig_bin - 2 + regular_spacing; + cb = 4 * sig_bin; + cbr = 4 * sig_bin + 2; + + /* exp_bin: [-1074, 971] */ + /* k = regular_spacing ? floor(log10(pow(2, exp_bin))) */ + /* : floor(log10(pow(2, exp_bin) * 3.0 / 4.0)) */ + /* = regular_spacing ? floor(exp_bin * log10(2)) */ + /* : floor(exp_bin * log10(2) + log10(3.0 / 4.0)) */ + k = (i32)(exp_bin * 315653 - (regular_spacing ? 131237 : 0)) >> 20; + + /* k: [-324, 292] */ + /* h = exp_bin + floor(log2(pow(10, e))) */ + /* = exp_bin + floor(log2(10) * e) */ + exp10 = -k; + h = exp_bin + ((exp10 * 217707) >> 16) + 1; + + pow10_table_get_sig(exp10, &pow10hi, &pow10lo); + pow10lo += (exp10 < POW10_SIG_TABLE_MIN_EXACT_EXP || + exp10 > POW10_SIG_TABLE_MAX_EXACT_EXP); + vbl = round_to_odd(pow10hi, pow10lo, cbl << h); + vb = round_to_odd(pow10hi, pow10lo, cb << h); + vbr = round_to_odd(pow10hi, pow10lo, cbr << h); + + lower = vbl + !is_even; + upper = vbr - !is_even; + + s = vb / 4; + if (s >= 10) { + sp = s / 10; + u_inside = (lower <= 40 * sp); + w_inside = (upper >= 40 * sp + 40); + if (u_inside != w_inside) { + *sig_dec = sp + w_inside; + *exp_dec = k + 1; + return; + } + } + + u_inside = (lower <= 4 * s); + w_inside = (upper >= 4 * s + 4); + + mid = 4 * s + 2; + round_up = (vb > mid) || (vb == mid && (s & 1) != 0); + + *sig_dec = s + ((u_inside != w_inside) ? w_inside : round_up); + *exp_dec = k; +} + +/** + Write a double number (requires 32 bytes buffer). + + We follows the ECMAScript specification to print floating point numbers, + but with the following changes: + 1. Keep the negative sign of 0.0 to preserve input information. + 2. Keep decimal point to indicate the number is floating point. + 3. Remove positive sign of exponent part. + */ +static_inline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) { + u64 sig_bin, sig_dec, sig_raw; + i32 exp_bin, exp_dec, sig_len, dot_pos, i, max; + u32 exp_raw, hi, lo; + u8 *hdr, *num_hdr, *num_end, *dot_end; + bool sign; + + /* decode raw bytes from IEEE-754 double format. */ + sign = (bool)(raw >> (F64_BITS - 1)); + sig_raw = raw & F64_SIG_MASK; + exp_raw = (u32)((raw & F64_EXP_MASK) >> F64_SIG_BITS); + + /* return inf and nan */ + if (unlikely(exp_raw == ((u32)1 << F64_EXP_BITS) - 1)) { + if (has_write_flag(INF_AND_NAN_AS_NULL)) { + byte_copy_4(buf, "null"); + return buf + 4; + } + else if (has_write_flag(ALLOW_INF_AND_NAN)) { + if (sig_raw == 0) { + buf[0] = '-'; + buf += sign; + byte_copy_8(buf, "Infinity"); + buf += 8; + return buf; + } else { + byte_copy_4(buf, "NaN"); + return buf + 3; + } + } + return NULL; + } + + /* add sign for all finite double value, including 0.0 and inf */ + buf[0] = '-'; + buf += sign; + hdr = buf; + + /* return zero */ + if ((raw << 1) == 0) { + byte_copy_4(buf, "0.0"); + buf += 3; + return buf; + } + + if (likely(exp_raw != 0)) { + /* normal number */ + sig_bin = sig_raw | ((u64)1 << F64_SIG_BITS); + exp_bin = (i32)exp_raw - F64_EXP_BIAS - F64_SIG_BITS; + + /* fast path for small integer number without fraction */ + if (-F64_SIG_BITS <= exp_bin && exp_bin <= 0) { + if (u64_tz_bits(sig_bin) >= (u32)-exp_bin) { + /* number is integer in range 1 to 0x1FFFFFFFFFFFFF */ + sig_dec = sig_bin >> -exp_bin; + buf = write_u64_len_1_to_16(sig_dec, buf); + byte_copy_2(buf, ".0"); + buf += 2; + return buf; + } + } + + /* binary to decimal */ + f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec); + + /* the sig length is 15 to 17 */ + sig_len = 17; + sig_len -= (sig_dec < (u64)100000000 * 100000000); + sig_len -= (sig_dec < (u64)100000000 * 10000000); + + /* the decimal point position relative to the first digit */ + dot_pos = sig_len + exp_dec; + + if (-6 < dot_pos && dot_pos <= 21) { + /* no need to write exponent part */ + if (dot_pos <= 0) { + /* dot before first digit */ + /* such as 0.1234, 0.000001234 */ + num_hdr = hdr + (2 - dot_pos); + num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec); + hdr[0] = '0'; + hdr[1] = '.'; + hdr += 2; + max = -dot_pos; + for (i = 0; i < max; i++) hdr[i] = '0'; + return num_end; + } else { + /* dot after first digit */ + /* such as 1.234, 1234.0, 123400000000000000000.0 */ + memset(hdr + 0, '0', 8); + memset(hdr + 8, '0', 8); + memset(hdr + 16, '0', 8); + num_hdr = hdr + 1; + num_end = write_u64_len_15_to_17_trim(num_hdr, sig_dec); + for (i = 0; i < dot_pos; i++) hdr[i] = hdr[i + 1]; + hdr[dot_pos] = '.'; + dot_end = hdr + dot_pos + 2; + return dot_end < num_end ? num_end : dot_end; + } + } else { + /* write with scientific notation */ + /* such as 1.234e56 */ + u8 *end = write_u64_len_15_to_17_trim(buf + 1, sig_dec); + end -= (end == buf + 2); /* remove '.0', e.g. 2.0e34 -> 2e34 */ + exp_dec += sig_len - 1; + hdr[0] = hdr[1]; + hdr[1] = '.'; + end[0] = 'e'; + buf = write_f64_exp(exp_dec, end + 1); + return buf; + } + + } else { + /* subnormal number */ + sig_bin = sig_raw; + exp_bin = 1 - F64_EXP_BIAS - F64_SIG_BITS; + + /* binary to decimal */ + f64_bin_to_dec(sig_raw, exp_raw, sig_bin, exp_bin, &sig_dec, &exp_dec); + + /* write significand part */ + buf = write_u64_len_1_to_17(sig_dec, buf + 1); + hdr[0] = hdr[1]; + hdr[1] = '.'; + do { + buf--; + exp_dec++; + } while (*buf == '0'); + exp_dec += (i32)(buf - hdr - 2); + buf += (*buf != '.'); + buf[0] = 'e'; + buf++; + + /* write exponent part */ + buf[0] = '-'; + buf++; + exp_dec = -exp_dec; + hi = ((u32)exp_dec * 656) >> 16; /* exp / 100 */ + lo = (u32)exp_dec - hi * 100; /* exp % 100 */ + buf[0] = (u8)((u8)hi + (u8)'0'); + byte_copy_2(buf + 1, digit_table + lo * 2); + buf += 3; + return buf; + } +} + +#else /* FP_WRITER */ + +/** Write a double number (requires 32 bytes buffer). */ +static_inline u8 *write_f64_raw(u8 *buf, u64 raw, yyjson_write_flag flg) { + /* + For IEEE 754, `DBL_DECIMAL_DIG` is 17 for round-trip. + For non-IEEE formats, 17 is used to avoid buffer overflow, + round-trip is not guaranteed. + */ +#if defined(DBL_DECIMAL_DIG) && DBL_DECIMAL_DIG != 17 + int dig = DBL_DECIMAL_DIG > 17 ? 17 : DBL_DECIMAL_DIG; +#else + int dig = 17; +#endif + + /* + The snprintf() function is locale-dependent. For currently known locales, + (en, zh, ja, ko, am, he, hi) use '.' as the decimal point, while other + locales use ',' as the decimal point. we need to replace ',' with '.' + to avoid the locale setting. + */ + f64 val = f64_from_raw(raw); +#if YYJSON_MSC_VER >= 1400 + int len = sprintf_s((char *)buf, 32, "%.*g", dig, val); +#elif defined(snprintf) || (YYJSON_STDC_VER >= 199901L) + int len = snprintf((char *)buf, 32, "%.*g", dig, val); +#else + int len = sprintf((char *)buf, "%.*g", dig, val); +#endif + + u8 *cur = buf; + if (unlikely(len < 1)) return NULL; + cur += (*cur == '-'); + if (unlikely(!digi_is_digit(*cur))) { + /* nan, inf, or bad output */ + if (has_write_flag(INF_AND_NAN_AS_NULL)) { + byte_copy_4(buf, "null"); + return buf + 4; + } + else if (has_write_flag(ALLOW_INF_AND_NAN)) { + if (*cur == 'i') { + byte_copy_8(cur, "Infinity"); + cur += 8; + return cur; + } else if (*cur == 'n') { + byte_copy_4(buf, "NaN"); + return buf + 3; + } + } + return NULL; + } else { + /* finite number */ + int i = 0; + bool fp = false; + for (; i < len; i++) { + if (buf[i] == ',') buf[i] = '.'; + if (digi_is_fp((u8)buf[i])) fp = true; + } + if (!fp) { + buf[len++] = '.'; + buf[len++] = '0'; + } + } + return buf + len; +} + +#endif /* FP_WRITER */ + +/** Write a JSON number (requires 32 bytes buffer). */ +static_inline u8 *write_number(u8 *cur, yyjson_val *val, + yyjson_write_flag flg) { + if (val->tag & YYJSON_SUBTYPE_REAL) { + u64 raw = val->uni.u64; + return write_f64_raw(cur, raw, flg); + } else { + u64 pos = val->uni.u64; + u64 neg = ~pos + 1; + usize sgn = ((val->tag & YYJSON_SUBTYPE_SINT) > 0) & ((i64)pos < 0); + *cur = '-'; + return write_u64(sgn ? neg : pos, cur + sgn); + } +} + + + +/*============================================================================== + * String Writer + *============================================================================*/ + +/** Character encode type, if (type > CHAR_ENC_ERR_1) bytes = type / 2; */ +typedef u8 char_enc_type; +#define CHAR_ENC_CPY_1 0 /* 1-byte UTF-8, copy. */ +#define CHAR_ENC_ERR_1 1 /* 1-byte UTF-8, error. */ +#define CHAR_ENC_ESC_A 2 /* 1-byte ASCII, escaped as '\x'. */ +#define CHAR_ENC_ESC_1 3 /* 1-byte UTF-8, escaped as '\uXXXX'. */ +#define CHAR_ENC_CPY_2 4 /* 2-byte UTF-8, copy. */ +#define CHAR_ENC_ESC_2 5 /* 2-byte UTF-8, escaped as '\uXXXX'. */ +#define CHAR_ENC_CPY_3 6 /* 3-byte UTF-8, copy. */ +#define CHAR_ENC_ESC_3 7 /* 3-byte UTF-8, escaped as '\uXXXX'. */ +#define CHAR_ENC_CPY_4 8 /* 4-byte UTF-8, copy. */ +#define CHAR_ENC_ESC_4 9 /* 4-byte UTF-8, escaped as '\uXXXX\uXXXX'. */ + +/** Character encode type table: don't escape unicode, don't escape '/'. + (generate with misc/make_tables.c) */ +static const char_enc_type enc_table_cpy[256] = { + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1 +}; + +/** Character encode type table: don't escape unicode, escape '/'. + (generate with misc/make_tables.c) */ +static const char_enc_type enc_table_cpy_slash[256] = { + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 8, 8, 8, 8, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1 +}; + +/** Character encode type table: escape unicode, don't escape '/'. + (generate with misc/make_tables.c) */ +static const char_enc_type enc_table_esc[256] = { + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1 +}; + +/** Character encode type table: escape unicode, escape '/'. + (generate with misc/make_tables.c) */ +static const char_enc_type enc_table_esc_slash[256] = { + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 3, 2, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 1, 1 +}; + +/** Escaped hex character table: ["00" "01" "02" ... "FD" "FE" "FF"]. + (generate with misc/make_tables.c) */ +yyjson_align(2) +static const u8 esc_hex_char_table[512] = { + '0', '0', '0', '1', '0', '2', '0', '3', + '0', '4', '0', '5', '0', '6', '0', '7', + '0', '8', '0', '9', '0', 'A', '0', 'B', + '0', 'C', '0', 'D', '0', 'E', '0', 'F', + '1', '0', '1', '1', '1', '2', '1', '3', + '1', '4', '1', '5', '1', '6', '1', '7', + '1', '8', '1', '9', '1', 'A', '1', 'B', + '1', 'C', '1', 'D', '1', 'E', '1', 'F', + '2', '0', '2', '1', '2', '2', '2', '3', + '2', '4', '2', '5', '2', '6', '2', '7', + '2', '8', '2', '9', '2', 'A', '2', 'B', + '2', 'C', '2', 'D', '2', 'E', '2', 'F', + '3', '0', '3', '1', '3', '2', '3', '3', + '3', '4', '3', '5', '3', '6', '3', '7', + '3', '8', '3', '9', '3', 'A', '3', 'B', + '3', 'C', '3', 'D', '3', 'E', '3', 'F', + '4', '0', '4', '1', '4', '2', '4', '3', + '4', '4', '4', '5', '4', '6', '4', '7', + '4', '8', '4', '9', '4', 'A', '4', 'B', + '4', 'C', '4', 'D', '4', 'E', '4', 'F', + '5', '0', '5', '1', '5', '2', '5', '3', + '5', '4', '5', '5', '5', '6', '5', '7', + '5', '8', '5', '9', '5', 'A', '5', 'B', + '5', 'C', '5', 'D', '5', 'E', '5', 'F', + '6', '0', '6', '1', '6', '2', '6', '3', + '6', '4', '6', '5', '6', '6', '6', '7', + '6', '8', '6', '9', '6', 'A', '6', 'B', + '6', 'C', '6', 'D', '6', 'E', '6', 'F', + '7', '0', '7', '1', '7', '2', '7', '3', + '7', '4', '7', '5', '7', '6', '7', '7', + '7', '8', '7', '9', '7', 'A', '7', 'B', + '7', 'C', '7', 'D', '7', 'E', '7', 'F', + '8', '0', '8', '1', '8', '2', '8', '3', + '8', '4', '8', '5', '8', '6', '8', '7', + '8', '8', '8', '9', '8', 'A', '8', 'B', + '8', 'C', '8', 'D', '8', 'E', '8', 'F', + '9', '0', '9', '1', '9', '2', '9', '3', + '9', '4', '9', '5', '9', '6', '9', '7', + '9', '8', '9', '9', '9', 'A', '9', 'B', + '9', 'C', '9', 'D', '9', 'E', '9', 'F', + 'A', '0', 'A', '1', 'A', '2', 'A', '3', + 'A', '4', 'A', '5', 'A', '6', 'A', '7', + 'A', '8', 'A', '9', 'A', 'A', 'A', 'B', + 'A', 'C', 'A', 'D', 'A', 'E', 'A', 'F', + 'B', '0', 'B', '1', 'B', '2', 'B', '3', + 'B', '4', 'B', '5', 'B', '6', 'B', '7', + 'B', '8', 'B', '9', 'B', 'A', 'B', 'B', + 'B', 'C', 'B', 'D', 'B', 'E', 'B', 'F', + 'C', '0', 'C', '1', 'C', '2', 'C', '3', + 'C', '4', 'C', '5', 'C', '6', 'C', '7', + 'C', '8', 'C', '9', 'C', 'A', 'C', 'B', + 'C', 'C', 'C', 'D', 'C', 'E', 'C', 'F', + 'D', '0', 'D', '1', 'D', '2', 'D', '3', + 'D', '4', 'D', '5', 'D', '6', 'D', '7', + 'D', '8', 'D', '9', 'D', 'A', 'D', 'B', + 'D', 'C', 'D', 'D', 'D', 'E', 'D', 'F', + 'E', '0', 'E', '1', 'E', '2', 'E', '3', + 'E', '4', 'E', '5', 'E', '6', 'E', '7', + 'E', '8', 'E', '9', 'E', 'A', 'E', 'B', + 'E', 'C', 'E', 'D', 'E', 'E', 'E', 'F', + 'F', '0', 'F', '1', 'F', '2', 'F', '3', + 'F', '4', 'F', '5', 'F', '6', 'F', '7', + 'F', '8', 'F', '9', 'F', 'A', 'F', 'B', + 'F', 'C', 'F', 'D', 'F', 'E', 'F', 'F' +}; + +/** Escaped single character table. (generate with misc/make_tables.c) */ +yyjson_align(2) +static const u8 esc_single_char_table[512] = { + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + '\\', 'b', '\\', 't', '\\', 'n', ' ', ' ', + '\\', 'f', '\\', 'r', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', '\\', '"', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', '\\', '/', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + '\\', '\\', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' +}; + +/** Returns the encode table with options. */ +static_inline const char_enc_type *get_enc_table_with_flag( + yyjson_read_flag flg) { + if (has_write_flag(ESCAPE_UNICODE)) { + if (has_write_flag(ESCAPE_SLASHES)) { + return enc_table_esc_slash; + } else { + return enc_table_esc; + } + } else { + if (has_write_flag(ESCAPE_SLASHES)) { + return enc_table_cpy_slash; + } else { + return enc_table_cpy; + } + } +} + +/** Write raw string. */ +static_inline u8 *write_raw(u8 *cur, const u8 *raw, usize raw_len) { + memcpy(cur, raw, raw_len); + return cur + raw_len; +} + +/** + Write string no-escape. + @param cur Buffer cursor. + @param str A UTF-8 string, null-terminator is not required. + @param str_len Length of string in bytes. + @return The buffer cursor after string. + */ +static_inline u8 *write_string_noesc(u8 *cur, const u8 *str, usize str_len) { + *cur++ = '"'; + while (str_len >= 16) { + byte_copy_16(cur, str); + cur += 16; + str += 16; + str_len -= 16; + } + while (str_len >= 4) { + byte_copy_4(cur, str); + cur += 4; + str += 4; + str_len -= 4; + } + while (str_len) { + *cur++ = *str++; + str_len -= 1; + } + *cur++ = '"'; + return cur; +} + +/** + Write UTF-8 string (requires len * 6 + 2 bytes buffer). + @param cur Buffer cursor. + @param esc Escape unicode. + @param inv Allow invalid unicode. + @param str A UTF-8 string, null-terminator is not required. + @param str_len Length of string in bytes. + @param enc_table Encode type table for character. + @return The buffer cursor after string, or NULL on invalid unicode. + */ +static_inline u8 *write_string(u8 *cur, bool esc, bool inv, + const u8 *str, usize str_len, + const char_enc_type *enc_table) { + + /* UTF-8 character mask and pattern, see `read_string()` for details. */ +#if YYJSON_ENDIAN == YYJSON_BIG_ENDIAN + const u16 b2_mask = 0xE0C0UL; + const u16 b2_patt = 0xC080UL; + const u16 b2_requ = 0x1E00UL; + const u32 b3_mask = 0xF0C0C000UL; + const u32 b3_patt = 0xE0808000UL; + const u32 b3_requ = 0x0F200000UL; + const u32 b3_erro = 0x0D200000UL; + const u32 b4_mask = 0xF8C0C0C0UL; + const u32 b4_patt = 0xF0808080UL; + const u32 b4_requ = 0x07300000UL; + const u32 b4_err0 = 0x04000000UL; + const u32 b4_err1 = 0x03300000UL; +#elif YYJSON_ENDIAN == YYJSON_LITTLE_ENDIAN + const u16 b2_mask = 0xC0E0UL; + const u16 b2_patt = 0x80C0UL; + const u16 b2_requ = 0x001EUL; + const u32 b3_mask = 0x00C0C0F0UL; + const u32 b3_patt = 0x008080E0UL; + const u32 b3_requ = 0x0000200FUL; + const u32 b3_erro = 0x0000200DUL; + const u32 b4_mask = 0xC0C0C0F8UL; + const u32 b4_patt = 0x808080F0UL; + const u32 b4_requ = 0x00003007UL; + const u32 b4_err0 = 0x00000004UL; + const u32 b4_err1 = 0x00003003UL; +#else + /* this should be evaluated at compile-time */ + v16_uni b2_mask_uni = {{ 0xE0, 0xC0 }}; + v16_uni b2_patt_uni = {{ 0xC0, 0x80 }}; + v16_uni b2_requ_uni = {{ 0x1E, 0x00 }}; + v32_uni b3_mask_uni = {{ 0xF0, 0xC0, 0xC0, 0x00 }}; + v32_uni b3_patt_uni = {{ 0xE0, 0x80, 0x80, 0x00 }}; + v32_uni b3_requ_uni = {{ 0x0F, 0x20, 0x00, 0x00 }}; + v32_uni b3_erro_uni = {{ 0x0D, 0x20, 0x00, 0x00 }}; + v32_uni b4_mask_uni = {{ 0xF8, 0xC0, 0xC0, 0xC0 }}; + v32_uni b4_patt_uni = {{ 0xF0, 0x80, 0x80, 0x80 }}; + v32_uni b4_requ_uni = {{ 0x07, 0x30, 0x00, 0x00 }}; + v32_uni b4_err0_uni = {{ 0x04, 0x00, 0x00, 0x00 }}; + v32_uni b4_err1_uni = {{ 0x03, 0x30, 0x00, 0x00 }}; + u16 b2_mask = b2_mask_uni.u; + u16 b2_patt = b2_patt_uni.u; + u16 b2_requ = b2_requ_uni.u; + u32 b3_mask = b3_mask_uni.u; + u32 b3_patt = b3_patt_uni.u; + u32 b3_requ = b3_requ_uni.u; + u32 b3_erro = b3_erro_uni.u; + u32 b4_mask = b4_mask_uni.u; + u32 b4_patt = b4_patt_uni.u; + u32 b4_requ = b4_requ_uni.u; + u32 b4_err0 = b4_err0_uni.u; + u32 b4_err1 = b4_err1_uni.u; +#endif + +#define is_valid_seq_2(uni) ( \ + ((uni & b2_mask) == b2_patt) && \ + ((uni & b2_requ)) \ +) + +#define is_valid_seq_3(uni) ( \ + ((uni & b3_mask) == b3_patt) && \ + ((tmp = (uni & b3_requ))) && \ + ((tmp != b3_erro)) \ +) + +#define is_valid_seq_4(uni) ( \ + ((uni & b4_mask) == b4_patt) && \ + ((tmp = (uni & b4_requ))) && \ + ((tmp & b4_err0) == 0 || (tmp & b4_err1) == 0) \ +) + + /* The replacement character U+FFFD, used to indicate invalid character. */ + const v32 rep = {{ 'F', 'F', 'F', 'D' }}; + const v32 pre = {{ '\\', 'u', '0', '0' }}; + + const u8 *src = str; + const u8 *end = str + str_len; + *cur++ = '"'; + +copy_ascii: + /* + Copy continuous ASCII, loop unrolling, same as the following code: + + while (end > src) ( + if (unlikely(enc_table[*src])) break; + *cur++ = *src++; + ); + */ +#define expr_jump(i) \ + if (unlikely(enc_table[src[i]])) goto stop_char_##i; + +#define expr_stop(i) \ + stop_char_##i: \ + memcpy(cur, src, i); \ + cur += i; src += i; goto copy_utf8; + + while (end - src >= 16) { + repeat16_incr(expr_jump) + byte_copy_16(cur, src); + cur += 16; src += 16; + } + + while (end - src >= 4) { + repeat4_incr(expr_jump) + byte_copy_4(cur, src); + cur += 4; src += 4; + } + + while (end > src) { + expr_jump(0) + *cur++ = *src++; + } + + *cur++ = '"'; + return cur; + + repeat16_incr(expr_stop) + +#undef expr_jump +#undef expr_stop + +copy_utf8: + if (unlikely(src + 4 > end)) { + if (end == src) goto copy_end; + if (end - src < enc_table[*src] / 2) goto err_one; + } + switch (enc_table[*src]) { + case CHAR_ENC_CPY_1: { + *cur++ = *src++; + goto copy_ascii; + } + case CHAR_ENC_CPY_2: { + u16 v; +#if YYJSON_DISABLE_UTF8_VALIDATION + byte_copy_2(cur, src); +#else + v = byte_load_2(src); + if (unlikely(!is_valid_seq_2(v))) goto err_cpy; + byte_copy_2(cur, src); +#endif + cur += 2; + src += 2; + goto copy_utf8; + } + case CHAR_ENC_CPY_3: { + u32 v, tmp; +#if YYJSON_DISABLE_UTF8_VALIDATION + if (likely(src + 4 <= end)) { + byte_copy_4(cur, src); + } else { + byte_copy_2(cur, src); + cur[2] = src[2]; + } +#else + if (likely(src + 4 <= end)) { + v = byte_load_4(src); + if (unlikely(!is_valid_seq_3(v))) goto err_cpy; + byte_copy_4(cur, src); + } else { + v = byte_load_3(src); + if (unlikely(!is_valid_seq_3(v))) goto err_cpy; + byte_copy_4(cur, &v); + } +#endif + cur += 3; + src += 3; + goto copy_utf8; + } + case CHAR_ENC_CPY_4: { + u32 v, tmp; +#if YYJSON_DISABLE_UTF8_VALIDATION + byte_copy_4(cur, src); +#else + v = byte_load_4(src); + if (unlikely(!is_valid_seq_4(v))) goto err_cpy; + byte_copy_4(cur, src); +#endif + cur += 4; + src += 4; + goto copy_utf8; + } + case CHAR_ENC_ESC_A: { + byte_copy_2(cur, &esc_single_char_table[*src * 2]); + cur += 2; + src += 1; + goto copy_utf8; + } + case CHAR_ENC_ESC_1: { + byte_copy_4(cur + 0, &pre); + byte_copy_2(cur + 4, &esc_hex_char_table[*src * 2]); + cur += 6; + src += 1; + goto copy_utf8; + } + case CHAR_ENC_ESC_2: { + u16 u, v; +#if !YYJSON_DISABLE_UTF8_VALIDATION + v = byte_load_2(src); + if (unlikely(!is_valid_seq_2(v))) goto err_esc; +#endif + u = (u16)(((u16)(src[0] & 0x1F) << 6) | + ((u16)(src[1] & 0x3F) << 0)); + byte_copy_2(cur + 0, &pre); + byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]); + byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]); + cur += 6; + src += 2; + goto copy_utf8; + } + case CHAR_ENC_ESC_3: { + u16 u; + u32 v, tmp; +#if !YYJSON_DISABLE_UTF8_VALIDATION + v = byte_load_3(src); + if (unlikely(!is_valid_seq_3(v))) goto err_esc; +#endif + u = (u16)(((u16)(src[0] & 0x0F) << 12) | + ((u16)(src[1] & 0x3F) << 6) | + ((u16)(src[2] & 0x3F) << 0)); + byte_copy_2(cur + 0, &pre); + byte_copy_2(cur + 2, &esc_hex_char_table[(u >> 8) * 2]); + byte_copy_2(cur + 4, &esc_hex_char_table[(u & 0xFF) * 2]); + cur += 6; + src += 3; + goto copy_utf8; + } + case CHAR_ENC_ESC_4: { + u32 hi, lo, u, v, tmp; +#if !YYJSON_DISABLE_UTF8_VALIDATION + v = byte_load_4(src); + if (unlikely(!is_valid_seq_4(v))) goto err_esc; +#endif + u = ((u32)(src[0] & 0x07) << 18) | + ((u32)(src[1] & 0x3F) << 12) | + ((u32)(src[2] & 0x3F) << 6) | + ((u32)(src[3] & 0x3F) << 0); + u -= 0x10000; + hi = (u >> 10) + 0xD800; + lo = (u & 0x3FF) + 0xDC00; + byte_copy_2(cur + 0, &pre); + byte_copy_2(cur + 2, &esc_hex_char_table[(hi >> 8) * 2]); + byte_copy_2(cur + 4, &esc_hex_char_table[(hi & 0xFF) * 2]); + byte_copy_2(cur + 6, &pre); + byte_copy_2(cur + 8, &esc_hex_char_table[(lo >> 8) * 2]); + byte_copy_2(cur + 10, &esc_hex_char_table[(lo & 0xFF) * 2]); + cur += 12; + src += 4; + goto copy_utf8; + } + case CHAR_ENC_ERR_1: { + goto err_one; + } + default: break; + } + +copy_end: + *cur++ = '"'; + return cur; + +err_one: + if (esc) goto err_esc; + else goto err_cpy; + +err_cpy: + if (!inv) return NULL; + *cur++ = *src++; + goto copy_utf8; + +err_esc: + if (!inv) return NULL; + byte_copy_2(cur + 0, &pre); + byte_copy_4(cur + 2, &rep); + cur += 6; + src += 1; + goto copy_utf8; + +#undef is_valid_seq_2 +#undef is_valid_seq_3 +#undef is_valid_seq_4 +} + + + +/*============================================================================== + * Writer Utilities + *============================================================================*/ + +/** Write null (requires 8 bytes buffer). */ +static_inline u8 *write_null(u8 *cur) { + v64 v = {{ 'n', 'u', 'l', 'l', ',', '\n', 0, 0 }}; + byte_copy_8(cur, &v); + return cur + 4; +} + +/** Write bool (requires 8 bytes buffer). */ +static_inline u8 *write_bool(u8 *cur, bool val) { + v64 v0 = {{ 'f', 'a', 'l', 's', 'e', ',', '\n', 0 }}; + v64 v1 = {{ 't', 'r', 'u', 'e', ',', '\n', 0, 0 }}; + if (val) { + byte_copy_8(cur, &v1); + } else { + byte_copy_8(cur, &v0); + } + return cur + 5 - val; +} + +/** Write indent (requires level x 4 bytes buffer). + Param spaces should not larger than 4. */ +static_inline u8 *write_indent(u8 *cur, usize level, usize spaces) { + while (level-- > 0) { + byte_copy_4(cur, " "); + cur += spaces; + } + return cur; +} + +/** Write data to file pointer. */ +static bool write_dat_to_fp(FILE *fp, u8 *dat, usize len, + yyjson_write_err *err) { + if (fwrite(dat, len, 1, fp) != 1) { + err->msg = "file writing failed"; + err->code = YYJSON_WRITE_ERROR_FILE_WRITE; + return false; + } + return true; +} + +/** Write data to file. */ +static bool write_dat_to_file(const char *path, u8 *dat, usize len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + err->msg = _msg; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + if (file) fclose(file); \ + return false; \ +} while (false) + + FILE *file = fopen_writeonly(path); + if (file == NULL) { + return_err(FILE_OPEN, "file opening failed"); + } + if (fwrite(dat, len, 1, file) != 1) { + return_err(FILE_WRITE, "file writing failed"); + } + if (fclose(file) != 0) { + file = NULL; + return_err(FILE_WRITE, "file closing failed"); + } + return true; + +#undef return_err +} + + + +/*============================================================================== + * JSON Writer Implementation + *============================================================================*/ + +typedef struct yyjson_write_ctx { + usize tag; +} yyjson_write_ctx; + +static_inline void yyjson_write_ctx_set(yyjson_write_ctx *ctx, + usize size, bool is_obj) { + ctx->tag = (size << 1) | (usize)is_obj; +} + +static_inline void yyjson_write_ctx_get(yyjson_write_ctx *ctx, + usize *size, bool *is_obj) { + usize tag = ctx->tag; + *size = tag >> 1; + *is_obj = (bool)(tag & 1); +} + +/** Write single JSON value. */ +static_inline u8 *yyjson_write_single(yyjson_val *val, + yyjson_write_flag flg, + yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + if (hdr) alc.free(alc.ctx, (void *)hdr); \ + *dat_len = 0; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + err->msg = _msg; \ + return NULL; \ +} while (false) + +#define incr_len(_len) do { \ + hdr = (u8 *)alc.malloc(alc.ctx, _len); \ + if (!hdr) goto fail_alloc; \ + cur = hdr; \ +} while (false) + +#define check_str_len(_len) do { \ + if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \ + goto fail_alloc; \ +} while (false) + + u8 *hdr = NULL, *cur; + usize str_len; + const u8 *str_ptr; + const char_enc_type *enc_table = get_enc_table_with_flag(flg); + bool cpy = (enc_table == enc_table_cpy); + bool esc = has_write_flag(ESCAPE_UNICODE) != 0; + bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0; + + switch (unsafe_yyjson_get_type(val)) { + case YYJSON_TYPE_RAW: + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len + 1); + cur = write_raw(cur, str_ptr, str_len); + break; + + case YYJSON_TYPE_STR: + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len * 6 + 4); + if (likely(cpy) && unsafe_yyjson_get_subtype(val)) { + cur = write_string_noesc(cur, str_ptr, str_len); + } else { + cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table); + if (unlikely(!cur)) goto fail_str; + } + break; + + case YYJSON_TYPE_NUM: + incr_len(32); + cur = write_number(cur, val, flg); + if (unlikely(!cur)) goto fail_num; + break; + + case YYJSON_TYPE_BOOL: + incr_len(8); + cur = write_bool(cur, unsafe_yyjson_get_bool(val)); + break; + + case YYJSON_TYPE_NULL: + incr_len(8); + cur = write_null(cur); + break; + + case YYJSON_TYPE_ARR: + incr_len(4); + byte_copy_2(cur, "[]"); + cur += 2; + break; + + case YYJSON_TYPE_OBJ: + incr_len(4); + byte_copy_2(cur, "{}"); + cur += 2; + break; + + default: + goto fail_type; + } + + *cur = '\0'; + *dat_len = (usize)(cur - hdr); + memset(err, 0, sizeof(yyjson_write_err)); + return hdr; + +fail_alloc: + return_err(MEMORY_ALLOCATION, "memory allocation failed"); +fail_type: + return_err(INVALID_VALUE_TYPE, "invalid JSON value type"); +fail_num: + return_err(NAN_OR_INF, "nan or inf number is not allowed"); +fail_str: + return_err(INVALID_STRING, "invalid utf-8 encoding in string"); + +#undef return_err +#undef check_str_len +#undef incr_len +} + +/** Write JSON document minify. + The root of this document should be a non-empty container. */ +static_inline u8 *yyjson_write_minify(const yyjson_val *root, + const yyjson_write_flag flg, + const yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + *dat_len = 0; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + err->msg = _msg; \ + if (hdr) alc.free(alc.ctx, hdr); \ + return NULL; \ +} while (false) + +#define incr_len(_len) do { \ + ext_len = (usize)(_len); \ + if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \ + alc_inc = yyjson_max(alc_len / 2, ext_len); \ + alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \ + if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \ + goto fail_alloc; \ + alc_len += alc_inc; \ + tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \ + if (unlikely(!tmp)) goto fail_alloc; \ + ctx_len = (usize)(end - (u8 *)ctx); \ + ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \ + memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \ + ctx = ctx_tmp; \ + cur = tmp + (cur - hdr); \ + end = tmp + alc_len; \ + hdr = tmp; \ + } \ +} while (false) + +#define check_str_len(_len) do { \ + if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \ + goto fail_alloc; \ +} while (false) + + yyjson_val *val; + yyjson_type val_type; + usize ctn_len, ctn_len_tmp; + bool ctn_obj, ctn_obj_tmp, is_key; + u8 *hdr, *cur, *end, *tmp; + yyjson_write_ctx *ctx, *ctx_tmp; + usize alc_len, alc_inc, ctx_len, ext_len, str_len; + const u8 *str_ptr; + const char_enc_type *enc_table = get_enc_table_with_flag(flg); + bool cpy = (enc_table == enc_table_cpy); + bool esc = has_write_flag(ESCAPE_UNICODE) != 0; + bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0; + + alc_len = root->uni.ofs / sizeof(yyjson_val); + alc_len = alc_len * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64; + alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx)); + hdr = (u8 *)alc.malloc(alc.ctx, alc_len); + if (!hdr) goto fail_alloc; + cur = hdr; + end = hdr + alc_len; + ctx = (yyjson_write_ctx *)(void *)end; + +doc_begin: + val = constcast(yyjson_val *)root; + val_type = unsafe_yyjson_get_type(val); + ctn_obj = (val_type == YYJSON_TYPE_OBJ); + ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + val++; + +val_begin: + val_type = unsafe_yyjson_get_type(val); + if (val_type == YYJSON_TYPE_STR) { + is_key = ((u8)ctn_obj & (u8)~ctn_len); + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len * 6 + 16); + if (likely(cpy) && unsafe_yyjson_get_subtype(val)) { + cur = write_string_noesc(cur, str_ptr, str_len); + } else { + cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table); + if (unlikely(!cur)) goto fail_str; + } + *cur++ = is_key ? ':' : ','; + goto val_end; + } + if (val_type == YYJSON_TYPE_NUM) { + incr_len(32); + cur = write_number(cur, val, flg); + if (unlikely(!cur)) goto fail_num; + *cur++ = ','; + goto val_end; + } + if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) == + (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) { + ctn_len_tmp = unsafe_yyjson_get_len(val); + ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ); + incr_len(16); + if (unlikely(ctn_len_tmp == 0)) { + /* write empty container */ + *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5)); + *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5)); + *cur++ = ','; + goto val_end; + } else { + /* push context, setup new container */ + yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj); + ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp; + ctn_obj = ctn_obj_tmp; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + val++; + goto val_begin; + } + } + if (val_type == YYJSON_TYPE_BOOL) { + incr_len(16); + cur = write_bool(cur, unsafe_yyjson_get_bool(val)); + cur++; + goto val_end; + } + if (val_type == YYJSON_TYPE_NULL) { + incr_len(16); + cur = write_null(cur); + cur++; + goto val_end; + } + if (val_type == YYJSON_TYPE_RAW) { + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len + 2); + cur = write_raw(cur, str_ptr, str_len); + *cur++ = ','; + goto val_end; + } + goto fail_type; + +val_end: + val++; + ctn_len--; + if (unlikely(ctn_len == 0)) goto ctn_end; + goto val_begin; + +ctn_end: + cur--; + *cur++ = (u8)(']' | ((u8)ctn_obj << 5)); + *cur++ = ','; + if (unlikely((u8 *)ctx >= end)) goto doc_end; + yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj); + ctn_len--; + if (likely(ctn_len > 0)) { + goto val_begin; + } else { + goto ctn_end; + } + +doc_end: + *--cur = '\0'; + *dat_len = (usize)(cur - hdr); + memset(err, 0, sizeof(yyjson_write_err)); + return hdr; + +fail_alloc: + return_err(MEMORY_ALLOCATION, "memory allocation failed"); +fail_type: + return_err(INVALID_VALUE_TYPE, "invalid JSON value type"); +fail_num: + return_err(NAN_OR_INF, "nan or inf number is not allowed"); +fail_str: + return_err(INVALID_STRING, "invalid utf-8 encoding in string"); + +#undef return_err +#undef incr_len +#undef check_str_len +} + +/** Write JSON document pretty. + The root of this document should be a non-empty container. */ +static_inline u8 *yyjson_write_pretty(const yyjson_val *root, + const yyjson_write_flag flg, + const yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + *dat_len = 0; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + err->msg = _msg; \ + if (hdr) alc.free(alc.ctx, hdr); \ + return NULL; \ +} while (false) + +#define incr_len(_len) do { \ + ext_len = (usize)(_len); \ + if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \ + alc_inc = yyjson_max(alc_len / 2, ext_len); \ + alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); \ + if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \ + goto fail_alloc; \ + alc_len += alc_inc; \ + tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \ + if (unlikely(!tmp)) goto fail_alloc; \ + ctx_len = (usize)(end - (u8 *)ctx); \ + ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \ + memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \ + ctx = ctx_tmp; \ + cur = tmp + (cur - hdr); \ + end = tmp + alc_len; \ + hdr = tmp; \ + } \ +} while (false) + +#define check_str_len(_len) do { \ + if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \ + goto fail_alloc; \ +} while (false) + + yyjson_val *val; + yyjson_type val_type; + usize ctn_len, ctn_len_tmp; + bool ctn_obj, ctn_obj_tmp, is_key, no_indent; + u8 *hdr, *cur, *end, *tmp; + yyjson_write_ctx *ctx, *ctx_tmp; + usize alc_len, alc_inc, ctx_len, ext_len, str_len, level; + const u8 *str_ptr; + const char_enc_type *enc_table = get_enc_table_with_flag(flg); + bool cpy = (enc_table == enc_table_cpy); + bool esc = has_write_flag(ESCAPE_UNICODE) != 0; + bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0; + usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4; + + alc_len = root->uni.ofs / sizeof(yyjson_val); + alc_len = alc_len * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64; + alc_len = size_align_up(alc_len, sizeof(yyjson_write_ctx)); + hdr = (u8 *)alc.malloc(alc.ctx, alc_len); + if (!hdr) goto fail_alloc; + cur = hdr; + end = hdr + alc_len; + ctx = (yyjson_write_ctx *)(void *)end; + +doc_begin: + val = constcast(yyjson_val *)root; + val_type = unsafe_yyjson_get_type(val); + ctn_obj = (val_type == YYJSON_TYPE_OBJ); + ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + *cur++ = '\n'; + val++; + level = 1; + +val_begin: + val_type = unsafe_yyjson_get_type(val); + if (val_type == YYJSON_TYPE_STR) { + is_key = (bool)((u8)ctn_obj & (u8)~ctn_len); + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + if (likely(cpy) && unsafe_yyjson_get_subtype(val)) { + cur = write_string_noesc(cur, str_ptr, str_len); + } else { + cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table); + if (unlikely(!cur)) goto fail_str; + } + *cur++ = is_key ? ':' : ','; + *cur++ = is_key ? ' ' : '\n'; + goto val_end; + } + if (val_type == YYJSON_TYPE_NUM) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(32 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_number(cur, val, flg); + if (unlikely(!cur)) goto fail_num; + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } + if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) == + (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + ctn_len_tmp = unsafe_yyjson_get_len(val); + ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ); + if (unlikely(ctn_len_tmp == 0)) { + /* write empty container */ + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5)); + *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5)); + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } else { + /* push context, setup new container */ + incr_len(32 + (no_indent ? 0 : level * 4)); + yyjson_write_ctx_set(--ctx, ctn_len, ctn_obj); + ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp; + ctn_obj = ctn_obj_tmp; + cur = write_indent(cur, no_indent ? 0 : level, spaces); + level++; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + *cur++ = '\n'; + val++; + goto val_begin; + } + } + if (val_type == YYJSON_TYPE_BOOL) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_bool(cur, unsafe_yyjson_get_bool(val)); + cur += 2; + goto val_end; + } + if (val_type == YYJSON_TYPE_NULL) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_null(cur); + cur += 2; + goto val_end; + } + if (val_type == YYJSON_TYPE_RAW) { + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len + 3); + cur = write_raw(cur, str_ptr, str_len); + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } + goto fail_type; + +val_end: + val++; + ctn_len--; + if (unlikely(ctn_len == 0)) goto ctn_end; + goto val_begin; + +ctn_end: + cur -= 2; + *cur++ = '\n'; + incr_len(level * 4); + cur = write_indent(cur, --level, spaces); + *cur++ = (u8)(']' | ((u8)ctn_obj << 5)); + if (unlikely((u8 *)ctx >= end)) goto doc_end; + yyjson_write_ctx_get(ctx++, &ctn_len, &ctn_obj); + ctn_len--; + *cur++ = ','; + *cur++ = '\n'; + if (likely(ctn_len > 0)) { + goto val_begin; + } else { + goto ctn_end; + } + +doc_end: + *cur = '\0'; + *dat_len = (usize)(cur - hdr); + memset(err, 0, sizeof(yyjson_write_err)); + return hdr; + +fail_alloc: + return_err(MEMORY_ALLOCATION, "memory allocation failed"); +fail_type: + return_err(INVALID_VALUE_TYPE, "invalid JSON value type"); +fail_num: + return_err(NAN_OR_INF, "nan or inf number is not allowed"); +fail_str: + return_err(INVALID_STRING, "invalid utf-8 encoding in string"); + +#undef return_err +#undef incr_len +#undef check_str_len +} + +char *yyjson_val_write_opts(const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + usize *dat_len, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + usize dummy_dat_len; + yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC; + yyjson_val *root = constcast(yyjson_val *)val; + + err = err ? err : &dummy_err; + dat_len = dat_len ? dat_len : &dummy_dat_len; + + if (unlikely(!root)) { + *dat_len = 0; + err->msg = "input JSON is NULL"; + err->code = YYJSON_READ_ERROR_INVALID_PARAMETER; + return NULL; + } + + if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) { + return (char *)yyjson_write_single(root, flg, alc, dat_len, err); + } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) { + return (char *)yyjson_write_pretty(root, flg, alc, dat_len, err); + } else { + return (char *)yyjson_write_minify(root, flg, alc, dat_len, err); + } +} + +char *yyjson_write_opts(const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + usize *dat_len, + yyjson_write_err *err) { + yyjson_val *root = doc ? doc->root : NULL; + return yyjson_val_write_opts(root, flg, alc_ptr, dat_len, err); +} + +bool yyjson_val_write_file(const char *path, + const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + u8 *dat; + usize dat_len = 0; + yyjson_val *root = constcast(yyjson_val *)val; + bool suc; + + alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC; + err = err ? err : &dummy_err; + if (unlikely(!path || !*path)) { + err->msg = "input path is invalid"; + err->code = YYJSON_READ_ERROR_INVALID_PARAMETER; + return false; + } + + dat = (u8 *)yyjson_val_write_opts(root, flg, alc_ptr, &dat_len, err); + if (unlikely(!dat)) return false; + suc = write_dat_to_file(path, dat, dat_len, err); + alc_ptr->free(alc_ptr->ctx, dat); + return suc; +} + +bool yyjson_val_write_fp(FILE *fp, + const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + u8 *dat; + usize dat_len = 0; + yyjson_val *root = constcast(yyjson_val *)val; + bool suc; + + alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC; + err = err ? err : &dummy_err; + if (unlikely(!fp)) { + err->msg = "input fp is invalid"; + err->code = YYJSON_READ_ERROR_INVALID_PARAMETER; + return false; + } + + dat = (u8 *)yyjson_val_write_opts(root, flg, alc_ptr, &dat_len, err); + if (unlikely(!dat)) return false; + suc = write_dat_to_fp(fp, dat, dat_len, err); + alc_ptr->free(alc_ptr->ctx, dat); + return suc; +} + +bool yyjson_write_file(const char *path, + const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_val *root = doc ? doc->root : NULL; + return yyjson_val_write_file(path, root, flg, alc_ptr, err); +} + +bool yyjson_write_fp(FILE *fp, + const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_val *root = doc ? doc->root : NULL; + return yyjson_val_write_fp(fp, root, flg, alc_ptr, err); +} + + + +/*============================================================================== + * Mutable JSON Writer Implementation + *============================================================================*/ + +typedef struct yyjson_mut_write_ctx { + usize tag; + yyjson_mut_val *ctn; +} yyjson_mut_write_ctx; + +static_inline void yyjson_mut_write_ctx_set(yyjson_mut_write_ctx *ctx, + yyjson_mut_val *ctn, + usize size, bool is_obj) { + ctx->tag = (size << 1) | (usize)is_obj; + ctx->ctn = ctn; +} + +static_inline void yyjson_mut_write_ctx_get(yyjson_mut_write_ctx *ctx, + yyjson_mut_val **ctn, + usize *size, bool *is_obj) { + usize tag = ctx->tag; + *size = tag >> 1; + *is_obj = (bool)(tag & 1); + *ctn = ctx->ctn; +} + +/** Get the estimated number of values for the mutable JSON document. */ +static_inline usize yyjson_mut_doc_estimated_val_num( + const yyjson_mut_doc *doc) { + usize sum = 0; + yyjson_val_chunk *chunk = doc->val_pool.chunks; + while (chunk) { + sum += chunk->chunk_size / sizeof(yyjson_mut_val) - 1; + if (chunk == doc->val_pool.chunks) { + sum -= (usize)(doc->val_pool.end - doc->val_pool.cur); + } + chunk = chunk->next; + } + return sum; +} + +/** Write single JSON value. */ +static_inline u8 *yyjson_mut_write_single(yyjson_mut_val *val, + yyjson_write_flag flg, + yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + return yyjson_write_single((yyjson_val *)val, flg, alc, dat_len, err); +} + +/** Write JSON document minify. + The root of this document should be a non-empty container. */ +static_inline u8 *yyjson_mut_write_minify(const yyjson_mut_val *root, + usize estimated_val_num, + yyjson_write_flag flg, + yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + *dat_len = 0; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + err->msg = _msg; \ + if (hdr) alc.free(alc.ctx, hdr); \ + return NULL; \ +} while (false) + +#define incr_len(_len) do { \ + ext_len = (usize)(_len); \ + if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \ + alc_inc = yyjson_max(alc_len / 2, ext_len); \ + alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \ + if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \ + goto fail_alloc; \ + alc_len += alc_inc; \ + tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \ + if (unlikely(!tmp)) goto fail_alloc; \ + ctx_len = (usize)(end - (u8 *)ctx); \ + ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \ + memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \ + ctx = ctx_tmp; \ + cur = tmp + (cur - hdr); \ + end = tmp + alc_len; \ + hdr = tmp; \ + } \ +} while (false) + +#define check_str_len(_len) do { \ + if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \ + goto fail_alloc; \ +} while (false) + + yyjson_mut_val *val, *ctn; + yyjson_type val_type; + usize ctn_len, ctn_len_tmp; + bool ctn_obj, ctn_obj_tmp, is_key; + u8 *hdr, *cur, *end, *tmp; + yyjson_mut_write_ctx *ctx, *ctx_tmp; + usize alc_len, alc_inc, ctx_len, ext_len, str_len; + const u8 *str_ptr; + const char_enc_type *enc_table = get_enc_table_with_flag(flg); + bool cpy = (enc_table == enc_table_cpy); + bool esc = has_write_flag(ESCAPE_UNICODE) != 0; + bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0; + + alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_MINIFY_RATIO + 64; + alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx)); + hdr = (u8 *)alc.malloc(alc.ctx, alc_len); + if (!hdr) goto fail_alloc; + cur = hdr; + end = hdr + alc_len; + ctx = (yyjson_mut_write_ctx *)(void *)end; + +doc_begin: + val = constcast(yyjson_mut_val *)root; + val_type = unsafe_yyjson_get_type(val); + ctn_obj = (val_type == YYJSON_TYPE_OBJ); + ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + ctn = val; + val = (yyjson_mut_val *)val->uni.ptr; /* tail */ + val = ctn_obj ? val->next->next : val->next; + +val_begin: + val_type = unsafe_yyjson_get_type(val); + if (val_type == YYJSON_TYPE_STR) { + is_key = ((u8)ctn_obj & (u8)~ctn_len); + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len * 6 + 16); + if (likely(cpy) && unsafe_yyjson_get_subtype(val)) { + cur = write_string_noesc(cur, str_ptr, str_len); + } else { + cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table); + if (unlikely(!cur)) goto fail_str; + } + *cur++ = is_key ? ':' : ','; + goto val_end; + } + if (val_type == YYJSON_TYPE_NUM) { + incr_len(32); + cur = write_number(cur, (yyjson_val *)val, flg); + if (unlikely(!cur)) goto fail_num; + *cur++ = ','; + goto val_end; + } + if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) == + (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) { + ctn_len_tmp = unsafe_yyjson_get_len(val); + ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ); + incr_len(16); + if (unlikely(ctn_len_tmp == 0)) { + /* write empty container */ + *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5)); + *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5)); + *cur++ = ','; + goto val_end; + } else { + /* push context, setup new container */ + yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj); + ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp; + ctn_obj = ctn_obj_tmp; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + ctn = val; + val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */ + val = ctn_obj ? val->next->next : val->next; + goto val_begin; + } + } + if (val_type == YYJSON_TYPE_BOOL) { + incr_len(16); + cur = write_bool(cur, unsafe_yyjson_get_bool(val)); + cur++; + goto val_end; + } + if (val_type == YYJSON_TYPE_NULL) { + incr_len(16); + cur = write_null(cur); + cur++; + goto val_end; + } + if (val_type == YYJSON_TYPE_RAW) { + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len + 2); + cur = write_raw(cur, str_ptr, str_len); + *cur++ = ','; + goto val_end; + } + goto fail_type; + +val_end: + ctn_len--; + if (unlikely(ctn_len == 0)) goto ctn_end; + val = val->next; + goto val_begin; + +ctn_end: + cur--; + *cur++ = (u8)(']' | ((u8)ctn_obj << 5)); + *cur++ = ','; + if (unlikely((u8 *)ctx >= end)) goto doc_end; + val = ctn->next; + yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj); + ctn_len--; + if (likely(ctn_len > 0)) { + goto val_begin; + } else { + goto ctn_end; + } + +doc_end: + *--cur = '\0'; + *dat_len = (usize)(cur - hdr); + err->code = YYJSON_WRITE_SUCCESS; + err->msg = "success"; + return hdr; + +fail_alloc: + return_err(MEMORY_ALLOCATION, "memory allocation failed"); +fail_type: + return_err(INVALID_VALUE_TYPE, "invalid JSON value type"); +fail_num: + return_err(NAN_OR_INF, "nan or inf number is not allowed"); +fail_str: + return_err(INVALID_STRING, "invalid utf-8 encoding in string"); + +#undef return_err +#undef incr_len +#undef check_str_len +} + +/** Write JSON document pretty. + The root of this document should be a non-empty container. */ +static_inline u8 *yyjson_mut_write_pretty(const yyjson_mut_val *root, + usize estimated_val_num, + yyjson_write_flag flg, + yyjson_alc alc, + usize *dat_len, + yyjson_write_err *err) { + +#define return_err(_code, _msg) do { \ + *dat_len = 0; \ + err->code = YYJSON_WRITE_ERROR_##_code; \ + err->msg = _msg; \ + if (hdr) alc.free(alc.ctx, hdr); \ + return NULL; \ +} while (false) + +#define incr_len(_len) do { \ + ext_len = (usize)(_len); \ + if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { \ + alc_inc = yyjson_max(alc_len / 2, ext_len); \ + alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); \ + if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) \ + goto fail_alloc; \ + alc_len += alc_inc; \ + tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); \ + if (unlikely(!tmp)) goto fail_alloc; \ + ctx_len = (usize)(end - (u8 *)ctx); \ + ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); \ + memmove((void *)ctx_tmp, (void *)(tmp + ((u8 *)ctx - hdr)), ctx_len); \ + ctx = ctx_tmp; \ + cur = tmp + (cur - hdr); \ + end = tmp + alc_len; \ + hdr = tmp; \ + } \ +} while (false) + +#define check_str_len(_len) do { \ + if ((sizeof(usize) < 8) && (_len >= (USIZE_MAX - 16) / 6)) \ + goto fail_alloc; \ +} while (false) + + yyjson_mut_val *val, *ctn; + yyjson_type val_type; + usize ctn_len, ctn_len_tmp; + bool ctn_obj, ctn_obj_tmp, is_key, no_indent; + u8 *hdr, *cur, *end, *tmp; + yyjson_mut_write_ctx *ctx, *ctx_tmp; + usize alc_len, alc_inc, ctx_len, ext_len, str_len, level; + const u8 *str_ptr; + const char_enc_type *enc_table = get_enc_table_with_flag(flg); + bool cpy = (enc_table == enc_table_cpy); + bool esc = has_write_flag(ESCAPE_UNICODE) != 0; + bool inv = has_write_flag(ALLOW_INVALID_UNICODE) != 0; + usize spaces = has_write_flag(PRETTY_TWO_SPACES) ? 2 : 4; + + alc_len = estimated_val_num * YYJSON_WRITER_ESTIMATED_PRETTY_RATIO + 64; + alc_len = size_align_up(alc_len, sizeof(yyjson_mut_write_ctx)); + hdr = (u8 *)alc.malloc(alc.ctx, alc_len); + if (!hdr) goto fail_alloc; + cur = hdr; + end = hdr + alc_len; + ctx = (yyjson_mut_write_ctx *)(void *)end; + +doc_begin: + val = constcast(yyjson_mut_val *)root; + val_type = unsafe_yyjson_get_type(val); + ctn_obj = (val_type == YYJSON_TYPE_OBJ); + ctn_len = unsafe_yyjson_get_len(val) << (u8)ctn_obj; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + *cur++ = '\n'; + ctn = val; + val = (yyjson_mut_val *)val->uni.ptr; /* tail */ + val = ctn_obj ? val->next->next : val->next; + level = 1; + +val_begin: + val_type = unsafe_yyjson_get_type(val); + if (val_type == YYJSON_TYPE_STR) { + is_key = (bool)((u8)ctn_obj & (u8)~ctn_len); + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len * 6 + 16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + if (likely(cpy) && unsafe_yyjson_get_subtype(val)) { + cur = write_string_noesc(cur, str_ptr, str_len); + } else { + cur = write_string(cur, esc, inv, str_ptr, str_len, enc_table); + if (unlikely(!cur)) goto fail_str; + } + *cur++ = is_key ? ':' : ','; + *cur++ = is_key ? ' ' : '\n'; + goto val_end; + } + if (val_type == YYJSON_TYPE_NUM) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(32 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_number(cur, (yyjson_val *)val, flg); + if (unlikely(!cur)) goto fail_num; + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } + if ((val_type & (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) == + (YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ)) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + ctn_len_tmp = unsafe_yyjson_get_len(val); + ctn_obj_tmp = (val_type == YYJSON_TYPE_OBJ); + if (unlikely(ctn_len_tmp == 0)) { + /* write empty container */ + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + *cur++ = (u8)('[' | ((u8)ctn_obj_tmp << 5)); + *cur++ = (u8)(']' | ((u8)ctn_obj_tmp << 5)); + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } else { + /* push context, setup new container */ + incr_len(32 + (no_indent ? 0 : level * 4)); + yyjson_mut_write_ctx_set(--ctx, ctn, ctn_len, ctn_obj); + ctn_len = ctn_len_tmp << (u8)ctn_obj_tmp; + ctn_obj = ctn_obj_tmp; + cur = write_indent(cur, no_indent ? 0 : level, spaces); + level++; + *cur++ = (u8)('[' | ((u8)ctn_obj << 5)); + *cur++ = '\n'; + ctn = val; + val = (yyjson_mut_val *)ctn->uni.ptr; /* tail */ + val = ctn_obj ? val->next->next : val->next; + goto val_begin; + } + } + if (val_type == YYJSON_TYPE_BOOL) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_bool(cur, unsafe_yyjson_get_bool(val)); + cur += 2; + goto val_end; + } + if (val_type == YYJSON_TYPE_NULL) { + no_indent = (bool)((u8)ctn_obj & (u8)ctn_len); + incr_len(16 + (no_indent ? 0 : level * 4)); + cur = write_indent(cur, no_indent ? 0 : level, spaces); + cur = write_null(cur); + cur += 2; + goto val_end; + } + if (val_type == YYJSON_TYPE_RAW) { + str_len = unsafe_yyjson_get_len(val); + str_ptr = (const u8 *)unsafe_yyjson_get_str(val); + check_str_len(str_len); + incr_len(str_len + 3); + cur = write_raw(cur, str_ptr, str_len); + *cur++ = ','; + *cur++ = '\n'; + goto val_end; + } + goto fail_type; + +val_end: + ctn_len--; + if (unlikely(ctn_len == 0)) goto ctn_end; + val = val->next; + goto val_begin; + +ctn_end: + cur -= 2; + *cur++ = '\n'; + incr_len(level * 4); + cur = write_indent(cur, --level, spaces); + *cur++ = (u8)(']' | ((u8)ctn_obj << 5)); + if (unlikely((u8 *)ctx >= end)) goto doc_end; + val = ctn->next; + yyjson_mut_write_ctx_get(ctx++, &ctn, &ctn_len, &ctn_obj); + ctn_len--; + *cur++ = ','; + *cur++ = '\n'; + if (likely(ctn_len > 0)) { + goto val_begin; + } else { + goto ctn_end; + } + +doc_end: + *cur = '\0'; + *dat_len = (usize)(cur - hdr); + err->code = YYJSON_WRITE_SUCCESS; + err->msg = "success"; + return hdr; + +fail_alloc: + return_err(MEMORY_ALLOCATION, "memory allocation failed"); +fail_type: + return_err(INVALID_VALUE_TYPE, "invalid JSON value type"); +fail_num: + return_err(NAN_OR_INF, "nan or inf number is not allowed"); +fail_str: + return_err(INVALID_STRING, "invalid utf-8 encoding in string"); + +#undef return_err +#undef incr_len +#undef check_str_len +} + +static char *yyjson_mut_write_opts_impl(const yyjson_mut_val *val, + usize estimated_val_num, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + usize *dat_len, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + usize dummy_dat_len; + yyjson_alc alc = alc_ptr ? *alc_ptr : YYJSON_DEFAULT_ALC; + yyjson_mut_val *root = constcast(yyjson_mut_val *)val; + + err = err ? err : &dummy_err; + dat_len = dat_len ? dat_len : &dummy_dat_len; + + if (unlikely(!root)) { + *dat_len = 0; + err->msg = "input JSON is NULL"; + err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER; + return NULL; + } + + if (!unsafe_yyjson_is_ctn(root) || unsafe_yyjson_get_len(root) == 0) { + return (char *)yyjson_mut_write_single(root, flg, alc, dat_len, err); + } else if (flg & (YYJSON_WRITE_PRETTY | YYJSON_WRITE_PRETTY_TWO_SPACES)) { + return (char *)yyjson_mut_write_pretty(root, estimated_val_num, + flg, alc, dat_len, err); + } else { + return (char *)yyjson_mut_write_minify(root, estimated_val_num, + flg, alc, dat_len, err); + } +} + +char *yyjson_mut_val_write_opts(const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + usize *dat_len, + yyjson_write_err *err) { + return yyjson_mut_write_opts_impl(val, 0, flg, alc_ptr, dat_len, err); +} + +char *yyjson_mut_write_opts(const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + usize *dat_len, + yyjson_write_err *err) { + yyjson_mut_val *root; + usize estimated_val_num; + if (likely(doc)) { + root = doc->root; + estimated_val_num = yyjson_mut_doc_estimated_val_num(doc); + } else { + root = NULL; + estimated_val_num = 0; + } + return yyjson_mut_write_opts_impl(root, estimated_val_num, + flg, alc_ptr, dat_len, err); +} + +bool yyjson_mut_val_write_file(const char *path, + const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + u8 *dat; + usize dat_len = 0; + yyjson_mut_val *root = constcast(yyjson_mut_val *)val; + bool suc; + + alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC; + err = err ? err : &dummy_err; + if (unlikely(!path || !*path)) { + err->msg = "input path is invalid"; + err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER; + return false; + } + + dat = (u8 *)yyjson_mut_val_write_opts(root, flg, alc_ptr, &dat_len, err); + if (unlikely(!dat)) return false; + suc = write_dat_to_file(path, dat, dat_len, err); + alc_ptr->free(alc_ptr->ctx, dat); + return suc; +} + +bool yyjson_mut_val_write_fp(FILE *fp, + const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_write_err dummy_err; + u8 *dat; + usize dat_len = 0; + yyjson_mut_val *root = constcast(yyjson_mut_val *)val; + bool suc; + + alc_ptr = alc_ptr ? alc_ptr : &YYJSON_DEFAULT_ALC; + err = err ? err : &dummy_err; + if (unlikely(!fp)) { + err->msg = "input fp is invalid"; + err->code = YYJSON_WRITE_ERROR_INVALID_PARAMETER; + return false; + } + + dat = (u8 *)yyjson_mut_val_write_opts(root, flg, alc_ptr, &dat_len, err); + if (unlikely(!dat)) return false; + suc = write_dat_to_fp(fp, dat, dat_len, err); + alc_ptr->free(alc_ptr->ctx, dat); + return suc; +} + +bool yyjson_mut_write_file(const char *path, + const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_mut_val *root = doc ? doc->root : NULL; + return yyjson_mut_val_write_file(path, root, flg, alc_ptr, err); +} + +bool yyjson_mut_write_fp(FILE *fp, + const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc_ptr, + yyjson_write_err *err) { + yyjson_mut_val *root = doc ? doc->root : NULL; + return yyjson_mut_val_write_fp(fp, root, flg, alc_ptr, err); +} + +#endif /* YYJSON_DISABLE_WRITER */ diff --git a/src/3rdparty/yyjson/yyjson.h b/src/3rdparty/yyjson/yyjson.h new file mode 100644 index 0000000000..a9740045ad --- /dev/null +++ b/src/3rdparty/yyjson/yyjson.h @@ -0,0 +1,7846 @@ +/*============================================================================== + Copyright (c) 2020 YaoYuan + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + *============================================================================*/ + +/** + @file yyjson.h + @date 2019-03-09 + @author YaoYuan + */ + +#ifndef YYJSON_H +#define YYJSON_H + + + +/*============================================================================== + * Header Files + *============================================================================*/ + +#include +#include +#include +#include +#include +#include + + + +/*============================================================================== + * Compile-time Options + *============================================================================*/ + +/* + Define as 1 to disable JSON reader if JSON parsing is not required. + + This will disable these functions at compile-time: + - yyjson_read() + - yyjson_read_opts() + - yyjson_read_file() + - yyjson_read_number() + - yyjson_mut_read_number() + + This will reduce the binary size by about 60%. + */ +#ifndef YYJSON_DISABLE_READER +#endif + +/* + Define as 1 to disable JSON writer if JSON serialization is not required. + + This will disable these functions at compile-time: + - yyjson_write() + - yyjson_write_file() + - yyjson_write_opts() + - yyjson_val_write() + - yyjson_val_write_file() + - yyjson_val_write_opts() + - yyjson_mut_write() + - yyjson_mut_write_file() + - yyjson_mut_write_opts() + - yyjson_mut_val_write() + - yyjson_mut_val_write_file() + - yyjson_mut_val_write_opts() + + This will reduce the binary size by about 30%. + */ +#ifndef YYJSON_DISABLE_WRITER +#endif + +/* + Define as 1 to disable JSON Pointer, JSON Patch and JSON Merge Patch supports. + + This will disable these functions at compile-time: + - yyjson_ptr_xxx() + - yyjson_mut_ptr_xxx() + - yyjson_doc_ptr_xxx() + - yyjson_mut_doc_ptr_xxx() + - yyjson_patch() + - yyjson_mut_patch() + - yyjson_merge_patch() + - yyjson_mut_merge_patch() + */ +#ifndef YYJSON_DISABLE_UTILS +#endif + +/* + Define as 1 to disable the fast floating-point number conversion in yyjson, + and use libc's `strtod/snprintf` instead. + + This will reduce the binary size by about 30%, but significantly slow down the + floating-point read/write speed. + */ +#ifndef YYJSON_DISABLE_FAST_FP_CONV +#endif + +/* + Define as 1 to disable non-standard JSON support at compile-time: + - Reading and writing inf/nan literal, such as `NaN`, `-Infinity`. + - Single line and multiple line comments. + - Single trailing comma at the end of an object or array. + - Invalid unicode in string value. + + This will also invalidate these run-time options: + - YYJSON_READ_ALLOW_INF_AND_NAN + - YYJSON_READ_ALLOW_COMMENTS + - YYJSON_READ_ALLOW_TRAILING_COMMAS + - YYJSON_READ_ALLOW_INVALID_UNICODE + - YYJSON_WRITE_ALLOW_INF_AND_NAN + - YYJSON_WRITE_ALLOW_INVALID_UNICODE + + This will reduce the binary size by about 10%, and speed up the reading and + writing speed by about 2% to 6%. + */ +#ifndef YYJSON_DISABLE_NON_STANDARD +#endif + +/* + Define as 1 to disable UTF-8 validation at compile time. + + If all input strings are guaranteed to be valid UTF-8 encoding (for example, + some language's String object has already validated the encoding), using this + flag can avoid redundant UTF-8 validation in yyjson. + + This flag can speed up the reading and writing speed of non-ASCII encoded + strings by about 3% to 7%. + + Note: If this flag is used while passing in illegal UTF-8 strings, the + following errors may occur: + - Escaped characters may be ignored when parsing JSON strings. + - Ending quotes may be ignored when parsing JSON strings, causing the string + to be concatenated to the next value. + - When accessing `yyjson_mut_val` for serialization, the string ending may be + accessed out of bounds, causing a segmentation fault. + */ +#ifndef YYJSON_DISABLE_UTF8_VALIDATION +#endif + +/* + Define as 1 to indicate that the target architecture does not support unaligned + memory access. Please refer to the comments in the C file for details. + */ +#ifndef YYJSON_DISABLE_UNALIGNED_MEMORY_ACCESS +#endif + +/* Define as 1 to export symbols when building this library as Windows DLL. */ +#ifndef YYJSON_EXPORTS +#endif + +/* Define as 1 to import symbols when using this library as Windows DLL. */ +#ifndef YYJSON_IMPORTS +#endif + +/* Define as 1 to include for compiler which doesn't support C99. */ +#ifndef YYJSON_HAS_STDINT_H +#endif + +/* Define as 1 to include for compiler which doesn't support C99. */ +#ifndef YYJSON_HAS_STDBOOL_H +#endif + + + +/*============================================================================== + * Compiler Macros + *============================================================================*/ + +/** compiler version (MSVC) */ +#ifdef _MSC_VER +# define YYJSON_MSC_VER _MSC_VER +#else +# define YYJSON_MSC_VER 0 +#endif + +/** compiler version (GCC) */ +#ifdef __GNUC__ +# define YYJSON_GCC_VER __GNUC__ +# if defined(__GNUC_PATCHLEVEL__) +# define yyjson_gcc_available(major, minor, patch) \ + ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) \ + >= (major * 10000 + minor * 100 + patch)) +# else +# define yyjson_gcc_available(major, minor, patch) \ + ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) \ + >= (major * 10000 + minor * 100 + patch)) +# endif +#else +# define YYJSON_GCC_VER 0 +# define yyjson_gcc_available(major, minor, patch) 0 +#endif + +/** real gcc check */ +#if !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__ICC) && \ + defined(__GNUC__) +# define YYJSON_IS_REAL_GCC 1 +#else +# define YYJSON_IS_REAL_GCC 0 +#endif + +/** C version (STDC) */ +#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__) +# define YYJSON_STDC_VER __STDC_VERSION__ +#else +# define YYJSON_STDC_VER 0 +#endif + +/** C++ version */ +#if defined(__cplusplus) +# define YYJSON_CPP_VER __cplusplus +#else +# define YYJSON_CPP_VER 0 +#endif + +/** compiler builtin check (since gcc 10.0, clang 2.6, icc 2021) */ +#ifndef yyjson_has_builtin +# ifdef __has_builtin +# define yyjson_has_builtin(x) __has_builtin(x) +# else +# define yyjson_has_builtin(x) 0 +# endif +#endif + +/** compiler attribute check (since gcc 5.0, clang 2.9, icc 17) */ +#ifndef yyjson_has_attribute +# ifdef __has_attribute +# define yyjson_has_attribute(x) __has_attribute(x) +# else +# define yyjson_has_attribute(x) 0 +# endif +#endif + +/** compiler feature check (since clang 2.6, icc 17) */ +#ifndef yyjson_has_feature +# ifdef __has_feature +# define yyjson_has_feature(x) __has_feature(x) +# else +# define yyjson_has_feature(x) 0 +# endif +#endif + +/** include check (since gcc 5.0, clang 2.7, icc 16, msvc 2017 15.3) */ +#ifndef yyjson_has_include +# ifdef __has_include +# define yyjson_has_include(x) __has_include(x) +# else +# define yyjson_has_include(x) 0 +# endif +#endif + +/** inline for compiler */ +#ifndef yyjson_inline +# if YYJSON_MSC_VER >= 1200 +# define yyjson_inline __forceinline +# elif defined(_MSC_VER) +# define yyjson_inline __inline +# elif yyjson_has_attribute(always_inline) || YYJSON_GCC_VER >= 4 +# define yyjson_inline __inline__ __attribute__((always_inline)) +# elif defined(__clang__) || defined(__GNUC__) +# define yyjson_inline __inline__ +# elif defined(__cplusplus) || YYJSON_STDC_VER >= 199901L +# define yyjson_inline inline +# else +# define yyjson_inline +# endif +#endif + +/** noinline for compiler */ +#ifndef yyjson_noinline +# if YYJSON_MSC_VER >= 1400 +# define yyjson_noinline __declspec(noinline) +# elif yyjson_has_attribute(noinline) || YYJSON_GCC_VER >= 4 +# define yyjson_noinline __attribute__((noinline)) +# else +# define yyjson_noinline +# endif +#endif + +/** align for compiler */ +#ifndef yyjson_align +# if YYJSON_MSC_VER >= 1300 +# define yyjson_align(x) __declspec(align(x)) +# elif yyjson_has_attribute(aligned) || defined(__GNUC__) +# define yyjson_align(x) __attribute__((aligned(x))) +# elif YYJSON_CPP_VER >= 201103L +# define yyjson_align(x) alignas(x) +# else +# define yyjson_align(x) +# endif +#endif + +/** likely for compiler */ +#ifndef yyjson_likely +# if yyjson_has_builtin(__builtin_expect) || \ + (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5) +# define yyjson_likely(expr) __builtin_expect(!!(expr), 1) +# else +# define yyjson_likely(expr) (expr) +# endif +#endif + +/** unlikely for compiler */ +#ifndef yyjson_unlikely +# if yyjson_has_builtin(__builtin_expect) || \ + (YYJSON_GCC_VER >= 4 && YYJSON_GCC_VER != 5) +# define yyjson_unlikely(expr) __builtin_expect(!!(expr), 0) +# else +# define yyjson_unlikely(expr) (expr) +# endif +#endif + +/** compile-time constant check for compiler */ +#ifndef yyjson_constant_p +# if yyjson_has_builtin(__builtin_constant_p) || (YYJSON_GCC_VER >= 3) +# define YYJSON_HAS_CONSTANT_P 1 +# define yyjson_constant_p(value) __builtin_constant_p(value) +# else +# define YYJSON_HAS_CONSTANT_P 0 +# define yyjson_constant_p(value) 0 +# endif +#endif + +/** deprecate warning */ +#ifndef yyjson_deprecated +# if YYJSON_MSC_VER >= 1400 +# define yyjson_deprecated(msg) __declspec(deprecated(msg)) +# elif yyjson_has_feature(attribute_deprecated_with_message) || \ + (YYJSON_GCC_VER > 4 || (YYJSON_GCC_VER == 4 && __GNUC_MINOR__ >= 5)) +# define yyjson_deprecated(msg) __attribute__((deprecated(msg))) +# elif YYJSON_GCC_VER >= 3 +# define yyjson_deprecated(msg) __attribute__((deprecated)) +# else +# define yyjson_deprecated(msg) +# endif +#endif + +/** function export */ +#ifndef yyjson_api +# if defined(_WIN32) +# if defined(YYJSON_EXPORTS) && YYJSON_EXPORTS +# define yyjson_api __declspec(dllexport) +# elif defined(YYJSON_IMPORTS) && YYJSON_IMPORTS +# define yyjson_api __declspec(dllimport) +# else +# define yyjson_api +# endif +# elif yyjson_has_attribute(visibility) || YYJSON_GCC_VER >= 4 +# define yyjson_api __attribute__((visibility("default"))) +# else +# define yyjson_api +# endif +#endif + +/** inline function export */ +#ifndef yyjson_api_inline +# define yyjson_api_inline static yyjson_inline +#endif + +/** stdint (C89 compatible) */ +#if (defined(YYJSON_HAS_STDINT_H) && YYJSON_HAS_STDINT_H) || \ + YYJSON_MSC_VER >= 1600 || YYJSON_STDC_VER >= 199901L || \ + defined(_STDINT_H) || defined(_STDINT_H_) || \ + defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \ + yyjson_has_include() +# include +#elif defined(_MSC_VER) +# if _MSC_VER < 1300 + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; +# else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; +# endif +#else +# if UCHAR_MAX == 0xFFU + typedef signed char int8_t; + typedef unsigned char uint8_t; +# else +# error cannot find 8-bit integer type +# endif +# if USHRT_MAX == 0xFFFFU + typedef unsigned short uint16_t; + typedef signed short int16_t; +# elif UINT_MAX == 0xFFFFU + typedef unsigned int uint16_t; + typedef signed int int16_t; +# else +# error cannot find 16-bit integer type +# endif +# if UINT_MAX == 0xFFFFFFFFUL + typedef unsigned int uint32_t; + typedef signed int int32_t; +# elif ULONG_MAX == 0xFFFFFFFFUL + typedef unsigned long uint32_t; + typedef signed long int32_t; +# elif USHRT_MAX == 0xFFFFFFFFUL + typedef unsigned short uint32_t; + typedef signed short int32_t; +# else +# error cannot find 32-bit integer type +# endif +# if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__) + typedef __INT64_TYPE__ int64_t; + typedef __UINT64_TYPE__ uint64_t; +# elif defined(__GNUC__) || defined(__clang__) +# if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined) + __extension__ typedef long long int64_t; +# endif + __extension__ typedef unsigned long long uint64_t; +# elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \ + defined(__SUNPRO_C) || defined(__SUNPRO_CC) + typedef long long int64_t; + typedef unsigned long long uint64_t; +# elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \ + defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC) + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; +# else +# error cannot find 64-bit integer type +# endif +#endif + +/** stdbool (C89 compatible) */ +#if (defined(YYJSON_HAS_STDBOOL_H) && YYJSON_HAS_STDBOOL_H) || \ + (yyjson_has_include() && !defined(__STRICT_ANSI__)) || \ + YYJSON_MSC_VER >= 1800 || YYJSON_STDC_VER >= 199901L +# include +#elif !defined(__bool_true_false_are_defined) +# define __bool_true_false_are_defined 1 +# if defined(__cplusplus) +# if defined(__GNUC__) && !defined(__STRICT_ANSI__) +# define _Bool bool +# if __cplusplus < 201103L +# define bool bool +# define false false +# define true true +# endif +# endif +# else +# define bool unsigned char +# define true 1 +# define false 0 +# endif +#endif + +/** char bit check */ +#if defined(CHAR_BIT) +# if CHAR_BIT != 8 +# error non 8-bit char is not supported +# endif +#endif + +/** + Microsoft Visual C++ 6.0 doesn't support converting number from u64 to f64: + error C2520: conversion from unsigned __int64 to double not implemented. + */ +#ifndef YYJSON_U64_TO_F64_NO_IMPL +# if (0 < YYJSON_MSC_VER) && (YYJSON_MSC_VER <= 1200) +# define YYJSON_U64_TO_F64_NO_IMPL 1 +# else +# define YYJSON_U64_TO_F64_NO_IMPL 0 +# endif +#endif + + + +/*============================================================================== + * Compile Hint Begin + *============================================================================*/ + +/* extern "C" begin */ +#ifdef __cplusplus +extern "C" { +#endif + +/* warning suppress begin */ +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wunused-function" +# pragma clang diagnostic ignored "-Wunused-parameter" +#elif defined(__GNUC__) +# if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) +# pragma GCC diagnostic push +# endif +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunused-parameter" +#elif defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4800) /* 'int': forcing value to 'true' or 'false' */ +#endif + + + +/*============================================================================== + * Version + *============================================================================*/ + +/** The major version of yyjson. */ +#define YYJSON_VERSION_MAJOR 0 + +/** The minor version of yyjson. */ +#define YYJSON_VERSION_MINOR 7 + +/** The patch version of yyjson. */ +#define YYJSON_VERSION_PATCH 0 + +/** The version of yyjson in hex: `(major << 16) | (minor << 8) | (patch)`. */ +#define YYJSON_VERSION_HEX 0x000700 + +/** The version string of yyjson. */ +#define YYJSON_VERSION_STRING "0.7.0" + +/** The version of yyjson in hex, same as `YYJSON_VERSION_HEX`. */ +yyjson_api uint32_t yyjson_version(void); + + + +/*============================================================================== + * JSON Types + *============================================================================*/ + +/** Type of a JSON value (3 bit). */ +typedef uint8_t yyjson_type; +/** No type, invalid. */ +#define YYJSON_TYPE_NONE ((uint8_t)0) /* _____000 */ +/** Raw string type, no subtype. */ +#define YYJSON_TYPE_RAW ((uint8_t)1) /* _____001 */ +/** Null type: `null` literal, no subtype. */ +#define YYJSON_TYPE_NULL ((uint8_t)2) /* _____010 */ +/** Boolean type, subtype: TRUE, FALSE. */ +#define YYJSON_TYPE_BOOL ((uint8_t)3) /* _____011 */ +/** Number type, subtype: UINT, SINT, REAL. */ +#define YYJSON_TYPE_NUM ((uint8_t)4) /* _____100 */ +/** String type, subtype: NONE, NOESC. */ +#define YYJSON_TYPE_STR ((uint8_t)5) /* _____101 */ +/** Array type, no subtype. */ +#define YYJSON_TYPE_ARR ((uint8_t)6) /* _____110 */ +/** Object type, no subtype. */ +#define YYJSON_TYPE_OBJ ((uint8_t)7) /* _____111 */ + +/** Subtype of a JSON value (2 bit). */ +typedef uint8_t yyjson_subtype; +/** No subtype. */ +#define YYJSON_SUBTYPE_NONE ((uint8_t)(0 << 3)) /* ___00___ */ +/** False subtype: `false` literal. */ +#define YYJSON_SUBTYPE_FALSE ((uint8_t)(0 << 3)) /* ___00___ */ +/** True subtype: `true` literal. */ +#define YYJSON_SUBTYPE_TRUE ((uint8_t)(1 << 3)) /* ___01___ */ +/** Unsigned integer subtype: `uint64_t`. */ +#define YYJSON_SUBTYPE_UINT ((uint8_t)(0 << 3)) /* ___00___ */ +/** Signed integer subtype: `int64_t`. */ +#define YYJSON_SUBTYPE_SINT ((uint8_t)(1 << 3)) /* ___01___ */ +/** Real number subtype: `double`. */ +#define YYJSON_SUBTYPE_REAL ((uint8_t)(2 << 3)) /* ___10___ */ +/** String that do not need to be escaped for writing (internal use). */ +#define YYJSON_SUBTYPE_NOESC ((uint8_t)(1 << 3)) /* ___01___ */ + +/** The mask used to extract the type of a JSON value. */ +#define YYJSON_TYPE_MASK ((uint8_t)0x07) /* _____111 */ +/** The number of bits used by the type. */ +#define YYJSON_TYPE_BIT ((uint8_t)3) +/** The mask used to extract the subtype of a JSON value. */ +#define YYJSON_SUBTYPE_MASK ((uint8_t)0x18) /* ___11___ */ +/** The number of bits used by the subtype. */ +#define YYJSON_SUBTYPE_BIT ((uint8_t)2) +/** The mask used to extract the reserved bits of a JSON value. */ +#define YYJSON_RESERVED_MASK ((uint8_t)0xE0) /* 111_____ */ +/** The number of reserved bits. */ +#define YYJSON_RESERVED_BIT ((uint8_t)3) +/** The mask used to extract the tag of a JSON value. */ +#define YYJSON_TAG_MASK ((uint8_t)0xFF) /* 11111111 */ +/** The number of bits used by the tag. */ +#define YYJSON_TAG_BIT ((uint8_t)8) + +/** Padding size for JSON reader. */ +#define YYJSON_PADDING_SIZE 4 + + + +/*============================================================================== + * Allocator + *============================================================================*/ + +/** + A memory allocator. + + Typically you don't need to use it, unless you want to customize your own + memory allocator. + */ +typedef struct yyjson_alc { + /** Same as libc's malloc(size), should not be NULL. */ + void *(*malloc)(void *ctx, size_t size); + /** Same as libc's realloc(ptr, size), should not be NULL. */ + void *(*realloc)(void *ctx, void *ptr, size_t old_size, size_t size); + /** Same as libc's free(ptr), should not be NULL. */ + void (*free)(void *ctx, void *ptr); + /** A context for malloc/realloc/free, can be NULL. */ + void *ctx; +} yyjson_alc; + +/** + A pool allocator uses fixed length pre-allocated memory. + + This allocator may be used to avoid malloc/realloc calls. The pre-allocated + memory should be held by the caller. The maximum amount of memory required to + read a JSON can be calculated using the `yyjson_read_max_memory_usage()` + function, but the amount of memory required to write a JSON cannot be directly + calculated. + + This is not a general-purpose allocator. If used to read multiple JSON + documents and only some of them are released, it may cause memory + fragmentation, leading to performance degradation and memory waste. Therefore, + it is recommended to use this allocator only for reading or writing a single + JSON document. + + @param alc The allocator to be initialized. + If this parameter is NULL, the function will fail and return false. + If `buf` or `size` is invalid, this will be set to an empty allocator. + @param buf The buffer memory for this allocator. + If this parameter is NULL, the function will fail and return false. + @param size The size of `buf`, in bytes. + If this parameter is less than 8 words (32/64 bytes on 32/64-bit OS), the + function will fail and return false. + @return true if the `alc` has been successfully initialized. + + @par Example + @code + // parse JSON with stack memory + char buf[1024]; + yyjson_alc alc; + yyjson_alc_pool_init(&alc, buf, 1024); + + const char *json = "{\"name\":\"Helvetica\",\"size\":16}" + yyjson_doc *doc = yyjson_read_opts(json, strlen(json), 0, &alc, NULL); + // the memory of `doc` is on the stack + @endcode + */ +yyjson_api bool yyjson_alc_pool_init(yyjson_alc *alc, void *buf, size_t size); + + + +/*============================================================================== + * JSON Structure + *============================================================================*/ + +/** + An immutable document for reading JSON. + This document holds memory for all its JSON values and strings. When it is no + longer used, the user should call `yyjson_doc_free()` to free its memory. + */ +typedef struct yyjson_doc yyjson_doc; + +/** + An immutable value for reading JSON. + A JSON Value has the same lifetime as its document. The memory is held by its + document and and cannot be freed alone. + */ +typedef struct yyjson_val yyjson_val; + +/** + A mutable document for building JSON. + This document holds memory for all its JSON values and strings. When it is no + longer used, the user should call `yyjson_mut_doc_free()` to free its memory. + */ +typedef struct yyjson_mut_doc yyjson_mut_doc; + +/** + A mutable value for building JSON. + A JSON Value has the same lifetime as its document. The memory is held by its + document and and cannot be freed alone. + */ +typedef struct yyjson_mut_val yyjson_mut_val; + + + +/*============================================================================== + * JSON Reader API + *============================================================================*/ + +/** Run-time options for JSON reader. */ +typedef uint32_t yyjson_read_flag; + +/** Default option (RFC 8259 compliant): + - Read positive integer as uint64_t. + - Read negative integer as int64_t. + - Read floating-point number as double with round-to-nearest mode. + - Read integer which cannot fit in uint64_t or int64_t as double. + - Report error if double number is infinity. + - Report error if string contains invalid UTF-8 character or BOM. + - Report error on trailing commas, comments, inf and nan literals. */ +static const yyjson_read_flag YYJSON_READ_NOFLAG = 0 << 0; + +/** Read the input data in-situ. + This option allows the reader to modify and use input data to store string + values, which can increase reading speed slightly. + The caller should hold the input data before free the document. + The input data must be padded by at least `YYJSON_PADDING_SIZE` bytes. + For example: `[1,2]` should be `[1,2]\0\0\0\0`, input length should be 5. */ +static const yyjson_read_flag YYJSON_READ_INSITU = 1 << 0; + +/** Stop when done instead of issuing an error if there's additional content + after a JSON document. This option may be used to parse small pieces of JSON + in larger data, such as `NDJSON`. */ +static const yyjson_read_flag YYJSON_READ_STOP_WHEN_DONE = 1 << 1; + +/** Allow single trailing comma at the end of an object or array, + such as `[1,2,3,]`, `{"a":1,"b":2,}` (non-standard). */ +static const yyjson_read_flag YYJSON_READ_ALLOW_TRAILING_COMMAS = 1 << 2; + +/** Allow C-style single line and multiple line comments (non-standard). */ +static const yyjson_read_flag YYJSON_READ_ALLOW_COMMENTS = 1 << 3; + +/** Allow inf/nan number and literal, case-insensitive, + such as 1e999, NaN, inf, -Infinity (non-standard). */ +static const yyjson_read_flag YYJSON_READ_ALLOW_INF_AND_NAN = 1 << 4; + +/** Read all numbers as raw strings (value with `YYJSON_TYPE_RAW` type), + inf/nan literal is also read as raw with `ALLOW_INF_AND_NAN` flag. */ +static const yyjson_read_flag YYJSON_READ_NUMBER_AS_RAW = 1 << 5; + +/** Allow reading invalid unicode when parsing string values (non-standard). + Invalid characters will be allowed to appear in the string values, but + invalid escape sequences will still be reported as errors. + This flag does not affect the performance of correctly encoded strings. + + @warning Strings in JSON values may contain incorrect encoding when this + option is used, you need to handle these strings carefully to avoid security + risks. */ +static const yyjson_read_flag YYJSON_READ_ALLOW_INVALID_UNICODE = 1 << 6; + +/** Read big numbers as raw strings. These big numbers include integers that + cannot be represented by `int64_t` and `uint64_t`, and floating-point + numbers that cannot be represented by finite `double`. + The flag will be overridden by `YYJSON_READ_NUMBER_AS_RAW` flag. */ +static const yyjson_read_flag YYJSON_READ_BIGNUM_AS_RAW = 1 << 7; + + + +/** Result code for JSON reader. */ +typedef uint32_t yyjson_read_code; + +/** Success, no error. */ +static const yyjson_read_code YYJSON_READ_SUCCESS = 0; + +/** Invalid parameter, such as NULL input string or 0 input length. */ +static const yyjson_read_code YYJSON_READ_ERROR_INVALID_PARAMETER = 1; + +/** Memory allocation failure occurs. */ +static const yyjson_read_code YYJSON_READ_ERROR_MEMORY_ALLOCATION = 2; + +/** Input JSON string is empty. */ +static const yyjson_read_code YYJSON_READ_ERROR_EMPTY_CONTENT = 3; + +/** Unexpected content after document, such as `[123]abc`. */ +static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CONTENT = 4; + +/** Unexpected ending, such as `[123`. */ +static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_END = 5; + +/** Unexpected character inside the document, such as `[abc]`. */ +static const yyjson_read_code YYJSON_READ_ERROR_UNEXPECTED_CHARACTER = 6; + +/** Invalid JSON structure, such as `[1,]`. */ +static const yyjson_read_code YYJSON_READ_ERROR_JSON_STRUCTURE = 7; + +/** Invalid comment, such as unclosed multi-line comment. */ +static const yyjson_read_code YYJSON_READ_ERROR_INVALID_COMMENT = 8; + +/** Invalid number, such as `123.e12`, `000`. */ +static const yyjson_read_code YYJSON_READ_ERROR_INVALID_NUMBER = 9; + +/** Invalid string, such as invalid escaped character inside a string. */ +static const yyjson_read_code YYJSON_READ_ERROR_INVALID_STRING = 10; + +/** Invalid JSON literal, such as `truu`. */ +static const yyjson_read_code YYJSON_READ_ERROR_LITERAL = 11; + +/** Failed to open a file. */ +static const yyjson_read_code YYJSON_READ_ERROR_FILE_OPEN = 12; + +/** Failed to read a file. */ +static const yyjson_read_code YYJSON_READ_ERROR_FILE_READ = 13; + +/** Error information for JSON reader. */ +typedef struct yyjson_read_err { + /** Error code, see `yyjson_read_code` for all possible values. */ + yyjson_read_code code; + /** Error message, constant, no need to free (NULL if success). */ + const char *msg; + /** Error byte position for input data (0 if success). */ + size_t pos; +} yyjson_read_err; + + + +/** + Read JSON with options. + + This function is thread-safe when: + 1. The `dat` is not modified by other threads. + 2. The `alc` is thread-safe or NULL. + + @param dat The JSON data (UTF-8 without BOM), null-terminator is not required. + If this parameter is NULL, the function will fail and return NULL. + The `dat` will not be modified without the flag `YYJSON_READ_INSITU`, so you + can pass a `const char *` string and case it to `char *` if you don't use + the `YYJSON_READ_INSITU` flag. + @param len The length of JSON data in bytes. + If this parameter is 0, the function will fail and return NULL. + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON reader. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON document, or NULL if an error occurs. + When it's no longer needed, it should be freed with `yyjson_doc_free()`. + */ +yyjson_api yyjson_doc *yyjson_read_opts(char *dat, + size_t len, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err); + +/** + Read a JSON file. + + This function is thread-safe when: + 1. The file is not modified by other threads. + 2. The `alc` is thread-safe or NULL. + + @param path The JSON file's path. + If this path is NULL or invalid, the function will fail and return NULL. + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON reader. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON document, or NULL if an error occurs. + When it's no longer needed, it should be freed with `yyjson_doc_free()`. + + @warning On 32-bit operating system, files larger than 2GB may fail to read. + */ +yyjson_api yyjson_doc *yyjson_read_file(const char *path, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err); + +/** + Read JSON from a file pointer. + + @param fp The file pointer. + The data will be read from the current position of the FILE to the end. + If this fp is NULL or invalid, the function will fail and return NULL. + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON reader. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON document, or NULL if an error occurs. + When it's no longer needed, it should be freed with `yyjson_doc_free()`. + + @warning On 32-bit operating system, files larger than 2GB may fail to read. + */ +yyjson_api yyjson_doc *yyjson_read_fp(FILE *fp, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err); + +/** + Read a JSON string. + + This function is thread-safe. + + @param dat The JSON data (UTF-8 without BOM), null-terminator is not required. + If this parameter is NULL, the function will fail and return NULL. + @param len The length of JSON data in bytes. + If this parameter is 0, the function will fail and return NULL. + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + @return A new JSON document, or NULL if an error occurs. + When it's no longer needed, it should be freed with `yyjson_doc_free()`. + */ +yyjson_api_inline yyjson_doc *yyjson_read(const char *dat, + size_t len, + yyjson_read_flag flg) { + flg &= ~YYJSON_READ_INSITU; /* const string cannot be modified */ + return yyjson_read_opts((char *)(void *)(size_t)(const void *)dat, + len, flg, NULL, NULL); +} + +/** + Returns the size of maximum memory usage to read a JSON data. + + You may use this value to avoid malloc() or calloc() call inside the reader + to get better performance, or read multiple JSON with one piece of memory. + + @param len The length of JSON data in bytes. + @param flg The JSON read options. + @return The maximum memory size to read this JSON, or 0 if overflow. + + @par Example + @code + // read multiple JSON with same pre-allocated memory + + char *dat1, *dat2, *dat3; // JSON data + size_t len1, len2, len3; // JSON length + size_t max_len = MAX(len1, MAX(len2, len3)); + yyjson_doc *doc; + + // use one allocator for multiple JSON + size_t size = yyjson_read_max_memory_usage(max_len, 0); + void *buf = malloc(size); + yyjson_alc alc; + yyjson_alc_pool_init(&alc, buf, size); + + // no more alloc() or realloc() call during reading + doc = yyjson_read_opts(dat1, len1, 0, &alc, NULL); + yyjson_doc_free(doc); + doc = yyjson_read_opts(dat2, len2, 0, &alc, NULL); + yyjson_doc_free(doc); + doc = yyjson_read_opts(dat3, len3, 0, &alc, NULL); + yyjson_doc_free(doc); + + free(buf); + @endcode + @see yyjson_alc_pool_init() + */ +yyjson_api_inline size_t yyjson_read_max_memory_usage(size_t len, + yyjson_read_flag flg) { + /* + 1. The max value count is (json_size / 2 + 1), + for example: "[1,2,3,4]" size is 9, value count is 5. + 2. Some broken JSON may cost more memory during reading, but fail at end, + for example: "[[[[[[[[". + 3. yyjson use 16 bytes per value, see struct yyjson_val. + 4. yyjson use dynamic memory with a growth factor of 1.5. + + The max memory size is (json_size / 2 * 16 * 1.5 + padding). + */ + size_t mul = (size_t)12 + !(flg & YYJSON_READ_INSITU); + size_t pad = 256; + size_t max = (size_t)(~(size_t)0); + if (flg & YYJSON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len; + if (len >= (max - pad - mul) / mul) return 0; + return len * mul + pad; +} + +/** + Read a JSON number. + + This function is thread-safe when data is not modified by other threads. + + @param dat The JSON data (UTF-8 without BOM), null-terminator is required. + If this parameter is NULL, the function will fail and return NULL. + @param val The output value where result is stored. + If this parameter is NULL, the function will fail and return NULL. + The value will hold either UINT or SINT or REAL number; + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`. + @param alc The memory allocator used for long number. + It is only used when the built-in floating point reader is disabled. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return If successful, a pointer to the character after the last character + used in the conversion, NULL if an error occurs. + */ +yyjson_api const char *yyjson_read_number(const char *dat, + yyjson_val *val, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err); + +/** + Read a JSON number. + + This function is thread-safe when data is not modified by other threads. + + @param dat The JSON data (UTF-8 without BOM), null-terminator is required. + If this parameter is NULL, the function will fail and return NULL. + @param val The output value where result is stored. + If this parameter is NULL, the function will fail and return NULL. + The value will hold either UINT or SINT or REAL number; + @param flg The JSON read options. + Multiple options can be combined with `|` operator. 0 means no options. + Supports `YYJSON_READ_NUMBER_AS_RAW` and `YYJSON_READ_ALLOW_INF_AND_NAN`. + @param alc The memory allocator used for long number. + It is only used when the built-in floating point reader is disabled. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return If successful, a pointer to the character after the last character + used in the conversion, NULL if an error occurs. + */ +yyjson_api_inline const char *yyjson_mut_read_number(const char *dat, + yyjson_mut_val *val, + yyjson_read_flag flg, + const yyjson_alc *alc, + yyjson_read_err *err) { + return yyjson_read_number(dat, (yyjson_val *)val, flg, alc, err); +} + + +/*============================================================================== + * JSON Writer API + *============================================================================*/ + +/** Run-time options for JSON writer. */ +typedef uint32_t yyjson_write_flag; + +/** Default option: + - Write JSON minify. + - Report error on inf or nan number. + - Report error on invalid UTF-8 string. + - Do not escape unicode or slash. */ +static const yyjson_write_flag YYJSON_WRITE_NOFLAG = 0 << 0; + +/** Write JSON pretty with 4 space indent. */ +static const yyjson_write_flag YYJSON_WRITE_PRETTY = 1 << 0; + +/** Escape unicode as `uXXXX`, make the output ASCII only. */ +static const yyjson_write_flag YYJSON_WRITE_ESCAPE_UNICODE = 1 << 1; + +/** Escape '/' as '\/'. */ +static const yyjson_write_flag YYJSON_WRITE_ESCAPE_SLASHES = 1 << 2; + +/** Write inf and nan number as 'Infinity' and 'NaN' literal (non-standard). */ +static const yyjson_write_flag YYJSON_WRITE_ALLOW_INF_AND_NAN = 1 << 3; + +/** Write inf and nan number as null literal. + This flag will override `YYJSON_WRITE_ALLOW_INF_AND_NAN` flag. */ +static const yyjson_write_flag YYJSON_WRITE_INF_AND_NAN_AS_NULL = 1 << 4; + +/** Allow invalid unicode when encoding string values (non-standard). + Invalid characters in string value will be copied byte by byte. + If `YYJSON_WRITE_ESCAPE_UNICODE` flag is also set, invalid character will be + escaped as `U+FFFD` (replacement character). + This flag does not affect the performance of correctly encoded strings. */ +static const yyjson_write_flag YYJSON_WRITE_ALLOW_INVALID_UNICODE = 1 << 5; + +/** Write JSON pretty with 2 space indent. + This flag will override `YYJSON_WRITE_PRETTY` flag. */ +static const yyjson_write_flag YYJSON_WRITE_PRETTY_TWO_SPACES = 1 << 6; + + + +/** Result code for JSON writer */ +typedef uint32_t yyjson_write_code; + +/** Success, no error. */ +static const yyjson_write_code YYJSON_WRITE_SUCCESS = 0; + +/** Invalid parameter, such as NULL document. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_PARAMETER = 1; + +/** Memory allocation failure occurs. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_MEMORY_ALLOCATION = 2; + +/** Invalid value type in JSON document. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_VALUE_TYPE = 3; + +/** NaN or Infinity number occurs. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_NAN_OR_INF = 4; + +/** Failed to open a file. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_OPEN = 5; + +/** Failed to write a file. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_WRITE = 6; + +/** Invalid unicode in string. */ +static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_STRING = 7; + +/** Error information for JSON writer. */ +typedef struct yyjson_write_err { + /** Error code, see `yyjson_write_code` for all possible values. */ + yyjson_write_code code; + /** Error message, constant, no need to free (NULL if success). */ + const char *msg; +} yyjson_write_err; + + + +/*============================================================================== + * JSON Document Writer API + *============================================================================*/ + +/** + Write a document to JSON string with options. + + This function is thread-safe when: + The `alc` is thread-safe or NULL. + + @param doc The JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free() or alc->free(). + */ +yyjson_api char *yyjson_write_opts(const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + size_t *len, + yyjson_write_err *err); + +/** + Write a document to JSON file with options. + + This function is thread-safe when: + 1. The file is not accessed by other threads. + 2. The `alc` is thread-safe or NULL. + + @param path The JSON file's path. + If this path is NULL or invalid, the function will fail and return false. + If this file is not empty, the content will be discarded. + @param doc The JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_write_file(const char *path, + const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a document to file pointer with options. + + @param fp The file pointer. + The data will be written to the current position of the file. + If this fp is NULL or invalid, the function will fail and return false. + @param doc The JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_write_fp(FILE *fp, + const yyjson_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a document to JSON string. + + This function is thread-safe. + + @param doc The JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free(). + */ +yyjson_api_inline char *yyjson_write(const yyjson_doc *doc, + yyjson_write_flag flg, + size_t *len) { + return yyjson_write_opts(doc, flg, NULL, len, NULL); +} + + + +/** + Write a document to JSON string with options. + + This function is thread-safe when: + 1. The `doc` is not modified by other threads. + 2. The `alc` is thread-safe or NULL. + + @param doc The mutable JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free() or alc->free(). + */ +yyjson_api char *yyjson_mut_write_opts(const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + size_t *len, + yyjson_write_err *err); + +/** + Write a document to JSON file with options. + + This function is thread-safe when: + 1. The file is not accessed by other threads. + 2. The `doc` is not modified by other threads. + 3. The `alc` is thread-safe or NULL. + + @param path The JSON file's path. + If this path is NULL or invalid, the function will fail and return false. + If this file is not empty, the content will be discarded. + @param doc The mutable JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_mut_write_file(const char *path, + const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a document to file pointer with options. + + @param fp The file pointer. + The data will be written to the current position of the file. + If this fp is NULL or invalid, the function will fail and return false. + @param doc The mutable JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_mut_write_fp(FILE *fp, + const yyjson_mut_doc *doc, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a document to JSON string. + + This function is thread-safe when: + The `doc` is not modified by other threads. + + @param doc The JSON document. + If this doc is NULL or has no root, the function will fail and return false. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free(). + */ +yyjson_api_inline char *yyjson_mut_write(const yyjson_mut_doc *doc, + yyjson_write_flag flg, + size_t *len) { + return yyjson_mut_write_opts(doc, flg, NULL, len, NULL); +} + + + +/*============================================================================== + * JSON Value Writer API + *============================================================================*/ + +/** + Write a value to JSON string with options. + + This function is thread-safe when: + The `alc` is thread-safe or NULL. + + @param val The JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free() or alc->free(). + */ +yyjson_api char *yyjson_val_write_opts(const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + size_t *len, + yyjson_write_err *err); + +/** + Write a value to JSON file with options. + + This function is thread-safe when: + 1. The file is not accessed by other threads. + 2. The `alc` is thread-safe or NULL. + + @param path The JSON file's path. + If this path is NULL or invalid, the function will fail and return false. + If this file is not empty, the content will be discarded. + @param val The JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_val_write_file(const char *path, + const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a value to file pointer with options. + + @param fp The file pointer. + The data will be written to the current position of the file. + If this path is NULL or invalid, the function will fail and return false. + @param val The JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_val_write_fp(FILE *fp, + const yyjson_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a value to JSON string. + + This function is thread-safe. + + @param val The JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free(). + */ +yyjson_api_inline char *yyjson_val_write(const yyjson_val *val, + yyjson_write_flag flg, + size_t *len) { + return yyjson_val_write_opts(val, flg, NULL, len, NULL); +} + +/** + Write a value to JSON string with options. + + This function is thread-safe when: + 1. The `val` is not modified by other threads. + 2. The `alc` is thread-safe or NULL. + + @param val The mutable JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free() or alc->free(). + */ +yyjson_api char *yyjson_mut_val_write_opts(const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + size_t *len, + yyjson_write_err *err); + +/** + Write a value to JSON file with options. + + This function is thread-safe when: + 1. The file is not accessed by other threads. + 2. The `val` is not modified by other threads. + 3. The `alc` is thread-safe or NULL. + + @param path The JSON file's path. + If this path is NULL or invalid, the function will fail and return false. + If this file is not empty, the content will be discarded. + @param val The mutable JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_mut_val_write_file(const char *path, + const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a value to JSON file with options. + + @param fp The file pointer. + The data will be written to the current position of the file. + If this path is NULL or invalid, the function will fail and return false. + @param val The mutable JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param alc The memory allocator used by JSON writer. + Pass NULL to use the libc's default allocator. + @param err A pointer to receive error information. + Pass NULL if you don't need error information. + @return true if successful, false if an error occurs. + + @warning On 32-bit operating system, files larger than 2GB may fail to write. + */ +yyjson_api bool yyjson_mut_val_write_fp(FILE *fp, + const yyjson_mut_val *val, + yyjson_write_flag flg, + const yyjson_alc *alc, + yyjson_write_err *err); + +/** + Write a value to JSON string. + + This function is thread-safe when: + The `val` is not modified by other threads. + + @param val The JSON root value. + If this parameter is NULL, the function will fail and return NULL. + @param flg The JSON write options. + Multiple options can be combined with `|` operator. 0 means no options. + @param len A pointer to receive output length in bytes (not including the + null-terminator). Pass NULL if you don't need length information. + @return A new JSON string, or NULL if an error occurs. + This string is encoded as UTF-8 with a null-terminator. + When it's no longer needed, it should be freed with free(). + */ +yyjson_api_inline char *yyjson_mut_val_write(const yyjson_mut_val *val, + yyjson_write_flag flg, + size_t *len) { + return yyjson_mut_val_write_opts(val, flg, NULL, len, NULL); +} + + + +/*============================================================================== + * JSON Document API + *============================================================================*/ + +/** Returns the root value of this JSON document. + Returns NULL if `doc` is NULL. */ +yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc); + +/** Returns read size of input JSON data. + Returns 0 if `doc` is NULL. + For example: the read size of `[1,2,3]` is 7 bytes. */ +yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc); + +/** Returns total value count in this JSON document. + Returns 0 if `doc` is NULL. + For example: the value count of `[1,2,3]` is 4. */ +yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc); + +/** Release the JSON document and free the memory. + After calling this function, the `doc` and all values from the `doc` are no + longer available. This function will do nothing if the `doc` is NULL. */ +yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc); + + + +/*============================================================================== + * JSON Value Type API + *============================================================================*/ + +/** Returns whether the JSON value is raw. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_raw(yyjson_val *val); + +/** Returns whether the JSON value is `null`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_null(yyjson_val *val); + +/** Returns whether the JSON value is `true`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_true(yyjson_val *val); + +/** Returns whether the JSON value is `false`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_false(yyjson_val *val); + +/** Returns whether the JSON value is bool (true/false). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_bool(yyjson_val *val); + +/** Returns whether the JSON value is unsigned integer (uint64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_uint(yyjson_val *val); + +/** Returns whether the JSON value is signed integer (int64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_sint(yyjson_val *val); + +/** Returns whether the JSON value is integer (uint64_t/int64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_int(yyjson_val *val); + +/** Returns whether the JSON value is real number (double). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_real(yyjson_val *val); + +/** Returns whether the JSON value is number (uint64_t/int64_t/double). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_num(yyjson_val *val); + +/** Returns whether the JSON value is string. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_str(yyjson_val *val); + +/** Returns whether the JSON value is array. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_arr(yyjson_val *val); + +/** Returns whether the JSON value is object. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_obj(yyjson_val *val); + +/** Returns whether the JSON value is container (array/object). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val); + + + +/*============================================================================== + * JSON Value Content API + *============================================================================*/ + +/** Returns the JSON value's type. + Returns YYJSON_TYPE_NONE if `val` is NULL. */ +yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val); + +/** Returns the JSON value's subtype. + Returns YYJSON_SUBTYPE_NONE if `val` is NULL. */ +yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val); + +/** Returns the JSON value's tag. + Returns 0 if `val` is NULL. */ +yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val); + +/** Returns the JSON value's type description. + The return value should be one of these strings: "raw", "null", "string", + "array", "object", "true", "false", "uint", "sint", "real", "unknown". */ +yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val); + +/** Returns the content if the value is raw. + Returns NULL if `val` is NULL or type is not raw. */ +yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val); + +/** Returns the content if the value is bool. + Returns NULL if `val` is NULL or type is not bool. */ +yyjson_api_inline bool yyjson_get_bool(yyjson_val *val); + +/** Returns the content and cast to uint64_t. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val); + +/** Returns the content and cast to int64_t. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val); + +/** Returns the content and cast to int. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline int yyjson_get_int(yyjson_val *val); + +/** Returns the content if the value is real number, or 0.0 on error. + Returns 0.0 if `val` is NULL or type is not real(double). */ +yyjson_api_inline double yyjson_get_real(yyjson_val *val); + +/** Returns the content and typecast to `double` if the value is number. + Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */ +yyjson_api_inline double yyjson_get_num(yyjson_val *val); + +/** Returns the content if the value is string. + Returns NULL if `val` is NULL or type is not string. */ +yyjson_api_inline const char *yyjson_get_str(yyjson_val *val); + +/** Returns the content length (string length, array size, object size. + Returns 0 if `val` is NULL or type is not string/array/object. */ +yyjson_api_inline size_t yyjson_get_len(yyjson_val *val); + +/** Returns whether the JSON value is equals to a string. + Returns false if input is NULL or type is not string. */ +yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str); + +/** Returns whether the JSON value is equals to a string. + The `str` should be a UTF-8 string, null-terminator is not required. + Returns false if input is NULL or type is not string. */ +yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str, + size_t len); + +/** Returns whether two JSON values are equal (deep compare). + Returns false if input is NULL. + @note the result may be inaccurate if object has duplicate keys. + @warning This function is recursive and may cause a stack overflow + if the object level is too deep. */ +yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs); + +/** Set the value to raw. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_raw(yyjson_val *val, + const char *raw, size_t len); + +/** Set the value to null. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_null(yyjson_val *val); + +/** Set the value to bool. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num); + +/** Set the value to uint. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num); + +/** Set the value to sint. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num); + +/** Set the value to int. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num); + +/** Set the value to real. + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num); + +/** Set the value to string (null-terminated). + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str); + +/** Set the value to string (with length). + Returns false if input is NULL or `val` is object or array. + @warning This will modify the `immutable` value, use with caution. */ +yyjson_api_inline bool yyjson_set_strn(yyjson_val *val, + const char *str, size_t len); + + + +/*============================================================================== + * JSON Array API + *============================================================================*/ + +/** Returns the number of elements in this array. + Returns 0 if `arr` is NULL or type is not array. */ +yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr); + +/** Returns the element at the specified position in this array. + Returns NULL if array is NULL/empty or the index is out of bounds. + @warning This function takes a linear search time if array is not flat. + For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat. */ +yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx); + +/** Returns the first element of this array. + Returns NULL if `arr` is NULL/empty or type is not array. */ +yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr); + +/** Returns the last element of this array. + Returns NULL if `arr` is NULL/empty or type is not array. + @warning This function takes a linear search time if array is not flat. + For example: `[1,{},3]` is flat, `[1,[2],3]` is not flat.*/ +yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr); + + + +/*============================================================================== + * JSON Array Iterator API + *============================================================================*/ + +/** + A JSON array iterator. + + @par Example + @code + yyjson_val *val; + yyjson_arr_iter iter = yyjson_arr_iter_with(arr); + while ((val = yyjson_arr_iter_next(&iter))) { + your_func(val); + } + @endcode + */ +typedef struct yyjson_arr_iter { + size_t idx; /**< next value's index */ + size_t max; /**< maximum index (arr.size) */ + yyjson_val *cur; /**< next value */ +} yyjson_arr_iter; + +/** + Initialize an iterator for this array. + + @param arr The array to be iterated over. + If this parameter is NULL or not an array, `iter` will be set to empty. + @param iter The iterator to be initialized. + If this parameter is NULL, the function will fail and return false. + @return true if the `iter` has been successfully initialized. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr, + yyjson_arr_iter *iter); + +/** + Create an iterator with an array , same as `yyjson_arr_iter_init()`. + + @param arr The array to be iterated over. + If this parameter is NULL or not an array, an empty iterator will returned. + @return A new iterator for the array. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr); + +/** + Returns whether the iteration has more elements. + If `iter` is NULL, this function will return false. + */ +yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter); + +/** + Returns the next element in the iteration, or NULL on end. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter); + +/** + Macro for iterating over an array. + It works like iterator, but with a more intuitive API. + + @par Example + @code + size_t idx, max; + yyjson_val *val; + yyjson_arr_foreach(arr, idx, max, val) { + your_func(idx, val); + } + @endcode + */ +#define yyjson_arr_foreach(arr, idx, max, val) \ + for ((idx) = 0, \ + (max) = yyjson_arr_size(arr), \ + (val) = yyjson_arr_get_first(arr); \ + (idx) < (max); \ + (idx)++, \ + (val) = unsafe_yyjson_get_next(val)) + + + +/*============================================================================== + * JSON Object API + *============================================================================*/ + +/** Returns the number of key-value pairs in this object. + Returns 0 if `obj` is NULL or type is not object. */ +yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj); + +/** Returns the value to which the specified key is mapped. + Returns NULL if this object contains no mapping for the key. + Returns NULL if `obj/key` is NULL, or type is not object. + + The `key` should be a null-terminated UTF-8 string. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj, const char *key); + +/** Returns the value to which the specified key is mapped. + Returns NULL if this object contains no mapping for the key. + Returns NULL if `obj/key` is NULL, or type is not object. + + The `key` should be a UTF-8 string, null-terminator is not required. + The `key_len` should be the length of the key, in bytes. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj, const char *key, + size_t key_len); + + + +/*============================================================================== + * JSON Object Iterator API + *============================================================================*/ + +/** + A JSON object iterator. + + @par Example + @code + yyjson_val *key, *val; + yyjson_obj_iter iter = yyjson_obj_iter_with(obj); + while ((key = yyjson_obj_iter_next(&iter))) { + val = yyjson_obj_iter_get_val(key); + your_func(key, val); + } + @endcode + + If the ordering of the keys is known at compile-time, you can use this method + to speed up value lookups: + @code + // {"k1":1, "k2": 3, "k3": 3} + yyjson_val *key, *val; + yyjson_obj_iter iter = yyjson_obj_iter_with(obj); + yyjson_val *v1 = yyjson_obj_iter_get(&iter, "k1"); + yyjson_val *v3 = yyjson_obj_iter_get(&iter, "k3"); + @endcode + @see yyjson_obj_iter_get() and yyjson_obj_iter_getn() + */ +typedef struct yyjson_obj_iter { + size_t idx; /**< next key's index */ + size_t max; /**< maximum key index (obj.size) */ + yyjson_val *cur; /**< next key */ + yyjson_val *obj; /**< the object being iterated */ +} yyjson_obj_iter; + +/** + Initialize an iterator for this object. + + @param obj The object to be iterated over. + If this parameter is NULL or not an object, `iter` will be set to empty. + @param iter The iterator to be initialized. + If this parameter is NULL, the function will fail and return false. + @return true if the `iter` has been successfully initialized. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj, + yyjson_obj_iter *iter); + +/** + Create an iterator with an object, same as `yyjson_obj_iter_init()`. + + @param obj The object to be iterated over. + If this parameter is NULL or not an object, an empty iterator will returned. + @return A new iterator for the object. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj); + +/** + Returns whether the iteration has more elements. + If `iter` is NULL, this function will return false. + */ +yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter); + +/** + Returns the next key in the iteration, or NULL on end. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter); + +/** + Returns the value for key inside the iteration. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key); + +/** + Iterates to a specified key and returns the value. + + This function does the same thing as `yyjson_obj_get()`, but is much faster + if the ordering of the keys is known at compile-time and you are using the same + order to look up the values. If the key exists in this object, then the + iterator will stop at the next key, otherwise the iterator will not change and + NULL is returned. + + @param iter The object iterator, should not be NULL. + @param key The key, should be a UTF-8 string with null-terminator. + @return The value to which the specified key is mapped. + NULL if this object contains no mapping for the key or input is invalid. + + @warning This function takes a linear search time if the key is not nearby. + */ +yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter, + const char *key); + +/** + Iterates to a specified key and returns the value. + + This function does the same thing as `yyjson_obj_getn()`, but is much faster + if the ordering of the keys is known at compile-time and you are using the same + order to look up the values. If the key exists in this object, then the + iterator will stop at the next key, otherwise the iterator will not change and + NULL is returned. + + @param iter The object iterator, should not be NULL. + @param key The key, should be a UTF-8 string, null-terminator is not required. + @param key_len The the length of `key`, in bytes. + @return The value to which the specified key is mapped. + NULL if this object contains no mapping for the key or input is invalid. + + @warning This function takes a linear search time if the key is not nearby. + */ +yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter, + const char *key, + size_t key_len); + +/** + Macro for iterating over an object. + It works like iterator, but with a more intuitive API. + + @par Example + @code + size_t idx, max; + yyjson_val *key, *val; + yyjson_obj_foreach(obj, idx, max, key, val) { + your_func(key, val); + } + @endcode + */ +#define yyjson_obj_foreach(obj, idx, max, key, val) \ + for ((idx) = 0, \ + (max) = yyjson_obj_size(obj), \ + (key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, \ + (val) = (key) + 1; \ + (idx) < (max); \ + (idx)++, \ + (key) = unsafe_yyjson_get_next(val), \ + (val) = (key) + 1) + + + +/*============================================================================== + * Mutable JSON Document API + *============================================================================*/ + +/** Returns the root value of this JSON document. + Returns NULL if `doc` is NULL. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc); + +/** Sets the root value of this JSON document. + Pass NULL to clear root value of the document. */ +yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc, + yyjson_mut_val *root); + +/** + Set the string pool size for a mutable document. + This function does not allocate memory immediately, but uses the size when + the next memory allocation is needed. + + If the caller knows the approximate bytes of strings that the document needs to + store (e.g. copy string with `yyjson_mut_strcpy` function), setting a larger + size can avoid multiple memory allocations and improve performance. + + @param doc The mutable document. + @param len The desired string pool size in bytes (total string length). + @return true if successful, false if size is 0 or overflow. + */ +yyjson_api bool yyjson_mut_doc_set_str_pool_size(yyjson_mut_doc *doc, + size_t len); + +/** + Set the value pool size for a mutable document. + This function does not allocate memory immediately, but uses the size when + the next memory allocation is needed. + + If the caller knows the approximate number of values that the document needs to + store (e.g. create new value with `yyjson_mut_xxx` functions), setting a larger + size can avoid multiple memory allocations and improve performance. + + @param doc The mutable document. + @param count The desired value pool size (number of `yyjson_mut_val`). + @return true if successful, false if size is 0 or overflow. + */ +yyjson_api bool yyjson_mut_doc_set_val_pool_size(yyjson_mut_doc *doc, + size_t count); + +/** Release the JSON document and free the memory. + After calling this function, the `doc` and all values from the `doc` are no + longer available. This function will do nothing if the `doc` is NULL. */ +yyjson_api void yyjson_mut_doc_free(yyjson_mut_doc *doc); + +/** Creates and returns a new mutable JSON document, returns NULL on error. + If allocator is NULL, the default allocator will be used. */ +yyjson_api yyjson_mut_doc *yyjson_mut_doc_new(const yyjson_alc *alc); + +/** Copies and returns a new mutable document from input, returns NULL on error. + This makes a `deep-copy` on the immutable document. + If allocator is NULL, the default allocator will be used. + @note `imut_doc` -> `mut_doc`. */ +yyjson_api yyjson_mut_doc *yyjson_doc_mut_copy(yyjson_doc *doc, + const yyjson_alc *alc); + +/** Copies and returns a new mutable document from input, returns NULL on error. + This makes a `deep-copy` on the mutable document. + If allocator is NULL, the default allocator will be used. + @note `mut_doc` -> `mut_doc`. */ +yyjson_api yyjson_mut_doc *yyjson_mut_doc_mut_copy(yyjson_mut_doc *doc, + const yyjson_alc *alc); + +/** Copies and returns a new mutable value from input, returns NULL on error. + This makes a `deep-copy` on the immutable value. + The memory was managed by mutable document. + @note `imut_val` -> `mut_val`. */ +yyjson_api yyjson_mut_val *yyjson_val_mut_copy(yyjson_mut_doc *doc, + yyjson_val *val); + +/** Copies and returns a new mutable value from input, returns NULL on error. + This makes a `deep-copy` on the mutable value. + The memory was managed by mutable document. + @note `mut_val` -> `mut_val`. + @warning This function is recursive and may cause a stack overflow + if the object level is too deep. */ +yyjson_api yyjson_mut_val *yyjson_mut_val_mut_copy(yyjson_mut_doc *doc, + yyjson_mut_val *val); + +/** Copies and returns a new immutable document from input, + returns NULL on error. This makes a `deep-copy` on the mutable document. + The returned document should be freed with `yyjson_doc_free()`. + @note `mut_doc` -> `imut_doc`. + @warning This function is recursive and may cause a stack overflow + if the object level is too deep. */ +yyjson_api yyjson_doc *yyjson_mut_doc_imut_copy(yyjson_mut_doc *doc, + const yyjson_alc *alc); + +/** Copies and returns a new immutable document from input, + returns NULL on error. This makes a `deep-copy` on the mutable value. + The returned document should be freed with `yyjson_doc_free()`. + @note `mut_val` -> `imut_doc`. + @warning This function is recursive and may cause a stack overflow + if the object level is too deep. */ +yyjson_api yyjson_doc *yyjson_mut_val_imut_copy(yyjson_mut_val *val, + const yyjson_alc *alc); + + + +/*============================================================================== + * Mutable JSON Value Type API + *============================================================================*/ + +/** Returns whether the JSON value is raw. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val); + +/** Returns whether the JSON value is `null`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val); + +/** Returns whether the JSON value is `true`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val); + +/** Returns whether the JSON value is `false`. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val); + +/** Returns whether the JSON value is bool (true/false). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val); + +/** Returns whether the JSON value is unsigned integer (uint64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val); + +/** Returns whether the JSON value is signed integer (int64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val); + +/** Returns whether the JSON value is integer (uint64_t/int64_t). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val); + +/** Returns whether the JSON value is real number (double). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val); + +/** Returns whether the JSON value is number (uint/sint/real). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val); + +/** Returns whether the JSON value is string. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val); + +/** Returns whether the JSON value is array. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val); + +/** Returns whether the JSON value is object. + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val); + +/** Returns whether the JSON value is container (array/object). + Returns false if `val` is NULL. */ +yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val); + + + +/*============================================================================== + * Mutable JSON Value Content API + *============================================================================*/ + +/** Returns the JSON value's type. + Returns `YYJSON_TYPE_NONE` if `val` is NULL. */ +yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val); + +/** Returns the JSON value's subtype. + Returns `YYJSON_SUBTYPE_NONE` if `val` is NULL. */ +yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val); + +/** Returns the JSON value's tag. + Returns 0 if `val` is NULL. */ +yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val); + +/** Returns the JSON value's type description. + The return value should be one of these strings: "raw", "null", "string", + "array", "object", "true", "false", "uint", "sint", "real", "unknown". */ +yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val); + +/** Returns the content if the value is raw. + Returns NULL if `val` is NULL or type is not raw. */ +yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val); + +/** Returns the content if the value is bool. + Returns NULL if `val` is NULL or type is not bool. */ +yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val); + +/** Returns the content and cast to uint64_t. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val); + +/** Returns the content and cast to int64_t. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val); + +/** Returns the content and cast to int. + Returns 0 if `val` is NULL or type is not integer(sint/uint). */ +yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val); + +/** Returns the content if the value is real number. + Returns 0.0 if `val` is NULL or type is not real(double). */ +yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val); + +/** Returns the content and typecast to `double` if the value is number. + Returns 0.0 if `val` is NULL or type is not number(uint/sint/real). */ +yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val); + +/** Returns the content if the value is string. + Returns NULL if `val` is NULL or type is not string. */ +yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val); + +/** Returns the content length (string length, array size, object size. + Returns 0 if `val` is NULL or type is not string/array/object. */ +yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val); + +/** Returns whether the JSON value is equals to a string. + The `str` should be a null-terminated UTF-8 string. + Returns false if input is NULL or type is not string. */ +yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val, + const char *str); + +/** Returns whether the JSON value is equals to a string. + The `str` should be a UTF-8 string, null-terminator is not required. + Returns false if input is NULL or type is not string. */ +yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val, + const char *str, size_t len); + +/** Returns whether two JSON values are equal (deep compare). + Returns false if input is NULL. + @note the result may be inaccurate if object has duplicate keys. + @warning This function is recursive and may cause a stack overflow + if the object level is too deep. */ +yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs, + yyjson_mut_val *rhs); + +/** Set the value to raw. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val, + const char *raw, size_t len); + +/** Set the value to null. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val); + +/** Set the value to bool. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num); + +/** Set the value to uint. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num); + +/** Set the value to sint. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num); + +/** Set the value to int. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num); + +/** Set the value to real. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num); + +/** Set the value to string (null-terminated). + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val, const char *str); + +/** Set the value to string (with length). + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val, + const char *str, size_t len); + +/** Set the value to array. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val); + +/** Set the value to array. + Returns false if input is NULL. + @warning This function should not be used on an existing object or array. */ +yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val); + + + +/*============================================================================== + * Mutable JSON Value Creation API + *============================================================================*/ + +/** Creates and returns a raw value, returns NULL on error. + The `str` should be a null-terminated UTF-8 string. + + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc, + const char *str); + +/** Creates and returns a raw value, returns NULL on error. + The `str` should be a UTF-8 string, null-terminator is not required. + + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc, + const char *str, + size_t len); + +/** Creates and returns a raw value, returns NULL on error. + The `str` should be a null-terminated UTF-8 string. + The input string is copied and held by the document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc, + const char *str); + +/** Creates and returns a raw value, returns NULL on error. + The `str` should be a UTF-8 string, null-terminator is not required. + The input string is copied and held by the document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc, + const char *str, + size_t len); + +/** Creates and returns a null value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc); + +/** Creates and returns a true value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc); + +/** Creates and returns a false value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc); + +/** Creates and returns a bool value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc, + bool val); + +/** Creates and returns an unsigned integer value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc, + uint64_t num); + +/** Creates and returns a signed integer value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc, + int64_t num); + +/** Creates and returns a signed integer value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc, + int64_t num); + +/** Creates and returns an real number value, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc, + double num); + +/** Creates and returns a string value, returns NULL on error. + The `str` should be a null-terminated UTF-8 string. + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc, + const char *str); + +/** Creates and returns a string value, returns NULL on error. + The `str` should be a UTF-8 string, null-terminator is not required. + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc, + const char *str, + size_t len); + +/** Creates and returns a string value, returns NULL on error. + The `str` should be a null-terminated UTF-8 string. + The input string is copied and held by the document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc, + const char *str); + +/** Creates and returns a string value, returns NULL on error. + The `str` should be a UTF-8 string, null-terminator is not required. + The input string is copied and held by the document. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc, + const char *str, + size_t len); + + + +/*============================================================================== + * Mutable JSON Array API + *============================================================================*/ + +/** Returns the number of elements in this array. + Returns 0 if `arr` is NULL or type is not array. */ +yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr); + +/** Returns the element at the specified position in this array. + Returns NULL if array is NULL/empty or the index is out of bounds. + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr, + size_t idx); + +/** Returns the first element of this array. + Returns NULL if `arr` is NULL/empty or type is not array. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first(yyjson_mut_val *arr); + +/** Returns the last element of this array. + Returns NULL if `arr` is NULL/empty or type is not array. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last(yyjson_mut_val *arr); + + + +/*============================================================================== + * Mutable JSON Array Iterator API + *============================================================================*/ + +/** + A mutable JSON array iterator. + + @warning You should not modify the array while iterating over it, but you can + use `yyjson_mut_arr_iter_remove()` to remove current value. + + @par Example + @code + yyjson_mut_val *val; + yyjson_mut_arr_iter iter = yyjson_mut_arr_iter_with(arr); + while ((val = yyjson_mut_arr_iter_next(&iter))) { + your_func(val); + if (your_val_is_unused(val)) { + yyjson_mut_arr_iter_remove(&iter); + } + } + @endcode + */ +typedef struct yyjson_mut_arr_iter { + size_t idx; /**< next value's index */ + size_t max; /**< maximum index (arr.size) */ + yyjson_mut_val *cur; /**< current value */ + yyjson_mut_val *pre; /**< previous value */ + yyjson_mut_val *arr; /**< the array being iterated */ +} yyjson_mut_arr_iter; + +/** + Initialize an iterator for this array. + + @param arr The array to be iterated over. + If this parameter is NULL or not an array, `iter` will be set to empty. + @param iter The iterator to be initialized. + If this parameter is NULL, the function will fail and return false. + @return true if the `iter` has been successfully initialized. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr, + yyjson_mut_arr_iter *iter); + +/** + Create an iterator with an array , same as `yyjson_mut_arr_iter_init()`. + + @param arr The array to be iterated over. + If this parameter is NULL or not an array, an empty iterator will returned. + @return A new iterator for the array. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with( + yyjson_mut_val *arr); + +/** + Returns whether the iteration has more elements. + If `iter` is NULL, this function will return false. + */ +yyjson_api_inline bool yyjson_mut_arr_iter_has_next( + yyjson_mut_arr_iter *iter); + +/** + Returns the next element in the iteration, or NULL on end. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next( + yyjson_mut_arr_iter *iter); + +/** + Removes and returns current element in the iteration. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove( + yyjson_mut_arr_iter *iter); + +/** + Macro for iterating over an array. + It works like iterator, but with a more intuitive API. + + @warning You should not modify the array while iterating over it. + + @par Example + @code + size_t idx, max; + yyjson_mut_val *val; + yyjson_mut_arr_foreach(arr, idx, max, val) { + your_func(idx, val); + } + @endcode + */ +#define yyjson_mut_arr_foreach(arr, idx, max, val) \ + for ((idx) = 0, \ + (max) = yyjson_mut_arr_size(arr), \ + (val) = yyjson_mut_arr_get_first(arr); \ + (idx) < (max); \ + (idx)++, \ + (val) = (val)->next) + + + +/*============================================================================== + * Mutable JSON Array Creation API + *============================================================================*/ + +/** + Creates and returns an empty mutable array. + @param doc A mutable document, used for memory allocation only. + @return The new array. NULL if input is NULL or memory allocation failed. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc); + +/** + Creates and returns a new mutable array with the given boolean values. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of boolean values. + @param count The value count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const bool vals[3] = { true, false, true }; + yyjson_mut_val *arr = yyjson_mut_arr_with_bool(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool( + yyjson_mut_doc *doc, const bool *vals, size_t count); + +/** + Creates and returns a new mutable array with the given sint numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of sint numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const int64_t vals[3] = { -1, 0, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint( + yyjson_mut_doc *doc, const int64_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given uint numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of uint numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const uint64_t vals[3] = { 0, 1, 0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_uint(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint( + yyjson_mut_doc *doc, const uint64_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given real numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of real numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const double vals[3] = { 0.1, 0.2, 0.3 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_real(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real( + yyjson_mut_doc *doc, const double *vals, size_t count); + +/** + Creates and returns a new mutable array with the given int8 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of int8 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const int8_t vals[3] = { -1, 0, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_sint8(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8( + yyjson_mut_doc *doc, const int8_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given int16 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of int16 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const int16_t vals[3] = { -1, 0, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_sint16(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16( + yyjson_mut_doc *doc, const int16_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given int32 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of int32 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const int32_t vals[3] = { -1, 0, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_sint32(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32( + yyjson_mut_doc *doc, const int32_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given int64 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of int64 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const int64_t vals[3] = { -1, 0, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_sint64(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64( + yyjson_mut_doc *doc, const int64_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given uint8 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of uint8 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const uint8_t vals[3] = { 0, 1, 0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_uint8(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8( + yyjson_mut_doc *doc, const uint8_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given uint16 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of uint16 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const uint16_t vals[3] = { 0, 1, 0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_uint16(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16( + yyjson_mut_doc *doc, const uint16_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given uint32 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of uint32 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const uint32_t vals[3] = { 0, 1, 0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_uint32(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32( + yyjson_mut_doc *doc, const uint32_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given uint64 numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of uint64 numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const uint64_t vals[3] = { 0, 1, 0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_uint64(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64( + yyjson_mut_doc *doc, const uint64_t *vals, size_t count); + +/** + Creates and returns a new mutable array with the given float numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of float numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const float vals[3] = { -1.0f, 0.0f, 1.0f }; + yyjson_mut_val *arr = yyjson_mut_arr_with_float(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float( + yyjson_mut_doc *doc, const float *vals, size_t count); + +/** + Creates and returns a new mutable array with the given double numbers. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of double numbers. + @param count The number count. If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const double vals[3] = { -1.0, 0.0, 1.0 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_double(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double( + yyjson_mut_doc *doc, const double *vals, size_t count); + +/** + Creates and returns a new mutable array with the given strings, these strings + will not be copied. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of UTF-8 null-terminator strings. + If this array contains NULL, the function will fail and return NULL. + @param count The number of values in `vals`. + If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @warning The input strings are not copied, you should keep these strings + unmodified for the lifetime of this JSON document. If these strings will be + modified, you should use `yyjson_mut_arr_with_strcpy()` instead. + + @par Example + @code + const char *vals[3] = { "a", "b", "c" }; + yyjson_mut_val *arr = yyjson_mut_arr_with_str(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str( + yyjson_mut_doc *doc, const char **vals, size_t count); + +/** + Creates and returns a new mutable array with the given strings and string + lengths, these strings will not be copied. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of UTF-8 strings, null-terminator is not required. + If this array contains NULL, the function will fail and return NULL. + @param lens A C array of string lengths, in bytes. + @param count The number of strings in `vals`. + If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @warning The input strings are not copied, you should keep these strings + unmodified for the lifetime of this JSON document. If these strings will be + modified, you should use `yyjson_mut_arr_with_strncpy()` instead. + + @par Example + @code + const char *vals[3] = { "a", "bb", "c" }; + const size_t lens[3] = { 1, 2, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn( + yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count); + +/** + Creates and returns a new mutable array with the given strings, these strings + will be copied. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of UTF-8 null-terminator strings. + If this array contains NULL, the function will fail and return NULL. + @param count The number of values in `vals`. + If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const char *vals[3] = { "a", "b", "c" }; + yyjson_mut_val *arr = yyjson_mut_arr_with_strcpy(doc, vals, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy( + yyjson_mut_doc *doc, const char **vals, size_t count); + +/** + Creates and returns a new mutable array with the given strings and string + lengths, these strings will be copied. + + @param doc A mutable document, used for memory allocation only. + If this parameter is NULL, the function will fail and return NULL. + @param vals A C array of UTF-8 strings, null-terminator is not required. + If this array contains NULL, the function will fail and return NULL. + @param lens A C array of string lengths, in bytes. + @param count The number of strings in `vals`. + If this value is 0, an empty array will return. + @return The new array. NULL if input is invalid or memory allocation failed. + + @par Example + @code + const char *vals[3] = { "a", "bb", "c" }; + const size_t lens[3] = { 1, 2, 1 }; + yyjson_mut_val *arr = yyjson_mut_arr_with_strn(doc, vals, lens, 3); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy( + yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count); + + + +/*============================================================================== + * Mutable JSON Array Modification API + *============================================================================*/ + +/** + Inserts a value into an array at a given index. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param val The value to be inserted. Returns false if it is NULL. + @param idx The index to which to insert the new value. + Returns false if the index is out of range. + @return Whether successful. + @warning This function takes a linear search time. + */ +yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr, + yyjson_mut_val *val, size_t idx); + +/** + Inserts a value at the end of the array. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param val The value to be inserted. Returns false if it is NULL. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr, + yyjson_mut_val *val); + +/** + Inserts a value at the head of the array. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param val The value to be inserted. Returns false if it is NULL. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr, + yyjson_mut_val *val); + +/** + Replaces a value at index and returns old value. + @param arr The array to which the value is to be replaced. + Returns false if it is NULL or not an array. + @param idx The index to which to replace the value. + Returns false if the index is out of range. + @param val The new value to replace. Returns false if it is NULL. + @return Old value, or NULL on error. + @warning This function takes a linear search time. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr, + size_t idx, + yyjson_mut_val *val); + +/** + Removes and returns a value at index. + @param arr The array from which the value is to be removed. + Returns false if it is NULL or not an array. + @param idx The index from which to remove the value. + Returns false if the index is out of range. + @return Old value, or NULL on error. + @warning This function takes a linear search time. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr, + size_t idx); + +/** + Removes and returns the first value in this array. + @param arr The array from which the value is to be removed. + Returns false if it is NULL or not an array. + @return The first value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first( + yyjson_mut_val *arr); + +/** + Removes and returns the last value in this array. + @param arr The array from which the value is to be removed. + Returns false if it is NULL or not an array. + @return The last value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last( + yyjson_mut_val *arr); + +/** + Removes all values within a specified range in the array. + @param arr The array from which the value is to be removed. + Returns false if it is NULL or not an array. + @param idx The start index of the range (0 is the first). + @param len The number of items in the range (can be 0). + @return Whether successful. + @warning This function takes a linear search time. + */ +yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr, + size_t idx, size_t len); + +/** + Removes all values in this array. + @param arr The array from which all of the values are to be removed. + Returns false if it is NULL or not an array. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr); + +/** + Rotates values in this array for the given number of times. + For example: `[1,2,3,4,5]` rotate 2 is `[3,4,5,1,2]`. + @param arr The array to be rotated. + @param idx Index (or times) to rotate. + @warning This function takes a linear search time. + */ +yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr, + size_t idx); + + + +/*============================================================================== + * Mutable JSON Array Modification Convenience API + *============================================================================*/ + +/** + Adds a value at the end of the array. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param val The value to be inserted. Returns false if it is NULL. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr, + yyjson_mut_val *val); + +/** + Adds a `null` value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc, + yyjson_mut_val *arr); + +/** + Adds a `true` value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc, + yyjson_mut_val *arr); + +/** + Adds a `false` value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc, + yyjson_mut_val *arr); + +/** + Adds a bool value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param val The bool value to be added. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + bool val); + +/** + Adds an unsigned integer value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param num The number to be added. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + uint64_t num); + +/** + Adds a signed integer value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param num The number to be added. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + int64_t num); + +/** + Adds a integer value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param num The number to be added. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + int64_t num); + +/** + Adds a double value at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param num The number to be added. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + double num); + +/** + Adds a string value at the end of the array (no copy). + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param str A null-terminated UTF-8 string. + @return Whether successful. + @warning The input string is not copied, you should keep this string unmodified + for the lifetime of this JSON document. + */ +yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str); + +/** + Adds a string value at the end of the array (no copy). + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param str A UTF-8 string, null-terminator is not required. + @param len The length of the string, in bytes. + @return Whether successful. + @warning The input string is not copied, you should keep this string unmodified + for the lifetime of this JSON document. + */ +yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str, + size_t len); + +/** + Adds a string value at the end of the array (copied). + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param str A null-terminated UTF-8 string. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str); + +/** + Adds a string value at the end of the array (copied). + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @param str A UTF-8 string, null-terminator is not required. + @param len The length of the string, in bytes. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str, + size_t len); + +/** + Creates and adds a new array at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @return The new array, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc, + yyjson_mut_val *arr); + +/** + Creates and adds a new object at the end of the array. + @param doc The `doc` is only used for memory allocation. + @param arr The array to which the value is to be inserted. + Returns false if it is NULL or not an array. + @return The new object, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc, + yyjson_mut_val *arr); + + + +/*============================================================================== + * Mutable JSON Object API + *============================================================================*/ + +/** Returns the number of key-value pairs in this object. + Returns 0 if `obj` is NULL or type is not object. */ +yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj); + +/** Returns the value to which the specified key is mapped. + Returns NULL if this object contains no mapping for the key. + Returns NULL if `obj/key` is NULL, or type is not object. + + The `key` should be a null-terminated UTF-8 string. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj, + const char *key); + +/** Returns the value to which the specified key is mapped. + Returns NULL if this object contains no mapping for the key. + Returns NULL if `obj/key` is NULL, or type is not object. + + The `key` should be a UTF-8 string, null-terminator is not required. + The `key_len` should be the length of the key, in bytes. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj, + const char *key, + size_t key_len); + + + +/*============================================================================== + * Mutable JSON Object Iterator API + *============================================================================*/ + +/** + A mutable JSON object iterator. + + @warning You should not modify the object while iterating over it, but you can + use `yyjson_mut_obj_iter_remove()` to remove current value. + + @par Example + @code + yyjson_mut_val *key, *val; + yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj); + while ((key = yyjson_mut_obj_iter_next(&iter))) { + val = yyjson_mut_obj_iter_get_val(key); + your_func(key, val); + if (your_val_is_unused(key, val)) { + yyjson_mut_obj_iter_remove(&iter); + } + } + @endcode + + If the ordering of the keys is known at compile-time, you can use this method + to speed up value lookups: + @code + // {"k1":1, "k2": 3, "k3": 3} + yyjson_mut_val *key, *val; + yyjson_mut_obj_iter iter = yyjson_mut_obj_iter_with(obj); + yyjson_mut_val *v1 = yyjson_mut_obj_iter_get(&iter, "k1"); + yyjson_mut_val *v3 = yyjson_mut_obj_iter_get(&iter, "k3"); + @endcode + @see `yyjson_mut_obj_iter_get()` and `yyjson_mut_obj_iter_getn()` + */ +typedef struct yyjson_mut_obj_iter { + size_t idx; /**< next key's index */ + size_t max; /**< maximum key index (obj.size) */ + yyjson_mut_val *cur; /**< current key */ + yyjson_mut_val *pre; /**< previous key */ + yyjson_mut_val *obj; /**< the object being iterated */ +} yyjson_mut_obj_iter; + +/** + Initialize an iterator for this object. + + @param obj The object to be iterated over. + If this parameter is NULL or not an array, `iter` will be set to empty. + @param iter The iterator to be initialized. + If this parameter is NULL, the function will fail and return false. + @return true if the `iter` has been successfully initialized. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj, + yyjson_mut_obj_iter *iter); + +/** + Create an iterator with an object, same as `yyjson_obj_iter_init()`. + + @param obj The object to be iterated over. + If this parameter is NULL or not an object, an empty iterator will returned. + @return A new iterator for the object. + + @note The iterator does not need to be destroyed. + */ +yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with( + yyjson_mut_val *obj); + +/** + Returns whether the iteration has more elements. + If `iter` is NULL, this function will return false. + */ +yyjson_api_inline bool yyjson_mut_obj_iter_has_next( + yyjson_mut_obj_iter *iter); + +/** + Returns the next key in the iteration, or NULL on end. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next( + yyjson_mut_obj_iter *iter); + +/** + Returns the value for key inside the iteration. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val( + yyjson_mut_val *key); + +/** + Removes current key-value pair in the iteration, returns the removed value. + If `iter` is NULL, this function will return NULL. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove( + yyjson_mut_obj_iter *iter); + +/** + Iterates to a specified key and returns the value. + + This function does the same thing as `yyjson_mut_obj_get()`, but is much faster + if the ordering of the keys is known at compile-time and you are using the same + order to look up the values. If the key exists in this object, then the + iterator will stop at the next key, otherwise the iterator will not change and + NULL is returned. + + @param iter The object iterator, should not be NULL. + @param key The key, should be a UTF-8 string with null-terminator. + @return The value to which the specified key is mapped. + NULL if this object contains no mapping for the key or input is invalid. + + @warning This function takes a linear search time if the key is not nearby. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get( + yyjson_mut_obj_iter *iter, const char *key); + +/** + Iterates to a specified key and returns the value. + + This function does the same thing as `yyjson_mut_obj_getn()` but is much faster + if the ordering of the keys is known at compile-time and you are using the same + order to look up the values. If the key exists in this object, then the + iterator will stop at the next key, otherwise the iterator will not change and + NULL is returned. + + @param iter The object iterator, should not be NULL. + @param key The key, should be a UTF-8 string, null-terminator is not required. + @param key_len The the length of `key`, in bytes. + @return The value to which the specified key is mapped. + NULL if this object contains no mapping for the key or input is invalid. + + @warning This function takes a linear search time if the key is not nearby. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn( + yyjson_mut_obj_iter *iter, const char *key, size_t key_len); + +/** + Macro for iterating over an object. + It works like iterator, but with a more intuitive API. + + @warning You should not modify the object while iterating over it. + + @par Example + @code + size_t idx, max; + yyjson_val *key, *val; + yyjson_obj_foreach(obj, idx, max, key, val) { + your_func(key, val); + } + @endcode + */ +#define yyjson_mut_obj_foreach(obj, idx, max, key, val) \ + for ((idx) = 0, \ + (max) = yyjson_mut_obj_size(obj), \ + (key) = (max) ? ((yyjson_mut_val *)(obj)->uni.ptr)->next->next : NULL, \ + (val) = (key) ? (key)->next : NULL; \ + (idx) < (max); \ + (idx)++, \ + (key) = (val)->next, \ + (val) = (key)->next) + + + +/*============================================================================== + * Mutable JSON Object Creation API + *============================================================================*/ + +/** Creates and returns a mutable object, returns NULL on error. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc); + +/** + Creates and returns a mutable object with keys and values, returns NULL on + error. The keys and values are not copied. The strings should be a + null-terminated UTF-8 string. + + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. + + @par Example + @code + const char *keys[2] = { "id", "name" }; + const char *vals[2] = { "01", "Harry" }; + yyjson_mut_val *obj = yyjson_mut_obj_with_str(doc, keys, vals, 2); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc, + const char **keys, + const char **vals, + size_t count); + +/** + Creates and returns a mutable object with key-value pairs and pair count, + returns NULL on error. The keys and values are not copied. The strings should + be a null-terminated UTF-8 string. + + @warning The input string is not copied, you should keep this string + unmodified for the lifetime of this JSON document. + + @par Example + @code + const char *kv_pairs[4] = { "id", "01", "name", "Harry" }; + yyjson_mut_val *obj = yyjson_mut_obj_with_kv(doc, kv_pairs, 2); + @endcode + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc, + const char **kv_pairs, + size_t pair_count); + + + +/*============================================================================== + * Mutable JSON Object Modification API + *============================================================================*/ + +/** + Adds a key-value pair at the end of the object. + This function allows duplicated key in one object. + @param obj The object to which the new key-value pair is to be added. + @param key The key, should be a string which is created by `yyjson_mut_str()`, + `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`. + @param val The value to add to the object. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val); +/** + Sets a key-value pair at the end of the object. + This function may remove all key-value pairs for the given key before add. + @param obj The object to which the new key-value pair is to be added. + @param key The key, should be a string which is created by `yyjson_mut_str()`, + `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`. + @param val The value to add to the object. If this value is null, the behavior + is same as `yyjson_mut_obj_remove()`. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val); + +/** + Inserts a key-value pair to the object at the given position. + This function allows duplicated key in one object. + @param obj The object to which the new key-value pair is to be added. + @param key The key, should be a string which is created by `yyjson_mut_str()`, + `yyjson_mut_strn()`, `yyjson_mut_strcpy()` or `yyjson_mut_strncpy()`. + @param val The value to add to the object. + @param idx The index to which to insert the new pair. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val, + size_t idx); + +/** + Removes all key-value pair from the object with given key. + @param obj The object from which the key-value pair is to be removed. + @param key The key, should be a string value. + @return The first matched value, or NULL if no matched value. + @warning This function takes a linear search time. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj, + yyjson_mut_val *key); + +/** + Removes all key-value pair from the object with given key. + @param obj The object from which the key-value pair is to be removed. + @param key The key, should be a UTF-8 string with null-terminator. + @return The first matched value, or NULL if no matched value. + @warning This function takes a linear search time. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key( + yyjson_mut_val *obj, const char *key); + +/** + Removes all key-value pair from the object with given key. + @param obj The object from which the key-value pair is to be removed. + @param key The key, should be a UTF-8 string, null-terminator is not required. + @param key_len The length of the key. + @return The first matched value, or NULL if no matched value. + @warning This function takes a linear search time. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn( + yyjson_mut_val *obj, const char *key, size_t key_len); + +/** + Removes all key-value pairs in this object. + @param obj The object from which all of the values are to be removed. + @return Whether successful. + */ +yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj); + +/** + Replaces value from the object with given key. + If the key is not exist, or the value is NULL, it will fail. + @param obj The object to which the value is to be replaced. + @param key The key, should be a string value. + @param val The value to replace into the object. + @return Whether successful. + @warning This function takes a linear search time. + */ +yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val); + +/** + Rotates key-value pairs in the object for the given number of times. + For example: `{"a":1,"b":2,"c":3,"d":4}` rotate 1 is + `{"b":2,"c":3,"d":4,"a":1}`. + @param obj The object to be rotated. + @param idx Index (or times) to rotate. + @return Whether successful. + @warning This function takes a linear search time. + */ +yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj, + size_t idx); + + + +/*============================================================================== + * Mutable JSON Object Modification Convenience API + *============================================================================*/ + +/** Adds a `null` value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key); + +/** Adds a `true` value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key); + +/** Adds a `false` value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key); + +/** Adds a bool value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, bool val); + +/** Adds an unsigned integer value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, uint64_t val); + +/** Adds a signed integer value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, int64_t val); + +/** Adds an int value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, int64_t val); + +/** Adds a double value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, double val); + +/** Adds a string value at the end of the object. + The `key` and `val` should be null-terminated UTF-8 strings. + This function allows duplicated key in one object. + + @warning The key/value string are not copied, you should keep these strings + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, const char *val); + +/** Adds a string value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + The `val` should be a UTF-8 string, null-terminator is not required. + The `len` should be the length of the `val`, in bytes. + This function allows duplicated key in one object. + + @warning The key/value string are not copied, you should keep these strings + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + const char *val, size_t len); + +/** Adds a string value at the end of the object. + The `key` and `val` should be null-terminated UTF-8 strings. + The value string is copied. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + const char *val); + +/** Adds a string value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + The `val` should be a UTF-8 string, null-terminator is not required. + The `len` should be the length of the `val`, in bytes. + This function allows duplicated key in one object. + + @warning The key/value string are not copied, you should keep these strings + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + const char *val, size_t len); + +/** Adds a JSON value at the end of the object. + The `key` should be a null-terminated UTF-8 string. + This function allows duplicated key in one object. + + @warning The key string are not copied, you should keep the string + unmodified for the lifetime of this JSON document. */ +yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + yyjson_mut_val *val); + +/** Removes all key-value pairs for the given key. + Returns the first value to which the specified key is mapped or NULL if this + object contains no mapping for the key. + The `key` should be a null-terminated UTF-8 string. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str( + yyjson_mut_val *obj, const char *key); + +/** Removes all key-value pairs for the given key. + Returns the first value to which the specified key is mapped or NULL if this + object contains no mapping for the key. + The `key` should be a UTF-8 string, null-terminator is not required. + The `len` should be the length of the key, in bytes. + + @warning This function takes a linear search time. */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn( + yyjson_mut_val *obj, const char *key, size_t len); + +/** Replaces all matching keys with the new key. + Returns true if at least one key was renamed. + The `key` and `new_key` should be a null-terminated UTF-8 string. + The `new_key` is copied and held by doc. + + @warning This function takes a linear search time. + If `new_key` already exists, it will cause duplicate keys. + */ +yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + const char *new_key); + +/** Replaces all matching keys with the new key. + Returns true if at least one key was renamed. + The `key` and `new_key` should be a UTF-8 string, + null-terminator is not required. The `new_key` is copied and held by doc. + + @warning This function takes a linear search time. + If `new_key` already exists, it will cause duplicate keys. + */ +yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + size_t len, + const char *new_key, + size_t new_len); + + + +/*============================================================================== + * JSON Pointer API (RFC 6901) + * https://tools.ietf.org/html/rfc6901 + *============================================================================*/ + +/** JSON Pointer error code. */ +typedef uint32_t yyjson_ptr_code; + +/** No JSON pointer error. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_NONE = 0; + +/** Invalid input parameter, such as NULL input. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_PARAMETER = 1; + +/** JSON pointer syntax error, such as invalid escape, token no prefix. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_SYNTAX = 2; + +/** JSON pointer resolve failed, such as index out of range, key not found. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_RESOLVE = 3; + +/** Document's root is NULL, but it is required for the function call. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_NULL_ROOT = 4; + +/** Cannot set root as the target is not a document. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_SET_ROOT = 5; + +/** The memory allocation failed and a new value could not be created. */ +static const yyjson_ptr_code YYJSON_PTR_ERR_MEMORY_ALLOCATION = 6; + +/** Error information for JSON pointer. */ +typedef struct yyjson_ptr_err { + /** Error code, see `yyjson_ptr_code` for all possible values. */ + yyjson_ptr_code code; + /** Error message, constant, no need to free (NULL if no error). */ + const char *msg; + /** Error byte position for input JSON pointer (0 if no error). */ + size_t pos; +} yyjson_ptr_err; + +/** + A context for JSON pointer operation. + + This struct stores the context of JSON Pointer operation result. The struct + can be used with three helper functions: `ctx_append()`, `ctx_replace()`, and + `ctx_remove()`, which perform the corresponding operations on the container + without re-parsing the JSON Pointer. + + For example: + @code + // doc before: {"a":[0,1,null]} + // ptr: "/a/2" + val = yyjson_mut_doc_ptr_getx(doc, ptr, strlen(ptr), &ctx, &err); + if (yyjson_is_null(val)) { + yyjson_ptr_ctx_remove(&ctx); + } + // doc after: {"a":[0,1]} + @endcode + */ +typedef struct yyjson_ptr_ctx { + /** + The container (parent) of the target value. It can be either an array or + an object. If the target location has no value, but all its parent + containers exist, and the target location can be used to insert a new + value, then `ctn` is the parent container of the target location. + Otherwise, `ctn` is NULL. + */ + yyjson_mut_val *ctn; + /** + The previous sibling of the target value. It can be either a value in an + array or a key in an object. As the container is a `circular linked list` + of elements, `pre` is the previous node of the target value. If the + operation is `add` or `set`, then `pre` is the previous node of the new + value, not the original target value. If the target value does not exist, + `pre` is NULL. + */ + yyjson_mut_val *pre; + /** + The removed value if the operation is `set`, `replace` or `remove`. It can + be used to restore the original state of the document if needed. + */ + yyjson_mut_val *old; +} yyjson_ptr_ctx; + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc, + const char *ptr); + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc, + const char *ptr, size_t len); + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param err A pointer to store the error information, or NULL if not needed. + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc, + const char *ptr, size_t len, + yyjson_ptr_err *err); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val, + const char *ptr); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val, + const char *ptr, size_t len); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param err A pointer to store the error information, or NULL if not needed. + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val, + const char *ptr, size_t len, + yyjson_ptr_err *err); + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc, + const char *ptr); + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc, + const char *ptr, + size_t len); + +/** + Get value by a JSON Pointer. + @param doc The JSON document to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The value referenced by the JSON pointer. + NULL if `doc` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val, + const char *ptr); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val, + const char *ptr, + size_t len); + +/** + Get value by a JSON Pointer. + @param val The JSON value to be queried. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The value referenced by the JSON pointer. + NULL if `val` or `ptr` is NULL, or the JSON pointer cannot be resolved. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Add (insert) value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param new_val The value to be added. + @return true if JSON pointer is valid and new value is added, false otherwise. + @note The parent nodes will be created if they do not exist. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc, + const char *ptr, + yyjson_mut_val *new_val); + +/** + Add (insert) value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be added. + @return true if JSON pointer is valid and new value is added, false otherwise. + @note The parent nodes will be created if they do not exist. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val); + +/** + Add (insert) value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be added. + @param create_parent Whether to create parent nodes if not exist. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return true if JSON pointer is valid and new value is added, false otherwise. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Add (insert) value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param doc Only used to create new values when needed. + @param new_val The value to be added. + @return true if JSON pointer is valid and new value is added, false otherwise. + @note The parent nodes will be created if they do not exist. + */ +yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val, + const char *ptr, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc); + +/** + Add (insert) value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param doc Only used to create new values when needed. + @param new_val The value to be added. + @return true if JSON pointer is valid and new value is added, false otherwise. + @note The parent nodes will be created if they do not exist. + */ +yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc); + +/** + Add (insert) value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param doc Only used to create new values when needed. + @param new_val The value to be added. + @param create_parent Whether to create parent nodes if not exist. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return true if JSON pointer is valid and new value is added, false otherwise. + */ +yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Set value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param new_val The value to be set, pass NULL to remove. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note The parent nodes will be created if they do not exist. + If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc, + const char *ptr, + yyjson_mut_val *new_val); + +/** + Set value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be set, pass NULL to remove. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note The parent nodes will be created if they do not exist. + If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val); + +/** + Set value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be set, pass NULL to remove. + @param create_parent Whether to create parent nodes if not exist. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Set value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param new_val The value to be set, pass NULL to remove. + @param doc Only used to create new values when needed. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note The parent nodes will be created if they do not exist. + If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val, + const char *ptr, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc); + +/** + Set value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be set, pass NULL to remove. + @param doc Only used to create new values when needed. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note The parent nodes will be created if they do not exist. + If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc); + +/** + Set value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The value to be set, pass NULL to remove. + @param doc Only used to create new values when needed. + @param create_parent Whether to create parent nodes if not exist. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return true if JSON pointer is valid and new value is set, false otherwise. + @note If the target value already exists, it will be replaced by the new value. + */ +yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Replace value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param new_val The new value to replace the old one. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace( + yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val); + +/** + Replace value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The new value to replace the old one. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen( + yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val); + +/** + Replace value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The new value to replace the old one. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex( + yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err); + +/** + Replace value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @param new_val The new value to replace the old one. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace( + yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val); + +/** + Replace value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The new value to replace the old one. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val); + +/** + Replace value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param new_val The new value to replace the old one. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The old value that was replaced, or NULL if not found. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err); + +/** + Remove value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove( + yyjson_mut_doc *doc, const char *ptr); + +/** + Remove value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen( + yyjson_mut_doc *doc, const char *ptr, size_t len); + +/** + Remove value by a JSON pointer. + @param doc The target JSON document. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex( + yyjson_mut_doc *doc, const char *ptr, size_t len, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err); + +/** + Remove value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8 with null-terminator). + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val, + const char *ptr); + +/** + Remove value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val, + const char *ptr, + size_t len); + +/** + Remove value by a JSON pointer. + @param val The target JSON value. + @param ptr The JSON pointer string (UTF-8, null-terminator is not required). + @param len The length of `ptr` in bytes. + @param ctx A pointer to store the result context, or NULL if not needed. + @param err A pointer to store the error information, or NULL if not needed. + @return The removed value, or NULL on error. + */ +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/** + Append value by JSON pointer context. + @param ctx The context from the `yyjson_mut_ptr_xxx()` calls. + @param key New key if `ctx->ctn` is object, or NULL if `ctx->ctn` is array. + @param val New value to be added. + @return true on success or false on fail. + */ +yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx, + yyjson_mut_val *key, + yyjson_mut_val *val); + +/** + Replace value by JSON pointer context. + @param ctx The context from the `yyjson_mut_ptr_xxx()` calls. + @param val New value to be replaced. + @return true on success or false on fail. + @note If success, the old value will be returned via `ctx->old`. + */ +yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx, + yyjson_mut_val *val); + +/** + Remove value by JSON pointer context. + @param ctx The context from the `yyjson_mut_ptr_xxx()` calls. + @return true on success or false on fail. + @note If success, the old value will be returned via `ctx->old`. + */ +yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx); + + + +/*============================================================================== + * JSON Patch API (RFC 6902) + * https://tools.ietf.org/html/rfc6902 + *============================================================================*/ + +/** Result code for JSON patch. */ +typedef uint32_t yyjson_patch_code; + +/** Success, no error. */ +static const yyjson_patch_code YYJSON_PATCH_SUCCESS = 0; + +/** Invalid parameter, such as NULL input or non-array patch. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_PARAMETER = 1; + +/** Memory allocation failure occurs. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_MEMORY_ALLOCATION = 2; + +/** JSON patch operation is not object type. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_OPERATION = 3; + +/** JSON patch operation is missing a required key. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_MISSING_KEY = 4; + +/** JSON patch operation member is invalid. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_INVALID_MEMBER = 5; + +/** JSON patch operation `test` not equal. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_EQUAL = 6; + +/** JSON patch operation failed on JSON pointer. */ +static const yyjson_patch_code YYJSON_PATCH_ERROR_POINTER = 7; + +/** Error information for JSON patch. */ +typedef struct yyjson_patch_err { + /** Error code, see `yyjson_patch_code` for all possible values. */ + yyjson_patch_code code; + /** Index of the error operation (0 if no error). */ + size_t idx; + /** Error message, constant, no need to free (NULL if no error). */ + const char *msg; + /** JSON pointer error if `code == YYJSON_PATCH_ERROR_POINTER`. */ + yyjson_ptr_err ptr; +} yyjson_patch_err; + +/** + Creates and returns a patched JSON value (RFC 6902). + The memory of the returned value is allocated by the `doc`. + The `err` is used to receive error information, pass NULL if not needed. + Returns NULL if the patch could not be applied. + */ +yyjson_api yyjson_mut_val *yyjson_patch(yyjson_mut_doc *doc, + yyjson_val *orig, + yyjson_val *patch, + yyjson_patch_err *err); + +/** + Creates and returns a patched JSON value (RFC 6902). + The memory of the returned value is allocated by the `doc`. + The `err` is used to receive error information, pass NULL if not needed. + Returns NULL if the patch could not be applied. + */ +yyjson_api yyjson_mut_val *yyjson_mut_patch(yyjson_mut_doc *doc, + yyjson_mut_val *orig, + yyjson_mut_val *patch, + yyjson_patch_err *err); + + + +/*============================================================================== + * JSON Merge-Patch API (RFC 7386) + * https://tools.ietf.org/html/rfc7386 + *============================================================================*/ + +/** + Creates and returns a merge-patched JSON value (RFC 7386). + The memory of the returned value is allocated by the `doc`. + Returns NULL if the patch could not be applied. + + @warning This function is recursive and may cause a stack overflow if the + object level is too deep. + */ +yyjson_api yyjson_mut_val *yyjson_merge_patch(yyjson_mut_doc *doc, + yyjson_val *orig, + yyjson_val *patch); + +/** + Creates and returns a merge-patched JSON value (RFC 7386). + The memory of the returned value is allocated by the `doc`. + Returns NULL if the patch could not be applied. + + @warning This function is recursive and may cause a stack overflow if the + object level is too deep. + */ +yyjson_api yyjson_mut_val *yyjson_mut_merge_patch(yyjson_mut_doc *doc, + yyjson_mut_val *orig, + yyjson_mut_val *patch); + + + +/*============================================================================== + * JSON Structure (Implementation) + *============================================================================*/ + +/** Payload of a JSON value (8 bytes). */ +typedef union yyjson_val_uni { + uint64_t u64; + int64_t i64; + double f64; + const char *str; + void *ptr; + size_t ofs; +} yyjson_val_uni; + +/** + Immutable JSON value, 16 bytes. + */ +struct yyjson_val { + uint64_t tag; /**< type, subtype and length */ + yyjson_val_uni uni; /**< payload */ +}; + +struct yyjson_doc { + /** Root value of the document (nonnull). */ + yyjson_val *root; + /** Allocator used by document (nonnull). */ + yyjson_alc alc; + /** The total number of bytes read when parsing JSON (nonzero). */ + size_t dat_read; + /** The total number of value read when parsing JSON (nonzero). */ + size_t val_read; + /** The string pool used by JSON values (nullable). */ + char *str_pool; +}; + + + +/*============================================================================== + * Unsafe JSON Value API (Implementation) + *============================================================================*/ + +/* + Whether the string does not need to be escaped for serialization. + This function is used to optimize the writing speed of small constant strings. + This function works only if the compiler can evaluate it at compile time. + + Clang supports it since v8.0, + earlier versions do not support constant_p(strlen) and return false. + GCC supports it since at least v4.4, + earlier versions may compile it as run-time instructions. + ICC supports it since at least v16, + earlier versions are uncertain. + + @param str The C string. + @param len The returnd value from strlen(str). + */ +yyjson_api_inline bool unsafe_yyjson_is_str_noesc(const char *str, size_t len) { +#if YYJSON_HAS_CONSTANT_P && \ + (!YYJSON_IS_REAL_GCC || yyjson_gcc_available(4, 4, 0)) + if (yyjson_constant_p(len) && len <= 32) { + /* + Same as the following loop: + + for (size_t i = 0; i < len; i++) { + char c = str[i]; + if (c < ' ' || c > '~' || c == '"' || c == '\\') return false; + } + + GCC evaluates it at compile time only if the string length is within 17 + and -O3 (which turns on the -fpeel-loops flag) is used. + So the loop is unrolled for GCC. + */ +# define yyjson_repeat32_incr(x) \ + x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \ + x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) \ + x(16) x(17) x(18) x(19) x(20) x(21) x(22) x(23) \ + x(24) x(25) x(26) x(27) x(28) x(29) x(30) x(31) +# define yyjson_check_char_noesc(i) \ + if (i < len) { \ + char c = str[i]; \ + if (c < ' ' || c > '~' || c == '"' || c == '\\') return false; } + yyjson_repeat32_incr(yyjson_check_char_noesc) +# undef yyjson_repeat32_incr +# undef yyjson_check_char_noesc + return true; + } +#else + (void)str; + (void)len; +#endif + return false; +} + +yyjson_api_inline yyjson_type unsafe_yyjson_get_type(void *val) { + uint8_t tag = (uint8_t)((yyjson_val *)val)->tag; + return (yyjson_type)(tag & YYJSON_TYPE_MASK); +} + +yyjson_api_inline yyjson_subtype unsafe_yyjson_get_subtype(void *val) { + uint8_t tag = (uint8_t)((yyjson_val *)val)->tag; + return (yyjson_subtype)(tag & YYJSON_SUBTYPE_MASK); +} + +yyjson_api_inline uint8_t unsafe_yyjson_get_tag(void *val) { + uint8_t tag = (uint8_t)((yyjson_val *)val)->tag; + return (uint8_t)(tag & YYJSON_TAG_MASK); +} + +yyjson_api_inline bool unsafe_yyjson_is_raw(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_RAW; +} + +yyjson_api_inline bool unsafe_yyjson_is_null(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NULL; +} + +yyjson_api_inline bool unsafe_yyjson_is_bool(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_BOOL; +} + +yyjson_api_inline bool unsafe_yyjson_is_num(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_NUM; +} + +yyjson_api_inline bool unsafe_yyjson_is_str(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_STR; +} + +yyjson_api_inline bool unsafe_yyjson_is_arr(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_ARR; +} + +yyjson_api_inline bool unsafe_yyjson_is_obj(void *val) { + return unsafe_yyjson_get_type(val) == YYJSON_TYPE_OBJ; +} + +yyjson_api_inline bool unsafe_yyjson_is_ctn(void *val) { + uint8_t mask = YYJSON_TYPE_ARR & YYJSON_TYPE_OBJ; + return (unsafe_yyjson_get_tag(val) & mask) == mask; +} + +yyjson_api_inline bool unsafe_yyjson_is_uint(void *val) { + const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + return unsafe_yyjson_get_tag(val) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_is_sint(void *val) { + const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + return unsafe_yyjson_get_tag(val) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_is_int(void *val) { + const uint8_t mask = YYJSON_TAG_MASK & (~YYJSON_SUBTYPE_SINT); + const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + return (unsafe_yyjson_get_tag(val) & mask) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_is_real(void *val) { + const uint8_t patt = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + return unsafe_yyjson_get_tag(val) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_is_true(void *val) { + const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE; + return unsafe_yyjson_get_tag(val) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_is_false(void *val) { + const uint8_t patt = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE; + return unsafe_yyjson_get_tag(val) == patt; +} + +yyjson_api_inline bool unsafe_yyjson_arr_is_flat(yyjson_val *val) { + size_t ofs = val->uni.ofs; + size_t len = (size_t)(val->tag >> YYJSON_TAG_BIT); + return len * sizeof(yyjson_val) + sizeof(yyjson_val) == ofs; +} + +yyjson_api_inline const char *unsafe_yyjson_get_raw(void *val) { + return ((yyjson_val *)val)->uni.str; +} + +yyjson_api_inline bool unsafe_yyjson_get_bool(void *val) { + uint8_t tag = unsafe_yyjson_get_tag(val); + return (bool)((tag & YYJSON_SUBTYPE_MASK) >> YYJSON_TYPE_BIT); +} + +yyjson_api_inline uint64_t unsafe_yyjson_get_uint(void *val) { + return ((yyjson_val *)val)->uni.u64; +} + +yyjson_api_inline int64_t unsafe_yyjson_get_sint(void *val) { + return ((yyjson_val *)val)->uni.i64; +} + +yyjson_api_inline int unsafe_yyjson_get_int(void *val) { + return (int)((yyjson_val *)val)->uni.i64; +} + +yyjson_api_inline double unsafe_yyjson_get_real(void *val) { + return ((yyjson_val *)val)->uni.f64; +} + +yyjson_api_inline double unsafe_yyjson_get_num(void *val) { + uint8_t tag = unsafe_yyjson_get_tag(val); + if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL)) { + return ((yyjson_val *)val)->uni.f64; + } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT)) { + return (double)((yyjson_val *)val)->uni.i64; + } else if (tag == (YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT)) { +#if YYJSON_U64_TO_F64_NO_IMPL + uint64_t msb = ((uint64_t)1) << 63; + uint64_t num = ((yyjson_val *)val)->uni.u64; + if ((num & msb) == 0) { + return (double)(int64_t)num; + } else { + return ((double)(int64_t)((num >> 1) | (num & 1))) * (double)2.0; + } +#else + return (double)((yyjson_val *)val)->uni.u64; +#endif + } + return 0.0; +} + +yyjson_api_inline const char *unsafe_yyjson_get_str(void *val) { + return ((yyjson_val *)val)->uni.str; +} + +yyjson_api_inline size_t unsafe_yyjson_get_len(void *val) { + return (size_t)(((yyjson_val *)val)->tag >> YYJSON_TAG_BIT); +} + +yyjson_api_inline yyjson_val *unsafe_yyjson_get_first(yyjson_val *ctn) { + return ctn + 1; +} + +yyjson_api_inline yyjson_val *unsafe_yyjson_get_next(yyjson_val *val) { + bool is_ctn = unsafe_yyjson_is_ctn(val); + size_t ctn_ofs = val->uni.ofs; + size_t ofs = (is_ctn ? ctn_ofs : sizeof(yyjson_val)); + return (yyjson_val *)(void *)((uint8_t *)val + ofs); +} + +yyjson_api_inline bool unsafe_yyjson_equals_strn(void *val, const char *str, + size_t len) { + return unsafe_yyjson_get_len(val) == len && + memcmp(((yyjson_val *)val)->uni.str, str, len) == 0; +} + +yyjson_api_inline bool unsafe_yyjson_equals_str(void *val, const char *str) { + return unsafe_yyjson_equals_strn(val, str, strlen(str)); +} + +yyjson_api_inline void unsafe_yyjson_set_type(void *val, yyjson_type type, + yyjson_subtype subtype) { + uint8_t tag = (type | subtype); + uint64_t new_tag = ((yyjson_val *)val)->tag; + new_tag = (new_tag & (~(uint64_t)YYJSON_TAG_MASK)) | (uint64_t)tag; + ((yyjson_val *)val)->tag = new_tag; +} + +yyjson_api_inline void unsafe_yyjson_set_len(void *val, size_t len) { + uint64_t tag = ((yyjson_val *)val)->tag & YYJSON_TAG_MASK; + tag |= (uint64_t)len << YYJSON_TAG_BIT; + ((yyjson_val *)val)->tag = tag; +} + +yyjson_api_inline void unsafe_yyjson_inc_len(void *val) { + uint64_t tag = ((yyjson_val *)val)->tag; + tag += (uint64_t)(1 << YYJSON_TAG_BIT); + ((yyjson_val *)val)->tag = tag; +} + +yyjson_api_inline void unsafe_yyjson_set_raw(void *val, const char *raw, + size_t len) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_RAW, YYJSON_SUBTYPE_NONE); + unsafe_yyjson_set_len(val, len); + ((yyjson_val *)val)->uni.str = raw; +} + +yyjson_api_inline void unsafe_yyjson_set_null(void *val) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_NULL, YYJSON_SUBTYPE_NONE); + unsafe_yyjson_set_len(val, 0); +} + +yyjson_api_inline void unsafe_yyjson_set_bool(void *val, bool num) { + yyjson_subtype subtype = num ? YYJSON_SUBTYPE_TRUE : YYJSON_SUBTYPE_FALSE; + unsafe_yyjson_set_type(val, YYJSON_TYPE_BOOL, subtype); + unsafe_yyjson_set_len(val, 0); +} + +yyjson_api_inline void unsafe_yyjson_set_uint(void *val, uint64_t num) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_UINT); + unsafe_yyjson_set_len(val, 0); + ((yyjson_val *)val)->uni.u64 = num; +} + +yyjson_api_inline void unsafe_yyjson_set_sint(void *val, int64_t num) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_SINT); + unsafe_yyjson_set_len(val, 0); + ((yyjson_val *)val)->uni.i64 = num; +} + +yyjson_api_inline void unsafe_yyjson_set_real(void *val, double num) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_NUM, YYJSON_SUBTYPE_REAL); + unsafe_yyjson_set_len(val, 0); + ((yyjson_val *)val)->uni.f64 = num; +} + +yyjson_api_inline void unsafe_yyjson_set_str(void *val, const char *str) { + size_t len = strlen(str); + bool noesc = unsafe_yyjson_is_str_noesc(str, len); + yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; + unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, sub); + unsafe_yyjson_set_len(val, len); + ((yyjson_val *)val)->uni.str = str; +} + +yyjson_api_inline void unsafe_yyjson_set_strn(void *val, const char *str, + size_t len) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_STR, YYJSON_SUBTYPE_NONE); + unsafe_yyjson_set_len(val, len); + ((yyjson_val *)val)->uni.str = str; +} + +yyjson_api_inline void unsafe_yyjson_set_arr(void *val, size_t size) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_ARR, YYJSON_SUBTYPE_NONE); + unsafe_yyjson_set_len(val, size); +} + +yyjson_api_inline void unsafe_yyjson_set_obj(void *val, size_t size) { + unsafe_yyjson_set_type(val, YYJSON_TYPE_OBJ, YYJSON_SUBTYPE_NONE); + unsafe_yyjson_set_len(val, size); +} + + + +/*============================================================================== + * JSON Document API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_val *yyjson_doc_get_root(yyjson_doc *doc) { + return doc ? doc->root : NULL; +} + +yyjson_api_inline size_t yyjson_doc_get_read_size(yyjson_doc *doc) { + return doc ? doc->dat_read : 0; +} + +yyjson_api_inline size_t yyjson_doc_get_val_count(yyjson_doc *doc) { + return doc ? doc->val_read : 0; +} + +yyjson_api_inline void yyjson_doc_free(yyjson_doc *doc) { + if (doc) { + yyjson_alc alc = doc->alc; + if (doc->str_pool) alc.free(alc.ctx, doc->str_pool); + alc.free(alc.ctx, doc); + } +} + + + +/*============================================================================== + * JSON Value Type API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_is_raw(yyjson_val *val) { + return val ? unsafe_yyjson_is_raw(val) : false; +} + +yyjson_api_inline bool yyjson_is_null(yyjson_val *val) { + return val ? unsafe_yyjson_is_null(val) : false; +} + +yyjson_api_inline bool yyjson_is_true(yyjson_val *val) { + return val ? unsafe_yyjson_is_true(val) : false; +} + +yyjson_api_inline bool yyjson_is_false(yyjson_val *val) { + return val ? unsafe_yyjson_is_false(val) : false; +} + +yyjson_api_inline bool yyjson_is_bool(yyjson_val *val) { + return val ? unsafe_yyjson_is_bool(val) : false; +} + +yyjson_api_inline bool yyjson_is_uint(yyjson_val *val) { + return val ? unsafe_yyjson_is_uint(val) : false; +} + +yyjson_api_inline bool yyjson_is_sint(yyjson_val *val) { + return val ? unsafe_yyjson_is_sint(val) : false; +} + +yyjson_api_inline bool yyjson_is_int(yyjson_val *val) { + return val ? unsafe_yyjson_is_int(val) : false; +} + +yyjson_api_inline bool yyjson_is_real(yyjson_val *val) { + return val ? unsafe_yyjson_is_real(val) : false; +} + +yyjson_api_inline bool yyjson_is_num(yyjson_val *val) { + return val ? unsafe_yyjson_is_num(val) : false; +} + +yyjson_api_inline bool yyjson_is_str(yyjson_val *val) { + return val ? unsafe_yyjson_is_str(val) : false; +} + +yyjson_api_inline bool yyjson_is_arr(yyjson_val *val) { + return val ? unsafe_yyjson_is_arr(val) : false; +} + +yyjson_api_inline bool yyjson_is_obj(yyjson_val *val) { + return val ? unsafe_yyjson_is_obj(val) : false; +} + +yyjson_api_inline bool yyjson_is_ctn(yyjson_val *val) { + return val ? unsafe_yyjson_is_ctn(val) : false; +} + + + +/*============================================================================== + * JSON Value Content API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_type yyjson_get_type(yyjson_val *val) { + return val ? unsafe_yyjson_get_type(val) : YYJSON_TYPE_NONE; +} + +yyjson_api_inline yyjson_subtype yyjson_get_subtype(yyjson_val *val) { + return val ? unsafe_yyjson_get_subtype(val) : YYJSON_SUBTYPE_NONE; +} + +yyjson_api_inline uint8_t yyjson_get_tag(yyjson_val *val) { + return val ? unsafe_yyjson_get_tag(val) : 0; +} + +yyjson_api_inline const char *yyjson_get_type_desc(yyjson_val *val) { + switch (yyjson_get_tag(val)) { + case YYJSON_TYPE_RAW | YYJSON_SUBTYPE_NONE: return "raw"; + case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE: return "null"; + case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NONE: return "string"; + case YYJSON_TYPE_STR | YYJSON_SUBTYPE_NOESC: return "string"; + case YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE: return "array"; + case YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE: return "object"; + case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE: return "true"; + case YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE: return "false"; + case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT: return "uint"; + case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT: return "sint"; + case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL: return "real"; + default: return "unknown"; + } +} + +yyjson_api_inline const char *yyjson_get_raw(yyjson_val *val) { + return yyjson_is_raw(val) ? unsafe_yyjson_get_raw(val) : NULL; +} + +yyjson_api_inline bool yyjson_get_bool(yyjson_val *val) { + return yyjson_is_bool(val) ? unsafe_yyjson_get_bool(val) : false; +} + +yyjson_api_inline uint64_t yyjson_get_uint(yyjson_val *val) { + return yyjson_is_int(val) ? unsafe_yyjson_get_uint(val) : 0; +} + +yyjson_api_inline int64_t yyjson_get_sint(yyjson_val *val) { + return yyjson_is_int(val) ? unsafe_yyjson_get_sint(val) : 0; +} + +yyjson_api_inline int yyjson_get_int(yyjson_val *val) { + return yyjson_is_int(val) ? unsafe_yyjson_get_int(val) : 0; +} + +yyjson_api_inline double yyjson_get_real(yyjson_val *val) { + return yyjson_is_real(val) ? unsafe_yyjson_get_real(val) : 0.0; +} + +yyjson_api_inline double yyjson_get_num(yyjson_val *val) { + return val ? unsafe_yyjson_get_num(val) : 0.0; +} + +yyjson_api_inline const char *yyjson_get_str(yyjson_val *val) { + return yyjson_is_str(val) ? unsafe_yyjson_get_str(val) : NULL; +} + +yyjson_api_inline size_t yyjson_get_len(yyjson_val *val) { + return val ? unsafe_yyjson_get_len(val) : 0; +} + +yyjson_api_inline bool yyjson_equals_str(yyjson_val *val, const char *str) { + if (yyjson_likely(val && str)) { + return unsafe_yyjson_is_str(val) && + unsafe_yyjson_equals_str(val, str); + } + return false; +} + +yyjson_api_inline bool yyjson_equals_strn(yyjson_val *val, const char *str, + size_t len) { + if (yyjson_likely(val && str)) { + return unsafe_yyjson_is_str(val) && + unsafe_yyjson_equals_strn(val, str, len); + } + return false; +} + +yyjson_api bool unsafe_yyjson_equals(yyjson_val *lhs, yyjson_val *rhs); + +yyjson_api_inline bool yyjson_equals(yyjson_val *lhs, yyjson_val *rhs) { + if (yyjson_unlikely(!lhs || !rhs)) return false; + return unsafe_yyjson_equals(lhs, rhs); +} + +yyjson_api_inline bool yyjson_set_raw(yyjson_val *val, + const char *raw, size_t len) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_raw(val, raw, len); + return true; +} + +yyjson_api_inline bool yyjson_set_null(yyjson_val *val) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_null(val); + return true; +} + +yyjson_api_inline bool yyjson_set_bool(yyjson_val *val, bool num) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_bool(val, num); + return true; +} + +yyjson_api_inline bool yyjson_set_uint(yyjson_val *val, uint64_t num) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_uint(val, num); + return true; +} + +yyjson_api_inline bool yyjson_set_sint(yyjson_val *val, int64_t num) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_sint(val, num); + return true; +} + +yyjson_api_inline bool yyjson_set_int(yyjson_val *val, int num) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_sint(val, (int64_t)num); + return true; +} + +yyjson_api_inline bool yyjson_set_real(yyjson_val *val, double num) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + unsafe_yyjson_set_real(val, num); + return true; +} + +yyjson_api_inline bool yyjson_set_str(yyjson_val *val, const char *str) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + if (yyjson_unlikely(!str)) return false; + unsafe_yyjson_set_str(val, str); + return true; +} + +yyjson_api_inline bool yyjson_set_strn(yyjson_val *val, + const char *str, size_t len) { + if (yyjson_unlikely(!val || unsafe_yyjson_is_ctn(val))) return false; + if (yyjson_unlikely(!str)) return false; + unsafe_yyjson_set_strn(val, str, len); + return true; +} + + + +/*============================================================================== + * JSON Array API (Implementation) + *============================================================================*/ + +yyjson_api_inline size_t yyjson_arr_size(yyjson_val *arr) { + return yyjson_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0; +} + +yyjson_api_inline yyjson_val *yyjson_arr_get(yyjson_val *arr, size_t idx) { + if (yyjson_likely(yyjson_is_arr(arr))) { + if (yyjson_likely(unsafe_yyjson_get_len(arr) > idx)) { + yyjson_val *val = unsafe_yyjson_get_first(arr); + if (unsafe_yyjson_arr_is_flat(arr)) { + return val + idx; + } else { + while (idx-- > 0) val = unsafe_yyjson_get_next(val); + return val; + } + } + } + return NULL; +} + +yyjson_api_inline yyjson_val *yyjson_arr_get_first(yyjson_val *arr) { + if (yyjson_likely(yyjson_is_arr(arr))) { + if (yyjson_likely(unsafe_yyjson_get_len(arr) > 0)) { + return unsafe_yyjson_get_first(arr); + } + } + return NULL; +} + +yyjson_api_inline yyjson_val *yyjson_arr_get_last(yyjson_val *arr) { + if (yyjson_likely(yyjson_is_arr(arr))) { + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_likely(len > 0)) { + yyjson_val *val = unsafe_yyjson_get_first(arr); + if (unsafe_yyjson_arr_is_flat(arr)) { + return val + (len - 1); + } else { + while (len-- > 1) val = unsafe_yyjson_get_next(val); + return val; + } + } + } + return NULL; +} + + + +/*============================================================================== + * JSON Array Iterator API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_arr_iter_init(yyjson_val *arr, + yyjson_arr_iter *iter) { + if (yyjson_likely(yyjson_is_arr(arr) && iter)) { + iter->idx = 0; + iter->max = unsafe_yyjson_get_len(arr); + iter->cur = unsafe_yyjson_get_first(arr); + return true; + } + if (iter) memset(iter, 0, sizeof(yyjson_arr_iter)); + return false; +} + +yyjson_api_inline yyjson_arr_iter yyjson_arr_iter_with(yyjson_val *arr) { + yyjson_arr_iter iter; + yyjson_arr_iter_init(arr, &iter); + return iter; +} + +yyjson_api_inline bool yyjson_arr_iter_has_next(yyjson_arr_iter *iter) { + return iter ? iter->idx < iter->max : false; +} + +yyjson_api_inline yyjson_val *yyjson_arr_iter_next(yyjson_arr_iter *iter) { + yyjson_val *val; + if (iter && iter->idx < iter->max) { + val = iter->cur; + iter->cur = unsafe_yyjson_get_next(val); + iter->idx++; + return val; + } + return NULL; +} + + + +/*============================================================================== + * JSON Object API (Implementation) + *============================================================================*/ + +yyjson_api_inline size_t yyjson_obj_size(yyjson_val *obj) { + return yyjson_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0; +} + +yyjson_api_inline yyjson_val *yyjson_obj_get(yyjson_val *obj, + const char *key) { + return yyjson_obj_getn(obj, key, key ? strlen(key) : 0); +} + +yyjson_api_inline yyjson_val *yyjson_obj_getn(yyjson_val *obj, + const char *_key, + size_t key_len) { + if (yyjson_likely(yyjson_is_obj(obj) && _key)) { + size_t len = unsafe_yyjson_get_len(obj); + yyjson_val *key = unsafe_yyjson_get_first(obj); + while (len-- > 0) { + if (unsafe_yyjson_equals_strn(key, _key, key_len)) return key + 1; + key = unsafe_yyjson_get_next(key + 1); + } + } + return NULL; +} + + + +/*============================================================================== + * JSON Object Iterator API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_obj_iter_init(yyjson_val *obj, + yyjson_obj_iter *iter) { + if (yyjson_likely(yyjson_is_obj(obj) && iter)) { + iter->idx = 0; + iter->max = unsafe_yyjson_get_len(obj); + iter->cur = unsafe_yyjson_get_first(obj); + iter->obj = obj; + return true; + } + if (iter) memset(iter, 0, sizeof(yyjson_obj_iter)); + return false; +} + +yyjson_api_inline yyjson_obj_iter yyjson_obj_iter_with(yyjson_val *obj) { + yyjson_obj_iter iter; + yyjson_obj_iter_init(obj, &iter); + return iter; +} + +yyjson_api_inline bool yyjson_obj_iter_has_next(yyjson_obj_iter *iter) { + return iter ? iter->idx < iter->max : false; +} + +yyjson_api_inline yyjson_val *yyjson_obj_iter_next(yyjson_obj_iter *iter) { + if (iter && iter->idx < iter->max) { + yyjson_val *key = iter->cur; + iter->idx++; + iter->cur = unsafe_yyjson_get_next(key + 1); + return key; + } + return NULL; +} + +yyjson_api_inline yyjson_val *yyjson_obj_iter_get_val(yyjson_val *key) { + return key ? key + 1 : NULL; +} + +yyjson_api_inline yyjson_val *yyjson_obj_iter_get(yyjson_obj_iter *iter, + const char *key) { + return yyjson_obj_iter_getn(iter, key, key ? strlen(key) : 0); +} + +yyjson_api_inline yyjson_val *yyjson_obj_iter_getn(yyjson_obj_iter *iter, + const char *key, + size_t key_len) { + if (iter && key) { + size_t idx = iter->idx; + size_t max = iter->max; + yyjson_val *cur = iter->cur; + if (yyjson_unlikely(idx == max)) { + idx = 0; + cur = unsafe_yyjson_get_first(iter->obj); + } + while (idx++ < max) { + yyjson_val *next = unsafe_yyjson_get_next(cur + 1); + if (unsafe_yyjson_equals_strn(cur, key, key_len)) { + iter->idx = idx; + iter->cur = next; + return cur + 1; + } + cur = next; + if (idx == iter->max && iter->idx < iter->max) { + idx = 0; + max = iter->idx; + cur = unsafe_yyjson_get_first(iter->obj); + } + } + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Structure (Implementation) + *============================================================================*/ + +/** + Mutable JSON value, 24 bytes. + The 'tag' and 'uni' field is same as immutable value. + The 'next' field links all elements inside the container to be a cycle. + */ +struct yyjson_mut_val { + uint64_t tag; /**< type, subtype and length */ + yyjson_val_uni uni; /**< payload */ + yyjson_mut_val *next; /**< the next value in circular linked list */ +}; + +/** + A memory chunk in string memory pool. + */ +typedef struct yyjson_str_chunk { + struct yyjson_str_chunk *next; /* next chunk linked list */ + size_t chunk_size; /* chunk size in bytes */ + /* char str[]; flexible array member */ +} yyjson_str_chunk; + +/** + A memory pool to hold all strings in a mutable document. + */ +typedef struct yyjson_str_pool { + char *cur; /* cursor inside current chunk */ + char *end; /* the end of current chunk */ + size_t chunk_size; /* chunk size in bytes while creating new chunk */ + size_t chunk_size_max; /* maximum chunk size in bytes */ + yyjson_str_chunk *chunks; /* a linked list of chunks, nullable */ +} yyjson_str_pool; + +/** + A memory chunk in value memory pool. + `sizeof(yyjson_val_chunk)` should not larger than `sizeof(yyjson_mut_val)`. + */ +typedef struct yyjson_val_chunk { + struct yyjson_val_chunk *next; /* next chunk linked list */ + size_t chunk_size; /* chunk size in bytes */ + /* char pad[sizeof(yyjson_mut_val) - sizeof(yyjson_val_chunk)]; padding */ + /* yyjson_mut_val vals[]; flexible array member */ +} yyjson_val_chunk; + +/** + A memory pool to hold all values in a mutable document. + */ +typedef struct yyjson_val_pool { + yyjson_mut_val *cur; /* cursor inside current chunk */ + yyjson_mut_val *end; /* the end of current chunk */ + size_t chunk_size; /* chunk size in bytes while creating new chunk */ + size_t chunk_size_max; /* maximum chunk size in bytes */ + yyjson_val_chunk *chunks; /* a linked list of chunks, nullable */ +} yyjson_val_pool; + +struct yyjson_mut_doc { + yyjson_mut_val *root; /**< root value of the JSON document, nullable */ + yyjson_alc alc; /**< a valid allocator, nonnull */ + yyjson_str_pool str_pool; /**< string memory pool */ + yyjson_val_pool val_pool; /**< value memory pool */ +}; + +/* Ensures the capacity to at least equal to the specified byte length. */ +yyjson_api bool unsafe_yyjson_str_pool_grow(yyjson_str_pool *pool, + const yyjson_alc *alc, + size_t len); + +/* Ensures the capacity to at least equal to the specified value count. */ +yyjson_api bool unsafe_yyjson_val_pool_grow(yyjson_val_pool *pool, + const yyjson_alc *alc, + size_t count); + +/* Allocate memory for string. */ +yyjson_api_inline char *unsafe_yyjson_mut_str_alc(yyjson_mut_doc *doc, + size_t len) { + char *mem; + const yyjson_alc *alc = &doc->alc; + yyjson_str_pool *pool = &doc->str_pool; + if (yyjson_unlikely((size_t)(pool->end - pool->cur) <= len)) { + if (yyjson_unlikely(!unsafe_yyjson_str_pool_grow(pool, alc, len + 1))) { + return NULL; + } + } + mem = pool->cur; + pool->cur = mem + len + 1; + return mem; +} + +yyjson_api_inline char *unsafe_yyjson_mut_strncpy(yyjson_mut_doc *doc, + const char *str, size_t len) { + char *mem = unsafe_yyjson_mut_str_alc(doc, len); + if (yyjson_unlikely(!mem)) return NULL; + memcpy((void *)mem, (const void *)str, len); + mem[len] = '\0'; + return mem; +} + +yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_val(yyjson_mut_doc *doc, + size_t count) { + yyjson_mut_val *val; + yyjson_alc *alc = &doc->alc; + yyjson_val_pool *pool = &doc->val_pool; + if (yyjson_unlikely((size_t)(pool->end - pool->cur) < count)) { + if (yyjson_unlikely(!unsafe_yyjson_val_pool_grow(pool, alc, count))) { + return NULL; + } + } + val = pool->cur; + pool->cur += count; + return val; +} + + + +/*============================================================================== + * Mutable JSON Document API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_root(yyjson_mut_doc *doc) { + return doc ? doc->root : NULL; +} + +yyjson_api_inline void yyjson_mut_doc_set_root(yyjson_mut_doc *doc, + yyjson_mut_val *root) { + if (doc) doc->root = root; +} + + + +/*============================================================================== + * Mutable JSON Value Type API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_mut_is_raw(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_raw(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_null(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_null(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_true(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_true(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_false(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_false(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_bool(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_bool(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_uint(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_uint(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_sint(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_sint(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_int(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_int(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_real(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_real(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_num(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_num(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_str(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_str(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_arr(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_arr(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_obj(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_obj(val) : false; +} + +yyjson_api_inline bool yyjson_mut_is_ctn(yyjson_mut_val *val) { + return val ? unsafe_yyjson_is_ctn(val) : false; +} + + + +/*============================================================================== + * Mutable JSON Value Content API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_type yyjson_mut_get_type(yyjson_mut_val *val) { + return yyjson_get_type((yyjson_val *)val); +} + +yyjson_api_inline yyjson_subtype yyjson_mut_get_subtype(yyjson_mut_val *val) { + return yyjson_get_subtype((yyjson_val *)val); +} + +yyjson_api_inline uint8_t yyjson_mut_get_tag(yyjson_mut_val *val) { + return yyjson_get_tag((yyjson_val *)val); +} + +yyjson_api_inline const char *yyjson_mut_get_type_desc(yyjson_mut_val *val) { + return yyjson_get_type_desc((yyjson_val *)val); +} + +yyjson_api_inline const char *yyjson_mut_get_raw(yyjson_mut_val *val) { + return yyjson_get_raw((yyjson_val *)val); +} + +yyjson_api_inline bool yyjson_mut_get_bool(yyjson_mut_val *val) { + return yyjson_get_bool((yyjson_val *)val); +} + +yyjson_api_inline uint64_t yyjson_mut_get_uint(yyjson_mut_val *val) { + return yyjson_get_uint((yyjson_val *)val); +} + +yyjson_api_inline int64_t yyjson_mut_get_sint(yyjson_mut_val *val) { + return yyjson_get_sint((yyjson_val *)val); +} + +yyjson_api_inline int yyjson_mut_get_int(yyjson_mut_val *val) { + return yyjson_get_int((yyjson_val *)val); +} + +yyjson_api_inline double yyjson_mut_get_real(yyjson_mut_val *val) { + return yyjson_get_real((yyjson_val *)val); +} + +yyjson_api_inline double yyjson_mut_get_num(yyjson_mut_val *val) { + return yyjson_get_num((yyjson_val *)val); +} + +yyjson_api_inline const char *yyjson_mut_get_str(yyjson_mut_val *val) { + return yyjson_get_str((yyjson_val *)val); +} + +yyjson_api_inline size_t yyjson_mut_get_len(yyjson_mut_val *val) { + return yyjson_get_len((yyjson_val *)val); +} + +yyjson_api_inline bool yyjson_mut_equals_str(yyjson_mut_val *val, + const char *str) { + return yyjson_equals_str((yyjson_val *)val, str); +} + +yyjson_api_inline bool yyjson_mut_equals_strn(yyjson_mut_val *val, + const char *str, size_t len) { + return yyjson_equals_strn((yyjson_val *)val, str, len); +} + +yyjson_api bool unsafe_yyjson_mut_equals(yyjson_mut_val *lhs, + yyjson_mut_val *rhs); + +yyjson_api_inline bool yyjson_mut_equals(yyjson_mut_val *lhs, + yyjson_mut_val *rhs) { + if (yyjson_unlikely(!lhs || !rhs)) return false; + return unsafe_yyjson_mut_equals(lhs, rhs); +} + +yyjson_api_inline bool yyjson_mut_set_raw(yyjson_mut_val *val, + const char *raw, size_t len) { + if (yyjson_unlikely(!val || !raw)) return false; + unsafe_yyjson_set_raw(val, raw, len); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_null(yyjson_mut_val *val) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_null(val); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_bool(yyjson_mut_val *val, bool num) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_bool(val, num); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_uint(yyjson_mut_val *val, uint64_t num) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_uint(val, num); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_sint(yyjson_mut_val *val, int64_t num) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_sint(val, num); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_int(yyjson_mut_val *val, int num) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_sint(val, (int64_t)num); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_real(yyjson_mut_val *val, double num) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_real(val, num); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_str(yyjson_mut_val *val, + const char *str) { + if (yyjson_unlikely(!val || !str)) return false; + unsafe_yyjson_set_str(val, str); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_strn(yyjson_mut_val *val, + const char *str, size_t len) { + if (yyjson_unlikely(!val || !str)) return false; + unsafe_yyjson_set_strn(val, str, len); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_arr(yyjson_mut_val *val) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_arr(val, 0); + return true; +} + +yyjson_api_inline bool yyjson_mut_set_obj(yyjson_mut_val *val) { + if (yyjson_unlikely(!val)) return false; + unsafe_yyjson_set_obj(val, 0); + return true; +} + + + +/*============================================================================== + * Mutable JSON Value Creation API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_mut_val *yyjson_mut_raw(yyjson_mut_doc *doc, + const char *str) { + if (yyjson_likely(str)) return yyjson_mut_rawn(doc, str, strlen(str)); + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawn(yyjson_mut_doc *doc, + const char *str, + size_t len) { + if (yyjson_likely(doc && str)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; + val->uni.str = str; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawcpy(yyjson_mut_doc *doc, + const char *str) { + if (yyjson_likely(str)) return yyjson_mut_rawncpy(doc, str, strlen(str)); + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_rawncpy(yyjson_mut_doc *doc, + const char *str, + size_t len) { + if (yyjson_likely(doc && str)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len); + if (yyjson_likely(val && new_str)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; + val->uni.str = new_str; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_null(yyjson_mut_doc *doc) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_true(yyjson_mut_doc *doc) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_false(yyjson_mut_doc *doc) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_bool(yyjson_mut_doc *doc, + bool _val) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)_val << 3); + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_uint(yyjson_mut_doc *doc, + uint64_t num) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = num; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_sint(yyjson_mut_doc *doc, + int64_t num) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = num; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_int(yyjson_mut_doc *doc, + int64_t num) { + return yyjson_mut_sint(doc, num); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_real(yyjson_mut_doc *doc, + double num) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.f64 = num; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_str(yyjson_mut_doc *doc, + const char *str) { + if (yyjson_likely(doc && str)) { + size_t len = strlen(str); + bool noesc = unsafe_yyjson_is_str_noesc(str, len); + yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | + (uint64_t)(YYJSON_TYPE_STR | sub); + val->uni.str = str; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_strn(yyjson_mut_doc *doc, + const char *str, + size_t len) { + if (yyjson_likely(doc && str)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = str; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_strcpy(yyjson_mut_doc *doc, + const char *str) { + if (yyjson_likely(doc && str)) { + size_t len = strlen(str); + bool noesc = unsafe_yyjson_is_str_noesc(str, len); + yyjson_subtype sub = noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len); + if (yyjson_likely(val && new_str)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | + (uint64_t)(YYJSON_TYPE_STR | sub); + val->uni.str = new_str; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_strncpy(yyjson_mut_doc *doc, + const char *str, + size_t len) { + if (yyjson_likely(doc && str)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + char *new_str = unsafe_yyjson_mut_strncpy(doc, str, len); + if (yyjson_likely(val && new_str)) { + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = new_str; + return val; + } + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Array API (Implementation) + *============================================================================*/ + +yyjson_api_inline size_t yyjson_mut_arr_size(yyjson_mut_val *arr) { + return yyjson_mut_is_arr(arr) ? unsafe_yyjson_get_len(arr) : 0; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get(yyjson_mut_val *arr, + size_t idx) { + if (yyjson_likely(idx < yyjson_mut_arr_size(arr))) { + yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr; + while (idx-- > 0) val = val->next; + return val->next; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_first( + yyjson_mut_val *arr) { + if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) { + return ((yyjson_mut_val *)arr->uni.ptr)->next; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_get_last( + yyjson_mut_val *arr) { + if (yyjson_likely(yyjson_mut_arr_size(arr) > 0)) { + return ((yyjson_mut_val *)arr->uni.ptr); + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Array Iterator API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_mut_arr_iter_init(yyjson_mut_val *arr, + yyjson_mut_arr_iter *iter) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && iter)) { + iter->idx = 0; + iter->max = unsafe_yyjson_get_len(arr); + iter->cur = iter->max ? (yyjson_mut_val *)arr->uni.ptr : NULL; + iter->pre = NULL; + iter->arr = arr; + return true; + } + if (iter) memset(iter, 0, sizeof(yyjson_mut_arr_iter)); + return false; +} + +yyjson_api_inline yyjson_mut_arr_iter yyjson_mut_arr_iter_with( + yyjson_mut_val *arr) { + yyjson_mut_arr_iter iter; + yyjson_mut_arr_iter_init(arr, &iter); + return iter; +} + +yyjson_api_inline bool yyjson_mut_arr_iter_has_next(yyjson_mut_arr_iter *iter) { + return iter ? iter->idx < iter->max : false; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_next( + yyjson_mut_arr_iter *iter) { + if (iter && iter->idx < iter->max) { + yyjson_mut_val *val = iter->cur; + iter->pre = val; + iter->cur = val->next; + iter->idx++; + return iter->cur; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_iter_remove( + yyjson_mut_arr_iter *iter) { + if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) { + yyjson_mut_val *prev = iter->pre; + yyjson_mut_val *cur = iter->cur; + yyjson_mut_val *next = cur->next; + if (yyjson_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev; + iter->idx--; + iter->max--; + unsafe_yyjson_set_len(iter->arr, iter->max); + prev->next = next; + iter->cur = next; + return cur; + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Array Creation API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr(yyjson_mut_doc *doc) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_ARR | YYJSON_SUBTYPE_NONE; + return val; + } + } + return NULL; +} + +#define yyjson_mut_arr_with_func(func) \ + if (yyjson_likely(doc && ((0 < count && count < \ + (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0))) { \ + yyjson_mut_val *arr = unsafe_yyjson_mut_val(doc, 1 + count); \ + if (yyjson_likely(arr)) { \ + arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; \ + if (count > 0) { \ + size_t i; \ + for (i = 0; i < count; i++) { \ + yyjson_mut_val *val = arr + i + 1; \ + func \ + val->next = val + 1; \ + } \ + arr[count].next = arr + 1; \ + arr->uni.ptr = arr + count; \ + } \ + return arr; \ + } \ + } \ + return NULL + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_bool( + yyjson_mut_doc *doc, const bool *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)vals[i] << 3); + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint( + yyjson_mut_doc *doc, const int64_t *vals, size_t count) { + return yyjson_mut_arr_with_sint64(doc, vals, count); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint( + yyjson_mut_doc *doc, const uint64_t *vals, size_t count) { + return yyjson_mut_arr_with_uint64(doc, vals, count); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_real( + yyjson_mut_doc *doc, const double *vals, size_t count) { + return yyjson_mut_arr_with_double(doc, vals, count); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint8( + yyjson_mut_doc *doc, const int8_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = (int64_t)vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint16( + yyjson_mut_doc *doc, const int16_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint32( + yyjson_mut_doc *doc, const int32_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_sint64( + yyjson_mut_doc *doc, const int64_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint8( + yyjson_mut_doc *doc, const uint8_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint16( + yyjson_mut_doc *doc, const uint16_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint32( + yyjson_mut_doc *doc, const uint32_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_uint64( + yyjson_mut_doc *doc, const uint64_t *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_float( + yyjson_mut_doc *doc, const float *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.f64 = (double)vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_double( + yyjson_mut_doc *doc, const double *vals, size_t count) { + yyjson_mut_arr_with_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.f64 = vals[i]; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_str( + yyjson_mut_doc *doc, const char **vals, size_t count) { + yyjson_mut_arr_with_func({ + uint64_t len = (uint64_t)strlen(vals[i]); + val->tag = (len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = vals[i]; + if (yyjson_unlikely(!val->uni.str)) return NULL; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strn( + yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) { + if (yyjson_unlikely(count > 0 && !lens)) return NULL; + yyjson_mut_arr_with_func({ + val->tag = ((uint64_t)lens[i] << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = vals[i]; + if (yyjson_unlikely(!val->uni.str)) return NULL; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strcpy( + yyjson_mut_doc *doc, const char **vals, size_t count) { + size_t len; + const char *str; + yyjson_mut_arr_with_func({ + str = vals[i]; + if (!str) return NULL; + len = strlen(str); + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len); + if (yyjson_unlikely(!val->uni.str)) return NULL; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_with_strncpy( + yyjson_mut_doc *doc, const char **vals, const size_t *lens, size_t count) { + size_t len; + const char *str; + if (yyjson_unlikely(count > 0 && !lens)) return NULL; + yyjson_mut_arr_with_func({ + str = vals[i]; + len = lens[i]; + val->tag = ((uint64_t)len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = unsafe_yyjson_mut_strncpy(doc, str, len); + if (yyjson_unlikely(!val->uni.str)) return NULL; + }); +} + +#undef yyjson_mut_arr_with_func + + + +/*============================================================================== + * Mutable JSON Array Modification API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_mut_arr_insert(yyjson_mut_val *arr, + yyjson_mut_val *val, size_t idx) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) { + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_likely(idx <= len)) { + unsafe_yyjson_set_len(arr, len + 1); + if (len == 0) { + val->next = val; + arr->uni.ptr = val; + } else { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + if (idx == len) { + prev->next = val; + val->next = next; + arr->uni.ptr = val; + } else { + while (idx-- > 0) { + prev = next; + next = next->next; + } + prev->next = val; + val->next = next; + } + } + return true; + } + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_append(yyjson_mut_val *arr, + yyjson_mut_val *val) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) { + size_t len = unsafe_yyjson_get_len(arr); + unsafe_yyjson_set_len(arr, len + 1); + if (len == 0) { + val->next = val; + } else { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + prev->next = val; + val->next = next; + } + arr->uni.ptr = val; + return true; + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_prepend(yyjson_mut_val *arr, + yyjson_mut_val *val) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) { + size_t len = unsafe_yyjson_get_len(arr); + unsafe_yyjson_set_len(arr, len + 1); + if (len == 0) { + val->next = val; + arr->uni.ptr = val; + } else { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + prev->next = val; + val->next = next; + } + return true; + } + return false; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_replace(yyjson_mut_val *arr, + size_t idx, + yyjson_mut_val *val) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && val)) { + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_likely(idx < len)) { + if (yyjson_likely(len > 1)) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + while (idx-- > 0) { + prev = next; + next = next->next; + } + prev->next = val; + val->next = next->next; + if ((void *)next == arr->uni.ptr) arr->uni.ptr = val; + return next; + } else { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + val->next = val; + arr->uni.ptr = val; + return prev; + } + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove(yyjson_mut_val *arr, + size_t idx) { + if (yyjson_likely(yyjson_mut_is_arr(arr))) { + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_likely(idx < len)) { + unsafe_yyjson_set_len(arr, len - 1); + if (yyjson_likely(len > 1)) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + while (idx-- > 0) { + prev = next; + next = next->next; + } + prev->next = next->next; + if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev; + return next; + } else { + return ((yyjson_mut_val *)arr->uni.ptr); + } + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_first( + yyjson_mut_val *arr) { + if (yyjson_likely(yyjson_mut_is_arr(arr))) { + size_t len = unsafe_yyjson_get_len(arr); + if (len > 1) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + prev->next = next->next; + unsafe_yyjson_set_len(arr, len - 1); + return next; + } else if (len == 1) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + unsafe_yyjson_set_len(arr, 0); + return prev; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_remove_last( + yyjson_mut_val *arr) { + if (yyjson_likely(yyjson_mut_is_arr(arr))) { + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_likely(len > 1)) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + yyjson_mut_val *next = prev->next; + unsafe_yyjson_set_len(arr, len - 1); + while (--len > 0) prev = prev->next; + prev->next = next; + next = (yyjson_mut_val *)arr->uni.ptr; + arr->uni.ptr = prev; + return next; + } else if (len == 1) { + yyjson_mut_val *prev = ((yyjson_mut_val *)arr->uni.ptr); + unsafe_yyjson_set_len(arr, 0); + return prev; + } + } + return NULL; +} + +yyjson_api_inline bool yyjson_mut_arr_remove_range(yyjson_mut_val *arr, + size_t _idx, size_t _len) { + if (yyjson_likely(yyjson_mut_is_arr(arr))) { + yyjson_mut_val *prev, *next; + bool tail_removed; + size_t len = unsafe_yyjson_get_len(arr); + if (yyjson_unlikely(_idx + _len > len)) return false; + if (yyjson_unlikely(_len == 0)) return true; + unsafe_yyjson_set_len(arr, len - _len); + if (yyjson_unlikely(len == _len)) return true; + tail_removed = (_idx + _len == len); + prev = ((yyjson_mut_val *)arr->uni.ptr); + while (_idx-- > 0) prev = prev->next; + next = prev->next; + while (_len-- > 0) next = next->next; + prev->next = next; + if (yyjson_unlikely(tail_removed)) arr->uni.ptr = prev; + return true; + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_clear(yyjson_mut_val *arr) { + if (yyjson_likely(yyjson_mut_is_arr(arr))) { + unsafe_yyjson_set_len(arr, 0); + return true; + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_rotate(yyjson_mut_val *arr, + size_t idx) { + if (yyjson_likely(yyjson_mut_is_arr(arr) && + unsafe_yyjson_get_len(arr) > idx)) { + yyjson_mut_val *val = (yyjson_mut_val *)arr->uni.ptr; + while (idx-- > 0) val = val->next; + arr->uni.ptr = (void *)val; + return true; + } + return false; +} + + + +/*============================================================================== + * Mutable JSON Array Modification Convenience API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_mut_arr_add_val(yyjson_mut_val *arr, + yyjson_mut_val *val) { + return yyjson_mut_arr_append(arr, val); +} + +yyjson_api_inline bool yyjson_mut_arr_add_null(yyjson_mut_doc *doc, + yyjson_mut_val *arr) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_null(doc); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_true(yyjson_mut_doc *doc, + yyjson_mut_val *arr) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_true(doc); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_false(yyjson_mut_doc *doc, + yyjson_mut_val *arr) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_false(doc); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_bool(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + bool _val) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_bool(doc, _val); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_uint(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + uint64_t num) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_uint(doc, num); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_sint(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + int64_t num) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_sint(doc, num); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_int(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + int64_t num) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_sint(doc, num); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_real(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + double num) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_real(doc, num); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_str(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_str(doc, str); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_strn(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str, size_t len) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_strn(doc, str, len); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_strcpy(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_strcpy(doc, str); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_arr_add_strncpy(yyjson_mut_doc *doc, + yyjson_mut_val *arr, + const char *str, size_t len) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_strncpy(doc, str, len); + return yyjson_mut_arr_append(arr, val); + } + return false; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_arr(yyjson_mut_doc *doc, + yyjson_mut_val *arr) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_arr(doc); + return yyjson_mut_arr_append(arr, val) ? val : NULL; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_arr_add_obj(yyjson_mut_doc *doc, + yyjson_mut_val *arr) { + if (yyjson_likely(doc && yyjson_mut_is_arr(arr))) { + yyjson_mut_val *val = yyjson_mut_obj(doc); + return yyjson_mut_arr_append(arr, val) ? val : NULL; + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Object API (Implementation) + *============================================================================*/ + +yyjson_api_inline size_t yyjson_mut_obj_size(yyjson_mut_val *obj) { + return yyjson_mut_is_obj(obj) ? unsafe_yyjson_get_len(obj) : 0; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_get(yyjson_mut_val *obj, + const char *key) { + return yyjson_mut_obj_getn(obj, key, key ? strlen(key) : 0); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_getn(yyjson_mut_val *obj, + const char *_key, + size_t key_len) { + size_t len = yyjson_mut_obj_size(obj); + if (yyjson_likely(len && _key)) { + yyjson_mut_val *key = ((yyjson_mut_val *)obj->uni.ptr)->next->next; + while (len-- > 0) { + if (unsafe_yyjson_equals_strn(key, _key, key_len)) return key->next; + key = key->next->next; + } + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Object Iterator API (Implementation) + *============================================================================*/ + +yyjson_api_inline bool yyjson_mut_obj_iter_init(yyjson_mut_val *obj, + yyjson_mut_obj_iter *iter) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && iter)) { + iter->idx = 0; + iter->max = unsafe_yyjson_get_len(obj); + iter->cur = iter->max ? (yyjson_mut_val *)obj->uni.ptr : NULL; + iter->pre = NULL; + iter->obj = obj; + return true; + } + if (iter) memset(iter, 0, sizeof(yyjson_mut_obj_iter)); + return false; +} + +yyjson_api_inline yyjson_mut_obj_iter yyjson_mut_obj_iter_with( + yyjson_mut_val *obj) { + yyjson_mut_obj_iter iter; + yyjson_mut_obj_iter_init(obj, &iter); + return iter; +} + +yyjson_api_inline bool yyjson_mut_obj_iter_has_next(yyjson_mut_obj_iter *iter) { + return iter ? iter->idx < iter->max : false; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_next( + yyjson_mut_obj_iter *iter) { + if (iter && iter->idx < iter->max) { + yyjson_mut_val *key = iter->cur; + iter->pre = key; + iter->cur = key->next->next; + iter->idx++; + return iter->cur; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get_val( + yyjson_mut_val *key) { + return key ? key->next : NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_remove( + yyjson_mut_obj_iter *iter) { + if (yyjson_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) { + yyjson_mut_val *prev = iter->pre; + yyjson_mut_val *cur = iter->cur; + yyjson_mut_val *next = cur->next->next; + if (yyjson_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev; + iter->idx--; + iter->max--; + unsafe_yyjson_set_len(iter->obj, iter->max); + prev->next->next = next; + iter->cur = prev; + return cur->next; + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_get( + yyjson_mut_obj_iter *iter, const char *key) { + return yyjson_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_iter_getn( + yyjson_mut_obj_iter *iter, const char *key, size_t key_len) { + if (iter && key) { + size_t idx = 0; + size_t max = iter->max; + yyjson_mut_val *pre, *cur = iter->cur; + while (idx++ < max) { + pre = cur; + cur = cur->next->next; + if (unsafe_yyjson_equals_strn(cur, key, key_len)) { + iter->idx += idx; + if (iter->idx > max) iter->idx -= max + 1; + iter->pre = pre; + iter->cur = cur; + return cur->next; + } + } + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Object Creation API (Implementation) + *============================================================================*/ + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj(yyjson_mut_doc *doc) { + if (yyjson_likely(doc)) { + yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); + if (yyjson_likely(val)) { + val->tag = YYJSON_TYPE_OBJ | YYJSON_SUBTYPE_NONE; + return val; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_str(yyjson_mut_doc *doc, + const char **keys, + const char **vals, + size_t count) { + if (yyjson_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) { + yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2); + if (yyjson_likely(obj)) { + obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ; + if (count > 0) { + size_t i; + for (i = 0; i < count; i++) { + yyjson_mut_val *key = obj + (i * 2 + 1); + yyjson_mut_val *val = obj + (i * 2 + 2); + uint64_t key_len = (uint64_t)strlen(keys[i]); + uint64_t val_len = (uint64_t)strlen(vals[i]); + key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + key->uni.str = keys[i]; + val->uni.str = vals[i]; + key->next = val; + val->next = val + 1; + } + obj[count * 2].next = obj + 1; + obj->uni.ptr = obj + (count * 2 - 1); + } + return obj; + } + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_with_kv(yyjson_mut_doc *doc, + const char **pairs, + size_t count) { + if (yyjson_likely(doc && ((count > 0 && pairs) || (count == 0)))) { + yyjson_mut_val *obj = unsafe_yyjson_mut_val(doc, 1 + count * 2); + if (yyjson_likely(obj)) { + obj->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_OBJ; + if (count > 0) { + size_t i; + for (i = 0; i < count; i++) { + yyjson_mut_val *key = obj + (i * 2 + 1); + yyjson_mut_val *val = obj + (i * 2 + 2); + const char *key_str = pairs[i * 2 + 0]; + const char *val_str = pairs[i * 2 + 1]; + uint64_t key_len = (uint64_t)strlen(key_str); + uint64_t val_len = (uint64_t)strlen(val_str); + key->tag = (key_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->tag = (val_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + key->uni.str = key_str; + val->uni.str = val_str; + key->next = val; + val->next = val + 1; + } + obj[count * 2].next = obj + 1; + obj->uni.ptr = obj + (count * 2 - 1); + } + return obj; + } + } + return NULL; +} + + + +/*============================================================================== + * Mutable JSON Object Modification API (Implementation) + *============================================================================*/ + +yyjson_api_inline void unsafe_yyjson_mut_obj_add(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val, + size_t len) { + if (yyjson_likely(len)) { + yyjson_mut_val *prev_val = ((yyjson_mut_val *)obj->uni.ptr)->next; + yyjson_mut_val *next_key = prev_val->next; + prev_val->next = key; + val->next = next_key; + } else { + val->next = key; + } + key->next = val; + obj->uni.ptr = (void *)key; + unsafe_yyjson_set_len(obj, len + 1); +} + +yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_obj_remove( + yyjson_mut_val *obj, const char *key, size_t key_len) { + size_t obj_len = unsafe_yyjson_get_len(obj); + if (obj_len) { + yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr; + yyjson_mut_val *cur_key = pre_key->next->next; + yyjson_mut_val *removed_item = NULL; + size_t i; + for (i = 0; i < obj_len; i++) { + if (unsafe_yyjson_equals_strn(cur_key, key, key_len)) { + if (!removed_item) removed_item = cur_key->next; + cur_key = cur_key->next->next; + pre_key->next->next = cur_key; + if (i + 1 == obj_len) obj->uni.ptr = pre_key; + i--; + obj_len--; + } else { + pre_key = cur_key; + cur_key = cur_key->next->next; + } + } + unsafe_yyjson_set_len(obj, obj_len); + return removed_item; + } else { + return NULL; + } +} + +yyjson_api_inline bool unsafe_yyjson_mut_obj_replace(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val) { + size_t key_len = unsafe_yyjson_get_len(key); + size_t obj_len = unsafe_yyjson_get_len(obj); + if (obj_len) { + yyjson_mut_val *pre_key = (yyjson_mut_val *)obj->uni.ptr; + yyjson_mut_val *cur_key = pre_key->next->next; + size_t i; + for (i = 0; i < obj_len; i++) { + if (unsafe_yyjson_equals_strn(cur_key, key->uni.str, key_len)) { + cur_key->next->tag = val->tag; + cur_key->next->uni.u64 = val->uni.u64; + return true; + } else { + cur_key = cur_key->next->next; + } + } + } + return false; +} + +yyjson_api_inline void unsafe_yyjson_mut_obj_rotate(yyjson_mut_val *obj, + size_t idx) { + yyjson_mut_val *key = (yyjson_mut_val *)obj->uni.ptr; + while (idx-- > 0) key = key->next->next; + obj->uni.ptr = (void *)key; +} + +yyjson_api_inline bool yyjson_mut_obj_add(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && + yyjson_mut_is_str(key) && val)) { + unsafe_yyjson_mut_obj_add(obj, key, val, unsafe_yyjson_get_len(obj)); + return true; + } + return false; +} + +yyjson_api_inline bool yyjson_mut_obj_put(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val) { + bool replaced = false; + size_t key_len; + yyjson_mut_obj_iter iter; + yyjson_mut_val *cur_key; + if (yyjson_unlikely(!yyjson_mut_is_obj(obj) || + !yyjson_mut_is_str(key))) return false; + key_len = unsafe_yyjson_get_len(key); + yyjson_mut_obj_iter_init(obj, &iter); + while ((cur_key = yyjson_mut_obj_iter_next(&iter)) != 0) { + if (unsafe_yyjson_equals_strn(cur_key, key->uni.str, key_len)) { + if (!replaced && val) { + replaced = true; + val->next = cur_key->next->next; + cur_key->next = val; + } else { + yyjson_mut_obj_iter_remove(&iter); + } + } + } + if (!replaced && val) unsafe_yyjson_mut_obj_add(obj, key, val, iter.max); + return true; +} + +yyjson_api_inline bool yyjson_mut_obj_insert(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val, + size_t idx) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && + yyjson_mut_is_str(key) && val)) { + size_t len = unsafe_yyjson_get_len(obj); + if (yyjson_likely(len >= idx)) { + if (len > idx) { + void *ptr = obj->uni.ptr; + unsafe_yyjson_mut_obj_rotate(obj, idx); + unsafe_yyjson_mut_obj_add(obj, key, val, len); + obj->uni.ptr = ptr; + } else { + unsafe_yyjson_mut_obj_add(obj, key, val, len); + } + return true; + } + } + return false; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove(yyjson_mut_val *obj, + yyjson_mut_val *key) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && yyjson_mut_is_str(key))) { + return unsafe_yyjson_mut_obj_remove(obj, key->uni.str, + unsafe_yyjson_get_len(key)); + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_key( + yyjson_mut_val *obj, const char *key) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) { + size_t key_len = strlen(key); + return unsafe_yyjson_mut_obj_remove(obj, key, key_len); + } + return NULL; +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_keyn( + yyjson_mut_val *obj, const char *key, size_t key_len) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && key)) { + return unsafe_yyjson_mut_obj_remove(obj, key, key_len); + } + return NULL; +} + +yyjson_api_inline bool yyjson_mut_obj_clear(yyjson_mut_val *obj) { + if (yyjson_likely(yyjson_mut_is_obj(obj))) { + unsafe_yyjson_set_len(obj, 0); + return true; + } + return false; +} + +yyjson_api_inline bool yyjson_mut_obj_replace(yyjson_mut_val *obj, + yyjson_mut_val *key, + yyjson_mut_val *val) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && + yyjson_mut_is_str(key) && val)) { + return unsafe_yyjson_mut_obj_replace(obj, key, val); + } + return false; +} + +yyjson_api_inline bool yyjson_mut_obj_rotate(yyjson_mut_val *obj, + size_t idx) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && + unsafe_yyjson_get_len(obj) > idx)) { + unsafe_yyjson_mut_obj_rotate(obj, idx); + return true; + } + return false; +} + + + +/*============================================================================== + * Mutable JSON Object Modification Convenience API (Implementation) + *============================================================================*/ + +#define yyjson_mut_obj_add_func(func) \ + if (yyjson_likely(doc && yyjson_mut_is_obj(obj) && _key)) { \ + yyjson_mut_val *key = unsafe_yyjson_mut_val(doc, 2); \ + if (yyjson_likely(key)) { \ + size_t len = unsafe_yyjson_get_len(obj); \ + yyjson_mut_val *val = key + 1; \ + size_t key_len = strlen(_key); \ + bool noesc = unsafe_yyjson_is_str_noesc(_key, key_len); \ + key->tag = YYJSON_TYPE_STR; \ + key->tag |= noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; \ + key->tag |= (uint64_t)strlen(_key) << YYJSON_TAG_BIT; \ + key->uni.str = _key; \ + func \ + unsafe_yyjson_mut_obj_add(obj, key, val, len); \ + return true; \ + } \ + } \ + return false + +yyjson_api_inline bool yyjson_mut_obj_add_null(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_true(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_TRUE; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_false(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_BOOL | YYJSON_SUBTYPE_FALSE; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_bool(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + bool _val) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_BOOL | (uint8_t)((uint8_t)(_val) << 3); + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_uint(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + uint64_t _val) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT; + val->uni.u64 = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_sint(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + int64_t _val) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_int(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + int64_t _val) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT; + val->uni.i64 = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_real(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + double _val) { + yyjson_mut_obj_add_func({ + val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; + val->uni.f64 = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_str(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + const char *_val) { + if (yyjson_unlikely(!_val)) return false; + yyjson_mut_obj_add_func({ + size_t val_len = strlen(_val); + bool val_noesc = unsafe_yyjson_is_str_noesc(_val, val_len); + val->tag = ((uint64_t)strlen(_val) << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->tag |= val_noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; + val->uni.str = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_strn(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + const char *_val, + size_t _len) { + if (yyjson_unlikely(!_val)) return false; + yyjson_mut_obj_add_func({ + val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + val->uni.str = _val; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_strcpy(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + const char *_val) { + if (yyjson_unlikely(!_val)) return false; + yyjson_mut_obj_add_func({ + size_t _len = strlen(_val); + val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len); + if (yyjson_unlikely(!val->uni.str)) return false; + val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_strncpy(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + const char *_val, + size_t _len) { + if (yyjson_unlikely(!_val)) return false; + yyjson_mut_obj_add_func({ + val->uni.str = unsafe_yyjson_mut_strncpy(doc, _val, _len); + if (yyjson_unlikely(!val->uni.str)) return false; + val->tag = ((uint64_t)_len << YYJSON_TAG_BIT) | YYJSON_TYPE_STR; + }); +} + +yyjson_api_inline bool yyjson_mut_obj_add_val(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *_key, + yyjson_mut_val *_val) { + if (yyjson_unlikely(!_val)) return false; + yyjson_mut_obj_add_func({ + val = _val; + }); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_str(yyjson_mut_val *obj, + const char *key) { + return yyjson_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_obj_remove_strn( + yyjson_mut_val *obj, const char *_key, size_t _len) { + if (yyjson_likely(yyjson_mut_is_obj(obj) && _key)) { + yyjson_mut_val *key; + yyjson_mut_obj_iter iter; + yyjson_mut_val *val_removed = NULL; + yyjson_mut_obj_iter_init(obj, &iter); + while ((key = yyjson_mut_obj_iter_next(&iter)) != NULL) { + if (unsafe_yyjson_equals_strn(key, _key, _len)) { + if (!val_removed) val_removed = key->next; + yyjson_mut_obj_iter_remove(&iter); + } + } + return val_removed; + } + return NULL; +} + +yyjson_api_inline bool yyjson_mut_obj_rename_key(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + const char *new_key) { + if (!key || !new_key) return false; + return yyjson_mut_obj_rename_keyn(doc, obj, key, strlen(key), + new_key, strlen(new_key)); +} + +yyjson_api_inline bool yyjson_mut_obj_rename_keyn(yyjson_mut_doc *doc, + yyjson_mut_val *obj, + const char *key, + size_t len, + const char *new_key, + size_t new_len) { + char *cpy_key = NULL; + yyjson_mut_val *old_key; + yyjson_mut_obj_iter iter; + if (!doc || !obj || !key || !new_key) return false; + yyjson_mut_obj_iter_init(obj, &iter); + while ((old_key = yyjson_mut_obj_iter_next(&iter))) { + if (unsafe_yyjson_equals_strn((void *)old_key, key, len)) { + if (!cpy_key) { + cpy_key = unsafe_yyjson_mut_strncpy(doc, new_key, new_len); + if (!cpy_key) return false; + } + yyjson_mut_set_strn(old_key, cpy_key, new_len); + } + } + return cpy_key != NULL; +} + + + +/*============================================================================== + * JSON Pointer API (Implementation) + *============================================================================*/ + +#define yyjson_ptr_set_err(_code, _msg) do { \ + if (err) { \ + err->code = YYJSON_PTR_ERR_##_code; \ + err->msg = _msg; \ + err->pos = 0; \ + } \ +} while(false) + +/* require: val != NULL, *ptr == '/', len > 0 */ +yyjson_api yyjson_val *unsafe_yyjson_ptr_getx(yyjson_val *val, + const char *ptr, size_t len, + yyjson_ptr_err *err); + +/* require: val != NULL, *ptr == '/', len > 0 */ +yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_getx(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */ +yyjson_api bool unsafe_yyjson_mut_ptr_putx(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, bool insert_new, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +/* require: val/err != NULL, *ptr == '/', len > 0 */ +yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_replacex( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err); + +/* require: val/err != NULL, *ptr == '/', len > 0 */ +yyjson_api yyjson_mut_val *unsafe_yyjson_mut_ptr_removex(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err); + +yyjson_api_inline yyjson_val *yyjson_doc_ptr_get(yyjson_doc *doc, + const char *ptr) { + if (yyjson_unlikely(!ptr)) return NULL; + return yyjson_doc_ptr_getn(doc, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_val *yyjson_doc_ptr_getn(yyjson_doc *doc, + const char *ptr, size_t len) { + return yyjson_doc_ptr_getx(doc, ptr, len, NULL); +} + +yyjson_api_inline yyjson_val *yyjson_doc_ptr_getx(yyjson_doc *doc, + const char *ptr, size_t len, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (yyjson_unlikely(!doc || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + return doc->root; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_ptr_getx(doc->root, ptr, len, err); +} + +yyjson_api_inline yyjson_val *yyjson_ptr_get(yyjson_val *val, + const char *ptr) { + if (yyjson_unlikely(!ptr)) return NULL; + return yyjson_ptr_getn(val, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_val *yyjson_ptr_getn(yyjson_val *val, + const char *ptr, size_t len) { + return yyjson_ptr_getx(val, ptr, len, NULL); +} + +yyjson_api_inline yyjson_val *yyjson_ptr_getx(yyjson_val *val, + const char *ptr, size_t len, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (yyjson_unlikely(!val || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + return val; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_ptr_getx(val, ptr, len, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_get(yyjson_mut_doc *doc, + const char *ptr) { + if (!ptr) return NULL; + return yyjson_mut_doc_ptr_getn(doc, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getn(yyjson_mut_doc *doc, + const char *ptr, + size_t len) { + return yyjson_mut_doc_ptr_getx(doc, ptr, len, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_getx(yyjson_mut_doc *doc, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!doc || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + return doc->root; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_getx(doc->root, ptr, len, ctx, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_get(yyjson_mut_val *val, + const char *ptr) { + if (!ptr) return NULL; + return yyjson_mut_ptr_getn(val, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getn(yyjson_mut_val *val, + const char *ptr, + size_t len) { + return yyjson_mut_ptr_getx(val, ptr, len, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_getx(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!val || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + return val; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_getx(val, ptr, len, ctx, err); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_add(yyjson_mut_doc *doc, + const char *ptr, + yyjson_mut_val *new_val) { + if (yyjson_unlikely(!ptr)) return false; + return yyjson_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_addn(yyjson_mut_doc *doc, + const char *ptr, + size_t len, + yyjson_mut_val *new_val) { + return yyjson_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_addx(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!doc || !ptr || !new_val)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return false; + } + if (yyjson_unlikely(len == 0)) { + if (doc->root) { + yyjson_ptr_set_err(SET_ROOT, "cannot set document's root"); + return false; + } else { + doc->root = new_val; + return true; + } + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return false; + } + if (yyjson_unlikely(!doc->root && !create_parent)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return false; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_mut_val *root = yyjson_mut_obj(doc); + if (yyjson_unlikely(!root)) { + yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value"); + return false; + } + if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc, + create_parent, true, ctx, err)) { + doc->root = root; + return true; + } + return false; + } + return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc, + create_parent, true, ctx, err); +} + +yyjson_api_inline bool yyjson_mut_ptr_add(yyjson_mut_val *val, + const char *ptr, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc) { + if (yyjson_unlikely(!ptr)) return false; + return yyjson_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc); +} + +yyjson_api_inline bool yyjson_mut_ptr_addn(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc) { + return yyjson_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL); +} + +yyjson_api_inline bool yyjson_mut_ptr_addx(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!val || !ptr || !new_val || !doc)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return false; + } + if (yyjson_unlikely(len == 0)) { + yyjson_ptr_set_err(SET_ROOT, "cannot set root"); + return false; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return false; + } + return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, + doc, create_parent, true, ctx, err); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_set(yyjson_mut_doc *doc, + const char *ptr, + yyjson_mut_val *new_val) { + if (yyjson_unlikely(!ptr)) return false; + return yyjson_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_setn(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val) { + return yyjson_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL); +} + +yyjson_api_inline bool yyjson_mut_doc_ptr_setx(yyjson_mut_doc *doc, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!doc || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return false; + } + if (yyjson_unlikely(len == 0)) { + if (ctx) ctx->old = doc->root; + doc->root = new_val; + return true; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return false; + } + if (!new_val) { + if (!doc->root) { + yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved"); + return false; + } + return !!unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err); + } + if (yyjson_unlikely(!doc->root && !create_parent)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return false; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_mut_val *root = yyjson_mut_obj(doc); + if (yyjson_unlikely(!root)) { + yyjson_ptr_set_err(MEMORY_ALLOCATION, "failed to create value"); + return false; + } + if (unsafe_yyjson_mut_ptr_putx(root, ptr, len, new_val, doc, + create_parent, false, ctx, err)) { + doc->root = root; + return true; + } + return false; + } + return unsafe_yyjson_mut_ptr_putx(doc->root, ptr, len, new_val, doc, + create_parent, false, ctx, err); +} + +yyjson_api_inline bool yyjson_mut_ptr_set(yyjson_mut_val *val, + const char *ptr, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc) { + if (yyjson_unlikely(!ptr)) return false; + return yyjson_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc); +} + +yyjson_api_inline bool yyjson_mut_ptr_setn(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc) { + return yyjson_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL); +} + +yyjson_api_inline bool yyjson_mut_ptr_setx(yyjson_mut_val *val, + const char *ptr, size_t len, + yyjson_mut_val *new_val, + yyjson_mut_doc *doc, + bool create_parent, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!val || !ptr || !doc)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return false; + } + if (yyjson_unlikely(len == 0)) { + yyjson_ptr_set_err(SET_ROOT, "cannot set root"); + return false; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return false; + } + if (!new_val) { + return !!unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err); + } + return unsafe_yyjson_mut_ptr_putx(val, ptr, len, new_val, doc, + create_parent, false, ctx, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replace( + yyjson_mut_doc *doc, const char *ptr, yyjson_mut_val *new_val) { + if (!ptr) return NULL; + return yyjson_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacen( + yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val) { + return yyjson_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_replacex( + yyjson_mut_doc *doc, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) { + + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!doc || !ptr || !new_val)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + yyjson_mut_val *root = doc->root; + if (yyjson_unlikely(!root)) { + yyjson_ptr_set_err(RESOLVE, "JSON pointer cannot be resolved"); + return NULL; + } + if (ctx) ctx->old = root; + doc->root = new_val; + return root; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return NULL; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_replacex(doc->root, ptr, len, new_val, + ctx, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replace( + yyjson_mut_val *val, const char *ptr, yyjson_mut_val *new_val) { + if (!ptr) return NULL; + return yyjson_mut_ptr_replacen(val, ptr, strlen(ptr), new_val); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacen( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val) { + return yyjson_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_replacex( + yyjson_mut_val *val, const char *ptr, size_t len, yyjson_mut_val *new_val, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) { + + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!val || !ptr || !new_val)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + yyjson_ptr_set_err(SET_ROOT, "cannot set root"); + return NULL; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_replacex(val, ptr, len, new_val, ctx, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_remove( + yyjson_mut_doc *doc, const char *ptr) { + if (!ptr) return NULL; + return yyjson_mut_doc_ptr_removen(doc, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removen( + yyjson_mut_doc *doc, const char *ptr, size_t len) { + return yyjson_mut_doc_ptr_removex(doc, ptr, len, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_ptr_removex( + yyjson_mut_doc *doc, const char *ptr, size_t len, + yyjson_ptr_ctx *ctx, yyjson_ptr_err *err) { + + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!doc || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(!doc->root)) { + yyjson_ptr_set_err(NULL_ROOT, "document's root is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + yyjson_mut_val *root = doc->root; + if (ctx) ctx->old = root; + doc->root = NULL; + return root; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_removex(doc->root, ptr, len, ctx, err); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_remove(yyjson_mut_val *val, + const char *ptr) { + if (!ptr) return NULL; + return yyjson_mut_ptr_removen(val, ptr, strlen(ptr)); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removen(yyjson_mut_val *val, + const char *ptr, + size_t len) { + return yyjson_mut_ptr_removex(val, ptr, len, NULL, NULL); +} + +yyjson_api_inline yyjson_mut_val *yyjson_mut_ptr_removex(yyjson_mut_val *val, + const char *ptr, + size_t len, + yyjson_ptr_ctx *ctx, + yyjson_ptr_err *err) { + yyjson_ptr_set_err(NONE, NULL); + if (ctx) memset(ctx, 0, sizeof(*ctx)); + + if (yyjson_unlikely(!val || !ptr)) { + yyjson_ptr_set_err(PARAMETER, "input parameter is NULL"); + return NULL; + } + if (yyjson_unlikely(len == 0)) { + yyjson_ptr_set_err(SET_ROOT, "cannot set root"); + return NULL; + } + if (yyjson_unlikely(*ptr != '/')) { + yyjson_ptr_set_err(SYNTAX, "no prefix '/'"); + return NULL; + } + return unsafe_yyjson_mut_ptr_removex(val, ptr, len, ctx, err); +} + +yyjson_api_inline bool yyjson_ptr_ctx_append(yyjson_ptr_ctx *ctx, + yyjson_mut_val *key, + yyjson_mut_val *val) { + yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val; + if (!ctx || !ctx->ctn || !val) return false; + ctn = ctx->ctn; + + if (yyjson_mut_is_obj(ctn)) { + if (!key) return false; + key->next = val; + pre_key = ctx->pre; + if (unsafe_yyjson_get_len(ctn) == 0) { + val->next = key; + ctn->uni.ptr = key; + ctx->pre = key; + } else if (!pre_key) { + pre_key = (yyjson_mut_val *)ctn->uni.ptr; + pre_val = pre_key->next; + val->next = pre_val->next; + pre_val->next = key; + ctn->uni.ptr = key; + ctx->pre = pre_key; + } else { + cur_key = pre_key->next->next; + cur_val = cur_key->next; + val->next = cur_val->next; + cur_val->next = key; + if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key; + ctx->pre = cur_key; + } + } else { + pre_val = ctx->pre; + if (unsafe_yyjson_get_len(ctn) == 0) { + val->next = val; + ctn->uni.ptr = val; + ctx->pre = val; + } else if (!pre_val) { + pre_val = (yyjson_mut_val *)ctn->uni.ptr; + val->next = pre_val->next; + pre_val->next = val; + ctn->uni.ptr = val; + ctx->pre = pre_val; + } else { + cur_val = pre_val->next; + val->next = cur_val->next; + cur_val->next = val; + if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val; + ctx->pre = cur_val; + } + } + unsafe_yyjson_inc_len(ctn); + return true; +} + +yyjson_api_inline bool yyjson_ptr_ctx_replace(yyjson_ptr_ctx *ctx, + yyjson_mut_val *val) { + yyjson_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val; + if (!ctx || !ctx->ctn || !ctx->pre || !val) return false; + ctn = ctx->ctn; + if (yyjson_mut_is_obj(ctn)) { + pre_key = ctx->pre; + pre_val = pre_key->next; + cur_key = pre_val->next; + cur_val = cur_key->next; + /* replace current value */ + cur_key->next = val; + val->next = cur_val->next; + ctx->old = cur_val; + } else { + pre_val = ctx->pre; + cur_val = pre_val->next; + /* replace current value */ + if (pre_val != cur_val) { + val->next = cur_val->next; + pre_val->next = val; + if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val; + } else { + val->next = val; + ctn->uni.ptr = val; + ctx->pre = val; + } + ctx->old = cur_val; + } + return true; +} + +yyjson_api_inline bool yyjson_ptr_ctx_remove(yyjson_ptr_ctx *ctx) { + yyjson_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val; + size_t len; + if (!ctx || !ctx->ctn || !ctx->pre) return false; + ctn = ctx->ctn; + if (yyjson_mut_is_obj(ctn)) { + pre_key = ctx->pre; + pre_val = pre_key->next; + cur_key = pre_val->next; + cur_val = cur_key->next; + /* remove current key-value */ + pre_val->next = cur_val->next; + if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key; + ctx->pre = NULL; + ctx->old = cur_val; + } else { + pre_val = ctx->pre; + cur_val = pre_val->next; + /* remove current key-value */ + pre_val->next = cur_val->next; + if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val; + ctx->pre = NULL; + ctx->old = cur_val; + } + len = unsafe_yyjson_get_len(ctn) - 1; + if (len == 0) ctn->uni.ptr = NULL; + unsafe_yyjson_set_len(ctn, len); + return true; +} + +#undef yyjson_ptr_set_err + + + +/*============================================================================== + * JSON Value at Pointer API (Implementation) + *============================================================================*/ + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type bool. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_bool( + yyjson_val *root, const char *ptr, bool *value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_bool(val)) { + *value = unsafe_yyjson_get_bool(val); + return true; + } else { + return false; + } +} + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type uint. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_uint( + yyjson_val *root, const char *ptr, uint64_t *value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_uint(val)) { + *value = unsafe_yyjson_get_uint(val); + return true; + } else { + return false; + } +} + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_sint( + yyjson_val *root, const char *ptr, int64_t *value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_sint(val)) { + *value = unsafe_yyjson_get_sint(val); + return true; + } else { + return false; + } +} + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type real. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_real( + yyjson_val *root, const char *ptr, double *value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_real(val)) { + *value = unsafe_yyjson_get_real(val); + return true; + } else { + return false; + } +} + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type sint, + uint or real. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_num( + yyjson_val *root, const char *ptr, double *value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_num(val)) { + *value = unsafe_yyjson_get_num(val); + return true; + } else { + return false; + } +} + +/** + Set provided `value` if the JSON Pointer (RFC 6901) exists and is type string. + Returns true if value at `ptr` exists and is the correct type, otherwise false. + */ +yyjson_api_inline bool yyjson_ptr_get_str( + yyjson_val *root, const char *ptr, const char **value) { + yyjson_val *val = yyjson_ptr_get(root, ptr); + if (value && yyjson_is_str(val)) { + *value = unsafe_yyjson_get_str(val); + return true; + } else { + return false; + } +} + + + +/*============================================================================== + * Deprecated + *============================================================================*/ + +/** @deprecated renamed to `yyjson_doc_ptr_get` */ +yyjson_deprecated("renamed to yyjson_doc_ptr_get") +yyjson_api_inline yyjson_val *yyjson_doc_get_pointer(yyjson_doc *doc, + const char *ptr) { + return yyjson_doc_ptr_get(doc, ptr); +} + +/** @deprecated renamed to `yyjson_doc_ptr_getn` */ +yyjson_deprecated("renamed to yyjson_doc_ptr_getn") +yyjson_api_inline yyjson_val *yyjson_doc_get_pointern(yyjson_doc *doc, + const char *ptr, + size_t len) { + return yyjson_doc_ptr_getn(doc, ptr, len); +} + +/** @deprecated renamed to `yyjson_mut_doc_ptr_get` */ +yyjson_deprecated("renamed to yyjson_mut_doc_ptr_get") +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointer( + yyjson_mut_doc *doc, const char *ptr) { + return yyjson_mut_doc_ptr_get(doc, ptr); +} + +/** @deprecated renamed to `yyjson_mut_doc_ptr_getn` */ +yyjson_deprecated("renamed to yyjson_mut_doc_ptr_getn") +yyjson_api_inline yyjson_mut_val *yyjson_mut_doc_get_pointern( + yyjson_mut_doc *doc, const char *ptr, size_t len) { + return yyjson_mut_doc_ptr_getn(doc, ptr, len); +} + +/** @deprecated renamed to `yyjson_ptr_get` */ +yyjson_deprecated("renamed to yyjson_ptr_get") +yyjson_api_inline yyjson_val *yyjson_get_pointer(yyjson_val *val, + const char *ptr) { + return yyjson_ptr_get(val, ptr); +} + +/** @deprecated renamed to `yyjson_ptr_getn` */ +yyjson_deprecated("renamed to yyjson_ptr_getn") +yyjson_api_inline yyjson_val *yyjson_get_pointern(yyjson_val *val, + const char *ptr, + size_t len) { + return yyjson_ptr_getn(val, ptr, len); +} + +/** @deprecated renamed to `yyjson_mut_ptr_get` */ +yyjson_deprecated("renamed to yyjson_mut_ptr_get") +yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointer(yyjson_mut_val *val, + const char *ptr) { + return yyjson_mut_ptr_get(val, ptr); +} + +/** @deprecated renamed to `yyjson_mut_ptr_getn` */ +yyjson_deprecated("renamed to yyjson_mut_ptr_getn") +yyjson_api_inline yyjson_mut_val *yyjson_mut_get_pointern(yyjson_mut_val *val, + const char *ptr, + size_t len) { + return yyjson_mut_ptr_getn(val, ptr, len); +} + +/** @deprecated renamed to `yyjson_mut_ptr_getn` */ +yyjson_deprecated("renamed to unsafe_yyjson_ptr_getn") +yyjson_api_inline yyjson_val *unsafe_yyjson_get_pointer(yyjson_val *val, + const char *ptr, + size_t len) { + yyjson_ptr_err err; + return unsafe_yyjson_ptr_getx(val, ptr, len, &err); +} + +/** @deprecated renamed to `unsafe_yyjson_mut_ptr_getx` */ +yyjson_deprecated("renamed to unsafe_yyjson_mut_ptr_getx") +yyjson_api_inline yyjson_mut_val *unsafe_yyjson_mut_get_pointer( + yyjson_mut_val *val, const char *ptr, size_t len) { + yyjson_ptr_err err; + return unsafe_yyjson_mut_ptr_getx(val, ptr, len, NULL, &err); +} + + + +/*============================================================================== + * Compiler Hint End + *============================================================================*/ + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) +# pragma GCC diagnostic pop +# endif +#elif defined(_MSC_VER) +# pragma warning(pop) +#endif /* warning suppress end */ + +#ifdef __cplusplus +} +#endif /* extern "C" end */ + +#endif /* YYJSON_H */ diff --git a/src/detection/terminalfont/terminalfont.c b/src/detection/terminalfont/terminalfont.c index 515c253501..c080fdd7e0 100644 --- a/src/detection/terminalfont/terminalfont.c +++ b/src/detection/terminalfont/terminalfont.c @@ -62,7 +62,6 @@ FF_MAYBE_UNUSED static void detectTTY(FFTerminalFontResult* terminalFont) #include "common/processing.h" #include -#include static const char* detectWTProfile(yyjson_val* profile, FFstrbuf* name, double* size) { diff --git a/src/fastfetch.h b/src/fastfetch.h index 3e77c204b5..06b2ee57e4 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -7,7 +7,8 @@ #include #include -#include + +#include "3rdparty/yyjson/yyjson.h" #include "util/FFstrbuf.h" #include "util/FFlist.h" From ee4bc2302a28181cf89d28bd5c46e744fd1f6553 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 14 Aug 2023 20:19:23 +0800 Subject: [PATCH 02/37] Chore: move mk_wcwidch to 3rdparty folder --- CMakeLists.txt | 2 +- src/3rdparty/mk_wcwidch/repo.json | 7 +++++++ src/{util => 3rdparty/mk_wcwidch}/wcwidth.c | 0 3 files changed, 8 insertions(+), 1 deletion(-) create mode 100644 src/3rdparty/mk_wcwidch/repo.json rename src/{util => 3rdparty/mk_wcwidch}/wcwidth.c (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 63b6df913e..f8d3d3ca76 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -601,7 +601,7 @@ endif() include(CheckFunctionExists) check_function_exists(wcwidth HAVE_WCWIDTH) if(NOT HAVE_WCWIDTH) - list(APPEND LIBFASTFETCH_SRC src/util/wcwidth.c) + list(APPEND LIBFASTFETCH_SRC src/3rdparty/mk_wcwidch/wcwidth.c) endif() add_library(libfastfetch OBJECT diff --git a/src/3rdparty/mk_wcwidch/repo.json b/src/3rdparty/mk_wcwidch/repo.json new file mode 100644 index 0000000000..8a71b4b811 --- /dev/null +++ b/src/3rdparty/mk_wcwidch/repo.json @@ -0,0 +1,7 @@ +{ + "home": "https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c", + "license": "Embed in source", + "version": "2007-05-26 (Unicode 5.0)", + "author": "Markus Kuhn", + "modified": "CarterLi" +} diff --git a/src/util/wcwidth.c b/src/3rdparty/mk_wcwidch/wcwidth.c similarity index 100% rename from src/util/wcwidth.c rename to src/3rdparty/mk_wcwidch/wcwidth.c From 3ff3feb0e110b8a5628af6945a8db2da926dba89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 14 Aug 2023 20:26:08 +0800 Subject: [PATCH 03/37] EdidHelper: silence compiler warnings --- src/util/edidHelper.c | 2 +- src/util/edidHelper.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/edidHelper.c b/src/util/edidHelper.c index 456d8c58be..5a375dfcf4 100644 --- a/src/util/edidHelper.c +++ b/src/util/edidHelper.c @@ -73,7 +73,7 @@ bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length) return true; } } - i += blkLen + 1; + i += (uint8_t) (blkLen + 1); } } return false; diff --git a/src/util/edidHelper.h b/src/util/edidHelper.h index 2009263761..75fa6ce8cb 100644 --- a/src/util/edidHelper.h +++ b/src/util/edidHelper.h @@ -10,6 +10,6 @@ void ffEdidGetVendorAndModel(const uint8_t edid[128], FFstrbuf* result); bool ffEdidGetName(const uint8_t edid[128], FFstrbuf* name); void ffEdidGetPhysicalResolution(const uint8_t edid[128], uint32_t* width, uint32_t* height); void ffEdidGetPhysicalSize(const uint8_t edid[128], uint32_t* width, uint32_t* height); // in mm -bool ffEdidGetHdrCompatible(const uint8_t edid[128], uint32_t length); +bool ffEdidGetHdrCompatible(const uint8_t* edid, uint32_t length); #endif From 2b2ebe0823faa46c02ae024025e9d826339e5dba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 15:05:51 +0800 Subject: [PATCH 04/37] Logo (Builtin): update venom; add venom_small --- src/logo/ascii/venom.txt | 34 +++++++++++++++++++--------------- src/logo/ascii/venom_small.txt | 11 +++++++++++ src/logo/builtin.c | 10 ++++++++++ 3 files changed, 40 insertions(+), 15 deletions(-) create mode 100644 src/logo/ascii/venom_small.txt diff --git a/src/logo/ascii/venom.txt b/src/logo/ascii/venom.txt index 680c12f94a..0512a79395 100644 --- a/src/logo/ascii/venom.txt +++ b/src/logo/ascii/venom.txt @@ -1,15 +1,19 @@ -::::::: ::::::: -mMMMMMMm dMMMMMMm -/MMMMMMMo +MMMMMMM/ - yMMMMMMN mMMMMMMy - NMMMMMMs oMMMMMMm - +MMMMMMN: NMMMMMM+ - hMMMMMMy sMMMMMMy - :NMMMMMM::NMMMMMN: - oMMMMMMyyMMMMMM+ - dMMMMMMMMMMMMh - /MMMMMMMMMMMN: - sMMMMMMMMMMo - mMMMMMMMMd - +MMMMMMMN: - :::::: +`-` + -yys+/-` + `oyyyyy: /osyyyyso+:. + /yyyyy+`+yyyyyyyyyys/. + .-yyyyys.:+//+oyyyyyyyo. + `oy/`oyyyyy/ ./syyyyy: + syyys`:yyyyyo` :yyyyy: + /yyyyo .syyyyy- .yyyyy. + yyyyy. +yyyyy/ /yyyy/ +`yyyyy :yyyyys` -yyyyo + yyyyy. `syyyyy- /yyyy/ + /yyyyo /yyyyy+ .yyyyy. + syyyys. -yyyyys.:yyyy: + `oyyyyyo-` `oyyyyy:.sy: + :syyyyyyso+/++`/yyyyyo`` + -oyyyyyyyyyyy-.syyyys. + -/+osyyyyso.`+yyyyy/ + .-/+syo` + `. diff --git a/src/logo/ascii/venom_small.txt b/src/logo/ascii/venom_small.txt new file mode 100644 index 0000000000..c1c17b483b --- /dev/null +++ b/src/logo/ascii/venom_small.txt @@ -0,0 +1,11 @@ + ++** + *===**====+* + *====* +===+ + *==*+===* *===* +*===* *===+ *===* +*===* +===+ *===* +*===* +===* *===* + *===* *===+*==* + +===+ *===+=* + *+====**===* + **++ diff --git a/src/logo/builtin.c b/src/logo/builtin.c index 8e1438d5be..22f2d44061 100644 --- a/src/logo/builtin.c +++ b/src/logo/builtin.c @@ -3899,6 +3899,16 @@ static const FFlogo V[] = { FF_COLOR_FG_BLUE, }, }, + // VenomSmall + { + .names = {"Venom_small"}, + .type = FF_LOGO_LINE_TYPE_SMALL_BIT, + .lines = FASTFETCH_DATATEXT_LOGO_VENOM_SMALL, + .colors = { + FF_COLOR_FG_LIGHT_BLACK, + FF_COLOR_FG_BLUE, + }, + }, // Vnux { .names = {"Vnux"}, From 8835f66b8cfca416dc4f0f398e69da830dd856ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 16:39:20 +0800 Subject: [PATCH 05/37] Fastfetch: unescape strings only when parsing `.conf` files So that `NO_CONFIG=1 ./fastfetch --os-key \\\\ -s os -l none` prints `\\: *` --- CHANGELOG.md | 7 +++++++ src/common/printing.c | 36 ++--------------------------------- src/common/printing.h | 1 - src/fastfetch.c | 38 ++++++++++++++++++++++++++++++++++++- src/modules/custom/custom.c | 2 +- 5 files changed, 47 insertions(+), 37 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 89cfb0b402..b1098eb19a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,10 @@ +# 2.0.1 + +Changes: +* Unescape strings only when parsing `.conf` files + * Previously: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\: *`. Note the backslashs are unescaped twice (once by shell and once by fastfetch). + * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *` + # 2.0.0 (beta) Fastfetch v2 introduces a new configuration file format: JSON config. Please refer to for details. diff --git a/src/common/printing.c b/src/common/printing.c index 1ef1a0ea68..35ab27aa03 100644 --- a/src/common/printing.c +++ b/src/common/printing.c @@ -36,7 +36,7 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrb ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){ {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex} }); - ffPrintUserString(key.chars); + ffStrbufWriteTo(&key, stdout); } if(!instance.config.pipe) @@ -56,8 +56,7 @@ void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFst if(buffer.length > 0) { ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor); - ffPrintUserString(buffer.chars); - putchar('\n'); + ffStrbufPutTo(&buffer, stdout); } } @@ -125,34 +124,3 @@ void ffPrintCharTimes(char c, uint32_t times) if(remaining > 0) fwrite(str, 1, remaining, stdout); } - -void ffPrintUserString(const char* value) -{ - while(*value != '\0') - { - if(*value != '\\') - { - putchar(*value); - ++value; - continue; - } - - ++value; - - if(*value == 'n') - putchar('\n'); - else if(*value == 't') - putchar('\t'); - else if(*value == 'e') - putchar('\e'); - else if(*value == '\\') - putchar('\\'); - else - { - putchar('\\'); - putchar(*value); - } - - ++value; - } -} diff --git a/src/common/printing.h b/src/common/printing.h index 8019a01cc6..e25c0f82c8 100644 --- a/src/common/printing.h +++ b/src/common/printing.h @@ -13,6 +13,5 @@ FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t module FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...); void ffPrintColor(const FFstrbuf* colorValue); void ffPrintCharTimes(char c, uint32_t times); -void ffPrintUserString(const char* str); #endif diff --git a/src/fastfetch.c b/src/fastfetch.c index e0e32f9d71..00d3d43ffe 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -584,6 +584,7 @@ static bool parseConfigFile(FFdata* data, const char* path) char* line = NULL; size_t len = 0; ssize_t read; + FF_STRBUF_AUTO_DESTROY unescaped = ffStrbufCreate(); while ((read = getline(&line, &len, file)) != -1) { @@ -628,7 +629,42 @@ static bool parseConfigFile(FFdata* data, const char* path) --lineEnd; } - parseOption(data, lineStart, valueStart); + if (strchr(valueStart, '\\')) + { + // Unescape all `\x`s + const char* value = valueStart; + while(*value != '\0') + { + if(*value != '\\') + { + ffStrbufAppendC(&unescaped, *value); + ++value; + continue; + } + + ++value; + + switch(*value) + { + case 'n': ffStrbufAppendC(&unescaped, '\n'); break; + case 't': ffStrbufAppendC(&unescaped, '\t'); break; + case 'e': ffStrbufAppendC(&unescaped, '\e'); break; + case '\\': ffStrbufAppendC(&unescaped, '\\'); break; + default: + ffStrbufAppendC(&unescaped, '\\'); + ffStrbufAppendC(&unescaped, *value); + break; + } + + ++value; + } + parseOption(data, lineStart, unescaped.chars); + ffStrbufClear(&unescaped); + } + else + { + parseOption(data, lineStart, valueStart); + } } if(line != NULL) diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c index 64ab00579a..105823651c 100644 --- a/src/modules/custom/custom.c +++ b/src/modules/custom/custom.c @@ -13,7 +13,7 @@ void ffPrintCustom(FFCustomOptions* options) } ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); - ffPrintUserString(options->moduleArgs.outputFormat.chars); + ffStrbufWriteTo(&options->moduleArgs.outputFormat, stdout); puts(FASTFETCH_TEXT_MODIFIER_RESET); } From c70787bde910f091c9405737ed8aa6a210eb302d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 16:52:35 +0800 Subject: [PATCH 06/37] Fastfetch: tidy --- src/fastfetch.h | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/fastfetch.h b/src/fastfetch.h index 06b2ee57e4..d8d4ccde71 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -54,6 +54,7 @@ typedef struct FFconfig uint8_t sizeNdigits; uint8_t sizeMaxPrefix; FFTemperatureUnit temperatureUnit; + uint32_t percentType; bool pipe; //disables logo and all escape sequences bool multithreading; bool stat; @@ -147,10 +148,6 @@ typedef struct FFconfig FFstrbuf libPulse; FFstrbuf libnm; FFstrbuf libDdcutil; - - uint32_t percentType; - - bool jsonConfig; } FFconfig; typedef struct FFstate From 20c2cdf7ba13b0033de94a07d127dd9627662eb7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 19:19:26 +0800 Subject: [PATCH 07/37] Monitor (Linux): fix EDID file reading Its file length is always 0 --- src/detection/monitor/monitor_linux.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/src/detection/monitor/monitor_linux.c b/src/detection/monitor/monitor_linux.c index a04276412e..5c72304fa1 100644 --- a/src/detection/monitor/monitor_linux.c +++ b/src/detection/monitor/monitor_linux.c @@ -3,7 +3,6 @@ #include "common/io/io.h" #include "util/edidHelper.h" #include "util/stringUtils.h" -#include "util/mallocHelper.h" #include #include @@ -30,15 +29,9 @@ const char* ffDetectMonitor(FFlist* results) ffStrbufAppendS(&drmDir, entry->d_name); ffStrbufAppendS(&drmDir, "/edid"); - struct stat fileStat; - if (stat(drmDir.chars, &fileStat) < 0 || fileStat.st_size == 0 || fileStat.st_size % 128 != 0) - { - ffStrbufSubstrBefore(&drmDir, drmDirLength); - continue; - } - - FF_AUTO_FREE uint8_t* edidData = malloc((size_t) fileStat.st_size); - if(ffReadFileData(drmDir.chars, sizeof(edidData), edidData) != sizeof(edidData)) + uint8_t edidData[512]; + ssize_t edidLength = ffReadFileData(drmDir.chars, sizeof(edidData), edidData); + if(edidLength <= 0 || edidLength % 128 != 0) { ffStrbufSubstrBefore(&drmDir, drmDirLength); continue; @@ -54,7 +47,7 @@ const char* ffDetectMonitor(FFlist* results) ffStrbufInit(&display->name); ffEdidGetName(edidData, &display->name); ffEdidGetPhysicalSize(edidData, &display->physicalWidth, &display->physicalHeight); - display->hdrCompatible = ffEdidGetHdrCompatible(edidData, (uint32_t) fileStat.st_size); + display->hdrCompatible = ffEdidGetHdrCompatible(edidData, (uint32_t) edidLength); } ffStrbufSubstrBefore(&drmDir, drmDirLength); From e6be90614a82ae7430d8f1e1375b708890fc09e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 17:10:09 +0800 Subject: [PATCH 08/37] fastfetch: support `--key-width` --- CHANGELOG.md | 5 ++++- doc/json_schema.json | 5 +++++ src/common/init.c | 1 + src/common/jsonconfig.c | 2 ++ src/common/printing.c | 3 +++ src/fastfetch.c | 2 ++ src/fastfetch.h | 1 + 7 files changed, 18 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b1098eb19a..83883afcbf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,10 @@ Changes: * Previously: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\: *`. Note the backslashs are unescaped twice (once by shell and once by fastfetch). * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *` -# 2.0.0 (beta) +Features: +* Add `--key-width` for aligning the left edge of values + +# 2.0.0-beta Fastfetch v2 introduces a new configuration file format: JSON config. Please refer to for details. diff --git a/doc/json_schema.json b/doc/json_schema.json index 279aac96c7..f311c92cb3 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -221,6 +221,11 @@ "title": "Use multiple threads to detect values", "default": true }, + "thread": { + "type": "boolean", + "title": "Alias of multithreading", + "default": true + }, "stat": { "type": "boolean", "title": "Show time usage (in ms) for individual modules", diff --git a/src/common/init.c b/src/common/init.c index a74be3e331..f102ef66af 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -68,6 +68,7 @@ static void defaultConfig(void) instance.config.multithreading = true; instance.config.stat = false; instance.config.noBuffer = false; + instance.config.keyWidth = 0; ffInitTitleOptions(&instance.config.title); ffInitOSOptions(&instance.config.os); diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index 7b623d7c57..601d8b4804 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -433,6 +433,8 @@ const char* ffParseDisplayJsonConfig(void) config->percentType = (uint32_t) yyjson_get_uint(val); else if (ffStrEqualsIgnCase(key, "noBuffer")) config->noBuffer = yyjson_get_bool(val); + else if (ffStrEqualsIgnCase(key, "keyWidth")) + config->keyWidth = (uint32_t) yyjson_get_uint(val); else return "Unknown display property"; } diff --git a/src/common/printing.c b/src/common/printing.c index 35ab27aa03..f62f50fa61 100644 --- a/src/common/printing.c +++ b/src/common/printing.c @@ -46,6 +46,9 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrb if(!instance.config.pipe) fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout); + + if (instance.config.keyWidth > 0) + printf("\e[%uG", (unsigned) (instance.config.keyWidth + instance.state.logoWidth)); } void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments) diff --git a/src/fastfetch.c b/src/fastfetch.c index 00d3d43ffe..58fd773e69 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -997,6 +997,8 @@ static void parseOption(FFdata* data, const char* key, const char* value) optionCheckString(key, value, &instance.config.colorTitle); ffOptionParseColor(value, &instance.config.colorTitle); } + else if(ffStrEqualsIgnCase(key, "--key-width")) + instance.config.keyWidth = ffOptionParseUInt32(key, value); else if(ffStrEqualsIgnCase(key, "--bright-color")) instance.config.brightColor = ffOptionParseBoolean(value); else if(ffStrEqualsIgnCase(key, "-c") || ffStrEqualsIgnCase(key, "--color")) diff --git a/src/fastfetch.h b/src/fastfetch.h index d8d4ccde71..3af517c7b3 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -60,6 +60,7 @@ typedef struct FFconfig bool stat; bool noBuffer; int32_t processingTimeout; + uint32_t keyWidth; // Module options that cannot be put in module option structure #if defined(__linux__) || defined(__FreeBSD__) From 98b9ef74cf06f764fe026ca4b5fc017d5bf6edc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 20:10:01 +0800 Subject: [PATCH 09/37] Disk (Linux): fix label detection --- CHANGELOG.md | 3 +++ src/detection/disk/disk_linux.c | 12 ++++-------- src/modules/disk/disk.c | 5 +++-- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 83883afcbf..041f0f97fd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,9 @@ Changes: Features: * Add `--key-width` for aligning the left edge of values +Bugfixes: +* Fix label detection (Disk, Linux) + # 2.0.0-beta Fastfetch v2 introduces a new configuration file format: JSON config. Please refer to for details. diff --git a/src/detection/disk/disk_linux.c b/src/detection/disk/disk_linux.c index afde1887e0..4241073316 100644 --- a/src/detection/disk/disk_linux.c +++ b/src/detection/disk/disk_linux.c @@ -122,20 +122,16 @@ static void detectName(FFDisk* disk, const FFstrbuf* device) FF_STRBUF_AUTO_DESTROY basePath = ffStrbufCreate(); - //Try partlabel first - ffStrbufSetS(&basePath, "/dev/disk/by-partlabel/"); + //Try label first + ffStrbufSetS(&basePath, "/dev/disk/by-label/"); detectNameFromPath(disk, &deviceStat, &basePath); - //Try label second if(disk->name.length == 0) { - ffStrbufSetS(&basePath, "/dev/disk/by-label/"); + //Try partlabel second + ffStrbufSetS(&basePath, "/dev/disk/by-partlabel/"); detectNameFromPath(disk, &deviceStat, &basePath); } - - //Use the mountpoint as a last resort - if(disk->name.length == 0) - ffStrbufAppend(&disk->name, &disk->mountpoint); } #ifdef __ANDROID__ diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c index 151596c27f..8346f38a45 100644 --- a/src/modules/disk/disk.c +++ b/src/modules/disk/disk.c @@ -34,8 +34,9 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) } else { - ffParseFormatString(&key, &options->moduleArgs.key, 1, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, &disk->mountpoint} + ffParseFormatString(&key, &options->moduleArgs.key, 2, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_STRBUF, &disk->mountpoint}, + {FF_FORMAT_ARG_TYPE_STRBUF, &disk->name}, }); } From ed9639c66bcec6955aa24fbaf45db6a162062b3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 20:59:29 +0800 Subject: [PATCH 10/37] Disk (Linux): replace all `\\x20` to real charactors in disk label --- src/detection/disk/disk_linux.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/detection/disk/disk_linux.c b/src/detection/disk/disk_linux.c index 4241073316..1d2e111b4e 100644 --- a/src/detection/disk/disk_linux.c +++ b/src/detection/disk/disk_linux.c @@ -132,6 +132,22 @@ static void detectName(FFDisk* disk, const FFstrbuf* device) ffStrbufSetS(&basePath, "/dev/disk/by-partlabel/"); detectNameFromPath(disk, &deviceStat, &basePath); } + + // Basic\x20data\x20partition + for (uint32_t i = ffStrbufFirstIndexS(&disk->name, "\\x"); + i != disk->name.length; + i = ffStrbufNextIndexS(&disk->name, i + 1, "\\x")) + { + uint32_t len = (uint32_t) strlen("\\x20"); + if (disk->name.length >= len) + { + char bak = disk->name.chars[i + len]; + disk->name.chars[i + len] = '\0'; + disk->name.chars[i] = (char) strtoul(&disk->name.chars[i + 2], NULL, 16); + ffStrbufRemoveSubstr(&disk->name, i + 1, i + len); + disk->name.chars[i + 1] = bak; + } + } } #ifdef __ANDROID__ From 8ed28673a9d11be307467ae9e617400cefc7eee7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Tue, 15 Aug 2023 21:40:22 +0800 Subject: [PATCH 11/37] Global: support `--module-key-width` per module --- doc/json_schema.json | 57 +++++++++++++++++++++++++ src/common/jsonconfig.c | 11 +++-- src/common/option.c | 10 ++++- src/common/option.h | 1 + src/common/printing.c | 45 ++++++++++--------- src/common/printing.h | 19 +++++++-- src/data/help.txt | 2 + src/fastfetch.c | 2 +- src/modules/battery/battery.c | 2 +- src/modules/bios/bios.c | 2 +- src/modules/bluetooth/bluetooth.c | 2 +- src/modules/board/board.c | 2 +- src/modules/brightness/brightness.c | 10 +++-- src/modules/chassis/chassis.c | 2 +- src/modules/colors/colors.c | 4 +- src/modules/command/command.c | 2 +- src/modules/cpu/cpu.c | 2 +- src/modules/cpuusage/cpuusage.c | 2 +- src/modules/cursor/cursor.c | 2 +- src/modules/custom/custom.c | 2 +- src/modules/datetime/datetime.c | 2 +- src/modules/de/de.c | 2 +- src/modules/disk/disk.c | 4 +- src/modules/display/display.c | 47 ++++++++++---------- src/modules/font/font.c | 2 +- src/modules/gamepad/gamepad.c | 2 +- src/modules/gpu/gpu.c | 2 +- src/modules/host/host.c | 2 +- src/modules/icons/icons.c | 2 +- src/modules/kernel/kernel.c | 2 +- src/modules/lm/lm.c | 2 +- src/modules/locale/locale.c | 2 +- src/modules/localip/localip.c | 16 ++++--- src/modules/media/media.c | 2 +- src/modules/memory/memory.c | 2 +- src/modules/monitor/monitor.c | 32 ++++++++------ src/modules/opencl/opencl.c | 2 +- src/modules/opengl/opengl.c | 2 +- src/modules/os/os.c | 2 +- src/modules/packages/packages.c | 2 +- src/modules/player/player.c | 2 +- src/modules/poweradapter/poweradapter.c | 2 +- src/modules/processes/processes.c | 2 +- src/modules/publicip/publicip.c | 2 +- src/modules/separator/separator.c | 2 +- src/modules/shell/shell.c | 2 +- src/modules/sound/sound.c | 2 +- src/modules/swap/swap.c | 2 +- src/modules/terminal/terminal.c | 2 +- src/modules/terminalfont/terminalfont.c | 2 +- src/modules/terminalsize/terminalsize.c | 2 +- src/modules/theme/theme.c | 2 +- src/modules/title/title.c | 4 +- src/modules/uptime/uptime.c | 2 +- src/modules/users/users.c | 2 +- src/modules/vulkan/vulkan.c | 2 +- src/modules/wallpaper/wallpaper.c | 2 +- src/modules/weather/weather.c | 2 +- src/modules/wifi/wifi.c | 2 +- src/modules/wm/wm.c | 2 +- src/modules/wmtheme/wmtheme.c | 2 +- 61 files changed, 227 insertions(+), 129 deletions(-) diff --git a/doc/json_schema.json b/doc/json_schema.json index f311c92cb3..561213a087 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -17,6 +17,12 @@ "title": "Color of the module key. Left empty to use `display.color.keys`", "$ref": "#/$defs/colors" }, + "keyWidth": { + "title": "Width of the module key. Use 0 to use `display.keyWidth`", + "type": "integer", + "minimum": 0, + "default": 0 + }, "format": { "title": "Output format of the module", "type": "string" @@ -314,6 +320,12 @@ "type": "boolean", "default": true }, + "keyWidth": { + "title": "Align the width of keys to number of characters, 0 to disable", + "type": "integer", + "minimum": 0, + "default": 0 + }, "binaryPrefix": { "type": "string", "title": "Set the binary prefix to used when printing bytes", @@ -595,6 +607,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -622,6 +637,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -645,6 +663,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -668,6 +689,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -721,6 +745,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -741,6 +768,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "title": "Text to print", "type": "string" @@ -777,6 +807,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -819,6 +852,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -856,6 +892,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -908,6 +947,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -936,6 +978,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -966,6 +1011,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -1008,6 +1056,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -1049,6 +1100,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } @@ -1082,6 +1136,9 @@ "keyColor": { "$ref": "#/$defs/keyColor" }, + "keyWidth": { + "$ref": "#/$defs/keyWidth" + }, "format": { "$ref": "#/$defs/format" } diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index 601d8b4804..794b32405c 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -17,14 +17,19 @@ bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* ffStrbufSetNS(&moduleArgs->key, (uint32_t) yyjson_get_len(val), yyjson_get_str(val)); return true; } + else if(ffStrEqualsIgnCase(key, "format")) + { + ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) yyjson_get_len(val), yyjson_get_str(val)); + return true; + } else if(ffStrEqualsIgnCase(key, "keyColor")) { ffOptionParseColor(yyjson_get_str(val), &moduleArgs->keyColor); return true; } - else if(ffStrEqualsIgnCase(key, "format")) + else if(ffStrEqualsIgnCase(key, "keyWidth")) { - ffStrbufSetNS(&moduleArgs->outputFormat, (uint32_t) yyjson_get_len(val), yyjson_get_str(val)); + moduleArgs->keyWidth = (uint32_t) yyjson_get_uint(val); return true; } return false; @@ -521,5 +526,5 @@ void ffPrintJsonConfig(void) { const char* error = printJsonConfig(); if (error) - ffPrintErrorString("JsonConfig", 0, NULL, NULL, "%s", error); + ffPrintErrorString("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error); } diff --git a/src/common/option.c b/src/common/option.c index dc4be709d0..cb72a385e3 100644 --- a/src/common/option.c +++ b/src/common/option.c @@ -34,6 +34,11 @@ bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const ffOptionParseString(argumentKey, value, &result->key); return true; } + else if(ffStrEqualsIgnCase(subKey, "format")) + { + ffOptionParseString(argumentKey, value, &result->outputFormat); + return true; + } else if(ffStrEqualsIgnCase(subKey, "key-color")) { if(value == NULL) @@ -44,9 +49,9 @@ bool ffOptionParseModuleArgs(const char* argumentKey, const char* subKey, const ffOptionParseColor(value, &result->keyColor); return true; } - else if(ffStrEqualsIgnCase(subKey, "format")) + else if(ffStrEqualsIgnCase(subKey, "key-width")) { - ffOptionParseString(argumentKey, value, &result->outputFormat); + result->keyWidth = ffOptionParseUInt32(argumentKey, value); return true; } return false; @@ -175,6 +180,7 @@ void ffOptionInitModuleArg(FFModuleArgs* args) ffStrbufInit(&args->key); ffStrbufInit(&args->keyColor); ffStrbufInit(&args->outputFormat); + args->keyWidth = 0; } void ffOptionDestroyModuleArg(FFModuleArgs* args) diff --git a/src/common/option.h b/src/common/option.h index bbd9565060..2ff3f08286 100644 --- a/src/common/option.h +++ b/src/common/option.h @@ -7,6 +7,7 @@ typedef struct FFModuleArgs FFstrbuf key; FFstrbuf keyColor; FFstrbuf outputFormat; + uint32_t keyWidth; } FFModuleArgs; typedef struct FFKeyValuePair diff --git a/src/common/printing.c b/src/common/printing.c index f62f50fa61..063127081c 100644 --- a/src/common/printing.c +++ b/src/common/printing.c @@ -2,7 +2,7 @@ #include "common/printing.h" #include "util/textModifier.h" -void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor) +void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType) { ffLogoPrintLine(); @@ -16,14 +16,14 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrb if (instance.config.brightColor) fputs(FASTFETCH_TEXT_MODIFIER_BOLT, stdout); - if(customKeyColor != NULL && customKeyColor->length > 0) - ffPrintColor(customKeyColor); + if(moduleArgs && !(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_COLOR) && moduleArgs->keyColor.length > 0) + ffPrintColor(&moduleArgs->keyColor); else ffPrintColor(&instance.config.colorKeys); } //NULL check is required for modules with custom keys, e.g. disk with the folder path - if(customKeyFormat == NULL || customKeyFormat->length == 0) + if((printType & FF_PRINT_TYPE_NO_CUSTOM_KEY) || !moduleArgs || moduleArgs->key.length == 0) { fputs(moduleName, stdout); @@ -33,7 +33,7 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrb else { FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate(); - ffParseFormatString(&key, customKeyFormat, 1, (FFformatarg[]){ + ffParseFormatString(&key, &moduleArgs->key, 1, (FFformatarg[]){ {FF_FORMAT_ARG_TYPE_UINT8, &moduleIndex} }); ffStrbufWriteTo(&key, stdout); @@ -47,33 +47,36 @@ void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrb if(!instance.config.pipe) fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout); - if (instance.config.keyWidth > 0) - printf("\e[%uG", (unsigned) (instance.config.keyWidth + instance.state.logoWidth)); + + if (!instance.config.pipe && !(printType & FF_PRINT_TYPE_NO_CUSTOM_KEY_WIDTH)) + { + uint32_t keyWidth = moduleArgs && moduleArgs->keyWidth > 0 ? moduleArgs->keyWidth : instance.config.keyWidth; + if (keyWidth > 0) + printf("\e[%uG", (unsigned) (keyWidth + instance.state.logoWidth)); + } } -void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments) +void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments) { - FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(256); - ffParseFormatString(&buffer, format, numArgs, arguments); + FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate(); + if (moduleArgs) + ffParseFormatString(&buffer, &moduleArgs->outputFormat, numArgs, arguments); + else + ffStrbufAppendS(&buffer, "unknown"); if(buffer.length > 0) { - ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor); + ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType); ffStrbufPutTo(&buffer, stdout); } } -void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments) -{ - ffPrintFormatString(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, &moduleArgs->outputFormat, numArgs, arguments); -} - -static void printError(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, va_list arguments) +static void printError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, va_list arguments) { if(!instance.config.showErrors) return; - ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor); + ffPrintLogoAndKey(moduleName, moduleIndex, moduleArgs, printType); if(!instance.config.pipe) fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout); @@ -86,11 +89,11 @@ static void printError(const char* moduleName, uint8_t moduleIndex, const FFstrb putchar('\n'); } -void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...) +void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...) { va_list arguments; va_start(arguments, message); - printError(moduleName, moduleIndex, customKeyFormat, customKeyColor, message, arguments); + printError(moduleName, moduleIndex, moduleArgs, printType, message, arguments); va_end(arguments); } @@ -98,7 +101,7 @@ void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArg { va_list arguments; va_start(arguments, message); - printError(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, message, arguments); + printError(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, message, arguments); va_end(arguments); } diff --git a/src/common/printing.h b/src/common/printing.h index e25c0f82c8..a03c555555 100644 --- a/src/common/printing.h +++ b/src/common/printing.h @@ -6,10 +6,21 @@ #include "fastfetch.h" #include "common/format.h" -void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor); -void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments); -void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments); -FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...); +typedef enum FFPrintType { + FF_PRINT_TYPE_DEFAULT = 0, + FF_PRINT_TYPE_NO_CUSTOM_KEY = 1 << 0, + FF_PRINT_TYPE_NO_CUSTOM_KEY_COLOR = 1 << 1, + FF_PRINT_TYPE_NO_CUSTOM_KEY_WIDTH = 1 << 2, + FF_PRINT_TYPE_NO_CUSTOM_OUTPUT_FORMAT = 1 << 3, // reserved +} FFPrintType; + +void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType); +void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, uint32_t numArgs, const FFformatarg* arguments); +static inline void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments) +{ + ffPrintFormatString(moduleName, moduleIndex, moduleArgs, FF_PRINT_TYPE_DEFAULT, numArgs, arguments); +} +FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, FFPrintType printType, const char* message, ...); FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...); void ffPrintColor(const FFstrbuf* colorValue); void ffPrintCharTimes(char c, uint32_t times); diff --git a/src/data/help.txt b/src/data/help.txt index 95a74429c2..4606bd48e5 100644 --- a/src/data/help.txt +++ b/src/data/help.txt @@ -58,6 +58,7 @@ Display options: -s,--structure : Set the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available. --color-keys : Set the color of the keys --color-title : Set the color of the title + --key-width : Align the width of keys to characters --bright-color : Set if the keys, title and ASCII logo should be printed in bright color. Default is true -c,--color : Set the color of both the keys and title --separator : Set the separator between key and value. Default is a colon with a space @@ -82,6 +83,7 @@ General module options: For modules which print multiple lines, the string is parsed as a format string with the index as first character. ---key-color : Override the global `--color-keys` option for each specific module. + ---key-width : Override the global `--key-width` option for each specific module. Library options: Set the path of a library to load --lib-PCI diff --git a/src/fastfetch.c b/src/fastfetch.c index 58fd773e69..45375573e6 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -1389,7 +1389,7 @@ static void parseStructureCommand(const char* line, FFlist* customValues) return ffPrintWMTheme(&instance.config.wmTheme); break; } - ffPrintErrorString(line, 0, NULL, NULL, ""); + ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, ""); } int main(int argc, const char** argv) diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c index 5f5a93329b..eba6ba5978 100644 --- a/src/modules/battery/battery.c +++ b/src/modules/battery/battery.c @@ -12,7 +12,7 @@ static void printBattery(FFBatteryOptions* options, BatteryResult* result, uint8 { if(instance.config.battery.moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); bool showStatus = !(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT) && diff --git a/src/modules/bios/bios.c b/src/modules/bios/bios.c index 398a7cc838..7aba0aef70 100644 --- a/src/modules/bios/bios.c +++ b/src/modules/bios/bios.c @@ -30,7 +30,7 @@ void ffPrintBios(FFBiosOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&bios.version, stdout); if (bios.release.length) printf(" (%s)", bios.release.chars); diff --git a/src/modules/bluetooth/bluetooth.c b/src/modules/bluetooth/bluetooth.c index bbd5e0e11a..06bf1ce221 100644 --- a/src/modules/bluetooth/bluetooth.c +++ b/src/modules/bluetooth/bluetooth.c @@ -10,7 +10,7 @@ static void printDevice(FFBluetoothOptions* options, const FFBluetoothDevice* de { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_BLUETOOTH_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&device->name, stdout); if(device->battery > 0) diff --git a/src/modules/board/board.c b/src/modules/board/board.c index 5c92ef20d9..6ad125896d 100644 --- a/src/modules/board/board.c +++ b/src/modules/board/board.c @@ -28,7 +28,7 @@ void ffPrintBoard(FFBoardOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result.name, stdout); if (result.version.length) printf(" (%s)", result.version.chars); diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c index 3e5ea3663e..d5aa58b46c 100644 --- a/src/modules/brightness/brightness.c +++ b/src/modules/brightness/brightness.c @@ -27,6 +27,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate(); + uint32_t index = 0; FF_LIST_FOR_EACH(FFBrightnessResult, item, result) { if(options->moduleArgs.key.length == 0) @@ -35,7 +36,9 @@ void ffPrintBrightness(FFBrightnessOptions* options) } else { - ffParseFormatString(&key, &options->moduleArgs.key, 1, (FFformatarg[]){ + uint32_t moduleIndex = result.length == 1 ? 0 : index + 1; + ffParseFormatString(&key, &options->moduleArgs.key, 2, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_UINT, &moduleIndex}, {FF_FORMAT_ARG_TYPE_STRBUF, &item->name} }); } @@ -44,7 +47,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY); if (instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { @@ -63,7 +66,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) } else { - ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_BRIGHTNESS_NUM_FORMAT_ARGS, (FFformatarg[]) { + ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_BRIGHTNESS_NUM_FORMAT_ARGS, (FFformatarg[]) { {FF_FORMAT_ARG_TYPE_FLOAT, &item->value}, {FF_FORMAT_ARG_TYPE_STRBUF, &item->name}, }); @@ -71,6 +74,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) ffStrbufClear(&key); ffStrbufDestroy(&item->name); + ++index; } } diff --git a/src/modules/chassis/chassis.c b/src/modules/chassis/chassis.c index e229748c8b..53ee101ad8 100644 --- a/src/modules/chassis/chassis.c +++ b/src/modules/chassis/chassis.c @@ -29,7 +29,7 @@ void ffPrintChassis(FFChassisOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result.type, stdout); if (result.version.length) printf(" (%s)", result.version.chars); diff --git a/src/modules/colors/colors.c b/src/modules/colors/colors.c index da559b5a34..0cceb28e81 100644 --- a/src/modules/colors/colors.c +++ b/src/modules/colors/colors.c @@ -122,7 +122,7 @@ void ffParseColorsJsonObject(yyjson_val* module) {}, }); if (error) - ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Invalid %s value: %s", key, error); + ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error); else options.symbol = (FFColorsSymbol) value; continue; @@ -134,7 +134,7 @@ void ffParseColorsJsonObject(yyjson_val* module) continue; } - ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key); + ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/command/command.c b/src/modules/command/command.c index 7337e7553d..c4390fc0d4 100644 --- a/src/modules/command/command.c +++ b/src/modules/command/command.c @@ -30,7 +30,7 @@ void ffPrintCommand(FFCommandOptions* options) return; } - ffPrintLogoAndKey(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&result, stdout); } diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c index 14d751685f..fe4379243e 100644 --- a/src/modules/cpu/cpu.c +++ b/src/modules/cpu/cpu.c @@ -30,7 +30,7 @@ void ffPrintCPU(FFCPUOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_CPU_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c index 32f24a4628..bb8e015ee9 100644 --- a/src/modules/cpuusage/cpuusage.c +++ b/src/modules/cpuusage/cpuusage.c @@ -21,7 +21,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_CPUUSAGE_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c index 06a8d3d91d..7a5602f5d7 100644 --- a/src/modules/cursor/cursor.c +++ b/src/modules/cursor/cursor.c @@ -28,7 +28,7 @@ void ffPrintCursor(FFCursorOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result.theme, stdout); if(result.size.length > 0) diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c index 105823651c..b7b6792411 100644 --- a/src/modules/custom/custom.c +++ b/src/modules/custom/custom.c @@ -12,7 +12,7 @@ void ffPrintCustom(FFCustomOptions* options) return; } - ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&options->moduleArgs.outputFormat, stdout); puts(FASTFETCH_TEXT_MODIFIER_RESET); } diff --git a/src/modules/datetime/datetime.c b/src/modules/datetime/datetime.c index 12134c178f..7d2cbd9418 100644 --- a/src/modules/datetime/datetime.c +++ b/src/modules/datetime/datetime.c @@ -43,7 +43,7 @@ void ffPrintDateTime(FFDateTimeOptions* options) } const FFDateTimeResult* datetime = ffDetectDateTime(); - ffPrintLogoAndKey(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); //yyyy-MM-dd HH:mm:ss printf("%u-%s-%02u %s:%s:%s\n", datetime->year, datetime->monthPretty.chars, datetime->dayInMonth, datetime->hourPretty.chars, datetime->minutePretty.chars, datetime->secondPretty.chars); diff --git a/src/modules/de/de.c b/src/modules/de/de.c index a32e6dc01c..db3c775b56 100644 --- a/src/modules/de/de.c +++ b/src/modules/de/de.c @@ -18,7 +18,7 @@ void ffPrintDE(FFDEOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_DE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_DE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result->dePrettyName, stdout); diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c index 8346f38a45..c7269a6d06 100644 --- a/src/modules/disk/disk.c +++ b/src/modules/disk/disk.c @@ -50,7 +50,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY); FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); @@ -96,7 +96,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) bool isExternal = !!(disk->type & FF_DISK_TYPE_EXTERNAL_BIT); bool isHidden = !!(disk->type & FF_DISK_TYPE_HIDDEN_BIT); - ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){ + ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISK_NUM_FORMAT_ARGS, (FFformatarg[]){ {FF_FORMAT_ARG_TYPE_STRBUF, &usedPretty}, {FF_FORMAT_ARG_TYPE_STRBUF, &totalPretty}, {FF_FORMAT_ARG_TYPE_UINT8, &bytesPercentage}, diff --git a/src/modules/display/display.c b/src/modules/display/display.c index 848936f619..6b7980a62d 100644 --- a/src/modules/display/display.c +++ b/src/modules/display/display.c @@ -18,7 +18,7 @@ void ffPrintDisplay(FFDisplayOptions* options) if (options->compactType != FF_DISPLAY_COMPACT_TYPE_NONE) { - ffPrintLogoAndKey(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); int index = 0; FF_LIST_FOR_EACH(FFDisplayResult, result, dsResult->displays) @@ -43,31 +43,32 @@ void ffPrintDisplay(FFDisplayOptions* options) for(uint32_t i = 0; i < dsResult->displays.length; i++) { FFDisplayResult* result = ffListGet(&dsResult->displays, i); - uint8_t moduleIndex = dsResult->displays.length == 1 ? 0 : (uint8_t) (i + 1); + uint32_t moduleIndex = dsResult->displays.length == 1 ? 0 : i + 1; const char* displayType = result->type == FF_DISPLAY_TYPE_UNKNOWN ? NULL : result->type == FF_DISPLAY_TYPE_BUILTIN ? "built-in" : "external"; - if(options->moduleArgs.outputFormat.length == 0) + ffStrbufClear(&key); + if(options->moduleArgs.key.length == 0) { - ffStrbufClear(&key); - if(options->moduleArgs.key.length == 0) - { - const char* subkey = result->name.length ? result->name.chars : displayType; - if (subkey) - ffStrbufAppendF(&key, "%s (%s)", FF_DISPLAY_MODULE_NAME, subkey); - else if (moduleIndex > 0) - ffStrbufAppendF(&key, "%s (%d)", FF_DISPLAY_MODULE_NAME, moduleIndex); - else - ffStrbufAppendS(&key, FF_DISPLAY_MODULE_NAME); - } + const char* subkey = result->name.length ? result->name.chars : displayType; + if (subkey) + ffStrbufAppendF(&key, "%s (%s)", FF_DISPLAY_MODULE_NAME, subkey); + else if (moduleIndex > 0) + ffStrbufAppendF(&key, "%s (%d)", FF_DISPLAY_MODULE_NAME, moduleIndex); else - { - ffParseFormatString(&key, &options->moduleArgs.key, 1, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_UINT, &i}, - {FF_FORMAT_ARG_TYPE_STRBUF, &result->name}, - {FF_FORMAT_ARG_TYPE_STRING, displayType}, - }); - } - ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor); + ffStrbufAppendS(&key, FF_DISPLAY_MODULE_NAME); + } + else + { + ffParseFormatString(&key, &options->moduleArgs.key, 3, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_UINT, &moduleIndex}, + {FF_FORMAT_ARG_TYPE_STRBUF, &result->name}, + {FF_FORMAT_ARG_TYPE_STRING, displayType}, + }); + } + + if(options->moduleArgs.outputFormat.length == 0) + { + ffPrintLogoAndKey(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY); printf("%ix%i", result->width, result->height); @@ -91,7 +92,7 @@ void ffPrintDisplay(FFDisplayOptions* options) } else { - ffPrintFormat(FF_DISPLAY_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_DISPLAY_NUM_FORMAT_ARGS, (FFformatarg[]) { + ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_DISPLAY_NUM_FORMAT_ARGS, (FFformatarg[]) { {FF_FORMAT_ARG_TYPE_UINT, &result->width}, {FF_FORMAT_ARG_TYPE_UINT, &result->height}, {FF_FORMAT_ARG_TYPE_DOUBLE, &result->refreshRate}, diff --git a/src/modules/font/font.c b/src/modules/font/font.c index 9a8195cd00..8bc328cd38 100644 --- a/src/modules/font/font.c +++ b/src/modules/font/font.c @@ -23,7 +23,7 @@ void ffPrintFont(FFFontOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_FONT_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&font.display, stdout); } else diff --git a/src/modules/gamepad/gamepad.c b/src/modules/gamepad/gamepad.c index e5f28704cc..18c417b3ca 100644 --- a/src/modules/gamepad/gamepad.c +++ b/src/modules/gamepad/gamepad.c @@ -10,7 +10,7 @@ static void printDevice(FFGamepadOptions* options, const FFGamepadDevice* device { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_GAMEPAD_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&device->name, stdout); } else diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c index 84a379f29a..9f25e72e6c 100644 --- a/src/modules/gpu/gpu.c +++ b/src/modules/gpu/gpu.c @@ -24,7 +24,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_GPU_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); FF_STRBUF_AUTO_DESTROY output = ffStrbufCreateA(gpu->vendor.length + 1 + gpu->name.length); diff --git a/src/modules/host/host.c b/src/modules/host/host.c index 53526f9ee8..5c878134b8 100644 --- a/src/modules/host/host.c +++ b/src/modules/host/host.c @@ -30,7 +30,7 @@ void ffPrintHost(FFHostOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_HOST_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); FF_STRBUF_AUTO_DESTROY output = ffStrbufCreate(); diff --git a/src/modules/icons/icons.c b/src/modules/icons/icons.c index e1defe320a..a79a973019 100644 --- a/src/modules/icons/icons.c +++ b/src/modules/icons/icons.c @@ -19,7 +19,7 @@ void ffPrintIcons(FFIconsOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&icons, stdout); } else diff --git a/src/modules/kernel/kernel.c b/src/modules/kernel/kernel.c index 8cef1ae069..e33233523f 100644 --- a/src/modules/kernel/kernel.c +++ b/src/modules/kernel/kernel.c @@ -9,7 +9,7 @@ void ffPrintKernel(FFKernelOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&instance.state.platform.systemRelease, stdout); #ifdef _WIN32 diff --git a/src/modules/lm/lm.c b/src/modules/lm/lm.c index adaf7d0949..c0608e8a0f 100644 --- a/src/modules/lm/lm.c +++ b/src/modules/lm/lm.c @@ -28,7 +28,7 @@ void ffPrintLM(FFLMOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_LM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_LM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result.service, stdout); if(result.version.length) printf(" %s", result.version.chars); diff --git a/src/modules/locale/locale.c b/src/modules/locale/locale.c index 46b4377a46..21e5a37561 100644 --- a/src/modules/locale/locale.c +++ b/src/modules/locale/locale.c @@ -19,7 +19,7 @@ void ffPrintLocale(FFLocaleOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&locale, stdout); } else diff --git a/src/modules/localip/localip.c b/src/modules/localip/localip.c index d3aeb3cba3..1b2772b019 100644 --- a/src/modules/localip/localip.c +++ b/src/modules/localip/localip.c @@ -13,7 +13,7 @@ static int sortIps(const FFLocalIpResult* left, const FFLocalIpResult* right) return ffStrbufComp(&left->name, &right->name); } -static void formatKey(const FFLocalIpOptions* options, const FFLocalIpResult* ip, FFstrbuf* key) +static void formatKey(const FFLocalIpOptions* options, const FFLocalIpResult* ip, uint32_t index, FFstrbuf* key) { if(options->moduleArgs.key.length == 0) { @@ -25,8 +25,10 @@ static void formatKey(const FFLocalIpOptions* options, const FFLocalIpResult* ip else { ffStrbufClear(key); - ffParseFormatString(key, &options->moduleArgs.key, 2, (FFformatarg[]){ + ffParseFormatString(key, &options->moduleArgs.key, 3, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_UINT, &index}, {FF_FORMAT_ARG_TYPE_STRBUF, &ip->name}, + {FF_FORMAT_ARG_TYPE_STRBUF, &ip->mac}, }); } } @@ -78,7 +80,7 @@ void ffPrintLocalIp(FFLocalIpOptions* options) if (options->showType & FF_LOCALIP_TYPE_COMPACT_BIT) { - ffPrintLogoAndKey(FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_LOCALIP_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); bool flag = false; @@ -98,22 +100,23 @@ void ffPrintLocalIp(FFLocalIpOptions* options) else { FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate(); + uint32_t index = 0; FF_LIST_FOR_EACH(FFLocalIpResult, ip, results) { if (options->defaultRouteOnly && !ip->defaultRoute) continue; - formatKey(options, ip, &key); + formatKey(options, ip, results.length == 1 ? 0 : index + 1, &key); if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY); printIp(ip, !options->defaultRouteOnly); putchar('\n'); } else { - ffPrintFormatString(key.chars, 0, NULL, &options->moduleArgs.keyColor, &options->moduleArgs.outputFormat, FF_LOCALIP_NUM_FORMAT_ARGS, (FFformatarg[]){ + ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_LOCALIP_NUM_FORMAT_ARGS, (FFformatarg[]){ {FF_FORMAT_ARG_TYPE_STRBUF, &ip->ipv4}, {FF_FORMAT_ARG_TYPE_STRBUF, &ip->ipv6}, {FF_FORMAT_ARG_TYPE_STRBUF, &ip->mac}, @@ -121,6 +124,7 @@ void ffPrintLocalIp(FFLocalIpOptions* options) {FF_FORMAT_ARG_TYPE_BOOL, &ip->defaultRoute}, }); } + ++index; } } diff --git a/src/modules/media/media.c b/src/modules/media/media.c index f28852e8c1..f2969dd9a5 100644 --- a/src/modules/media/media.c +++ b/src/modules/media/media.c @@ -80,7 +80,7 @@ void ffPrintMedia(FFMediaOptions* options) if(artistInSongTitle(&songPretty, &artistPretty)) ffStrbufClear(&artistPretty); - ffPrintLogoAndKey(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(artistPretty.length > 0) { diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c index 8bd1e7e8f5..7bc505c6ec 100644 --- a/src/modules/memory/memory.c +++ b/src/modules/memory/memory.c @@ -31,7 +31,7 @@ void ffPrintMemory(FFMemoryOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if (storage.bytesTotal == 0) puts("Disabled"); else diff --git a/src/modules/monitor/monitor.c b/src/modules/monitor/monitor.c index 9802234810..a267f393ca 100644 --- a/src/modules/monitor/monitor.c +++ b/src/modules/monitor/monitor.c @@ -26,27 +26,30 @@ void ffPrintMonitor(FFMonitorOptions* options) return; } - uint8_t index = 0; FF_STRBUF_AUTO_DESTROY key = ffStrbufCreate(); + uint32_t index = 0; FF_LIST_FOR_EACH(FFMonitorResult, display, result) { double inch = sqrt(display->physicalWidth * display->physicalWidth + display->physicalHeight * display->physicalHeight) / 25.4; double ppi = sqrt(display->width * display->width + display->height * display->height) / inch; + ffStrbufClear(&key); + if(options->moduleArgs.key.length == 0) + { + ffStrbufAppendF(&key, "%s (%s)", FF_MONITOR_MODULE_NAME, display->name.chars); + } + else + { + uint32_t moduleIndex = result.length == 1 ? 0 : index + 1; + ffParseFormatString(&key, &options->moduleArgs.key, 2, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_UINT, &moduleIndex}, + {FF_FORMAT_ARG_TYPE_STRBUF, &display->name}, + }); + } + if(options->moduleArgs.outputFormat.length == 0) { - ffStrbufClear(&key); - if(options->moduleArgs.key.length == 0) - { - ffStrbufAppendF(&key, "%s (%s)", FF_MONITOR_MODULE_NAME, display->name.chars); - } - else - { - ffParseFormatString(&key, &options->moduleArgs.key, 1, (FFformatarg[]){ - {FF_FORMAT_ARG_TYPE_STRBUF, &display->name}, - }); - } - ffPrintLogoAndKey(key.chars, 0, NULL, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY); printf("%ux%u px", display->width, display->height); if (inch > 0) @@ -56,7 +59,7 @@ void ffPrintMonitor(FFMonitorOptions* options) } else { - ffPrintFormat(FF_MONITOR_MODULE_NAME, index, &options->moduleArgs, FF_MONITOR_NUM_FORMAT_ARGS, (FFformatarg[]) { + ffPrintFormatString(key.chars, 0, &options->moduleArgs, FF_PRINT_TYPE_NO_CUSTOM_KEY, FF_MONITOR_NUM_FORMAT_ARGS, (FFformatarg[]) { {FF_FORMAT_ARG_TYPE_STRBUF, &display->name}, {FF_FORMAT_ARG_TYPE_UINT, &display->width}, {FF_FORMAT_ARG_TYPE_UINT, &display->height}, @@ -68,6 +71,7 @@ void ffPrintMonitor(FFMonitorOptions* options) } ffStrbufDestroy(&display->name); + ++index; } } diff --git a/src/modules/opencl/opencl.c b/src/modules/opencl/opencl.c index 3fd3ce1ebd..daa4da00a2 100644 --- a/src/modules/opencl/opencl.c +++ b/src/modules/opencl/opencl.c @@ -21,7 +21,7 @@ void ffPrintOpenCL(FFOpenCLOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&opencl.version, stdout); } else diff --git a/src/modules/opengl/opengl.c b/src/modules/opengl/opengl.c index e5f5bc9fcf..e4d6ec0089 100644 --- a/src/modules/opengl/opengl.c +++ b/src/modules/opengl/opengl.c @@ -23,7 +23,7 @@ void ffPrintOpenGL(FFOpenGLOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); puts(result.version.chars); } else diff --git a/src/modules/os/os.c b/src/modules/os/os.c index 1193067426..299079c680 100644 --- a/src/modules/os/os.c +++ b/src/modules/os/os.c @@ -115,7 +115,7 @@ void ffPrintOS(FFOSOptions* options) else buildOutputDefault(os, &result); - ffPrintLogoAndKey(FF_OS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_OS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&result, stdout); } else diff --git a/src/modules/packages/packages.c b/src/modules/packages/packages.c index 0fa86f31ce..cb8c6ba2ab 100644 --- a/src/modules/packages/packages.c +++ b/src/modules/packages/packages.c @@ -21,7 +21,7 @@ void ffPrintPackages(FFPackagesOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); #define FF_PRINT_PACKAGE_NAME(var, name) \ if(counts.var > 0) \ diff --git a/src/modules/player/player.c b/src/modules/player/player.c index 1503a9cad5..d78fc3f2f9 100644 --- a/src/modules/player/player.c +++ b/src/modules/player/player.c @@ -59,7 +59,7 @@ void ffPrintPlayer(FFPlayerOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_PLAYER_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&playerPretty, stdout); } else diff --git a/src/modules/poweradapter/poweradapter.c b/src/modules/poweradapter/poweradapter.c index 629a096b16..a5af37c03f 100644 --- a/src/modules/poweradapter/poweradapter.c +++ b/src/modules/poweradapter/poweradapter.c @@ -32,7 +32,7 @@ void ffPrintPowerAdapter(FFPowerAdapterOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_POWERADAPTER_DISPLAY_NAME, i, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(result->name.length > 0) puts(result->name.chars); diff --git a/src/modules/processes/processes.c b/src/modules/processes/processes.c index bc5cf63b90..81b8041246 100644 --- a/src/modules/processes/processes.c +++ b/src/modules/processes/processes.c @@ -19,7 +19,7 @@ void ffPrintProcesses(FFProcessesOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); printf("%u\n", numProcesses); } diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c index 24d65ea3cf..a5707e20e0 100644 --- a/src/modules/publicip/publicip.c +++ b/src/modules/publicip/publicip.c @@ -62,7 +62,7 @@ void ffPrintPublicIp(FFPublicIpOptions* options) if (options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_PUBLICIP_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if (options->url.length == 0) { diff --git a/src/modules/separator/separator.c b/src/modules/separator/separator.c index a8d1d212c1..74108fd3b3 100644 --- a/src/modules/separator/separator.c +++ b/src/modules/separator/separator.c @@ -121,7 +121,7 @@ void ffParseSeparatorJsonObject(yyjson_val* module) continue; } - ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key); + ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/shell/shell.c b/src/modules/shell/shell.c index efaca74410..00a305db77 100644 --- a/src/modules/shell/shell.c +++ b/src/modules/shell/shell.c @@ -18,7 +18,7 @@ void ffPrintShell(FFShellOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result->shellPrettyName, stdout); if(result->shellVersion.length > 0) diff --git a/src/modules/sound/sound.c b/src/modules/sound/sound.c index 2955c8f5b1..d3e0e86ddd 100644 --- a/src/modules/sound/sound.c +++ b/src/modules/sound/sound.c @@ -10,7 +10,7 @@ static void printDevice(FFSoundOptions* options, const FFSoundDevice* device, ui { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_SOUND_MODULE_NAME, index, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_SOUND_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&device->name, stdout); if(device->volume != FF_SOUND_VOLUME_UNKNOWN) diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c index 5f13b286e0..744e4ed9c4 100644 --- a/src/modules/swap/swap.c +++ b/src/modules/swap/swap.c @@ -31,7 +31,7 @@ void ffPrintSwap(FFSwapOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if (storage.bytesTotal == 0) puts("Disabled"); else diff --git a/src/modules/terminal/terminal.c b/src/modules/terminal/terminal.c index 315ede3bcc..ed257fd525 100644 --- a/src/modules/terminal/terminal.c +++ b/src/modules/terminal/terminal.c @@ -20,7 +20,7 @@ void ffPrintTerminal(FFTerminalOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(result->terminalVersion.length) printf("%s %s\n", result->terminalPrettyName.chars, result->terminalVersion.chars); diff --git a/src/modules/terminalfont/terminalfont.c b/src/modules/terminalfont/terminalfont.c index 9e9b683d87..2c28860272 100644 --- a/src/modules/terminalfont/terminalfont.c +++ b/src/modules/terminalfont/terminalfont.c @@ -22,7 +22,7 @@ void ffPrintTerminalFont(FFTerminalFontOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_TERMINALFONT_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&terminalFont.font.pretty, stdout); if(terminalFont.fallback.pretty.length) { diff --git a/src/modules/terminalsize/terminalsize.c b/src/modules/terminalsize/terminalsize.c index e33966eb56..3a794cbfec 100644 --- a/src/modules/terminalsize/terminalsize.c +++ b/src/modules/terminalsize/terminalsize.c @@ -19,7 +19,7 @@ void ffPrintTerminalSize(FFTerminalSizeOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_TERMINALSIZE_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_TERMINALSIZE_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); printf("%u columns x %u rows", result.columns, result.rows); if (result.width != 0 && result.height != 0) diff --git a/src/modules/theme/theme.c b/src/modules/theme/theme.c index 741e47c724..053c7cb57a 100644 --- a/src/modules/theme/theme.c +++ b/src/modules/theme/theme.c @@ -19,7 +19,7 @@ void ffPrintTheme(FFThemeOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_THEME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&theme, stdout); } else diff --git a/src/modules/title/title.c b/src/modules/title/title.c index ef3d7abe46..297b0a6bbb 100644 --- a/src/modules/title/title.c +++ b/src/modules/title/title.c @@ -29,7 +29,7 @@ void ffPrintTitle(FFTitleOptions* options) if (options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_TITLE_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(options->moduleArgs.key.length == 0 ? NULL : FF_TITLE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); printTitlePart(&instance.state.platform.userName, &options->colorUser); @@ -142,7 +142,7 @@ void ffParseTitleJsonObject(yyjson_val* module) continue; } - ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key); + ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/uptime/uptime.c b/src/modules/uptime/uptime.c index f6a4bd424d..3de7d80f7b 100644 --- a/src/modules/uptime/uptime.c +++ b/src/modules/uptime/uptime.c @@ -25,7 +25,7 @@ void ffPrintUptime(FFUptimeOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(days == 0 && hours == 0 && minutes == 0) { diff --git a/src/modules/users/users.c b/src/modules/users/users.c index ed18e7b14e..260cd87d33 100644 --- a/src/modules/users/users.c +++ b/src/modules/users/users.c @@ -32,7 +32,7 @@ void ffPrintUsers(FFUsersOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_USERS_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); puts(result.chars); } else diff --git a/src/modules/vulkan/vulkan.c b/src/modules/vulkan/vulkan.c index b4e51dfb94..aa79c6ddfd 100644 --- a/src/modules/vulkan/vulkan.c +++ b/src/modules/vulkan/vulkan.c @@ -18,7 +18,7 @@ void ffPrintVulkan(FFVulkanOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(vulkan->apiVersion.length > 0) { diff --git a/src/modules/wallpaper/wallpaper.c b/src/modules/wallpaper/wallpaper.c index 54785f6ca9..08720f891a 100644 --- a/src/modules/wallpaper/wallpaper.c +++ b/src/modules/wallpaper/wallpaper.c @@ -30,7 +30,7 @@ void ffPrintWallpaper(FFWallpaperOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); puts(filename); } else diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c index b80875108e..a32292f7d6 100644 --- a/src/modules/weather/weather.c +++ b/src/modules/weather/weather.c @@ -42,7 +42,7 @@ void ffPrintWeather(FFWeatherOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufPutTo(&result, stdout); } else diff --git a/src/modules/wifi/wifi.c b/src/modules/wifi/wifi.c index cda7771414..6798c063ff 100644 --- a/src/modules/wifi/wifi.c +++ b/src/modules/wifi/wifi.c @@ -29,7 +29,7 @@ void ffPrintWifi(FFWifiOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_WIFI_MODULE_NAME, moduleIndex, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); if(item->conn.ssid.length) { ffStrbufWriteTo(&item->conn.ssid, stdout); diff --git a/src/modules/wm/wm.c b/src/modules/wm/wm.c index 6f60107ff3..018bbee732 100644 --- a/src/modules/wm/wm.c +++ b/src/modules/wm/wm.c @@ -18,7 +18,7 @@ void ffPrintWM(FFWMOptions* options) if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_WM_MODULE_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_WM_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); ffStrbufWriteTo(&result->wmPrettyName, stdout); diff --git a/src/modules/wmtheme/wmtheme.c b/src/modules/wmtheme/wmtheme.c index da66e8ad88..c61f216e64 100644 --- a/src/modules/wmtheme/wmtheme.c +++ b/src/modules/wmtheme/wmtheme.c @@ -14,7 +14,7 @@ void ffPrintWMTheme(FFWMThemeOptions* options) { if(options->moduleArgs.outputFormat.length == 0) { - ffPrintLogoAndKey(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs.key, &options->moduleArgs.keyColor); + ffPrintLogoAndKey(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); puts(themeOrError.chars); } else From 559bca42236d2b87dfb8b99c5c26060fe9ad347c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Wed, 16 Aug 2023 14:41:56 +0800 Subject: [PATCH 12/37] Global: add `--bar-char-elapsed`, `--bar-char-total` and `--bar-border` options --- CHANGELOG.md | 1 + doc/json_schema.json | 21 +++++++++++++++++ src/common/bar.c | 50 ++++++++++++++++++++++++----------------- src/common/init.c | 9 ++++++-- src/common/jsonconfig.c | 17 ++++++++++++++ src/data/help.txt | 3 +++ src/fastfetch.c | 6 +++++ src/fastfetch.h | 3 +++ src/modules/swap/swap.c | 19 +++++++++++----- 9 files changed, 101 insertions(+), 28 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 041f0f97fd..313eec7259 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ Changes: Features: * Add `--key-width` for aligning the left edge of values +* Add `--bar-char-elapsed`, `--bar-char-total` and `--bar-border` options Bugfixes: * Fix label detection (Disk, Linux) diff --git a/doc/json_schema.json b/doc/json_schema.json index 561213a087..7980a28376 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -352,6 +352,27 @@ "enum": ["CELSIUS", "C", "FAHRENHEIT", "F", "KELVIN", "K"], "default": "C" }, + "bar": { + "type": "object", + "title": "Set the bar configuration", + "properties": { + "charElapsed": { + "type": "string", + "title": "Set the character to use in elapsed part", + "default": "â– " + }, + "charTotal": { + "type": "string", + "title": "Set the character to use in total part", + "default": "-" + }, + "border": { + "type": "boolean", + "title": "Whether to show a border around the bar", + "default": true + } + } + }, "percentType": { "type": "number", "title": "Set the percentage output type. 1 for percentage number, 2 for bar, 3 for both, 6 for bar only, 9 for colored number", diff --git a/src/common/bar.c b/src/common/bar.c index e42a07c2a1..f71326a17f 100644 --- a/src/common/bar.c +++ b/src/common/bar.c @@ -1,5 +1,6 @@ +#include "common/bar.h" +#include "common/color.h" #include "util/textModifier.h" -#include "bar.h" // green, yellow, red: print the color on nth (0~9) block // set its value == 10 means the color will not be printed @@ -15,37 +16,46 @@ void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_ percent = (uint8_t)(percent + 5) / 10; assert(percent <= 10); - if(!instance.config.pipe) - ffStrbufAppendS(buffer, "\033[97m[ "); - else - ffStrbufAppendS(buffer, "[ "); + if(instance.config.barBorder) + { + if(!instance.config.pipe) + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m[ "); + else + ffStrbufAppendS(buffer, "[ "); + } for (uint8_t i = 0; i < percent; ++i) { if(!instance.config.pipe) { if (i == green) - ffStrbufAppendS(buffer, "\033[32m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m"); else if (i == yellow) - ffStrbufAppendS(buffer, "\033[93m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m"); else if (i == red) - ffStrbufAppendS(buffer, "\033[91m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m"); } - ffStrbufAppendS(buffer, "â– "); + ffStrbufAppend(buffer, &instance.config.barCharElapsed); } if (percent < 10) { if(!instance.config.pipe) - ffStrbufAppendS(buffer, "\033[97m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m"); for (uint8_t i = percent; i < 10; ++i) - ffStrbufAppendS(buffer, "-"); + ffStrbufAppend(buffer, &instance.config.barCharTotal); + } + + if(instance.config.barBorder) + { + if(!instance.config.pipe) + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m ]"); + else + ffStrbufAppendS(buffer, " ]"); } if(!instance.config.pipe) - ffStrbufAppendS(buffer, "\033[97m ]" FASTFETCH_TEXT_MODIFIER_RESET); - else - ffStrbufAppendS(buffer, " ]"); + ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET); } // if (green < yellow) @@ -71,20 +81,20 @@ void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_ if(green < yellow) { if (percent <= green) - ffStrbufAppendS(buffer, "\033[32m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m"); else if (percent <= yellow) - ffStrbufAppendS(buffer, "\033[93m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m"); else - ffStrbufAppendS(buffer, "\033[91m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m"); } else { if (percent >= green) - ffStrbufAppendS(buffer, "\033[32m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m"); else if (percent >= yellow) - ffStrbufAppendS(buffer, "\033[93m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m"); else - ffStrbufAppendS(buffer, "\033[91m"); + ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m"); } } ffStrbufAppendF(buffer, "%u%%", (unsigned) percent); diff --git a/src/common/init.c b/src/common/init.c index f102ef66af..61c6ad9c1a 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -70,6 +70,11 @@ static void defaultConfig(void) instance.config.noBuffer = false; instance.config.keyWidth = 0; + ffStrbufInitStatic(&instance.config.barCharElapsed, "â– "); + ffStrbufInitStatic(&instance.config.barCharTotal, "-"); + instance.config.barBorder = true; + instance.config.percentType = 1; + ffInitTitleOptions(&instance.config.title); ffInitOSOptions(&instance.config.os); ffInitHostOptions(&instance.config.host); @@ -146,8 +151,6 @@ static void defaultConfig(void) ffStrbufInit(&instance.config.libPulse); ffStrbufInit(&instance.config.libnm); ffStrbufInit(&instance.config.libDdcutil); - - instance.config.percentType = 1; } void ffInitInstance(void) @@ -273,6 +276,8 @@ static void destroyConfig(void) ffStrbufDestroy(&instance.config.colorKeys); ffStrbufDestroy(&instance.config.colorTitle); ffStrbufDestroy(&instance.config.keyValueSeparator); + ffStrbufDestroy(&instance.config.barCharElapsed); + ffStrbufDestroy(&instance.config.barCharTotal); #if defined(__linux__) || defined(__FreeBSD__) ffStrbufDestroy(&instance.config.playerName); diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index 794b32405c..b96ed5186a 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -436,6 +436,23 @@ const char* ffParseDisplayJsonConfig(void) } else if (ffStrEqualsIgnCase(key, "percentType")) config->percentType = (uint32_t) yyjson_get_uint(val); + else if (ffStrEqualsIgnCase(key, "bar")) + { + if (yyjson_is_obj(val)) + { + const char* charElapsed = yyjson_get_str(yyjson_obj_get(val, "charElapsed")); + if (charElapsed) + ffStrbufSetS(&config->barCharElapsed, charElapsed); + const char* charTotal = yyjson_get_str(yyjson_obj_get(val, "charTotal")); + if (charTotal) + ffStrbufSetS(&config->barCharTotal, charTotal); + yyjson_val* border = yyjson_obj_get(val, "border"); + if (border) + config->barBorder = yyjson_get_bool(border); + } + else + return "display.bar must be an object"; + } else if (ffStrEqualsIgnCase(key, "noBuffer")) config->noBuffer = yyjson_get_bool(val); else if (ffStrEqualsIgnCase(key, "keyWidth")) diff --git a/src/data/help.txt b/src/data/help.txt index 4606bd48e5..7f8642d378 100644 --- a/src/data/help.txt +++ b/src/data/help.txt @@ -69,6 +69,9 @@ Display options: --hide-cursor : Whether to hide the cursor during the run --binary-prefix : Set the binary prefix to used. Must be IEC, SI or JEDEC. Default is IEC --percent-type : Set the percentage output type. 1 for percentage number, 2 for bar, 3 for both, 6 for bar only, 9 for colored number. Default is 1 + --bar-char-elapsed : Set the character to use in elapsed part. Default is 'â– ' + --bar-char-total : Set the character to use in total part. Default is '-' + --bar-border : Whether to show a border around the bar. Default is true --no-buffer : Set if the stdout application buffer should be disabled. Default is false --size-ndigits : Set the number of digits to keep after the decimal point when formatting sizes --size-max-prefix : Set the largest binary prefix to use when formatting sizes. Default is YB diff --git a/src/fastfetch.c b/src/fastfetch.c index 45375573e6..939e6895f2 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -1047,6 +1047,12 @@ static void parseOption(FFdata* data, const char* key, const char* value) } else if(ffStrEqualsIgnCase(key, "--percent-type")) instance.config.percentType = ffOptionParseUInt32(key, value); + else if(ffStrEqualsIgnCase(key, "--bar-char-elapsed")) + ffOptionParseString(key, value, &instance.config.barCharElapsed); + else if(ffStrEqualsIgnCase(key, "--bar-char-total")) + ffOptionParseString(key, value, &instance.config.barCharTotal); + else if(ffStrEqualsIgnCase(key, "--bar-border")) + instance.config.barBorder = ffOptionParseBoolean(value); else if(ffStrEqualsIgnCase(key, "--no-buffer")) instance.config.noBuffer = ffOptionParseBoolean(value); diff --git a/src/fastfetch.h b/src/fastfetch.h index 3af517c7b3..61b72be5b8 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -54,6 +54,9 @@ typedef struct FFconfig uint8_t sizeNdigits; uint8_t sizeMaxPrefix; FFTemperatureUnit temperatureUnit; + FFstrbuf barCharElapsed; + FFstrbuf barCharTotal; + bool barBorder; uint32_t percentType; bool pipe; //disables logo and all escape sequences bool multithreading; diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c index 744e4ed9c4..844bfe8967 100644 --- a/src/modules/swap/swap.c +++ b/src/modules/swap/swap.c @@ -32,12 +32,19 @@ void ffPrintSwap(FFSwapOptions* options) if(options->moduleArgs.outputFormat.length == 0) { ffPrintLogoAndKey(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); + FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); if (storage.bytesTotal == 0) - puts("Disabled"); + { + if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) + { + ffAppendPercentBar(&str, 0, 0, 5, 8); + ffStrbufAppendC(&str, ' '); + } + if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT)) + ffStrbufAppendS(&str, "Disabled"); + } else { - FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); - if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { ffAppendPercentBar(&str, percentage, 0, 5, 8); @@ -49,10 +56,10 @@ void ffPrintSwap(FFSwapOptions* options) if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0); - - ffStrbufTrimRight(&str, ' '); - ffStrbufPutTo(&str, stdout); } + + ffStrbufTrimRight(&str, ' '); + ffStrbufPutTo(&str, stdout); } else { From 4b714c7057062901f927c9b5bf9d905b958b3eee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Wed, 16 Aug 2023 14:52:20 +0800 Subject: [PATCH 13/37] Doc: update changelog --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 313eec7259..1df312cdce 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,11 +6,11 @@ Changes: * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *` Features: -* Add `--key-width` for aligning the left edge of values +* Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width` * Add `--bar-char-elapsed`, `--bar-char-total` and `--bar-border` options Bugfixes: -* Fix label detection (Disk, Linux) +* Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux) # 2.0.0-beta From a0c4f2febd8db69bcdf0f860b62fa75e823b1bfe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Wed, 16 Aug 2023 16:46:21 +0800 Subject: [PATCH 14/37] Global: support `--bar-width` --- CHANGELOG.md | 2 +- doc/json_schema.json | 6 +++++ presets/examples/9.jsonc | 28 ++++++++++++++++++++++++ src/common/bar.c | 34 +++++++++++++---------------- src/common/bar.h | 4 ++-- src/common/init.c | 1 + src/common/jsonconfig.c | 6 +++++ src/data/help.txt | 1 + src/fastfetch.c | 2 ++ src/fastfetch.h | 1 + src/modules/battery/battery.c | 8 +++---- src/modules/brightness/brightness.c | 4 ++-- src/modules/cpuusage/cpuusage.c | 4 ++-- src/modules/disk/disk.c | 6 ++--- src/modules/gpu/gpu.c | 2 +- src/modules/memory/memory.c | 8 +++---- src/modules/swap/swap.c | 10 ++++----- 17 files changed, 84 insertions(+), 43 deletions(-) create mode 100644 presets/examples/9.jsonc diff --git a/CHANGELOG.md b/CHANGELOG.md index 1df312cdce..052e00c5b0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,7 +7,7 @@ Changes: Features: * Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width` -* Add `--bar-char-elapsed`, `--bar-char-total` and `--bar-border` options +* Add `--bar-char-elapsed`, `--bar-char-total`, `--bar-width` and `--bar-border` options Bugfixes: * Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux) diff --git a/doc/json_schema.json b/doc/json_schema.json index 7980a28376..0ecf5920ad 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -370,6 +370,12 @@ "type": "boolean", "title": "Whether to show a border around the bar", "default": true + }, + "width": { + "type": "integer", + "title": "Set the width of the bar", + "minimum": 1, + "default": 10 } } }, diff --git a/presets/examples/9.jsonc b/presets/examples/9.jsonc new file mode 100644 index 0000000000..1dd6f7307d --- /dev/null +++ b/presets/examples/9.jsonc @@ -0,0 +1,28 @@ +{ + "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json", + "logo": { + "type": "small" + }, + "display": { + "percentType": 6, + "keyWidth": 11, + "bar": { + "charElapsed": "=", + "charTotal": "-", + "width": 13 + } + }, + "modules": [ + "title", + "separator", + "memory", + "swap", + "disk", + "battery", + { + "type": "colors", + "paddingLeft": 11, + "symbol": "circle" + } + ] +} diff --git a/src/common/bar.c b/src/common/bar.c index f71326a17f..549c3ba504 100644 --- a/src/common/bar.c +++ b/src/common/bar.c @@ -2,19 +2,15 @@ #include "common/color.h" #include "util/textModifier.h" -// green, yellow, red: print the color on nth (0~9) block -// set its value == 10 means the color will not be printed -void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red) +void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red) { - assert(green <= 10 && yellow <= 10 && red <= 10); + assert(green <= 100 && yellow <= 100 && red <= 100); - // [ 0%, 5%) prints 0 blocks - // [ 5%, 15%) prints 1 block; - // ... - // [85%, 95%) prints 9 blocks; - // [95%,100%] prints 10 blocks - percent = (uint8_t)(percent + 5) / 10; - assert(percent <= 10); + uint32_t blocksPercent = (uint32_t) (percent / 100.0 * instance.config.barWidth + 0.5); + uint32_t blocksGreen = (uint32_t) (green / 100.0 * instance.config.barWidth + 0.5); + uint32_t blocksYellow = (uint32_t) (yellow / 100.0 * instance.config.barWidth + 0.5); + uint32_t blocksRed = (uint32_t) (red / 100.0 * instance.config.barWidth + 0.5); + assert(blocksPercent <= instance.config.barWidth); if(instance.config.barBorder) { @@ -24,25 +20,25 @@ void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_ ffStrbufAppendS(buffer, "[ "); } - for (uint8_t i = 0; i < percent; ++i) + for (uint32_t i = 0; i < blocksPercent; ++i) { if(!instance.config.pipe) { - if (i == green) + if (i == blocksGreen) ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_GREEN "m"); - else if (i == yellow) + else if (i == blocksYellow) ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_YELLOW "m"); - else if (i == red) + else if (i == blocksRed) ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m"); } ffStrbufAppend(buffer, &instance.config.barCharElapsed); } - if (percent < 10) + if (blocksPercent < instance.config.barWidth) { if(!instance.config.pipe) ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_WHITE "m"); - for (uint8_t i = percent; i < 10; ++i) + for (uint32_t i = blocksPercent; i < instance.config.barWidth; ++i) ffStrbufAppend(buffer, &instance.config.barCharTotal); } @@ -67,7 +63,7 @@ void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_ // [green, 100]: print green // [yellow, green): print yellow // [0, yellow): PRINT RED -void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses) +void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses) { assert(green <= 100 && yellow <= 100); @@ -97,7 +93,7 @@ void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_ ffStrbufAppendS(buffer, "\e[" FF_COLOR_FG_LIGHT_RED "m"); } } - ffStrbufAppendF(buffer, "%u%%", (unsigned) percent); + ffStrbufAppendF(buffer, "%u%%", (unsigned) (percent + 0.5)); if (colored && !instance.config.pipe) { diff --git a/src/common/bar.h b/src/common/bar.h index d776454d4d..d35276cef8 100644 --- a/src/common/bar.h +++ b/src/common/bar.h @@ -13,7 +13,7 @@ enum FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3, }; -void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red); -void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses); +void ffAppendPercentBar(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, uint8_t red); +void ffAppendPercentNum(FFstrbuf* buffer, double percent, uint8_t green, uint8_t yellow, bool parentheses); #endif diff --git a/src/common/init.c b/src/common/init.c index 61c6ad9c1a..3510818b31 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -72,6 +72,7 @@ static void defaultConfig(void) ffStrbufInitStatic(&instance.config.barCharElapsed, "â– "); ffStrbufInitStatic(&instance.config.barCharTotal, "-"); + instance.config.barWidth = 10; instance.config.barBorder = true; instance.config.percentType = 1; diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index b96ed5186a..e504eafda4 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -443,12 +443,18 @@ const char* ffParseDisplayJsonConfig(void) const char* charElapsed = yyjson_get_str(yyjson_obj_get(val, "charElapsed")); if (charElapsed) ffStrbufSetS(&config->barCharElapsed, charElapsed); + const char* charTotal = yyjson_get_str(yyjson_obj_get(val, "charTotal")); if (charTotal) ffStrbufSetS(&config->barCharTotal, charTotal); + yyjson_val* border = yyjson_obj_get(val, "border"); if (border) config->barBorder = yyjson_get_bool(border); + + yyjson_val* width = yyjson_obj_get(val, "width"); + if (width) + config->barWidth = (uint8_t) yyjson_get_uint(width); } else return "display.bar must be an object"; diff --git a/src/data/help.txt b/src/data/help.txt index 7f8642d378..4cac377694 100644 --- a/src/data/help.txt +++ b/src/data/help.txt @@ -71,6 +71,7 @@ Display options: --percent-type : Set the percentage output type. 1 for percentage number, 2 for bar, 3 for both, 6 for bar only, 9 for colored number. Default is 1 --bar-char-elapsed : Set the character to use in elapsed part. Default is 'â– ' --bar-char-total : Set the character to use in total part. Default is '-' + --bar-width : Set the width of the bar, in number of characters. Default is 10 --bar-border : Whether to show a border around the bar. Default is true --no-buffer : Set if the stdout application buffer should be disabled. Default is false --size-ndigits : Set the number of digits to keep after the decimal point when formatting sizes diff --git a/src/fastfetch.c b/src/fastfetch.c index 939e6895f2..1625126bd0 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -1051,6 +1051,8 @@ static void parseOption(FFdata* data, const char* key, const char* value) ffOptionParseString(key, value, &instance.config.barCharElapsed); else if(ffStrEqualsIgnCase(key, "--bar-char-total")) ffOptionParseString(key, value, &instance.config.barCharTotal); + else if(ffStrEqualsIgnCase(key, "--bar-width")) + instance.config.barWidth = (uint8_t) ffOptionParseUInt32(key, value); else if(ffStrEqualsIgnCase(key, "--bar-border")) instance.config.barBorder = ffOptionParseBoolean(value); else if(ffStrEqualsIgnCase(key, "--no-buffer")) diff --git a/src/fastfetch.h b/src/fastfetch.h index 61b72be5b8..3a493eea5b 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -56,6 +56,7 @@ typedef struct FFconfig FFTemperatureUnit temperatureUnit; FFstrbuf barCharElapsed; FFstrbuf barCharTotal; + uint8_t barWidth; bool barBorder; uint32_t percentType; bool pipe; //disables logo and all escape sequences diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c index eba6ba5978..2dac37d054 100644 --- a/src/modules/battery/battery.c +++ b/src/modules/battery/battery.c @@ -26,11 +26,11 @@ static void printBattery(FFBatteryOptions* options, BatteryResult* result, uint8 if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { if(result->capacity <= 20) - ffAppendPercentBar(&str, (uint8_t)result->capacity, 10, 10, 0); + ffAppendPercentBar(&str, result->capacity, 100, 100, 0); else if(result->capacity <= 50) - ffAppendPercentBar(&str, (uint8_t)result->capacity, 10, 0, 10); + ffAppendPercentBar(&str, result->capacity, 100, 0, 100); else - ffAppendPercentBar(&str, (uint8_t)result->capacity, 0, 10, 10); + ffAppendPercentBar(&str, result->capacity, 0, 100, 100); } if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) @@ -38,7 +38,7 @@ static void printBattery(FFBatteryOptions* options, BatteryResult* result, uint8 if(str.length > 0) ffStrbufAppendC(&str, ' '); - ffAppendPercentNum(&str, (uint8_t) result->capacity, 51, 21, str.length > 0); + ffAppendPercentNum(&str, result->capacity, 51, 21, str.length > 0); } } diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c index d5aa58b46c..3e6a564c38 100644 --- a/src/modules/brightness/brightness.c +++ b/src/modules/brightness/brightness.c @@ -51,7 +51,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) if (instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { - ffAppendPercentBar(&str, (uint8_t) (item->value + 0.5), 0, 10, 10); + ffAppendPercentBar(&str, item->value, 0, 100, 100); } if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) @@ -59,7 +59,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) if(str.length > 0) ffStrbufAppendC(&str, ' '); - ffAppendPercentNum(&str, (uint8_t) (item->value + 0.5), 10, 10, str.length > 0); + ffAppendPercentNum(&str, item->value, 10, 10, str.length > 0); } ffStrbufPutTo(&str, stdout); diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c index bb8e015ee9..263fe109f8 100644 --- a/src/modules/cpuusage/cpuusage.c +++ b/src/modules/cpuusage/cpuusage.c @@ -25,12 +25,12 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options) FF_STRBUF_AUTO_DESTROY str = ffStrbufCreate(); if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) - ffAppendPercentBar(&str, (uint8_t)percentage, 0, 5, 8); + ffAppendPercentBar(&str, percentage, 0, 50, 80); if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) { if(str.length > 0) ffStrbufAppendC(&str, ' '); - ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0); + ffAppendPercentNum(&str, percentage, 50, 80, str.length > 0); } ffStrbufPutTo(&str, stdout); } diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c index c7269a6d06..e79bcd692e 100644 --- a/src/modules/disk/disk.c +++ b/src/modules/disk/disk.c @@ -46,7 +46,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate(); ffParseSize(disk->bytesTotal, &totalPretty); - uint8_t bytesPercentage = disk->bytesTotal > 0 ? (uint8_t) (((long double) disk->bytesUsed / (long double) disk->bytesTotal) * 100.0) : 0; + double bytesPercentage = disk->bytesTotal > 0 ? (double) disk->bytesUsed / (double) disk->bytesTotal * 100.0 : 0; if(options->moduleArgs.outputFormat.length == 0) { @@ -58,7 +58,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) { if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { - ffAppendPercentBar(&str, bytesPercentage, 0, 5, 8); + ffAppendPercentBar(&str, bytesPercentage, 0, 50, 80); ffStrbufAppendC(&str, ' '); } @@ -67,7 +67,7 @@ static void printDisk(FFDiskOptions* options, const FFDisk* disk) if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) { - ffAppendPercentNum(&str, (uint8_t) bytesPercentage, 50, 80, str.length > 0); + ffAppendPercentNum(&str, bytesPercentage, 50, 80, str.length > 0); ffStrbufAppendC(&str, ' '); } } diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c index 9f25e72e6c..b1b8fa090b 100644 --- a/src/modules/gpu/gpu.c +++ b/src/modules/gpu/gpu.c @@ -58,7 +58,7 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu if(gpu->dedicated.used != FF_GPU_VMEM_SIZE_UNSET) { ffStrbufAppendS(&output, ", "); - ffAppendPercentNum(&output, (uint8_t) (gpu->dedicated.used * 100 / gpu->dedicated.total), 50, 80, false); + ffAppendPercentNum(&output, (double) gpu->dedicated.used / (double) gpu->dedicated.total * 100.0, 50, 80, false); } ffStrbufAppendC(&output, ')'); } diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c index 7bc505c6ec..a8b78316ba 100644 --- a/src/modules/memory/memory.c +++ b/src/modules/memory/memory.c @@ -25,9 +25,9 @@ void ffPrintMemory(FFMemoryOptions* options) FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate(); ffParseSize(storage.bytesTotal, &totalPretty); - uint8_t percentage = storage.bytesTotal == 0 + double percentage = storage.bytesTotal == 0 ? 0 - : (uint8_t) (((long double) storage.bytesUsed / (long double) storage.bytesTotal) * 100.0); + : (double) storage.bytesUsed / (double) storage.bytesTotal * 100.0; if(options->moduleArgs.outputFormat.length == 0) { @@ -40,7 +40,7 @@ void ffPrintMemory(FFMemoryOptions* options) if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { - ffAppendPercentBar(&str, percentage, 0, 5, 8); + ffAppendPercentBar(&str, percentage, 0, 50, 80); ffStrbufAppendC(&str, ' '); } @@ -48,7 +48,7 @@ void ffPrintMemory(FFMemoryOptions* options) ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars); if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) - ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0); + ffAppendPercentNum(&str, percentage, 50, 80, str.length > 0); ffStrbufTrimRight(&str, ' '); ffStrbufPutTo(&str, stdout); diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c index 844bfe8967..7da77e0862 100644 --- a/src/modules/swap/swap.c +++ b/src/modules/swap/swap.c @@ -25,9 +25,9 @@ void ffPrintSwap(FFSwapOptions* options) FF_STRBUF_AUTO_DESTROY totalPretty = ffStrbufCreate(); ffParseSize(storage.bytesTotal, &totalPretty); - uint8_t percentage = storage.bytesTotal == 0 + double percentage = storage.bytesTotal == 0 ? 0 - : (uint8_t) (((long double) storage.bytesUsed / (long double) storage.bytesTotal) * 100.0); + : (double) storage.bytesUsed / (double) storage.bytesTotal * 100.0; if(options->moduleArgs.outputFormat.length == 0) { @@ -37,7 +37,7 @@ void ffPrintSwap(FFSwapOptions* options) { if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { - ffAppendPercentBar(&str, 0, 0, 5, 8); + ffAppendPercentBar(&str, 0, 0, 50, 80); ffStrbufAppendC(&str, ' '); } if(!(instance.config.percentType & FF_PERCENTAGE_TYPE_HIDE_OTHERS_BIT)) @@ -47,7 +47,7 @@ void ffPrintSwap(FFSwapOptions* options) { if(instance.config.percentType & FF_PERCENTAGE_TYPE_BAR_BIT) { - ffAppendPercentBar(&str, percentage, 0, 5, 8); + ffAppendPercentBar(&str, percentage, 0, 50, 80); ffStrbufAppendC(&str, ' '); } @@ -55,7 +55,7 @@ void ffPrintSwap(FFSwapOptions* options) ffStrbufAppendF(&str, "%s / %s ", usedPretty.chars, totalPretty.chars); if(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_BIT) - ffAppendPercentNum(&str, (uint8_t) percentage, 50, 80, str.length > 0); + ffAppendPercentNum(&str, percentage, 50, 80, str.length > 0); } ffStrbufTrimRight(&str, ' '); From 75323d64f89db316df539305fbc0e88e829448a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Wed, 16 Aug 2023 16:51:54 +0800 Subject: [PATCH 15/37] Chore: fix typo --- CHANGELOG.md | 2 +- src/detection/host/host_linux.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 052e00c5b0..137724688e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -46,7 +46,7 @@ Features: * Support iTerm non-ascii font detection (Terminal, macOS) * Add option `--title-color-user`, `--title-color-at` and `--title-color-host` (Title) * Add Exherbo logo and package manager count (Packages, Linux, #503) -* Add module `Terminal Size` which prints the number of terminal width and height in charactors and pixels +* Add module `Terminal Size` which prints the number of terminal width and height in characters and pixels * Add new option `--temperature-unit` * Better CPU and Host detection for Android (Android) * Support yakuake terminal version & font detection (Terminal, Linux) diff --git a/src/detection/host/host_linux.c b/src/detection/host/host_linux.c index 05e48cbbce..674d93b5e3 100644 --- a/src/detection/host/host_linux.c +++ b/src/detection/host/host_linux.c @@ -59,7 +59,7 @@ const char* ffDetectHost(FFHostResult* host) ffStrbufAppendF(&host->productName, " - %s", wslDistroName); ffStrbufAppendS(&host->productFamily, "WSL"); - FF_STRBUF_AUTO_DESTROY wslVer = ffStrbufCreate(); //Wide charactors + FF_STRBUF_AUTO_DESTROY wslVer = ffStrbufCreate(); //Wide characters if(!ffProcessAppendStdOut(&wslVer, (char* const[]){ "wsl.exe", "--version", From c888254f70608320c84454701f5d98c8e884c587 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Thu, 17 Aug 2023 10:56:54 +0800 Subject: [PATCH 16/37] Modules: major code refactor Also fix some bugs found when refactoring --- CHANGELOG.md | 1 + doc/json_schema.json | 2 +- src/common/init.c | 152 ++++----- src/common/jsonconfig.c | 117 +++---- src/common/option.h | 24 ++ src/fastfetch.c | 389 +++++++++++++----------- src/fastfetch.h | 3 +- src/flashfetch.c | 2 +- src/modules/battery/battery.c | 15 +- src/modules/battery/battery.h | 2 +- src/modules/battery/option.h | 2 +- src/modules/bios/bios.c | 13 +- src/modules/bios/bios.h | 2 +- src/modules/bios/option.h | 2 +- src/modules/bluetooth/bluetooth.c | 15 +- src/modules/bluetooth/bluetooth.h | 2 +- src/modules/bluetooth/option.h | 2 +- src/modules/board/board.c | 13 +- src/modules/board/board.h | 2 +- src/modules/board/option.h | 2 +- src/modules/break/break.c | 21 +- src/modules/break/break.h | 7 +- src/modules/break/option.h | 10 + src/modules/brightness/brightness.c | 13 +- src/modules/brightness/brightness.h | 2 +- src/modules/brightness/option.h | 2 +- src/modules/chassis/chassis.c | 13 +- src/modules/chassis/chassis.h | 2 +- src/modules/chassis/option.h | 2 +- src/modules/colors/colors.c | 13 +- src/modules/colors/colors.h | 2 +- src/modules/colors/option.h | 2 +- src/modules/command/command.c | 17 +- src/modules/command/command.h | 2 +- src/modules/command/option.h | 2 +- src/modules/cpu/cpu.c | 15 +- src/modules/cpu/cpu.h | 2 +- src/modules/cpu/option.h | 2 +- src/modules/cpuusage/cpuusage.c | 13 +- src/modules/cpuusage/cpuusage.h | 2 +- src/modules/cpuusage/option.h | 2 +- src/modules/cursor/cursor.c | 13 +- src/modules/cursor/cursor.h | 2 +- src/modules/cursor/option.h | 2 +- src/modules/custom/custom.c | 13 +- src/modules/custom/custom.h | 2 +- src/modules/custom/option.h | 2 +- src/modules/datetime/datetime.c | 13 +- src/modules/datetime/datetime.h | 2 +- src/modules/datetime/option.h | 2 +- src/modules/de/de.c | 13 +- src/modules/de/de.h | 2 +- src/modules/de/option.h | 2 +- src/modules/disk/disk.c | 32 +- src/modules/disk/disk.h | 2 +- src/modules/disk/option.h | 2 +- src/modules/display/display.c | 19 +- src/modules/display/display.h | 2 +- src/modules/display/option.h | 2 +- src/modules/font/font.c | 13 +- src/modules/font/font.h | 2 +- src/modules/font/option.h | 2 +- src/modules/gamepad/gamepad.c | 13 +- src/modules/gamepad/gamepad.h | 2 +- src/modules/gamepad/option.h | 2 +- src/modules/gpu/gpu.c | 21 +- src/modules/gpu/gpu.h | 2 +- src/modules/gpu/option.h | 2 +- src/modules/host/host.c | 13 +- src/modules/host/host.h | 2 +- src/modules/host/option.h | 2 +- src/modules/icons/icons.c | 13 +- src/modules/icons/icons.h | 2 +- src/modules/icons/option.h | 2 +- src/modules/kernel/kernel.c | 13 +- src/modules/kernel/kernel.h | 2 +- src/modules/kernel/option.h | 2 +- src/modules/lm/lm.c | 13 +- src/modules/lm/lm.h | 2 +- src/modules/lm/option.h | 2 +- src/modules/locale/locale.c | 13 +- src/modules/locale/locale.h | 2 +- src/modules/locale/option.h | 2 +- src/modules/localip/localip.c | 37 +-- src/modules/localip/localip.h | 2 +- src/modules/localip/option.h | 2 +- src/modules/media/media.c | 13 +- src/modules/media/media.h | 2 +- src/modules/media/option.h | 2 +- src/modules/memory/memory.c | 13 +- src/modules/memory/memory.h | 2 +- src/modules/memory/option.h | 2 +- src/modules/monitor/monitor.c | 13 +- src/modules/monitor/monitor.h | 2 +- src/modules/monitor/option.h | 2 +- src/modules/opencl/opencl.c | 13 +- src/modules/opencl/opencl.h | 2 +- src/modules/opencl/option.h | 2 +- src/modules/opengl/opengl.c | 17 +- src/modules/opengl/opengl.h | 2 +- src/modules/opengl/option.h | 2 +- src/modules/options.h | 1 + src/modules/os/option.h | 2 +- src/modules/os/os.c | 13 +- src/modules/os/os.h | 2 +- src/modules/packages/option.h | 2 +- src/modules/packages/packages.c | 13 +- src/modules/packages/packages.h | 2 +- src/modules/player/option.h | 2 +- src/modules/player/player.c | 13 +- src/modules/player/player.h | 2 +- src/modules/poweradapter/option.h | 2 +- src/modules/poweradapter/poweradapter.c | 13 +- src/modules/poweradapter/poweradapter.h | 2 +- src/modules/processes/option.h | 2 +- src/modules/processes/processes.c | 13 +- src/modules/processes/processes.h | 2 +- src/modules/publicip/option.h | 2 +- src/modules/publicip/publicip.c | 17 +- src/modules/publicip/publicip.h | 2 +- src/modules/separator/option.h | 2 +- src/modules/separator/separator.c | 11 +- src/modules/separator/separator.h | 2 +- src/modules/shell/option.h | 2 +- src/modules/shell/shell.c | 13 +- src/modules/shell/shell.h | 2 +- src/modules/sound/option.h | 2 +- src/modules/sound/sound.c | 17 +- src/modules/sound/sound.h | 2 +- src/modules/swap/option.h | 2 +- src/modules/swap/swap.c | 13 +- src/modules/swap/swap.h | 2 +- src/modules/terminal/option.h | 2 +- src/modules/terminal/terminal.c | 13 +- src/modules/terminal/terminal.h | 2 +- src/modules/terminalfont/option.h | 2 +- src/modules/terminalfont/terminalfont.c | 13 +- src/modules/terminalfont/terminalfont.h | 2 +- src/modules/terminalsize/option.h | 2 +- src/modules/terminalsize/terminalsize.c | 13 +- src/modules/terminalsize/terminalsize.h | 2 +- src/modules/theme/option.h | 2 +- src/modules/theme/theme.c | 13 +- src/modules/theme/theme.h | 2 +- src/modules/title/option.h | 2 +- src/modules/title/title.c | 19 +- src/modules/title/title.h | 2 +- src/modules/uptime/option.h | 2 +- src/modules/uptime/uptime.c | 13 +- src/modules/uptime/uptime.h | 2 +- src/modules/users/option.h | 2 +- src/modules/users/users.c | 13 +- src/modules/users/users.h | 2 +- src/modules/vulkan/option.h | 2 +- src/modules/vulkan/vulkan.c | 13 +- src/modules/vulkan/vulkan.h | 2 +- src/modules/wallpaper/option.h | 2 +- src/modules/wallpaper/wallpaper.c | 13 +- src/modules/wallpaper/wallpaper.h | 2 +- src/modules/weather/option.h | 2 +- src/modules/weather/weather.c | 19 +- src/modules/weather/weather.h | 2 +- src/modules/wifi/option.h | 2 +- src/modules/wifi/wifi.c | 13 +- src/modules/wifi/wifi.h | 2 +- src/modules/wm/option.h | 2 +- src/modules/wm/wm.c | 13 +- src/modules/wm/wm.h | 2 +- src/modules/wmtheme/option.h | 2 +- src/modules/wmtheme/wmtheme.c | 13 +- src/modules/wmtheme/wmtheme.h | 2 +- 171 files changed, 767 insertions(+), 952 deletions(-) create mode 100644 src/modules/break/option.h diff --git a/CHANGELOG.md b/CHANGELOG.md index 137724688e..13c92129af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ Features: Bugfixes: * Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux) +* Fix some module options were not inited # 2.0.0-beta diff --git a/doc/json_schema.json b/doc/json_schema.json index 0ecf5920ad..46991ab180 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -373,7 +373,7 @@ }, "width": { "type": "integer", - "title": "Set the width of the bar", + "title": "Set the width of the bar, in number of characters", "minimum": 1, "default": 10 } diff --git a/src/common/init.c b/src/common/init.c index 3510818b31..afd58bcc75 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -76,57 +76,60 @@ static void defaultConfig(void) instance.config.barBorder = true; instance.config.percentType = 1; - ffInitTitleOptions(&instance.config.title); - ffInitOSOptions(&instance.config.os); - ffInitHostOptions(&instance.config.host); + ffInitBatteryOptions(&instance.config.battery); ffInitBiosOptions(&instance.config.bios); + ffInitBluetoothOptions(&instance.config.bluetooth); ffInitBoardOptions(&instance.config.board); + ffInitBreakOptions(&instance.config.break_); ffInitBrightnessOptions(&instance.config.brightness); + ffInitCPUOptions(&instance.config.cpu); + ffInitCPUUsageOptions(&instance.config.cpuUsage); ffInitChassisOptions(&instance.config.chassis); + ffInitColorsOptions(&instance.config.colors); ffInitCommandOptions(&instance.config.command); + ffInitCursorOptions(&instance.config.cursor); ffInitCustomOptions(&instance.config.custom); - ffInitKernelOptions(&instance.config.kernel); - ffInitUptimeOptions(&instance.config.uptime); - ffInitProcessesOptions(&instance.config.processes); - ffInitPackagesOptions(&instance.config.packages); - ffInitShellOptions(&instance.config.shell); - ffInitDisplayOptions(&instance.config.display); ffInitDEOptions(&instance.config.de); - ffInitWMOptions(&instance.config.wm); - ffInitWMThemeOptions(&instance.config.wmTheme); - ffInitThemeOptions(&instance.config.theme); - ffInitIconsOptions(&instance.config.icons); + ffInitDateTimeOptions(&instance.config.dateTime); + ffInitDiskOptions(&instance.config.disk); + ffInitDisplayOptions(&instance.config.display); ffInitFontOptions(&instance.config.font); - ffInitCursorOptions(&instance.config.cursor); - ffInitTerminalOptions(&instance.config.terminal); - ffInitTerminalFontOptions(&instance.config.terminalFont); - ffInitCPUOptions(&instance.config.cpu); - ffInitCPUUsageOptions(&instance.config.cpuUsage); ffInitGPUOptions(&instance.config.gpu); - ffInitMemoryOptions(&instance.config.memory); - ffInitSwapOptions(&instance.config.swap); - ffInitDiskOptions(&instance.config.disk); - ffInitBatteryOptions(&instance.config.battery); - ffInitPowerAdapterOptions(&instance.config.powerAdapter); + ffInitGamepadOptions(&instance.config.gamepad); + ffInitHostOptions(&instance.config.host); + ffInitIconsOptions(&instance.config.icons); + ffInitKernelOptions(&instance.config.kernel); ffInitLMOptions(&instance.config.lm); - ffInitLocaleOptions(&instance.config.locale); ffInitLocalIpOptions(&instance.config.localIP); - ffInitPublicIpOptions(&instance.config.publicIP); - ffInitWeatherOptions(&instance.config.weather); - ffInitWifiOptions(&instance.config.wifi); - ffInitPlayerOptions(&instance.config.player); + ffInitLocaleOptions(&instance.config.locale); ffInitMediaOptions(&instance.config.media); - ffInitDateTimeOptions(&instance.config.dateTime); - ffInitVulkanOptions(&instance.config.vulkan); - ffInitWallpaperOptions(&instance.config.wallpaper); - ffInitOpenGLOptions(&instance.config.openGL); + ffInitMemoryOptions(&instance.config.memory); + ffInitMonitorOptions(&instance.config.monitor); + ffInitOSOptions(&instance.config.os); ffInitOpenCLOptions(&instance.config.openCL); - ffInitUsersOptions(&instance.config.users); - ffInitBluetoothOptions(&instance.config.bluetooth); - ffInitSoundOptions(&instance.config.sound); + ffInitOpenGLOptions(&instance.config.openGL); + ffInitPackagesOptions(&instance.config.packages); + ffInitPlayerOptions(&instance.config.player); + ffInitPowerAdapterOptions(&instance.config.powerAdapter); + ffInitProcessesOptions(&instance.config.processes); + ffInitPublicIpOptions(&instance.config.publicIP); ffInitSeparatorOptions(&instance.config.separator); - ffInitGamepadOptions(&instance.config.gamepad); - ffInitColorsOptions(&instance.config.colors); + ffInitShellOptions(&instance.config.shell); + ffInitSoundOptions(&instance.config.sound); + ffInitSwapOptions(&instance.config.swap); + ffInitTerminalFontOptions(&instance.config.terminalFont); + ffInitTerminalOptions(&instance.config.terminal); + ffInitTerminalSizeOptions(&instance.config.terminalSize); + ffInitThemeOptions(&instance.config.theme); + ffInitTitleOptions(&instance.config.title); + ffInitUptimeOptions(&instance.config.uptime); + ffInitUsersOptions(&instance.config.users); + ffInitVulkanOptions(&instance.config.vulkan); + ffInitWMOptions(&instance.config.wm); + ffInitWMThemeOptions(&instance.config.wmTheme); + ffInitWallpaperOptions(&instance.config.wallpaper); + ffInitWeatherOptions(&instance.config.weather); + ffInitWifiOptions(&instance.config.wifi); ffStrbufInit(&instance.config.libPCI); ffStrbufInit(&instance.config.libVulkan); @@ -285,57 +288,60 @@ static void destroyConfig(void) ffStrbufDestroy(&instance.config.osFile); #endif - ffDestroyTitleOptions(&instance.config.title); - ffDestroyOSOptions(&instance.config.os); - ffDestroyHostOptions(&instance.config.host); + ffDestroyBatteryOptions(&instance.config.battery); ffDestroyBiosOptions(&instance.config.bios); + ffDestroyBluetoothOptions(&instance.config.bluetooth); ffDestroyBoardOptions(&instance.config.board); + ffDestroyBreakOptions(&instance.config.break_); ffDestroyBrightnessOptions(&instance.config.brightness); + ffDestroyCPUOptions(&instance.config.cpu); + ffDestroyCPUUsageOptions(&instance.config.cpuUsage); ffDestroyChassisOptions(&instance.config.chassis); + ffDestroyColorsOptions(&instance.config.colors); ffDestroyCommandOptions(&instance.config.command); + ffDestroyCursorOptions(&instance.config.cursor); ffDestroyCustomOptions(&instance.config.custom); - ffDestroyKernelOptions(&instance.config.kernel); - ffDestroyUptimeOptions(&instance.config.uptime); - ffDestroyProcessesOptions(&instance.config.processes); - ffDestroyPackagesOptions(&instance.config.packages); - ffDestroyShellOptions(&instance.config.shell); - ffDestroyDisplayOptions(&instance.config.display); ffDestroyDEOptions(&instance.config.de); - ffDestroyWMOptions(&instance.config.wm); - ffDestroyWMThemeOptions(&instance.config.wmTheme); - ffDestroyThemeOptions(&instance.config.theme); - ffDestroyIconsOptions(&instance.config.icons); + ffDestroyDateTimeOptions(&instance.config.dateTime); + ffDestroyDiskOptions(&instance.config.disk); + ffDestroyDisplayOptions(&instance.config.display); ffDestroyFontOptions(&instance.config.font); - ffDestroyCursorOptions(&instance.config.cursor); - ffDestroyTerminalOptions(&instance.config.terminal); - ffDestroyTerminalFontOptions(&instance.config.terminalFont); - ffDestroyCPUOptions(&instance.config.cpu); - ffDestroyCPUUsageOptions(&instance.config.cpuUsage); ffDestroyGPUOptions(&instance.config.gpu); - ffDestroyMemoryOptions(&instance.config.memory); - ffDestroySwapOptions(&instance.config.swap); - ffDestroyDiskOptions(&instance.config.disk); - ffDestroyBatteryOptions(&instance.config.battery); - ffDestroyPowerAdapterOptions(&instance.config.powerAdapter); + ffDestroyGamepadOptions(&instance.config.gamepad); + ffDestroyHostOptions(&instance.config.host); + ffDestroyIconsOptions(&instance.config.icons); + ffDestroyKernelOptions(&instance.config.kernel); ffDestroyLMOptions(&instance.config.lm); - ffDestroyLocaleOptions(&instance.config.locale); ffDestroyLocalIpOptions(&instance.config.localIP); - ffDestroyPublicIpOptions(&instance.config.publicIP); - ffDestroyWallpaperOptions(&instance.config.wallpaper); - ffDestroyWeatherOptions(&instance.config.weather); - ffDestroyWifiOptions(&instance.config.wifi); - ffDestroyPlayerOptions(&instance.config.player); + ffDestroyLocaleOptions(&instance.config.locale); ffDestroyMediaOptions(&instance.config.media); - ffDestroyDateTimeOptions(&instance.config.dateTime); - ffDestroyVulkanOptions(&instance.config.vulkan); - ffDestroyOpenGLOptions(&instance.config.openGL); + ffDestroyMemoryOptions(&instance.config.memory); + ffDestroyMonitorOptions(&instance.config.monitor); + ffDestroyOSOptions(&instance.config.os); ffDestroyOpenCLOptions(&instance.config.openCL); - ffDestroyUsersOptions(&instance.config.users); - ffDestroyBluetoothOptions(&instance.config.bluetooth); + ffDestroyOpenGLOptions(&instance.config.openGL); + ffDestroyPackagesOptions(&instance.config.packages); + ffDestroyPlayerOptions(&instance.config.player); + ffDestroyPowerAdapterOptions(&instance.config.powerAdapter); + ffDestroyProcessesOptions(&instance.config.processes); + ffDestroyPublicIpOptions(&instance.config.publicIP); ffDestroySeparatorOptions(&instance.config.separator); + ffDestroyShellOptions(&instance.config.shell); ffDestroySoundOptions(&instance.config.sound); - ffDestroyGamepadOptions(&instance.config.gamepad); - ffDestroyColorsOptions(&instance.config.colors); + ffDestroySwapOptions(&instance.config.swap); + ffDestroyTerminalFontOptions(&instance.config.terminalFont); + ffDestroyTerminalOptions(&instance.config.terminal); + ffDestroyTerminalSizeOptions(&instance.config.terminalSize); + ffDestroyThemeOptions(&instance.config.theme); + ffDestroyTitleOptions(&instance.config.title); + ffDestroyUptimeOptions(&instance.config.uptime); + ffDestroyUsersOptions(&instance.config.users); + ffDestroyVulkanOptions(&instance.config.vulkan); + ffDestroyWMOptions(&instance.config.wm); + ffDestroyWMThemeOptions(&instance.config.wmTheme); + ffDestroyWallpaperOptions(&instance.config.wallpaper); + ffDestroyWeatherOptions(&instance.config.weather); + ffDestroyWifiOptions(&instance.config.wifi); ffStrbufDestroy(&instance.config.libPCI); ffStrbufDestroy(&instance.config.libVulkan); diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index e504eafda4..8e1ecdaaf9 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -70,11 +70,13 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p return "Invalid enum value type; must be a string or integer"; } -static inline bool tryModule(const char* type, yyjson_val* module, const char* moduleName, void (*const f)(yyjson_val *module)) +static inline bool tryModule(const char* type, yyjson_val* module, void* options) { - if (ffStrEqualsIgnCase(type, moduleName)) + FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; + if (ffStrEqualsIgnCase(type, baseInfo->name)) { - f(module); + if (module) baseInfo->parseJsonObject(options, module); + baseInfo->printModule(options); return true; } return false; @@ -82,144 +84,145 @@ static inline bool tryModule(const char* type, yyjson_val* module, const char* m static bool parseModuleJsonObject(const char* type, yyjson_val* module) { + FFconfig* cfg = &instance.config; switch (toupper(type[0])) { case 'B': { return - tryModule(type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) || - tryModule(type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) || - tryModule(type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) || - tryModule(type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) || - tryModule(type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) || - tryModule(type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) || + tryModule(type, module, &cfg->battery) || + tryModule(type, module, &cfg->bios) || + tryModule(type, module, &cfg->bluetooth) || + tryModule(type, module, &cfg->board) || + tryModule(type, module, &cfg->break_) || + tryModule(type, module, &cfg->brightness) || false; } case 'C': { return - tryModule(type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) || - tryModule(type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) || - tryModule(type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) || - tryModule(type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) || - tryModule(type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) || - tryModule(type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) || - tryModule(type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) || + tryModule(type, module, &cfg->chassis) || + tryModule(type, module, &cfg->command) || + tryModule(type, module, &cfg->colors) || + tryModule(type, module, &cfg->cpu) || + tryModule(type, module, &cfg->cpuUsage) || + tryModule(type, module, &cfg->cursor) || + tryModule(type, module, &cfg->custom) || false; } case 'D': { return - tryModule(type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) || - tryModule(type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) || - tryModule(type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) || - tryModule(type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) || + tryModule(type, module, &cfg->dateTime) || + tryModule(type, module, &cfg->de) || + tryModule(type, module, &cfg->display) || + tryModule(type, module, &cfg->disk) || false; } case 'F': { return - tryModule(type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) || + tryModule(type, module, &cfg->font) || false; } case 'G': { return - tryModule(type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) || - tryModule(type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) || + tryModule(type, module, &cfg->gamepad) || + tryModule(type, module, &cfg->gpu) || false; } case 'H': { return - tryModule(type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) || + tryModule(type, module, &cfg->host) || false; } case 'I': { return - tryModule(type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) || + tryModule(type, module, &cfg->icons) || false; } case 'K': { return - tryModule(type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) || + tryModule(type, module, &cfg->kernel) || false; } case 'L': { return - tryModule(type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) || - tryModule(type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) || - tryModule(type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) || + tryModule(type, module, &cfg->lm) || + tryModule(type, module, &cfg->locale) || + tryModule(type, module, &cfg->localIP) || false; } case 'M': { return - tryModule(type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) || - tryModule(type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) || - tryModule(type, module, FF_MONITOR_MODULE_NAME, ffParseMonitorJsonObject) || + tryModule(type, module, &cfg->media) || + tryModule(type, module, &cfg->memory) || + tryModule(type, module, &cfg->monitor) || false; } case 'O': { return - tryModule(type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) || - tryModule(type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) || - tryModule(type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) || + tryModule(type, module, &cfg->openCL) || + tryModule(type, module, &cfg->openGL) || + tryModule(type, module, &cfg->os) || false; } case 'P': { return - tryModule(type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) || - tryModule(type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) || - tryModule(type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) || - tryModule(type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) || - tryModule(type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) || + tryModule(type, module, &cfg->packages) || + tryModule(type, module, &cfg->player) || + tryModule(type, module, &cfg->powerAdapter) || + tryModule(type, module, &cfg->processes) || + tryModule(type, module, &cfg->publicIP) || false; } case 'S': { return - tryModule(type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) || - tryModule(type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) || - tryModule(type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) || - tryModule(type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) || + tryModule(type, module, &cfg->separator) || + tryModule(type, module, &cfg->shell) || + tryModule(type, module, &cfg->sound) || + tryModule(type, module, &cfg->swap) || false; } case 'T': { return - tryModule(type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) || - tryModule(type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) || - tryModule(type, module, FF_TERMINALSIZE_MODULE_NAME, ffParseTerminalSizeJsonObject) || - tryModule(type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) || - tryModule(type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) || + tryModule(type, module, &cfg->terminal) || + tryModule(type, module, &cfg->terminalFont) || + tryModule(type, module, &cfg->terminalSize) || + tryModule(type, module, &cfg->title) || + tryModule(type, module, &cfg->theme) || false; } case 'U': { return - tryModule(type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) || - tryModule(type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) || + tryModule(type, module, &cfg->uptime) || + tryModule(type, module, &cfg->users) || false; } case 'V': { return - tryModule(type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) || + tryModule(type, module, &cfg->vulkan) || false; } case 'W': { return - tryModule(type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) || - tryModule(type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) || - tryModule(type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) || - tryModule(type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) || - tryModule(type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) || + tryModule(type, module, &cfg->wallpaper) || + tryModule(type, module, &cfg->weather) || + tryModule(type, module, &cfg->wm) || + tryModule(type, module, &cfg->wifi) || + tryModule(type, module, &cfg->wmTheme) || false; } diff --git a/src/common/option.h b/src/common/option.h index 2ff3f08286..724ca7c5ac 100644 --- a/src/common/option.h +++ b/src/common/option.h @@ -1,6 +1,30 @@ #pragma once #include "util/FFstrbuf.h" +#include "3rdparty/yyjson/yyjson.h" + +// Must be the first field of FFModuleOptions +typedef struct FFModuleBaseInfo +{ + const char* name; + void (*parseCommandOptions)(void* options, const char* key, const char* value); + void (*parseJsonObject)(void* options, yyjson_val *module); + void (*printModule)(void* options); +} FFModuleBaseInfo; + +static inline void ffOptionInitModuleBaseInfo( + FFModuleBaseInfo* baseInfo, + const char* name, + void* parseCommandOptions, // void (*const parseCommandOptions)(void* options, const char* key, const char* value) + void* parseJsonObject, // void (*const parseJsonObject)(void* options, yyjson_val *module) + void* printModule // void (*const printModule)(void* options) +) +{ + baseInfo->name = name; + baseInfo->parseCommandOptions = parseCommandOptions; + baseInfo->parseJsonObject = parseJsonObject; + baseInfo->printModule = printModule; +} typedef struct FFModuleArgs { diff --git a/src/fastfetch.c b/src/fastfetch.c index 1625126bd0..4f338f1169 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -1062,59 +1062,60 @@ static void parseOption(FFdata* data, const char* key, const char* value) //Module args options// /////////////////////// - else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} - else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {} - else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} + else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {} else if(ffParseBiosCommandOptions(&instance.config.bios, key, value)) {} + else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {} else if(ffParseBoardCommandOptions(&instance.config.board, key, value)) {} + else if(ffParseBreakCommandOptions(&instance.config.break_, key, value)) {} + else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {} + else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {} + else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {} else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {} + else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {} else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {} + else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {} else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {} - else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {} - else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {} - else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {} - else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {} - else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {} - else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {} - else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {} - else if(ffParseMonitorCommandOptions(&instance.config.nativeResolution, key, value)) {} else if(ffParseDECommandOptions(&instance.config.de, key, value)) {} - else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {} - else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {} - else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {} - else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {} - else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {} - else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {} - else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {} + else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {} + else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {} + else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {} else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {} - else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {} - else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {} - else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {} - else if(ffParseTerminalSizeCommandOptions(&instance.config.terminalSize, key, value)) {} - else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {} - else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {} else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {} - else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {} - else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {} - else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {} - else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {} - else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {} - else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {} + else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {} + else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {} + else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {} + else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {} else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {} - else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {} - else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {} - else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {} + else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {} else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {} - else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {} - else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {} - else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {} + else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {} + else if(ffParseMonitorCommandOptions(&instance.config.monitor, key, value)) {} + else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} + else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {} - else if(ffParseUsersCommandOptions(&instance.config.users, key, value)) {} - else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {} + else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {} + else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {} + else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {} + else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {} + else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {} + else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {} else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {} + else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {} else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {} - else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {} - else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {} + else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {} + else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {} + else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {} + else if(ffParseTerminalSizeCommandOptions(&instance.config.terminalSize, key, value)) {} + else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {} + else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {} + else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {} + else if(ffParseUsersCommandOptions(&instance.config.users, key, value)) {} + else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {} + else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {} + else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {} + else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {} + else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {} + else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {} /////////////////// //Library options// @@ -1235,6 +1236,166 @@ static void parseArguments(FFdata* data, int argc, const char** argv) } } +static inline bool tryModule(const char* type, void* options) +{ + FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; + if (ffStrEqualsIgnCase(type, baseInfo->name)) + { + baseInfo->printModule(options); + return true; + } + return false; +} + +static bool parseModuleCommand(const char* type) +{ + FFconfig* cfg = &instance.config; + switch (toupper(type[0])) + { + case 'B': { + return + tryModule(type, &cfg->battery) || + tryModule(type, &cfg->bios) || + tryModule(type, &cfg->bluetooth) || + tryModule(type, &cfg->board) || + tryModule(type, &cfg->break_) || + tryModule(type, &cfg->brightness) || + false; + } + + case 'C': { + return + tryModule(type, &cfg->chassis) || + tryModule(type, &cfg->command) || + tryModule(type, &cfg->colors) || + tryModule(type, &cfg->cpu) || + tryModule(type, &cfg->cpuUsage) || + tryModule(type, &cfg->cursor) || + tryModule(type, &cfg->custom) || + false; + } + + case 'D': { + return + tryModule(type, &cfg->dateTime) || + tryModule(type, &cfg->de) || + tryModule(type, &cfg->display) || + tryModule(type, &cfg->disk) || + false; + } + + case 'F': { + return + tryModule(type, &cfg->font) || + false; + } + + case 'G': { + return + tryModule(type, &cfg->gamepad) || + tryModule(type, &cfg->gpu) || + false; + } + + case 'H': { + return + tryModule(type, &cfg->host) || + false; + } + + case 'I': { + return + tryModule(type, &cfg->icons) || + false; + } + + case 'K': { + return + tryModule(type, &cfg->kernel) || + false; + } + + case 'L': { + return + tryModule(type, &cfg->lm) || + tryModule(type, &cfg->locale) || + tryModule(type, &cfg->localIP) || + false; + } + + case 'M': { + return + tryModule(type, &cfg->media) || + tryModule(type, &cfg->memory) || + tryModule(type, &cfg->monitor) || + false; + } + + case 'O': { + return + tryModule(type, &cfg->openCL) || + tryModule(type, &cfg->openGL) || + tryModule(type, &cfg->os) || + false; + } + + case 'P': { + return + tryModule(type, &cfg->packages) || + tryModule(type, &cfg->player) || + tryModule(type, &cfg->powerAdapter) || + tryModule(type, &cfg->processes) || + tryModule(type, &cfg->publicIP) || + false; + } + + case 'S': { + return + tryModule(type, &cfg->separator) || + tryModule(type, &cfg->shell) || + tryModule(type, &cfg->sound) || + tryModule(type, &cfg->swap) || + false; + } + + case 'T': { + return + tryModule(type, &cfg->terminal) || + tryModule(type, &cfg->terminalFont) || + tryModule(type, &cfg->terminalSize) || + tryModule(type, &cfg->title) || + tryModule(type, &cfg->theme) || + false; + } + + case 'U': { + return + tryModule(type, &cfg->uptime) || + tryModule(type, &cfg->users) || + false; + } + + case 'V': { + return + tryModule(type, &cfg->vulkan) || + false; + } + + case 'W': { + return + tryModule(type, &cfg->wallpaper) || + tryModule(type, &cfg->weather) || + tryModule(type, &cfg->wm) || + tryModule(type, &cfg->wifi) || + tryModule(type, &cfg->wmTheme) || + false; + } + + default: + return false; + } +} + static void parseStructureCommand(const char* line, FFlist* customValues) { // handle `--set` and `--set-keyless` @@ -1252,152 +1413,8 @@ static void parseStructureCommand(const char* line, FFlist* customValues) } } - switch (toupper(line[0])) - { - case 'B': - if(ffStrEqualsIgnCase(line, FF_BATTERY_MODULE_NAME)) - return ffPrintBattery(&instance.config.battery); - if(ffStrEqualsIgnCase(line, FF_BIOS_MODULE_NAME)) - return ffPrintBios(&instance.config.bios); - if(ffStrEqualsIgnCase(line, FF_BLUETOOTH_MODULE_NAME)) - return ffPrintBluetooth(&instance.config.bluetooth); - if(ffStrEqualsIgnCase(line, FF_BOARD_MODULE_NAME)) - return ffPrintBoard(&instance.config.board); - if(ffStrEqualsIgnCase(line, FF_BREAK_MODULE_NAME)) - return ffPrintBreak(); - if(ffStrEqualsIgnCase(line, FF_BRIGHTNESS_MODULE_NAME)) - return ffPrintBrightness(&instance.config.brightness); - break; - case 'C': - if(ffStrEqualsIgnCase(line, FF_CHASSIS_MODULE_NAME)) - return ffPrintChassis(&instance.config.chassis); - if(ffStrEqualsIgnCase(line, FF_COMMAND_MODULE_NAME)) - return ffPrintCommand(&instance.config.command); - if(ffStrEqualsIgnCase(line, FF_CPU_MODULE_NAME)) - return ffPrintCPU(&instance.config.cpu); - if(ffStrEqualsIgnCase(line, FF_CPUUSAGE_MODULE_NAME)) - return ffPrintCPUUsage(&instance.config.cpuUsage); - if(ffStrEqualsIgnCase(line, FF_COLORS_MODULE_NAME)) - return ffPrintColors(&instance.config.colors); - if(ffStrEqualsIgnCase(line, FF_CURSOR_MODULE_NAME)) - return ffPrintCursor(&instance.config.cursor); - if(ffStrEqualsIgnCase(line, FF_CUSTOM_MODULE_NAME)) - return ffPrintCustom(&instance.config.custom); - break; - case 'D': - if(ffStrEqualsIgnCase(line, FF_DATETIME_MODULE_NAME)) - return ffPrintDateTime(&instance.config.dateTime); - if(ffStrEqualsIgnCase(line, FF_DE_MODULE_NAME)) - return ffPrintDE(&instance.config.de); - if(ffStrEqualsIgnCase(line, FF_DISPLAY_MODULE_NAME)) - return ffPrintDisplay(&instance.config.display); - if(ffStrEqualsIgnCase(line, FF_DISK_MODULE_NAME)) - return ffPrintDisk(&instance.config.disk); - break; - case 'F': - if(ffStrEqualsIgnCase(line, FF_FONT_MODULE_NAME)) - return ffPrintFont(&instance.config.font); - break; - case 'G': - if(ffStrEqualsIgnCase(line, FF_GAMEPAD_MODULE_NAME)) - return ffPrintGamepad(&instance.config.gamepad); - if(ffStrEqualsIgnCase(line, FF_GPU_MODULE_NAME)) - return ffPrintGPU(&instance.config.gpu); - break; - case 'H': - if(ffStrEqualsIgnCase(line, FF_HOST_MODULE_NAME)) - return ffPrintHost(&instance.config.host); - break; - case 'I': - if(ffStrEqualsIgnCase(line, FF_ICONS_MODULE_NAME)) - return ffPrintIcons(&instance.config.icons); - break; - case 'K': - if(ffStrEqualsIgnCase(line, FF_KERNEL_MODULE_NAME)) - return ffPrintKernel(&instance.config.kernel); - break; - case 'L': - if(ffStrEqualsIgnCase(line, FF_LM_MODULE_NAME)) - return ffPrintLM(&instance.config.lm); - if(ffStrEqualsIgnCase(line, FF_LOCALE_MODULE_NAME)) - return ffPrintLocale(&instance.config.locale); - if(ffStrEqualsIgnCase(line, FF_LOCALIP_MODULE_NAME)) - return ffPrintLocalIp(&instance.config.localIP); - break; - case 'M': - if(ffStrEqualsIgnCase(line, FF_MEDIA_MODULE_NAME)) - return ffPrintMedia(&instance.config.media); - if(ffStrEqualsIgnCase(line, FF_MEMORY_MODULE_NAME)) - return ffPrintMemory(&instance.config.memory); - if(ffStrEqualsIgnCase(line, FF_MONITOR_MODULE_NAME)) - return ffPrintMonitor(&instance.config.nativeResolution); - break; - case 'O': - if(ffStrEqualsIgnCase(line, FF_OPENCL_MODULE_NAME)) - return ffPrintOpenCL(&instance.config.openCL); - if(ffStrEqualsIgnCase(line, FF_OPENGL_MODULE_NAME)) - return ffPrintOpenGL(&instance.config.openGL); - if(ffStrEqualsIgnCase(line, FF_OS_MODULE_NAME)) - return ffPrintOS(&instance.config.os); - break; - case 'P': - if(ffStrEqualsIgnCase(line, FF_PACKAGES_MODULE_NAME)) - return ffPrintPackages(&instance.config.packages); - if(ffStrEqualsIgnCase(line, FF_PLAYER_MODULE_NAME)) - return ffPrintPlayer(&instance.config.player); - if(ffStrEqualsIgnCase(line, FF_POWERADAPTER_MODULE_NAME)) - return ffPrintPowerAdapter(&instance.config.powerAdapter); - if(ffStrEqualsIgnCase(line, FF_PROCESSES_MODULE_NAME)) - return ffPrintProcesses(&instance.config.processes); - if(ffStrEqualsIgnCase(line, FF_PUBLICIP_MODULE_NAME)) - return ffPrintPublicIp(&instance.config.publicIP); - break; - case 'S': - if(ffStrEqualsIgnCase(line, FF_SEPARATOR_MODULE_NAME)) - return ffPrintSeparator(&instance.config.separator); - if(ffStrEqualsIgnCase(line, FF_SHELL_MODULE_NAME)) - return ffPrintShell(&instance.config.shell); - if(ffStrEqualsIgnCase(line, FF_SOUND_MODULE_NAME)) - return ffPrintSound(&instance.config.sound); - if(ffStrEqualsIgnCase(line, FF_SWAP_MODULE_NAME)) - return ffPrintSwap(&instance.config.swap); - break; - case 'T': - if(ffStrEqualsIgnCase(line, FF_TERMINAL_MODULE_NAME)) - return ffPrintTerminal(&instance.config.terminal); - if(ffStrEqualsIgnCase(line, FF_TERMINALFONT_MODULE_NAME)) - return ffPrintTerminalFont(&instance.config.terminalFont); - if(ffStrEqualsIgnCase(line, FF_TERMINALSIZE_MODULE_NAME)) - return ffPrintTerminalSize(&instance.config.terminalSize); - if(ffStrEqualsIgnCase(line, FF_TITLE_MODULE_NAME)) - return ffPrintTitle(&instance.config.title); - if(ffStrEqualsIgnCase(line, FF_THEME_MODULE_NAME)) - return ffPrintTheme(&instance.config.theme); - break; - case 'U': - if(ffStrEqualsIgnCase(line, FF_UPTIME_MODULE_NAME)) - return ffPrintUptime(&instance.config.uptime); - if(ffStrEqualsIgnCase(line, FF_USERS_MODULE_NAME)) - return ffPrintUsers(&instance.config.users); - break; - case 'V': - if(ffStrEqualsIgnCase(line, FF_VULKAN_MODULE_NAME)) - return ffPrintVulkan(&instance.config.vulkan); - break; - case 'W': - if(ffStrEqualsIgnCase(line, FF_WALLPAPER_MODULE_NAME)) - return ffPrintWallpaper(&instance.config.wallpaper); - if(ffStrEqualsIgnCase(line, FF_WEATHER_MODULE_NAME)) - return ffPrintWeather(&instance.config.weather); - if(ffStrEqualsIgnCase(line, FF_WIFI_MODULE_NAME)) - return ffPrintWifi(&instance.config.wifi); - if(ffStrEqualsIgnCase(line, FF_WM_MODULE_NAME)) - return ffPrintWM(&instance.config.wm); - if(ffStrEqualsIgnCase(line, FF_WMTHEME_MODULE_NAME)) - return ffPrintWMTheme(&instance.config.wmTheme); - break; - } - ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, ""); + if(!parseModuleCommand(line)) + ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, ""); } int main(int argc, const char** argv) diff --git a/src/fastfetch.h b/src/fastfetch.h index 3a493eea5b..0cfa892875 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -117,7 +117,7 @@ typedef struct FFconfig FFWeatherOptions weather; FFPlayerOptions player; FFMediaOptions media; - FFMonitorOptions nativeResolution; + FFMonitorOptions monitor; FFDateTimeOptions dateTime; FFVulkanOptions vulkan; FFOpenGLOptions openGL; @@ -127,6 +127,7 @@ typedef struct FFconfig FFSeparatorOptions separator; FFSoundOptions sound; FFGamepadOptions gamepad; + FFBreakOptions break_; FFColorsOptions colors; FFstrbuf libPCI; diff --git a/src/flashfetch.c b/src/flashfetch.c index 3417548f59..355238ac40 100644 --- a/src/flashfetch.c +++ b/src/flashfetch.c @@ -62,7 +62,7 @@ int main(void) //ffPrintBluetooth(&instance.config.bluetooth); //ffPrintSound(&instance.config.sound); //ffPrintGamepad(&instance.config.gamepad); - ffPrintBreak(); + ffPrintBreak(&instance.config.break_); ffPrintColors(&instance.config.colors); ffFinish(); diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c index 2dac37d054..9a10d4973c 100644 --- a/src/modules/battery/battery.c +++ b/src/modules/battery/battery.c @@ -105,7 +105,7 @@ void ffPrintBattery(FFBatteryOptions* options) void ffInitBatteryOptions(FFBatteryOptions* options) { - options->moduleName = FF_BATTERY_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BATTERY_MODULE_NAME, ffParseBatteryCommandOptions, ffParseBatteryJsonObject, ffPrintBattery); ffOptionInitModuleArg(&options->moduleArgs); options->temp = false; @@ -147,11 +147,8 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options) #endif } -void ffParseBatteryJsonObject(yyjson_val* module) +void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module) { - FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options; - ffInitBatteryOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -162,7 +159,7 @@ void ffParseBatteryJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; #ifdef __linux__ @@ -175,13 +172,11 @@ void ffParseBatteryJsonObject(yyjson_val* module) if (ffStrEqualsIgnCase(key, "temp")) { - options.temp = yyjson_get_bool(val); + options->temp = yyjson_get_bool(val); continue; } - ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintBattery(&options); } diff --git a/src/modules/battery/battery.h b/src/modules/battery/battery.h index a57a3718c5..26312bca7d 100644 --- a/src/modules/battery/battery.h +++ b/src/modules/battery/battery.h @@ -9,4 +9,4 @@ void ffPrintBattery(FFBatteryOptions* options); void ffInitBatteryOptions(FFBatteryOptions* options); bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, const char* value); void ffDestroyBatteryOptions(FFBatteryOptions* options); -void ffParseBatteryJsonObject(yyjson_val* module); +void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module); diff --git a/src/modules/battery/option.h b/src/modules/battery/option.h index 73632b9c67..51bbb0c016 100644 --- a/src/modules/battery/option.h +++ b/src/modules/battery/option.h @@ -6,7 +6,7 @@ typedef struct FFBatteryOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; bool temp; diff --git a/src/modules/bios/bios.c b/src/modules/bios/bios.c index 7aba0aef70..d1c9bb6f08 100644 --- a/src/modules/bios/bios.c +++ b/src/modules/bios/bios.c @@ -55,7 +55,7 @@ void ffPrintBios(FFBiosOptions* options) void ffInitBiosOptions(FFBiosOptions* options) { - options->moduleName = FF_BIOS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BIOS_MODULE_NAME, ffParseBiosCommandOptions, ffParseBiosJsonObject, ffPrintBios); ffOptionInitModuleArg(&options->moduleArgs); } @@ -74,11 +74,8 @@ void ffDestroyBiosOptions(FFBiosOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseBiosJsonObject(yyjson_val* module) +void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module) { - FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options; - ffInitBiosOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -89,12 +86,10 @@ void ffParseBiosJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintBios(&options); } diff --git a/src/modules/bios/bios.h b/src/modules/bios/bios.h index a82606f03a..aaaf15d650 100644 --- a/src/modules/bios/bios.h +++ b/src/modules/bios/bios.h @@ -8,4 +8,4 @@ void ffPrintBios(FFBiosOptions* options); void ffInitBiosOptions(FFBiosOptions* options); bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const char* value); void ffDestroyBiosOptions(FFBiosOptions* options); -void ffParseBiosJsonObject(yyjson_val* module); +void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module); diff --git a/src/modules/bios/option.h b/src/modules/bios/option.h index 6c0f674206..483e7b664f 100644 --- a/src/modules/bios/option.h +++ b/src/modules/bios/option.h @@ -6,6 +6,6 @@ typedef struct FFBiosOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFBiosOptions; diff --git a/src/modules/bluetooth/bluetooth.c b/src/modules/bluetooth/bluetooth.c index 06bf1ce221..eed9d609bc 100644 --- a/src/modules/bluetooth/bluetooth.c +++ b/src/modules/bluetooth/bluetooth.c @@ -75,7 +75,7 @@ void ffPrintBluetooth(FFBluetoothOptions* options) void ffInitBluetoothOptions(FFBluetoothOptions* options) { - options->moduleName = FF_BLUETOOTH_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothCommandOptions, ffParseBluetoothJsonObject, ffPrintBluetooth); ffOptionInitModuleArg(&options->moduleArgs); options->showDisconnected = false; } @@ -101,11 +101,8 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseBluetoothJsonObject(yyjson_val* module) +void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module) { - FFBluetoothOptions __attribute__((__cleanup__(ffDestroyBluetoothOptions))) options; - ffInitBluetoothOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -116,18 +113,16 @@ void ffParseBluetoothJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "showDisconnected")) { - options.showDisconnected = yyjson_get_bool(val); + options->showDisconnected = yyjson_get_bool(val); continue; } - ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintBluetooth(&options); } diff --git a/src/modules/bluetooth/bluetooth.h b/src/modules/bluetooth/bluetooth.h index 1a54baf1d5..411bb39651 100644 --- a/src/modules/bluetooth/bluetooth.h +++ b/src/modules/bluetooth/bluetooth.h @@ -8,4 +8,4 @@ void ffPrintBluetooth(FFBluetoothOptions* options); void ffInitBluetoothOptions(FFBluetoothOptions* options); bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key, const char* value); void ffDestroyBluetoothOptions(FFBluetoothOptions* options); -void ffParseBluetoothJsonObject(yyjson_val* module); +void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module); diff --git a/src/modules/bluetooth/option.h b/src/modules/bluetooth/option.h index b347dc4660..bbe9e1c543 100644 --- a/src/modules/bluetooth/option.h +++ b/src/modules/bluetooth/option.h @@ -6,7 +6,7 @@ typedef struct FFBluetoothOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; bool showDisconnected; diff --git a/src/modules/board/board.c b/src/modules/board/board.c index 6ad125896d..6ce7a847a0 100644 --- a/src/modules/board/board.c +++ b/src/modules/board/board.c @@ -51,7 +51,7 @@ void ffPrintBoard(FFBoardOptions* options) void ffInitBoardOptions(FFBoardOptions* options) { - options->moduleName = FF_BOARD_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BOARD_MODULE_NAME, ffParseBoardCommandOptions, ffParseBoardJsonObject, ffPrintBoard); ffOptionInitModuleArg(&options->moduleArgs); } @@ -70,11 +70,8 @@ void ffDestroyBoardOptions(FFBoardOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseBoardJsonObject(yyjson_val* module) +void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module) { - FFBoardOptions __attribute__((__cleanup__(ffDestroyBoardOptions))) options; - ffInitBoardOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -85,12 +82,10 @@ void ffParseBoardJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintBoard(&options); } diff --git a/src/modules/board/board.h b/src/modules/board/board.h index 112eabbf2d..f5531368e7 100644 --- a/src/modules/board/board.h +++ b/src/modules/board/board.h @@ -8,4 +8,4 @@ void ffPrintBoard(FFBoardOptions* options); void ffInitBoardOptions(FFBoardOptions* options); bool ffParseBoardCommandOptions(FFBoardOptions* options, const char* key, const char* value); void ffDestroyBoardOptions(FFBoardOptions* options); -void ffParseBoardJsonObject(yyjson_val* module); +void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module); diff --git a/src/modules/board/option.h b/src/modules/board/option.h index 582854d236..1640ff3d37 100644 --- a/src/modules/board/option.h +++ b/src/modules/board/option.h @@ -6,6 +6,6 @@ typedef struct FFBoardOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFBoardOptions; diff --git a/src/modules/break/break.c b/src/modules/break/break.c index 1dc3c8e0ae..87821ee001 100644 --- a/src/modules/break/break.c +++ b/src/modules/break/break.c @@ -1,13 +1,28 @@ #include "common/printing.h" #include "modules/break/break.h" -void ffPrintBreak(void) +void ffPrintBreak(FF_MAYBE_UNUSED FFBreakOptions* options) { ffLogoPrintLine(); putchar('\n'); } -void ffParseBreakJsonObject(FF_MAYBE_UNUSED yyjson_val* module) +void ffInitBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options) { - return ffPrintBreak(); + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BREAK_MODULE_NAME, ffParseBreakCommandOptions, ffParseBreakJsonObject, ffPrintBreak); +} + +bool ffParseBreakCommandOptions(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED const char* key, FF_MAYBE_UNUSED const char* value) +{ + return false; +} + +void ffDestroyBreakOptions(FF_MAYBE_UNUSED FFBreakOptions* options) +{ +} + +void ffParseBreakJsonObject(FF_MAYBE_UNUSED FFBreakOptions* options, FF_MAYBE_UNUSED yyjson_val* module) +{ + ffPrintBreak(options); + return; } diff --git a/src/modules/break/break.h b/src/modules/break/break.h index f87c81d3d7..155548cf6d 100644 --- a/src/modules/break/break.h +++ b/src/modules/break/break.h @@ -4,5 +4,8 @@ #define FF_BREAK_MODULE_NAME "Break" -void ffPrintBreak(); -void ffParseBreakJsonObject(yyjson_val* module); +void ffPrintBreak(FFBreakOptions* options); +void ffInitBreakOptions(FFBreakOptions* options); +bool ffParseBreakCommandOptions(FFBreakOptions* options, const char* key, const char* value); +void ffDestroyBreakOptions(FFBreakOptions* options); +void ffParseBreakJsonObject(FFBreakOptions* options, yyjson_val* module); diff --git a/src/modules/break/option.h b/src/modules/break/option.h new file mode 100644 index 0000000000..4d2870c268 --- /dev/null +++ b/src/modules/break/option.h @@ -0,0 +1,10 @@ +#pragma once + +// This file will be included in "fastfetch.h", do NOT put unnecessary things here + +#include "common/option.h" + +typedef struct FFBreakOptions +{ + FFModuleBaseInfo moduleInfo; +} FFBreakOptions; diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c index 3e6a564c38..4a29ae7512 100644 --- a/src/modules/brightness/brightness.c +++ b/src/modules/brightness/brightness.c @@ -80,7 +80,7 @@ void ffPrintBrightness(FFBrightnessOptions* options) void ffInitBrightnessOptions(FFBrightnessOptions* options) { - options->moduleName = FF_BRIGHTNESS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessCommandOptions, ffParseBrightnessJsonObject, ffPrintBrightness); ffOptionInitModuleArg(&options->moduleArgs); } @@ -99,11 +99,8 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseBrightnessJsonObject(yyjson_val* module) +void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module) { - FFBrightnessOptions __attribute__((__cleanup__(ffDestroyBrightnessOptions))) options; - ffInitBrightnessOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -114,12 +111,10 @@ void ffParseBrightnessJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintBrightness(&options); } diff --git a/src/modules/brightness/brightness.h b/src/modules/brightness/brightness.h index f9724d65c7..1272e5d0f4 100644 --- a/src/modules/brightness/brightness.h +++ b/src/modules/brightness/brightness.h @@ -8,4 +8,4 @@ void ffPrintBrightness(FFBrightnessOptions* options); void ffInitBrightnessOptions(FFBrightnessOptions* options); bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* key, const char* value); void ffDestroyBrightnessOptions(FFBrightnessOptions* options); -void ffParseBrightnessJsonObject(yyjson_val* module); +void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module); diff --git a/src/modules/brightness/option.h b/src/modules/brightness/option.h index 803ea4792e..aa67ac1903 100644 --- a/src/modules/brightness/option.h +++ b/src/modules/brightness/option.h @@ -6,6 +6,6 @@ typedef struct FFBrightnessOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFBrightnessOptions; diff --git a/src/modules/chassis/chassis.c b/src/modules/chassis/chassis.c index 53ee101ad8..baf5a9ec4b 100644 --- a/src/modules/chassis/chassis.c +++ b/src/modules/chassis/chassis.c @@ -52,7 +52,7 @@ void ffPrintChassis(FFChassisOptions* options) void ffInitChassisOptions(FFChassisOptions* options) { - options->moduleName = FF_CHASSIS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CHASSIS_MODULE_NAME, ffParseChassisCommandOptions, ffParseChassisJsonObject, ffPrintChassis); ffOptionInitModuleArg(&options->moduleArgs); } @@ -71,11 +71,8 @@ void ffDestroyChassisOptions(FFChassisOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseChassisJsonObject(yyjson_val* module) +void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module) { - FFChassisOptions __attribute__((__cleanup__(ffDestroyChassisOptions))) options; - ffInitChassisOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -86,12 +83,10 @@ void ffParseChassisJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintChassis(&options); } diff --git a/src/modules/chassis/chassis.h b/src/modules/chassis/chassis.h index 0526608da9..5fe4bb62fd 100644 --- a/src/modules/chassis/chassis.h +++ b/src/modules/chassis/chassis.h @@ -8,4 +8,4 @@ void ffPrintChassis(FFChassisOptions* options); void ffInitChassisOptions(FFChassisOptions* options); bool ffParseChassisCommandOptions(FFChassisOptions* options, const char* key, const char* value); void ffDestroyChassisOptions(FFChassisOptions* options); -void ffParseChassisJsonObject(yyjson_val* module); +void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module); diff --git a/src/modules/chassis/option.h b/src/modules/chassis/option.h index 939fd165d7..de6338cd50 100644 --- a/src/modules/chassis/option.h +++ b/src/modules/chassis/option.h @@ -6,6 +6,6 @@ typedef struct FFChassisOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFChassisOptions; diff --git a/src/modules/colors/colors.c b/src/modules/colors/colors.c index 0cceb28e81..e1ec1a90ca 100644 --- a/src/modules/colors/colors.c +++ b/src/modules/colors/colors.c @@ -57,7 +57,7 @@ void ffPrintColors(FFColorsOptions* options) void ffInitColorsOptions(FFColorsOptions* options) { - options->moduleName = FF_COLORS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COLORS_MODULE_NAME, ffParseColorsCommandOptions, ffParseColorsJsonObject, ffPrintColors); options->symbol = FF_COLORS_SYMBOL_BLOCK; options->paddingLeft = 0; } @@ -94,11 +94,8 @@ void ffDestroyColorsOptions(FF_MAYBE_UNUSED FFColorsOptions* options) { } -void ffParseColorsJsonObject(yyjson_val* module) +void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module) { - FFColorsOptions __attribute__((__cleanup__(ffDestroyColorsOptions))) options; - ffInitColorsOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -124,19 +121,17 @@ void ffParseColorsJsonObject(yyjson_val* module) if (error) ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error); else - options.symbol = (FFColorsSymbol) value; + options->symbol = (FFColorsSymbol) value; continue; } if (ffStrEqualsIgnCase(key, "paddingLeft")) { - options.paddingLeft = (uint32_t) yyjson_get_uint(val); + options->paddingLeft = (uint32_t) yyjson_get_uint(val); continue; } ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } - - ffPrintColors(&options); } diff --git a/src/modules/colors/colors.h b/src/modules/colors/colors.h index 64ebe96c86..674bcd8176 100644 --- a/src/modules/colors/colors.h +++ b/src/modules/colors/colors.h @@ -8,4 +8,4 @@ void ffPrintColors(FFColorsOptions* options); void ffInitColorsOptions(FFColorsOptions* options); void ffDestroyColorsOptions(FFColorsOptions* options); bool ffParseColorsCommandOptions(FFColorsOptions* options, const char* key, const char* value); -void ffParseColorsJsonObject(yyjson_val* module); +void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module); diff --git a/src/modules/colors/option.h b/src/modules/colors/option.h index afcb23fb64..a17029bd84 100644 --- a/src/modules/colors/option.h +++ b/src/modules/colors/option.h @@ -16,7 +16,7 @@ typedef enum FFColorsSymbol typedef struct FFColorsOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFColorsSymbol symbol; uint32_t paddingLeft; } FFColorsOptions; diff --git a/src/modules/command/command.c b/src/modules/command/command.c index c4390fc0d4..de25c50041 100644 --- a/src/modules/command/command.c +++ b/src/modules/command/command.c @@ -36,7 +36,7 @@ void ffPrintCommand(FFCommandOptions* options) void ffInitCommandOptions(FFCommandOptions* options) { - options->moduleName = FF_COMMAND_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_COMMAND_MODULE_NAME, ffParseCommandCommandOptions, ffParseCommandJsonObject, ffPrintCommand); ffOptionInitModuleArg(&options->moduleArgs); ffStrbufInitStatic(&options->shell, @@ -79,11 +79,8 @@ void ffDestroyCommandOptions(FFCommandOptions* options) ffStrbufDestroy(&options->text); } -void ffParseCommandJsonObject(yyjson_val* module) +void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module) { - FFCommandOptions __attribute__((__cleanup__(ffDestroyCommandOptions))) options; - ffInitCommandOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -94,24 +91,22 @@ void ffParseCommandJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "shell")) { - ffStrbufSetS(&options.shell, yyjson_get_str(val)); + ffStrbufSetS(&options->shell, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "text")) { - ffStrbufSetS(&options.text, yyjson_get_str(val)); + ffStrbufSetS(&options->text, yyjson_get_str(val)); continue; } - ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintCommand(&options); } diff --git a/src/modules/command/command.h b/src/modules/command/command.h index eca179b358..8ee5cc82c1 100644 --- a/src/modules/command/command.h +++ b/src/modules/command/command.h @@ -8,4 +8,4 @@ void ffPrintCommand(FFCommandOptions* options); void ffInitCommandOptions(FFCommandOptions* options); bool ffParseCommandCommandOptions(FFCommandOptions* options, const char* key, const char* value); void ffDestroyCommandOptions(FFCommandOptions* options); -void ffParseCommandJsonObject(yyjson_val* module); +void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module); diff --git a/src/modules/command/option.h b/src/modules/command/option.h index 41d3408a4a..6aab8a3c2d 100644 --- a/src/modules/command/option.h +++ b/src/modules/command/option.h @@ -6,7 +6,7 @@ typedef struct FFCommandOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFstrbuf shell; diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c index fe4379243e..5556c2e585 100644 --- a/src/modules/cpu/cpu.c +++ b/src/modules/cpu/cpu.c @@ -79,7 +79,7 @@ void ffPrintCPU(FFCPUOptions* options) void ffInitCPUOptions(FFCPUOptions* options) { - options->moduleName = FF_CPU_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPU_MODULE_NAME, ffParseCPUCommandOptions, ffParseCPUJsonObject, ffPrintCPU); ffOptionInitModuleArg(&options->moduleArgs); options->temp = false; } @@ -105,11 +105,8 @@ void ffDestroyCPUOptions(FFCPUOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseCPUJsonObject(yyjson_val* module) +void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module) { - FFCPUOptions __attribute__((__cleanup__(ffDestroyCPUOptions))) options; - ffInitCPUOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -120,18 +117,16 @@ void ffParseCPUJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "temp")) { - options.temp = yyjson_get_bool(val); + options->temp = yyjson_get_bool(val); continue; } - ffPrintError(FF_CPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintCPU(&options); } diff --git a/src/modules/cpu/cpu.h b/src/modules/cpu/cpu.h index 731149d5bc..acff0a13ce 100644 --- a/src/modules/cpu/cpu.h +++ b/src/modules/cpu/cpu.h @@ -8,4 +8,4 @@ void ffPrintCPU(FFCPUOptions* options); void ffInitCPUOptions(FFCPUOptions* options); bool ffParseCPUCommandOptions(FFCPUOptions* options, const char* key, const char* value); void ffDestroyCPUOptions(FFCPUOptions* options); -void ffParseCPUJsonObject(yyjson_val* module); +void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module); diff --git a/src/modules/cpu/option.h b/src/modules/cpu/option.h index 9e54bfeafc..1902ddfc27 100644 --- a/src/modules/cpu/option.h +++ b/src/modules/cpu/option.h @@ -6,7 +6,7 @@ typedef struct FFCPUOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; bool temp; diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c index 263fe109f8..59a4ae3cc3 100644 --- a/src/modules/cpuusage/cpuusage.c +++ b/src/modules/cpuusage/cpuusage.c @@ -44,7 +44,7 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options) void ffInitCPUUsageOptions(FFCPUUsageOptions* options) { - options->moduleName = FF_CPUUSAGE_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageCommandOptions, ffParseCPUUsageJsonObject, ffPrintCPUUsage); ffOptionInitModuleArg(&options->moduleArgs); } @@ -63,11 +63,8 @@ void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseCPUUsageJsonObject(yyjson_val* module) +void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module) { - FFCPUUsageOptions __attribute__((__cleanup__(ffDestroyCPUUsageOptions))) options; - ffInitCPUUsageOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -78,12 +75,10 @@ void ffParseCPUUsageJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintCPUUsage(&options); } diff --git a/src/modules/cpuusage/cpuusage.h b/src/modules/cpuusage/cpuusage.h index e0275a5ea9..5a221f554c 100644 --- a/src/modules/cpuusage/cpuusage.h +++ b/src/modules/cpuusage/cpuusage.h @@ -10,4 +10,4 @@ void ffPrintCPUUsage(FFCPUUsageOptions* options); void ffInitCPUUsageOptions(FFCPUUsageOptions* options); bool ffParseCPUUsageCommandOptions(FFCPUUsageOptions* options, const char* key, const char* value); void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options); -void ffParseCPUUsageJsonObject(yyjson_val* module); +void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module); diff --git a/src/modules/cpuusage/option.h b/src/modules/cpuusage/option.h index c779b6c5a5..9468553016 100644 --- a/src/modules/cpuusage/option.h +++ b/src/modules/cpuusage/option.h @@ -6,6 +6,6 @@ typedef struct FFCPUUsageOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFCPUUsageOptions; diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c index 7a5602f5d7..a011643e3c 100644 --- a/src/modules/cursor/cursor.c +++ b/src/modules/cursor/cursor.c @@ -52,7 +52,7 @@ void ffPrintCursor(FFCursorOptions* options) void ffInitCursorOptions(FFCursorOptions* options) { - options->moduleName = FF_CURSOR_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CURSOR_MODULE_NAME, ffParseCursorCommandOptions, ffParseCursorJsonObject, ffPrintCursor); ffOptionInitModuleArg(&options->moduleArgs); } @@ -71,11 +71,8 @@ void ffDestroyCursorOptions(FFCursorOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseCursorJsonObject(yyjson_val* module) +void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module) { - FFCursorOptions __attribute__((__cleanup__(ffDestroyCursorOptions))) options; - ffInitCursorOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -86,12 +83,10 @@ void ffParseCursorJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintCursor(&options); } diff --git a/src/modules/cursor/cursor.h b/src/modules/cursor/cursor.h index 5c23741a2c..ff849b5476 100644 --- a/src/modules/cursor/cursor.h +++ b/src/modules/cursor/cursor.h @@ -8,4 +8,4 @@ void ffPrintCursor(FFCursorOptions* options); void ffInitCursorOptions(FFCursorOptions* options); bool ffParseCursorCommandOptions(FFCursorOptions* options, const char* key, const char* value); void ffDestroyCursorOptions(FFCursorOptions* options); -void ffParseCursorJsonObject(yyjson_val* module); +void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module); diff --git a/src/modules/cursor/option.h b/src/modules/cursor/option.h index 9a648c844c..26c2bb9f4e 100644 --- a/src/modules/cursor/option.h +++ b/src/modules/cursor/option.h @@ -6,6 +6,6 @@ typedef struct FFCursorOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFCursorOptions; diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c index b7b6792411..f1f4a2d815 100644 --- a/src/modules/custom/custom.c +++ b/src/modules/custom/custom.c @@ -19,7 +19,7 @@ void ffPrintCustom(FFCustomOptions* options) void ffInitCustomOptions(FFCustomOptions* options) { - options->moduleName = FF_CUSTOM_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_CUSTOM_MODULE_NAME, ffParseCustomCommandOptions, ffParseCustomJsonObject, ffPrintCustom); ffOptionInitModuleArg(&options->moduleArgs); } @@ -38,11 +38,8 @@ void ffDestroyCustomOptions(FFCustomOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseCustomJsonObject(yyjson_val* module) +void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module) { - FFCustomOptions __attribute__((__cleanup__(ffDestroyCustomOptions))) options; - ffInitCustomOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -53,12 +50,10 @@ void ffParseCustomJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintCustom(&options); } diff --git a/src/modules/custom/custom.h b/src/modules/custom/custom.h index 6d1981d7c8..4c4c40b5d9 100644 --- a/src/modules/custom/custom.h +++ b/src/modules/custom/custom.h @@ -8,4 +8,4 @@ void ffPrintCustom(FFCustomOptions* options); void ffInitCustomOptions(FFCustomOptions* options); bool ffParseCustomCommandOptions(FFCustomOptions* options, const char* key, const char* value); void ffDestroyCustomOptions(FFCustomOptions* options); -void ffParseCustomJsonObject(yyjson_val* module); +void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module); diff --git a/src/modules/custom/option.h b/src/modules/custom/option.h index f2b2388318..b0776a833a 100644 --- a/src/modules/custom/option.h +++ b/src/modules/custom/option.h @@ -6,6 +6,6 @@ typedef struct FFCustomOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFCustomOptions; diff --git a/src/modules/datetime/datetime.c b/src/modules/datetime/datetime.c index 7d2cbd9418..a89d5238a9 100644 --- a/src/modules/datetime/datetime.c +++ b/src/modules/datetime/datetime.c @@ -51,7 +51,7 @@ void ffPrintDateTime(FFDateTimeOptions* options) void ffInitDateTimeOptions(FFDateTimeOptions* options) { - options->moduleName = FF_DATETIME_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DATETIME_MODULE_NAME, ffParseDateTimeCommandOptions, ffParseDateTimeJsonObject, ffPrintDateTime); ffOptionInitModuleArg(&options->moduleArgs); } @@ -70,11 +70,8 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseDateTimeJsonObject(yyjson_val* module) +void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module) { - FFDateTimeOptions __attribute__((__cleanup__(ffDestroyDateTimeOptions))) options; - ffInitDateTimeOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -85,12 +82,10 @@ void ffParseDateTimeJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintDateTime(&options); } diff --git a/src/modules/datetime/datetime.h b/src/modules/datetime/datetime.h index 269343711c..6ccb30b278 100644 --- a/src/modules/datetime/datetime.h +++ b/src/modules/datetime/datetime.h @@ -8,4 +8,4 @@ void ffPrintDateTime(FFDateTimeOptions* options); void ffInitDateTimeOptions(FFDateTimeOptions* options); bool ffParseDateTimeCommandOptions(FFDateTimeOptions* options, const char* key, const char* value); void ffDestroyDateTimeOptions(FFDateTimeOptions* options); -void ffParseDateTimeJsonObject(yyjson_val* module); +void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module); diff --git a/src/modules/datetime/option.h b/src/modules/datetime/option.h index 1c32501e65..f9d25cfe39 100644 --- a/src/modules/datetime/option.h +++ b/src/modules/datetime/option.h @@ -6,6 +6,6 @@ typedef struct FFDateTimeOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFDateTimeOptions; diff --git a/src/modules/de/de.c b/src/modules/de/de.c index db3c775b56..e4abefd0bf 100644 --- a/src/modules/de/de.c +++ b/src/modules/de/de.c @@ -42,7 +42,7 @@ void ffPrintDE(FFDEOptions* options) void ffInitDEOptions(FFDEOptions* options) { - options->moduleName = FF_DE_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DE_MODULE_NAME, ffParseDECommandOptions, ffParseDEJsonObject, ffPrintDE); ffOptionInitModuleArg(&options->moduleArgs); } @@ -61,11 +61,8 @@ void ffDestroyDEOptions(FFDEOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseDEJsonObject(yyjson_val* module) +void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module) { - FFDEOptions __attribute__((__cleanup__(ffDestroyDEOptions))) options; - ffInitDEOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -76,12 +73,10 @@ void ffParseDEJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_DE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintDE(&options); } diff --git a/src/modules/de/de.h b/src/modules/de/de.h index 2676655847..0a4e145411 100644 --- a/src/modules/de/de.h +++ b/src/modules/de/de.h @@ -8,4 +8,4 @@ void ffPrintDE(FFDEOptions* options); void ffInitDEOptions(FFDEOptions* options); bool ffParseDECommandOptions(FFDEOptions* options, const char* key, const char* value); void ffDestroyDEOptions(FFDEOptions* options); -void ffParseDEJsonObject(yyjson_val* module); +void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module); diff --git a/src/modules/de/option.h b/src/modules/de/option.h index 52b8954e72..8ad2b2000d 100644 --- a/src/modules/de/option.h +++ b/src/modules/de/option.h @@ -6,6 +6,6 @@ typedef struct FFDEOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFDEOptions; diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c index e79bcd692e..a43a1537ea 100644 --- a/src/modules/disk/disk.c +++ b/src/modules/disk/disk.c @@ -184,10 +184,9 @@ void ffPrintDisk(FFDiskOptions* options) } } - void ffInitDiskOptions(FFDiskOptions* options) { - options->moduleName = FF_DISK_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISK_MODULE_NAME, ffParseDiskCommandOptions, ffParseDiskJsonObject, ffPrintDisk); ffOptionInitModuleArg(&options->moduleArgs); ffStrbufInit(&options->folders); @@ -260,11 +259,8 @@ void ffDestroyDiskOptions(FFDiskOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseDiskJsonObject(yyjson_val* module) +void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module) { - FFDiskOptions __attribute__((__cleanup__(ffDestroyDiskOptions))) options; - ffInitDiskOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -275,54 +271,52 @@ void ffParseDiskJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "folders")) { - ffStrbufSetS(&options.folders, yyjson_get_str(val)); + ffStrbufSetS(&options->folders, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "showExternal")) { if (yyjson_get_bool(val)) - options.showTypes |= FF_DISK_TYPE_EXTERNAL_BIT; + options->showTypes |= FF_DISK_TYPE_EXTERNAL_BIT; else - options.showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT; + options->showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT; continue; } if (ffStrEqualsIgnCase(key, "showHidden")) { if (yyjson_get_bool(val)) - options.showTypes |= FF_DISK_TYPE_HIDDEN_BIT; + options->showTypes |= FF_DISK_TYPE_HIDDEN_BIT; else - options.showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT; + options->showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT; continue; } if (ffStrEqualsIgnCase(key, "showSubvolumes")) { if (yyjson_get_bool(val)) - options.showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT; + options->showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT; else - options.showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT; + options->showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT; continue; } if (ffStrEqualsIgnCase(key, "showUnknown")) { if (yyjson_get_bool(val)) - options.showTypes |= FF_DISK_TYPE_UNKNOWN_BIT; + options->showTypes |= FF_DISK_TYPE_UNKNOWN_BIT; else - options.showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT; + options->showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT; continue; } - ffPrintError(FF_DISK_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintDisk(&options); } diff --git a/src/modules/disk/disk.h b/src/modules/disk/disk.h index aa508df141..1f71f766be 100644 --- a/src/modules/disk/disk.h +++ b/src/modules/disk/disk.h @@ -8,4 +8,4 @@ void ffPrintDisk(FFDiskOptions* options); void ffInitDiskOptions(FFDiskOptions* options); bool ffParseDiskCommandOptions(FFDiskOptions* options, const char* key, const char* value); void ffDestroyDiskOptions(FFDiskOptions* options); -void ffParseDiskJsonObject(yyjson_val* module); +void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module); diff --git a/src/modules/disk/option.h b/src/modules/disk/option.h index 702e5bcbf5..07e603cd13 100644 --- a/src/modules/disk/option.h +++ b/src/modules/disk/option.h @@ -16,7 +16,7 @@ typedef enum FFDiskType typedef struct FFDiskOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFstrbuf folders; diff --git a/src/modules/display/display.c b/src/modules/display/display.c index 6b7980a62d..7c11267aa8 100644 --- a/src/modules/display/display.c +++ b/src/modules/display/display.c @@ -109,7 +109,7 @@ void ffPrintDisplay(FFDisplayOptions* options) void ffInitDisplayOptions(FFDisplayOptions* options) { - options->moduleName = FF_DISPLAY_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_DISPLAY_MODULE_NAME, ffParseDisplayCommandOptions, ffParseDisplayJsonObject, ffPrintDisplay); ffOptionInitModuleArg(&options->moduleArgs); options->compactType = FF_DISPLAY_COMPACT_TYPE_NONE; options->preciseRefreshRate = false; @@ -147,11 +147,8 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseDisplayJsonObject(yyjson_val* module) +void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module) { - FFDisplayOptions __attribute__((__cleanup__(ffDestroyDisplayOptions))) options; - ffInitDisplayOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -162,7 +159,7 @@ void ffParseDisplayJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "compactType")) @@ -175,21 +172,19 @@ void ffParseDisplayJsonObject(yyjson_val* module) {}, }); if (error) - ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error); + ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); else - options.compactType = (FFDisplayCompactType) value; + options->compactType = (FFDisplayCompactType) value; continue; } if (ffStrEqualsIgnCase(key, "preciseRefreshRate")) { - options.preciseRefreshRate = yyjson_get_bool(val); + options->preciseRefreshRate = yyjson_get_bool(val); continue; } - ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintDisplay(&options); } diff --git a/src/modules/display/display.h b/src/modules/display/display.h index 66196f0638..b2f7570564 100644 --- a/src/modules/display/display.h +++ b/src/modules/display/display.h @@ -8,4 +8,4 @@ void ffPrintDisplay(FFDisplayOptions* options); void ffInitDisplayOptions(FFDisplayOptions* options); bool ffParseDisplayCommandOptions(FFDisplayOptions* options, const char* key, const char* value); void ffDestroyDisplayOptions(FFDisplayOptions* options); -void ffParseDisplayJsonObject(yyjson_val* module); +void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module); diff --git a/src/modules/display/option.h b/src/modules/display/option.h index 20def688c4..70b4c2be06 100644 --- a/src/modules/display/option.h +++ b/src/modules/display/option.h @@ -13,7 +13,7 @@ typedef enum FFDisplayCompactType typedef struct FFDisplayOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFDisplayCompactType compactType; diff --git a/src/modules/font/font.c b/src/modules/font/font.c index 8bc328cd38..dee13f91b2 100644 --- a/src/modules/font/font.c +++ b/src/modules/font/font.c @@ -45,7 +45,7 @@ void ffPrintFont(FFFontOptions* options) void ffInitFontOptions(FFFontOptions* options) { - options->moduleName = FF_FONT_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_FONT_MODULE_NAME, ffParseFontCommandOptions, ffParseFontJsonObject, ffPrintFont); ffOptionInitModuleArg(&options->moduleArgs); } @@ -64,11 +64,8 @@ void ffDestroyFontOptions(FFFontOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseFontJsonObject(yyjson_val* module) +void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module) { - FFFontOptions __attribute__((__cleanup__(ffDestroyFontOptions))) options; - ffInitFontOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -79,12 +76,10 @@ void ffParseFontJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_FONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintFont(&options); } diff --git a/src/modules/font/font.h b/src/modules/font/font.h index a4e46f65ac..a51f9d4471 100644 --- a/src/modules/font/font.h +++ b/src/modules/font/font.h @@ -8,4 +8,4 @@ void ffPrintFont(FFFontOptions* options); void ffInitFontOptions(FFFontOptions* options); bool ffParseFontCommandOptions(FFFontOptions* options, const char* key, const char* value); void ffDestroyFontOptions(FFFontOptions* options); -void ffParseFontJsonObject(yyjson_val* module); +void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module); diff --git a/src/modules/font/option.h b/src/modules/font/option.h index 9318bac4b6..12552bcceb 100644 --- a/src/modules/font/option.h +++ b/src/modules/font/option.h @@ -6,6 +6,6 @@ typedef struct FFFontOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFFontOptions; diff --git a/src/modules/gamepad/gamepad.c b/src/modules/gamepad/gamepad.c index 18c417b3ca..e057d45c3c 100644 --- a/src/modules/gamepad/gamepad.c +++ b/src/modules/gamepad/gamepad.c @@ -51,7 +51,7 @@ void ffPrintGamepad(FFGamepadOptions* options) void ffInitGamepadOptions(FFGamepadOptions* options) { - options->moduleName = FF_GAMEPAD_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GAMEPAD_MODULE_NAME, ffParseGamepadCommandOptions, ffParseGamepadJsonObject, ffPrintGamepad); ffOptionInitModuleArg(&options->moduleArgs); } @@ -70,11 +70,8 @@ void ffDestroyGamepadOptions(FFGamepadOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseGamepadJsonObject(yyjson_val* module) +void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module) { - FFGamepadOptions __attribute__((__cleanup__(ffDestroyGamepadOptions))) options; - ffInitGamepadOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -85,12 +82,10 @@ void ffParseGamepadJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintGamepad(&options); } diff --git a/src/modules/gamepad/gamepad.h b/src/modules/gamepad/gamepad.h index df81768d78..eae8a8a175 100644 --- a/src/modules/gamepad/gamepad.h +++ b/src/modules/gamepad/gamepad.h @@ -8,4 +8,4 @@ void ffPrintGamepad(FFGamepadOptions* options); void ffInitGamepadOptions(FFGamepadOptions* options); bool ffParseGamepadCommandOptions(FFGamepadOptions* options, const char* key, const char* value); void ffDestroyGamepadOptions(FFGamepadOptions* options); -void ffParseGamepadJsonObject(yyjson_val* module); +void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module); diff --git a/src/modules/gamepad/option.h b/src/modules/gamepad/option.h index 6cca7f2fdc..f455b3a429 100644 --- a/src/modules/gamepad/option.h +++ b/src/modules/gamepad/option.h @@ -6,6 +6,6 @@ typedef struct FFGamepadOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFGamepadOptions; diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c index b1b8fa090b..58c85648b0 100644 --- a/src/modules/gpu/gpu.c +++ b/src/modules/gpu/gpu.c @@ -121,7 +121,7 @@ void ffPrintGPU(FFGPUOptions* options) void ffInitGPUOptions(FFGPUOptions* options) { - options->moduleName = FF_GPU_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_GPU_MODULE_NAME, ffParseGPUCommandOptions, ffParseGPUJsonObject, ffPrintGPU); ffOptionInitModuleArg(&options->moduleArgs); options->forceVulkan = false; @@ -166,11 +166,8 @@ void ffDestroyGPUOptions(FFGPUOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseGPUJsonObject(yyjson_val* module) +void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module) { - FFGPUOptions __attribute__((__cleanup__(ffDestroyGPUOptions))) options; - ffInitGPUOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -181,18 +178,18 @@ void ffParseGPUJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "temp")) { - options.temp = yyjson_get_bool(val); + options->temp = yyjson_get_bool(val); continue; } if (ffStrEqualsIgnCase(key, "forceVulkan")) { - options.forceVulkan = yyjson_get_bool(val); + options->forceVulkan = yyjson_get_bool(val); continue; } @@ -206,15 +203,13 @@ void ffParseGPUJsonObject(yyjson_val* module) {}, }); if (error) - ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error); + ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); else - options.hideType = (FFGPUType) value; + options->hideType = (FFGPUType) value; continue; } - ffPrintError(FF_GPU_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintGPU(&options); } diff --git a/src/modules/gpu/gpu.h b/src/modules/gpu/gpu.h index 9462e5fa07..b5334730a0 100644 --- a/src/modules/gpu/gpu.h +++ b/src/modules/gpu/gpu.h @@ -8,4 +8,4 @@ void ffPrintGPU(FFGPUOptions* options); void ffInitGPUOptions(FFGPUOptions* options); bool ffParseGPUCommandOptions(FFGPUOptions* options, const char* key, const char* value); void ffDestroyGPUOptions(FFGPUOptions* options); -void ffParseGPUJsonObject(yyjson_val* module); +void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module); diff --git a/src/modules/gpu/option.h b/src/modules/gpu/option.h index 0aaa6a6f7d..8525d61273 100644 --- a/src/modules/gpu/option.h +++ b/src/modules/gpu/option.h @@ -13,7 +13,7 @@ typedef enum FFGPUType typedef struct FFGPUOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFGPUType hideType; diff --git a/src/modules/host/host.c b/src/modules/host/host.c index 5c878134b8..b7033ec0bf 100644 --- a/src/modules/host/host.c +++ b/src/modules/host/host.c @@ -67,7 +67,7 @@ void ffPrintHost(FFHostOptions* options) void ffInitHostOptions(FFHostOptions* options) { - options->moduleName = FF_HOST_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_HOST_MODULE_NAME, ffParseHostCommandOptions, ffParseHostJsonObject, ffPrintHost); ffOptionInitModuleArg(&options->moduleArgs); } @@ -86,11 +86,8 @@ void ffDestroyHostOptions(FFHostOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseHostJsonObject(yyjson_val* module) +void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module) { - FFHostOptions __attribute__((__cleanup__(ffDestroyHostOptions))) options; - ffInitHostOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -101,12 +98,10 @@ void ffParseHostJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintHost(&options); } diff --git a/src/modules/host/host.h b/src/modules/host/host.h index 9c9368a27e..5a689288af 100644 --- a/src/modules/host/host.h +++ b/src/modules/host/host.h @@ -8,4 +8,4 @@ void ffPrintHost(FFHostOptions* options); void ffInitHostOptions(FFHostOptions* options); bool ffParseHostCommandOptions(FFHostOptions* options, const char* key, const char* value); void ffDestroyHostOptions(FFHostOptions* options); -void ffParseHostJsonObject(yyjson_val* module); +void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module); diff --git a/src/modules/host/option.h b/src/modules/host/option.h index 59073e934e..1c6bf26f34 100644 --- a/src/modules/host/option.h +++ b/src/modules/host/option.h @@ -6,6 +6,6 @@ typedef struct FFHostOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFHostOptions; diff --git a/src/modules/icons/icons.c b/src/modules/icons/icons.c index a79a973019..ede179b66b 100644 --- a/src/modules/icons/icons.c +++ b/src/modules/icons/icons.c @@ -32,7 +32,7 @@ void ffPrintIcons(FFIconsOptions* options) void ffInitIconsOptions(FFIconsOptions* options) { - options->moduleName = FF_ICONS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_ICONS_MODULE_NAME, ffParseIconsCommandOptions, ffParseIconsJsonObject, ffPrintIcons); ffOptionInitModuleArg(&options->moduleArgs); } @@ -51,11 +51,8 @@ void ffDestroyIconsOptions(FFIconsOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseIconsJsonObject(yyjson_val* module) +void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module) { - FFIconsOptions __attribute__((__cleanup__(ffDestroyIconsOptions))) options; - ffInitIconsOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -66,12 +63,10 @@ void ffParseIconsJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_ICONS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintIcons(&options); } diff --git a/src/modules/icons/icons.h b/src/modules/icons/icons.h index 3d4bd7e0d4..97533b096a 100644 --- a/src/modules/icons/icons.h +++ b/src/modules/icons/icons.h @@ -8,4 +8,4 @@ void ffPrintIcons(FFIconsOptions* options); void ffInitIconsOptions(FFIconsOptions* options); bool ffParseIconsCommandOptions(FFIconsOptions* options, const char* key, const char* value); void ffDestroyIconsOptions(FFIconsOptions* options); -void ffParseIconsJsonObject(yyjson_val* module); +void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module); diff --git a/src/modules/icons/option.h b/src/modules/icons/option.h index fc6427aa41..456668796f 100644 --- a/src/modules/icons/option.h +++ b/src/modules/icons/option.h @@ -6,6 +6,6 @@ typedef struct FFIconsOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFIconsOptions; diff --git a/src/modules/kernel/kernel.c b/src/modules/kernel/kernel.c index e33233523f..e830debe1f 100644 --- a/src/modules/kernel/kernel.c +++ b/src/modules/kernel/kernel.c @@ -32,7 +32,7 @@ void ffPrintKernel(FFKernelOptions* options) void ffInitKernelOptions(FFKernelOptions* options) { - options->moduleName = FF_KERNEL_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_KERNEL_MODULE_NAME, ffParseKernelCommandOptions, ffParseKernelJsonObject, ffPrintKernel); ffOptionInitModuleArg(&options->moduleArgs); } @@ -51,11 +51,8 @@ void ffDestroyKernelOptions(FFKernelOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseKernelJsonObject(yyjson_val* module) +void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module) { - FFKernelOptions __attribute__((__cleanup__(ffDestroyKernelOptions))) options; - ffInitKernelOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -66,12 +63,10 @@ void ffParseKernelJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintKernel(&options); } diff --git a/src/modules/kernel/kernel.h b/src/modules/kernel/kernel.h index 906a89c11c..943641d602 100644 --- a/src/modules/kernel/kernel.h +++ b/src/modules/kernel/kernel.h @@ -8,4 +8,4 @@ void ffPrintKernel(FFKernelOptions* options); void ffInitKernelOptions(FFKernelOptions* options); bool ffParseKernelCommandOptions(FFKernelOptions* options, const char* key, const char* value); void ffDestroyKernelOptions(FFKernelOptions* options); -void ffParseKernelJsonObject(yyjson_val* module); +void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module); diff --git a/src/modules/kernel/option.h b/src/modules/kernel/option.h index 434c3069de..fd3cb17a3c 100644 --- a/src/modules/kernel/option.h +++ b/src/modules/kernel/option.h @@ -6,6 +6,6 @@ typedef struct FFKernelOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFKernelOptions; diff --git a/src/modules/lm/lm.c b/src/modules/lm/lm.c index c0608e8a0f..3c3053e8e7 100644 --- a/src/modules/lm/lm.c +++ b/src/modules/lm/lm.c @@ -51,7 +51,7 @@ void ffPrintLM(FFLMOptions* options) void ffInitLMOptions(FFLMOptions* options) { - options->moduleName = FF_LM_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LM_MODULE_NAME, ffParseLMCommandOptions, ffParseLMJsonObject, ffPrintLM); ffOptionInitModuleArg(&options->moduleArgs); } @@ -70,11 +70,8 @@ void ffDestroyLMOptions(FFLMOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseLMJsonObject(yyjson_val* module) +void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module) { - FFLMOptions __attribute__((__cleanup__(ffDestroyLMOptions))) options; - ffInitLMOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -85,12 +82,10 @@ void ffParseLMJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_LM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintLM(&options); } diff --git a/src/modules/lm/lm.h b/src/modules/lm/lm.h index 788405bed9..079f90e5f6 100644 --- a/src/modules/lm/lm.h +++ b/src/modules/lm/lm.h @@ -8,4 +8,4 @@ void ffPrintLM(FFLMOptions* options); void ffInitLMOptions(FFLMOptions* options); bool ffParseLMCommandOptions(FFLMOptions* options, const char* key, const char* value); void ffDestroyLMOptions(FFLMOptions* options); -void ffParseLMJsonObject(yyjson_val* module); +void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module); diff --git a/src/modules/lm/option.h b/src/modules/lm/option.h index 2a788186cb..4255382ff0 100644 --- a/src/modules/lm/option.h +++ b/src/modules/lm/option.h @@ -6,6 +6,6 @@ typedef struct FFLMOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFLMOptions; diff --git a/src/modules/locale/locale.c b/src/modules/locale/locale.c index 21e5a37561..10e00802ec 100644 --- a/src/modules/locale/locale.c +++ b/src/modules/locale/locale.c @@ -32,7 +32,7 @@ void ffPrintLocale(FFLocaleOptions* options) void ffInitLocaleOptions(FFLocaleOptions* options) { - options->moduleName = FF_LOCALE_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALE_MODULE_NAME, ffParseLocaleCommandOptions, ffParseLocaleJsonObject, ffPrintLocale); ffOptionInitModuleArg(&options->moduleArgs); } @@ -51,11 +51,8 @@ void ffDestroyLocaleOptions(FFLocaleOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseLocaleJsonObject(yyjson_val* module) +void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module) { - FFLocaleOptions __attribute__((__cleanup__(ffDestroyLocaleOptions))) options; - ffInitLocaleOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -66,12 +63,10 @@ void ffParseLocaleJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintLocale(&options); } diff --git a/src/modules/locale/locale.h b/src/modules/locale/locale.h index 91e4968785..405f697c9d 100644 --- a/src/modules/locale/locale.h +++ b/src/modules/locale/locale.h @@ -8,4 +8,4 @@ void ffPrintLocale(FFLocaleOptions* options); void ffInitLocaleOptions(FFLocaleOptions* options); bool ffParseLocaleCommandOptions(FFLocaleOptions* options, const char* key, const char* value); void ffDestroyLocaleOptions(FFLocaleOptions* options); -void ffParseLocaleJsonObject(yyjson_val* module); +void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module); diff --git a/src/modules/locale/option.h b/src/modules/locale/option.h index 3e32530372..c6ba96720c 100644 --- a/src/modules/locale/option.h +++ b/src/modules/locale/option.h @@ -6,6 +6,6 @@ typedef struct FFLocaleOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFLocaleOptions; diff --git a/src/modules/localip/localip.c b/src/modules/localip/localip.c index 1b2772b019..95ed7b2561 100644 --- a/src/modules/localip/localip.c +++ b/src/modules/localip/localip.c @@ -139,7 +139,7 @@ void ffPrintLocalIp(FFLocalIpOptions* options) void ffInitLocalIpOptions(FFLocalIpOptions* options) { - options->moduleName = FF_LOCALIP_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_LOCALIP_MODULE_NAME, ffParseLocalIpCommandOptions, ffParseLocalIpJsonObject, ffPrintLocalIp); ffOptionInitModuleArg(&options->moduleArgs); options->showType = FF_LOCALIP_TYPE_IPV4_BIT; @@ -220,11 +220,8 @@ void ffDestroyLocalIpOptions(FFLocalIpOptions* options) ffStrbufDestroy(&options->namePrefix); } -void ffParseLocalIpJsonObject(yyjson_val* module) +void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module) { - FFLocalIpOptions __attribute__((__cleanup__(ffDestroyLocalIpOptions))) options; - ffInitLocalIpOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -235,69 +232,67 @@ void ffParseLocalIpJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "showIpv4")) { if (yyjson_get_bool(val)) - options.showType |= FF_LOCALIP_TYPE_IPV4_BIT; + options->showType |= FF_LOCALIP_TYPE_IPV4_BIT; else - options.showType &= ~FF_LOCALIP_TYPE_IPV4_BIT; + options->showType &= ~FF_LOCALIP_TYPE_IPV4_BIT; continue; } if (ffStrEqualsIgnCase(key, "showIpv6")) { if (yyjson_get_bool(val)) - options.showType |= FF_LOCALIP_TYPE_IPV6_BIT; + options->showType |= FF_LOCALIP_TYPE_IPV6_BIT; else - options.showType &= ~FF_LOCALIP_TYPE_IPV6_BIT; + options->showType &= ~FF_LOCALIP_TYPE_IPV6_BIT; continue; } if (ffStrEqualsIgnCase(key, "showMac")) { if (yyjson_get_bool(val)) - options.showType |= FF_LOCALIP_TYPE_MAC_BIT; + options->showType |= FF_LOCALIP_TYPE_MAC_BIT; else - options.showType &= ~FF_LOCALIP_TYPE_MAC_BIT; + options->showType &= ~FF_LOCALIP_TYPE_MAC_BIT; continue; } if (ffStrEqualsIgnCase(key, "showLoop")) { if (yyjson_get_bool(val)) - options.showType |= FF_LOCALIP_TYPE_LOOP_BIT; + options->showType |= FF_LOCALIP_TYPE_LOOP_BIT; else - options.showType &= ~FF_LOCALIP_TYPE_LOOP_BIT; + options->showType &= ~FF_LOCALIP_TYPE_LOOP_BIT; continue; } if (ffStrEqualsIgnCase(key, "compact")) { if (yyjson_get_bool(val)) - options.showType |= FF_LOCALIP_TYPE_COMPACT_BIT; + options->showType |= FF_LOCALIP_TYPE_COMPACT_BIT; else - options.showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT; + options->showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT; continue; } if (ffStrEqualsIgnCase(key, "namePrefix")) { - ffStrbufSetS(&options.namePrefix, yyjson_get_str(val)); + ffStrbufSetS(&options->namePrefix, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "defaultRouteOnly")) { - options.defaultRouteOnly = yyjson_get_bool(val); + options->defaultRouteOnly = yyjson_get_bool(val); continue; } - ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintLocalIp(&options); } diff --git a/src/modules/localip/localip.h b/src/modules/localip/localip.h index 8d1270c23d..114459c6f5 100644 --- a/src/modules/localip/localip.h +++ b/src/modules/localip/localip.h @@ -8,4 +8,4 @@ void ffPrintLocalIp(FFLocalIpOptions* options); void ffInitLocalIpOptions(FFLocalIpOptions* options); bool ffParseLocalIpCommandOptions(FFLocalIpOptions* options, const char* key, const char* value); void ffDestroyLocalIpOptions(FFLocalIpOptions* options); -void ffParseLocalIpJsonObject(yyjson_val* module); +void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module); diff --git a/src/modules/localip/option.h b/src/modules/localip/option.h index 8d58b82358..e2bdda0e38 100644 --- a/src/modules/localip/option.h +++ b/src/modules/localip/option.h @@ -17,7 +17,7 @@ typedef enum FFLocalIpType typedef struct FFLocalIpOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFLocalIpType showType; diff --git a/src/modules/media/media.c b/src/modules/media/media.c index f2969dd9a5..10fcd66ffa 100644 --- a/src/modules/media/media.c +++ b/src/modules/media/media.c @@ -107,7 +107,7 @@ void ffPrintMedia(FFMediaOptions* options) void ffInitMediaOptions(FFMediaOptions* options) { - options->moduleName = FF_MEDIA_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEDIA_MODULE_NAME, ffParseMediaCommandOptions, ffParseMediaJsonObject, ffPrintMedia); ffOptionInitModuleArg(&options->moduleArgs); } @@ -126,11 +126,8 @@ void ffDestroyMediaOptions(FFMediaOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseMediaJsonObject(yyjson_val* module) +void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module) { - FFMediaOptions __attribute__((__cleanup__(ffDestroyMediaOptions))) options; - ffInitMediaOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -141,12 +138,10 @@ void ffParseMediaJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintMedia(&options); } diff --git a/src/modules/media/media.h b/src/modules/media/media.h index 52fb6ba50b..f5267e5794 100644 --- a/src/modules/media/media.h +++ b/src/modules/media/media.h @@ -8,4 +8,4 @@ void ffPrintMedia(FFMediaOptions* options); void ffInitMediaOptions(FFMediaOptions* options); bool ffParseMediaCommandOptions(FFMediaOptions* options, const char* key, const char* value); void ffDestroyMediaOptions(FFMediaOptions* options); -void ffParseMediaJsonObject(yyjson_val* module); +void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module); diff --git a/src/modules/media/option.h b/src/modules/media/option.h index 8498c6e9bb..cb57b8b6e8 100644 --- a/src/modules/media/option.h +++ b/src/modules/media/option.h @@ -6,6 +6,6 @@ typedef struct FFMediaOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFMediaOptions; diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c index a8b78316ba..b5691e17e9 100644 --- a/src/modules/memory/memory.c +++ b/src/modules/memory/memory.c @@ -66,7 +66,7 @@ void ffPrintMemory(FFMemoryOptions* options) void ffInitMemoryOptions(FFMemoryOptions* options) { - options->moduleName = FF_MEMORY_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MEMORY_MODULE_NAME, ffParseMemoryCommandOptions, ffParseMemoryJsonObject, ffPrintMemory); ffOptionInitModuleArg(&options->moduleArgs); } @@ -85,11 +85,8 @@ void ffDestroyMemoryOptions(FFMemoryOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseMemoryJsonObject(yyjson_val* module) +void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module) { - FFMemoryOptions __attribute__((__cleanup__(ffDestroyMemoryOptions))) options; - ffInitMemoryOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -100,12 +97,10 @@ void ffParseMemoryJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintMemory(&options); } diff --git a/src/modules/memory/memory.h b/src/modules/memory/memory.h index e63a45e282..aec76b21f7 100644 --- a/src/modules/memory/memory.h +++ b/src/modules/memory/memory.h @@ -8,4 +8,4 @@ void ffPrintMemory(FFMemoryOptions* options); void ffInitMemoryOptions(FFMemoryOptions* options); bool ffParseMemoryCommandOptions(FFMemoryOptions* options, const char* key, const char* value); void ffDestroyMemoryOptions(FFMemoryOptions* options); -void ffParseMemoryJsonObject(yyjson_val* module); +void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module); diff --git a/src/modules/memory/option.h b/src/modules/memory/option.h index 1f8b30bf19..b908943e44 100644 --- a/src/modules/memory/option.h +++ b/src/modules/memory/option.h @@ -6,6 +6,6 @@ typedef struct FFMemoryOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFMemoryOptions; diff --git a/src/modules/monitor/monitor.c b/src/modules/monitor/monitor.c index a267f393ca..406263c71c 100644 --- a/src/modules/monitor/monitor.c +++ b/src/modules/monitor/monitor.c @@ -77,7 +77,7 @@ void ffPrintMonitor(FFMonitorOptions* options) void ffInitMonitorOptions(FFMonitorOptions* options) { - options->moduleName = FF_MONITOR_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_MONITOR_MODULE_NAME, ffParseMonitorCommandOptions, ffParseMonitorJsonObject, ffPrintMonitor); ffOptionInitModuleArg(&options->moduleArgs); } @@ -96,11 +96,8 @@ void ffDestroyMonitorOptions(FFMonitorOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseMonitorJsonObject(yyjson_val* module) +void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module) { - FFMonitorOptions __attribute__((__cleanup__(ffDestroyMonitorOptions))) options; - ffInitMonitorOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -111,12 +108,10 @@ void ffParseMonitorJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintMonitor(&options); } diff --git a/src/modules/monitor/monitor.h b/src/modules/monitor/monitor.h index a95a3fa740..ff03d26e96 100644 --- a/src/modules/monitor/monitor.h +++ b/src/modules/monitor/monitor.h @@ -8,4 +8,4 @@ void ffPrintMonitor(FFMonitorOptions* options); void ffInitMonitorOptions(FFMonitorOptions* options); bool ffParseMonitorCommandOptions(FFMonitorOptions* options, const char* key, const char* value); void ffDestroyMonitorOptions(FFMonitorOptions* options); -void ffParseMonitorJsonObject(yyjson_val* module); +void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module); diff --git a/src/modules/monitor/option.h b/src/modules/monitor/option.h index ee2efc964a..b474ae7b25 100644 --- a/src/modules/monitor/option.h +++ b/src/modules/monitor/option.h @@ -6,6 +6,6 @@ typedef struct FFMonitorOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFMonitorOptions; diff --git a/src/modules/opencl/opencl.c b/src/modules/opencl/opencl.c index daa4da00a2..0d06bd8847 100644 --- a/src/modules/opencl/opencl.c +++ b/src/modules/opencl/opencl.c @@ -41,7 +41,7 @@ void ffPrintOpenCL(FFOpenCLOptions* options) void ffInitOpenCLOptions(FFOpenCLOptions* options) { - options->moduleName = FF_OPENCL_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENCL_MODULE_NAME, ffParseOpenCLCommandOptions, ffParseOpenCLJsonObject, ffPrintOpenCL); ffOptionInitModuleArg(&options->moduleArgs); } @@ -60,11 +60,8 @@ void ffDestroyOpenCLOptions(FFOpenCLOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseOpenCLJsonObject(yyjson_val* module) +void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module) { - FFOpenCLOptions __attribute__((__cleanup__(ffDestroyOpenCLOptions))) options; - ffInitOpenCLOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -75,12 +72,10 @@ void ffParseOpenCLJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintOpenCL(&options); } diff --git a/src/modules/opencl/opencl.h b/src/modules/opencl/opencl.h index b01a2a4803..f5e2a32c2c 100644 --- a/src/modules/opencl/opencl.h +++ b/src/modules/opencl/opencl.h @@ -8,4 +8,4 @@ void ffPrintOpenCL(FFOpenCLOptions* options); void ffInitOpenCLOptions(FFOpenCLOptions* options); bool ffParseOpenCLCommandOptions(FFOpenCLOptions* options, const char* key, const char* value); void ffDestroyOpenCLOptions(FFOpenCLOptions* options); -void ffParseOpenCLJsonObject(yyjson_val* module); +void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module); diff --git a/src/modules/opencl/option.h b/src/modules/opencl/option.h index addac5245d..048c9b2668 100644 --- a/src/modules/opencl/option.h +++ b/src/modules/opencl/option.h @@ -6,6 +6,6 @@ typedef struct FFOpenCLOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFOpenCLOptions; diff --git a/src/modules/opengl/opengl.c b/src/modules/opengl/opengl.c index e4d6ec0089..94838b646d 100644 --- a/src/modules/opengl/opengl.c +++ b/src/modules/opengl/opengl.c @@ -44,7 +44,7 @@ void ffPrintOpenGL(FFOpenGLOptions* options) void ffInitOpenGLOptions(FFOpenGLOptions* options) { - options->moduleName = FF_OPENGL_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OPENGL_MODULE_NAME, ffParseOpenGLCommandOptions, ffParseOpenGLJsonObject, ffPrintOpenGL); ffOptionInitModuleArg(&options->moduleArgs); #if defined(__linux__) || defined(__FreeBSD__) @@ -80,11 +80,8 @@ void ffDestroyOpenGLOptions(FFOpenGLOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseOpenGLJsonObject(yyjson_val* module) +void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module) { - FFOpenGLOptions __attribute__((__cleanup__(ffDestroyOpenGLOptions))) options; - ffInitOpenGLOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -95,7 +92,7 @@ void ffParseOpenGLJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; #if defined(__linux__) || defined(__FreeBSD__) @@ -110,16 +107,14 @@ void ffParseOpenGLJsonObject(yyjson_val* module) {}, }); if (error) - ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error); + ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); else - options.library = (FFOpenGLLibrary) value; + options->library = (FFOpenGLLibrary) value; continue; } #endif - ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintOpenGL(&options); } diff --git a/src/modules/opengl/opengl.h b/src/modules/opengl/opengl.h index 5d4f1ab88a..5d0b1937bc 100644 --- a/src/modules/opengl/opengl.h +++ b/src/modules/opengl/opengl.h @@ -8,4 +8,4 @@ void ffPrintOpenGL(FFOpenGLOptions* options); void ffInitOpenGLOptions(FFOpenGLOptions* options); bool ffParseOpenGLCommandOptions(FFOpenGLOptions* options, const char* key, const char* value); void ffDestroyOpenGLOptions(FFOpenGLOptions* options); -void ffParseOpenGLJsonObject(yyjson_val* module); +void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module); diff --git a/src/modules/opengl/option.h b/src/modules/opengl/option.h index 712374d935..dd151f3d3c 100644 --- a/src/modules/opengl/option.h +++ b/src/modules/opengl/option.h @@ -16,7 +16,7 @@ typedef enum FFOpenGLLibrary typedef struct FFOpenGLOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; #if defined(__linux__) || defined(__FreeBSD__) diff --git a/src/modules/options.h b/src/modules/options.h index fbd845d3af..84bc4764b6 100644 --- a/src/modules/options.h +++ b/src/modules/options.h @@ -6,6 +6,7 @@ #include "modules/bios/option.h" #include "modules/bluetooth/option.h" #include "modules/board/option.h" +#include "modules/break/option.h" #include "modules/brightness/option.h" #include "modules/chassis/option.h" #include "modules/cpu/option.h" diff --git a/src/modules/os/option.h b/src/modules/os/option.h index be1bfda1fc..ae098a53a3 100644 --- a/src/modules/os/option.h +++ b/src/modules/os/option.h @@ -6,6 +6,6 @@ typedef struct FFOSOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFOSOptions; diff --git a/src/modules/os/os.c b/src/modules/os/os.c index 299079c680..b0e9ac1fbf 100644 --- a/src/modules/os/os.c +++ b/src/modules/os/os.c @@ -139,7 +139,7 @@ void ffPrintOS(FFOSOptions* options) void ffInitOSOptions(FFOSOptions* options) { - options->moduleName = FF_OS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_OS_MODULE_NAME, ffParseOSCommandOptions, ffParseOSJsonObject, ffPrintOS); ffOptionInitModuleArg(&options->moduleArgs); } @@ -158,11 +158,8 @@ void ffDestroyOSOptions(FFOSOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseOSJsonObject(yyjson_val* module) +void ffParseOSJsonObject(FFOSOptions* options, yyjson_val* module) { - FFOSOptions __attribute__((__cleanup__(ffDestroyOSOptions))) options; - ffInitOSOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -173,12 +170,10 @@ void ffParseOSJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_OS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_OS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintOS(&options); } diff --git a/src/modules/os/os.h b/src/modules/os/os.h index 36856d9b1a..07320194d3 100644 --- a/src/modules/os/os.h +++ b/src/modules/os/os.h @@ -8,4 +8,4 @@ void ffPrintOS(FFOSOptions* options); void ffInitOSOptions(FFOSOptions* options); bool ffParseOSCommandOptions(FFOSOptions* options, const char* key, const char* value); void ffDestroyOSOptions(FFOSOptions* options); -void ffParseOSJsonObject(yyjson_val* module); +void ffParseOSJsonObject(FFOSOptions* options, yyjson_val* module); diff --git a/src/modules/packages/option.h b/src/modules/packages/option.h index e06b8403b3..eb3050b96f 100644 --- a/src/modules/packages/option.h +++ b/src/modules/packages/option.h @@ -6,6 +6,6 @@ typedef struct FFPackagesOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFPackagesOptions; diff --git a/src/modules/packages/packages.c b/src/modules/packages/packages.c index cb8c6ba2ab..6d9374f198 100644 --- a/src/modules/packages/packages.c +++ b/src/modules/packages/packages.c @@ -99,7 +99,7 @@ void ffPrintPackages(FFPackagesOptions* options) void ffInitPackagesOptions(FFPackagesOptions* options) { - options->moduleName = FF_PACKAGES_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PACKAGES_MODULE_NAME, ffParsePackagesCommandOptions, ffParsePackagesJsonObject, ffPrintPackages); ffOptionInitModuleArg(&options->moduleArgs); } @@ -118,11 +118,8 @@ void ffDestroyPackagesOptions(FFPackagesOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParsePackagesJsonObject(yyjson_val* module) +void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module) { - FFPackagesOptions __attribute__((__cleanup__(ffDestroyPackagesOptions))) options; - ffInitPackagesOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -133,12 +130,10 @@ void ffParsePackagesJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintPackages(&options); } diff --git a/src/modules/packages/packages.h b/src/modules/packages/packages.h index 87516579a4..14fd7301d9 100644 --- a/src/modules/packages/packages.h +++ b/src/modules/packages/packages.h @@ -8,4 +8,4 @@ void ffPrintPackages(FFPackagesOptions* options); void ffInitPackagesOptions(FFPackagesOptions* options); bool ffParsePackagesCommandOptions(FFPackagesOptions* options, const char* key, const char* value); void ffDestroyPackagesOptions(FFPackagesOptions* options); -void ffParsePackagesJsonObject(yyjson_val* module); +void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module); diff --git a/src/modules/player/option.h b/src/modules/player/option.h index e270560550..1d34797fb3 100644 --- a/src/modules/player/option.h +++ b/src/modules/player/option.h @@ -6,6 +6,6 @@ typedef struct FFPlayerOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFPlayerOptions; diff --git a/src/modules/player/player.c b/src/modules/player/player.c index d78fc3f2f9..cca9a240f3 100644 --- a/src/modules/player/player.c +++ b/src/modules/player/player.c @@ -75,7 +75,7 @@ void ffPrintPlayer(FFPlayerOptions* options) void ffInitPlayerOptions(FFPlayerOptions* options) { - options->moduleName = FF_PLAYER_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PLAYER_MODULE_NAME, ffParsePlayerCommandOptions, ffParsePlayerJsonObject, ffPrintPlayer); ffOptionInitModuleArg(&options->moduleArgs); } @@ -94,11 +94,8 @@ void ffDestroyPlayerOptions(FFPlayerOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParsePlayerJsonObject(yyjson_val* module) +void ffParsePlayerJsonObject(FFPlayerOptions* options, yyjson_val* module) { - FFPlayerOptions __attribute__((__cleanup__(ffDestroyPlayerOptions))) options; - ffInitPlayerOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -109,12 +106,10 @@ void ffParsePlayerJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_PLAYER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_PLAYER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintPlayer(&options); } diff --git a/src/modules/player/player.h b/src/modules/player/player.h index 6f09b425f0..f63e12250d 100644 --- a/src/modules/player/player.h +++ b/src/modules/player/player.h @@ -9,4 +9,4 @@ void ffPrintPlayer(FFPlayerOptions* options); void ffInitPlayerOptions(FFPlayerOptions* options); bool ffParsePlayerCommandOptions(FFPlayerOptions* options, const char* key, const char* value); void ffDestroyPlayerOptions(FFPlayerOptions* options); -void ffParsePlayerJsonObject(yyjson_val* module); +void ffParsePlayerJsonObject(FFPlayerOptions* options, yyjson_val* module); diff --git a/src/modules/poweradapter/option.h b/src/modules/poweradapter/option.h index 7acaf29ee7..02a72eaf77 100644 --- a/src/modules/poweradapter/option.h +++ b/src/modules/poweradapter/option.h @@ -6,6 +6,6 @@ typedef struct FFPowerAdapterOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFPowerAdapterOptions; diff --git a/src/modules/poweradapter/poweradapter.c b/src/modules/poweradapter/poweradapter.c index a5af37c03f..c3babafbd3 100644 --- a/src/modules/poweradapter/poweradapter.c +++ b/src/modules/poweradapter/poweradapter.c @@ -65,7 +65,7 @@ void ffPrintPowerAdapter(FFPowerAdapterOptions* options) void ffInitPowerAdapterOptions(FFPowerAdapterOptions* options) { - options->moduleName = FF_POWERADAPTER_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterCommandOptions, ffParsePowerAdapterJsonObject, ffPrintPowerAdapter); ffOptionInitModuleArg(&options->moduleArgs); } @@ -84,11 +84,8 @@ void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParsePowerAdapterJsonObject(yyjson_val* module) +void ffParsePowerAdapterJsonObject(FFPowerAdapterOptions* options, yyjson_val* module) { - FFPowerAdapterOptions __attribute__((__cleanup__(ffDestroyPowerAdapterOptions))) options; - ffInitPowerAdapterOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -99,12 +96,10 @@ void ffParsePowerAdapterJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_POWERADAPTER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_POWERADAPTER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintPowerAdapter(&options); } diff --git a/src/modules/poweradapter/poweradapter.h b/src/modules/poweradapter/poweradapter.h index 93c6a77046..e9490c8323 100644 --- a/src/modules/poweradapter/poweradapter.h +++ b/src/modules/poweradapter/poweradapter.h @@ -8,4 +8,4 @@ void ffPrintPowerAdapter(FFPowerAdapterOptions* options); void ffInitPowerAdapterOptions(FFPowerAdapterOptions* options); bool ffParsePowerAdapterCommandOptions(FFPowerAdapterOptions* options, const char* key, const char* value); void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options); -void ffParsePowerAdapterJsonObject(yyjson_val* module); +void ffParsePowerAdapterJsonObject(FFPowerAdapterOptions* options, yyjson_val* module); diff --git a/src/modules/processes/option.h b/src/modules/processes/option.h index 9d2cd80866..6946ecad49 100644 --- a/src/modules/processes/option.h +++ b/src/modules/processes/option.h @@ -6,6 +6,6 @@ typedef struct FFProcessesOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFProcessesOptions; diff --git a/src/modules/processes/processes.c b/src/modules/processes/processes.c index 81b8041246..b759184c22 100644 --- a/src/modules/processes/processes.c +++ b/src/modules/processes/processes.c @@ -33,7 +33,7 @@ void ffPrintProcesses(FFProcessesOptions* options) void ffInitProcessesOptions(FFProcessesOptions* options) { - options->moduleName = FF_PROCESSES_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PROCESSES_MODULE_NAME, ffParseProcessesCommandOptions, ffParseProcessesJsonObject, ffPrintProcesses); ffOptionInitModuleArg(&options->moduleArgs); } @@ -52,11 +52,8 @@ void ffDestroyProcessesOptions(FFProcessesOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseProcessesJsonObject(yyjson_val* module) +void ffParseProcessesJsonObject(FFProcessesOptions* options, yyjson_val* module) { - FFProcessesOptions __attribute__((__cleanup__(ffDestroyProcessesOptions))) options; - ffInitProcessesOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -67,12 +64,10 @@ void ffParseProcessesJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintProcesses(&options); } diff --git a/src/modules/processes/processes.h b/src/modules/processes/processes.h index 84696356d0..724faf7fb0 100644 --- a/src/modules/processes/processes.h +++ b/src/modules/processes/processes.h @@ -8,4 +8,4 @@ void ffPrintProcesses(FFProcessesOptions* options); void ffInitProcessesOptions(FFProcessesOptions* options); bool ffParseProcessesCommandOptions(FFProcessesOptions* options, const char* key, const char* value); void ffDestroyProcessesOptions(FFProcessesOptions* options); -void ffParseProcessesJsonObject(yyjson_val* module); +void ffParseProcessesJsonObject(FFProcessesOptions* options, yyjson_val* module); diff --git a/src/modules/publicip/option.h b/src/modules/publicip/option.h index aef383fc5e..f05b95c233 100644 --- a/src/modules/publicip/option.h +++ b/src/modules/publicip/option.h @@ -6,7 +6,7 @@ typedef struct FFPublicIpOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFstrbuf url; diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c index a5707e20e0..3c71b9b68a 100644 --- a/src/modules/publicip/publicip.c +++ b/src/modules/publicip/publicip.c @@ -91,7 +91,7 @@ void ffPrintPublicIp(FFPublicIpOptions* options) void ffInitPublicIpOptions(FFPublicIpOptions* options) { - options->moduleName = FF_PUBLICIP_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpCommandOptions, ffParsePublicIpJsonObject, ffPrintPublicIp); ffOptionInitModuleArg(&options->moduleArgs); ffStrbufInit(&options->url); @@ -127,11 +127,8 @@ void ffDestroyPublicIpOptions(FFPublicIpOptions* options) ffStrbufDestroy(&options->url); } -void ffParsePublicIpJsonObject(yyjson_val* module) +void ffParsePublicIpJsonObject(FFPublicIpOptions* options, yyjson_val* module) { - FFPublicIpOptions __attribute__((__cleanup__(ffDestroyPublicIpOptions))) options; - ffInitPublicIpOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -142,24 +139,22 @@ void ffParsePublicIpJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "url")) { - ffStrbufSetS(&options.url, yyjson_get_str(val)); + ffStrbufSetS(&options->url, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "timeout")) { - options.timeout = (uint32_t) yyjson_get_uint(val); + options->timeout = (uint32_t) yyjson_get_uint(val); continue; } - ffPrintError(FF_PUBLICIP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_PUBLICIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintPublicIp(&options); } diff --git a/src/modules/publicip/publicip.h b/src/modules/publicip/publicip.h index 8328023f50..6a7c739d2e 100644 --- a/src/modules/publicip/publicip.h +++ b/src/modules/publicip/publicip.h @@ -10,4 +10,4 @@ void ffPrintPublicIp(FFPublicIpOptions* options); void ffInitPublicIpOptions(FFPublicIpOptions* options); bool ffParsePublicIpCommandOptions(FFPublicIpOptions* options, const char* key, const char* value); void ffDestroyPublicIpOptions(FFPublicIpOptions* options); -void ffParsePublicIpJsonObject(yyjson_val* module); +void ffParsePublicIpJsonObject(FFPublicIpOptions* options, yyjson_val* module); diff --git a/src/modules/separator/option.h b/src/modules/separator/option.h index 10f5effdf2..c858e6193a 100644 --- a/src/modules/separator/option.h +++ b/src/modules/separator/option.h @@ -6,7 +6,7 @@ typedef struct FFSeparatorOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFstrbuf string; } FFSeparatorOptions; diff --git a/src/modules/separator/separator.c b/src/modules/separator/separator.c index 74108fd3b3..dd860a3b03 100644 --- a/src/modules/separator/separator.c +++ b/src/modules/separator/separator.c @@ -77,7 +77,7 @@ void ffPrintSeparator(FFSeparatorOptions* options) void ffInitSeparatorOptions(FFSeparatorOptions* options) { - options->moduleName = FF_SEPARATOR_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorCommandOptions, ffParseSeparatorJsonObject, ffPrintSeparator); ffStrbufInit(&options->string); } @@ -100,11 +100,8 @@ void ffDestroySeparatorOptions(FFSeparatorOptions* options) ffStrbufDestroy(&options->string); } -void ffParseSeparatorJsonObject(yyjson_val* module) +void ffParseSeparatorJsonObject(FFSeparatorOptions* options, yyjson_val* module) { - FFSeparatorOptions __attribute__((__cleanup__(ffDestroySeparatorOptions))) options; - ffInitSeparatorOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -117,13 +114,11 @@ void ffParseSeparatorJsonObject(yyjson_val* module) if (ffStrEqualsIgnCase(key, "string")) { - ffStrbufSetS(&options.string, yyjson_get_str(val)); + ffStrbufSetS(&options->string, yyjson_get_str(val)); continue; } ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } - - ffPrintSeparator(&options); } diff --git a/src/modules/separator/separator.h b/src/modules/separator/separator.h index 3e97ac4640..a5dc91285b 100644 --- a/src/modules/separator/separator.h +++ b/src/modules/separator/separator.h @@ -8,4 +8,4 @@ void ffPrintSeparator(FFSeparatorOptions* options); void ffInitSeparatorOptions(FFSeparatorOptions* options); bool ffParseSeparatorCommandOptions(FFSeparatorOptions* options, const char* key, const char* value); void ffDestroySeparatorOptions(FFSeparatorOptions* options); -void ffParseSeparatorJsonObject(yyjson_val* module); +void ffParseSeparatorJsonObject(FFSeparatorOptions* options, yyjson_val* module); diff --git a/src/modules/shell/option.h b/src/modules/shell/option.h index dd6223a366..4d430e8184 100644 --- a/src/modules/shell/option.h +++ b/src/modules/shell/option.h @@ -6,7 +6,7 @@ typedef struct FFShellOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; bool version; diff --git a/src/modules/shell/shell.c b/src/modules/shell/shell.c index 00a305db77..b9c7a4dae5 100644 --- a/src/modules/shell/shell.c +++ b/src/modules/shell/shell.c @@ -45,7 +45,7 @@ void ffPrintShell(FFShellOptions* options) void ffInitShellOptions(FFShellOptions* options) { - options->moduleName = FF_SHELL_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SHELL_MODULE_NAME, ffParseShellCommandOptions, ffParseShellJsonObject, ffPrintShell); ffOptionInitModuleArg(&options->moduleArgs); } @@ -64,11 +64,8 @@ void ffDestroyShellOptions(FFShellOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseShellJsonObject(yyjson_val* module) +void ffParseShellJsonObject(FFShellOptions* options, yyjson_val* module) { - FFShellOptions __attribute__((__cleanup__(ffDestroyShellOptions))) options; - ffInitShellOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -79,12 +76,10 @@ void ffParseShellJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_SHELL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintShell(&options); } diff --git a/src/modules/shell/shell.h b/src/modules/shell/shell.h index b2579cd49d..4e4f976bfe 100644 --- a/src/modules/shell/shell.h +++ b/src/modules/shell/shell.h @@ -8,4 +8,4 @@ void ffPrintShell(FFShellOptions* options); void ffInitShellOptions(FFShellOptions* options); bool ffParseShellCommandOptions(FFShellOptions* options, const char* key, const char* value); void ffDestroyShellOptions(FFShellOptions* options); -void ffParseShellJsonObject(yyjson_val* module); +void ffParseShellJsonObject(FFShellOptions* options, yyjson_val* module); diff --git a/src/modules/sound/option.h b/src/modules/sound/option.h index b0586036bb..11f652602b 100644 --- a/src/modules/sound/option.h +++ b/src/modules/sound/option.h @@ -13,7 +13,7 @@ typedef enum FFSoundType typedef struct FFSoundOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFSoundType soundType; diff --git a/src/modules/sound/sound.c b/src/modules/sound/sound.c index d3e0e86ddd..f206c2b184 100644 --- a/src/modules/sound/sound.c +++ b/src/modules/sound/sound.c @@ -85,7 +85,7 @@ void ffPrintSound(FFSoundOptions* options) void ffInitSoundOptions(FFSoundOptions* options) { - options->moduleName = FF_SOUND_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SOUND_MODULE_NAME, ffParseSoundCommandOptions, ffParseSoundJsonObject, ffPrintSound); ffOptionInitModuleArg(&options->moduleArgs); options->soundType = FF_SOUND_TYPE_MAIN; @@ -117,11 +117,8 @@ void ffDestroySoundOptions(FFSoundOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseSoundJsonObject(yyjson_val* module) +void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module) { - FFSoundOptions __attribute__((__cleanup__(ffDestroySoundOptions))) options; - ffInitSoundOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -132,7 +129,7 @@ void ffParseSoundJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "soundType")) @@ -145,15 +142,13 @@ void ffParseSoundJsonObject(yyjson_val* module) {}, }); if (error) - ffPrintError(FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error); + ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); else - options.soundType = (FFSoundType) value; + options->soundType = (FFSoundType) value; continue; } - ffPrintError(FF_SOUND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintSound(&options); } diff --git a/src/modules/sound/sound.h b/src/modules/sound/sound.h index 4b02f4d24a..c35c168012 100644 --- a/src/modules/sound/sound.h +++ b/src/modules/sound/sound.h @@ -8,4 +8,4 @@ void ffPrintSound(FFSoundOptions* options); void ffInitSoundOptions(FFSoundOptions* options); bool ffParseSoundCommandOptions(FFSoundOptions* options, const char* key, const char* value); void ffDestroySoundOptions(FFSoundOptions* options); -void ffParseSoundJsonObject(yyjson_val* module); +void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module); diff --git a/src/modules/swap/option.h b/src/modules/swap/option.h index 4053cfbe10..52fea1733f 100644 --- a/src/modules/swap/option.h +++ b/src/modules/swap/option.h @@ -6,6 +6,6 @@ typedef struct FFSwapOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFSwapOptions; diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c index 7da77e0862..aa1b1b9a18 100644 --- a/src/modules/swap/swap.c +++ b/src/modules/swap/swap.c @@ -73,7 +73,7 @@ void ffPrintSwap(FFSwapOptions* options) void ffInitSwapOptions(FFSwapOptions* options) { - options->moduleName = FF_SWAP_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_SWAP_MODULE_NAME, ffParseSwapCommandOptions, ffParseSwapJsonObject, ffPrintSwap); ffOptionInitModuleArg(&options->moduleArgs); } @@ -92,11 +92,8 @@ void ffDestroySwapOptions(FFSwapOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseSwapJsonObject(yyjson_val* module) +void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module) { - FFSwapOptions __attribute__((__cleanup__(ffDestroySwapOptions))) options; - ffInitSwapOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -107,12 +104,10 @@ void ffParseSwapJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_SWAP_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintSwap(&options); } diff --git a/src/modules/swap/swap.h b/src/modules/swap/swap.h index 3cd4f5b14e..5921ad9c54 100644 --- a/src/modules/swap/swap.h +++ b/src/modules/swap/swap.h @@ -8,4 +8,4 @@ void ffPrintSwap(FFSwapOptions* options); void ffInitSwapOptions(FFSwapOptions* options); bool ffParseSwapCommandOptions(FFSwapOptions* options, const char* key, const char* value); void ffDestroySwapOptions(FFSwapOptions* options); -void ffParseSwapJsonObject(yyjson_val* module); +void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module); diff --git a/src/modules/terminal/option.h b/src/modules/terminal/option.h index 151129e130..e974c9979b 100644 --- a/src/modules/terminal/option.h +++ b/src/modules/terminal/option.h @@ -6,6 +6,6 @@ typedef struct FFTerminalOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFTerminalOptions; diff --git a/src/modules/terminal/terminal.c b/src/modules/terminal/terminal.c index ed257fd525..2cba2e3022 100644 --- a/src/modules/terminal/terminal.c +++ b/src/modules/terminal/terminal.c @@ -46,7 +46,7 @@ void ffPrintTerminal(FFTerminalOptions* options) void ffInitTerminalOptions(FFTerminalOptions* options) { - options->moduleName = FF_TERMINAL_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINAL_MODULE_NAME, ffParseTerminalCommandOptions, ffParseTerminalJsonObject, ffPrintTerminal); ffOptionInitModuleArg(&options->moduleArgs); } @@ -65,11 +65,8 @@ void ffDestroyTerminalOptions(FFTerminalOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseTerminalJsonObject(yyjson_val* module) +void ffParseTerminalJsonObject(FFTerminalOptions* options, yyjson_val* module) { - FFTerminalOptions __attribute__((__cleanup__(ffDestroyTerminalOptions))) options; - ffInitTerminalOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -80,12 +77,10 @@ void ffParseTerminalJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintTerminal(&options); } diff --git a/src/modules/terminal/terminal.h b/src/modules/terminal/terminal.h index 45372754dc..09949b00d0 100644 --- a/src/modules/terminal/terminal.h +++ b/src/modules/terminal/terminal.h @@ -8,4 +8,4 @@ void ffPrintTerminal(FFTerminalOptions* options); void ffInitTerminalOptions(FFTerminalOptions* options); bool ffParseTerminalCommandOptions(FFTerminalOptions* options, const char* key, const char* value); void ffDestroyTerminalOptions(FFTerminalOptions* options); -void ffParseTerminalJsonObject(yyjson_val* module); +void ffParseTerminalJsonObject(FFTerminalOptions* options, yyjson_val* module); diff --git a/src/modules/terminalfont/option.h b/src/modules/terminalfont/option.h index ba62efbb5e..64417bf0aa 100644 --- a/src/modules/terminalfont/option.h +++ b/src/modules/terminalfont/option.h @@ -6,6 +6,6 @@ typedef struct FFTerminalFontOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFTerminalFontOptions; diff --git a/src/modules/terminalfont/terminalfont.c b/src/modules/terminalfont/terminalfont.c index 2c28860272..f0bb786c4b 100644 --- a/src/modules/terminalfont/terminalfont.c +++ b/src/modules/terminalfont/terminalfont.c @@ -49,7 +49,7 @@ void ffPrintTerminalFont(FFTerminalFontOptions* options) void ffInitTerminalFontOptions(FFTerminalFontOptions* options) { - options->moduleName = FF_TERMINALFONT_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontCommandOptions, ffParseTerminalFontJsonObject, ffPrintTerminalFont); ffOptionInitModuleArg(&options->moduleArgs); } @@ -68,11 +68,8 @@ void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseTerminalFontJsonObject(yyjson_val* module) +void ffParseTerminalFontJsonObject(FFTerminalFontOptions* options, yyjson_val* module) { - FFTerminalFontOptions __attribute__((__cleanup__(ffDestroyTerminalFontOptions))) options; - ffInitTerminalFontOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -83,12 +80,10 @@ void ffParseTerminalFontJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_TERMINALFONT_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_TERMINALFONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintTerminalFont(&options); } diff --git a/src/modules/terminalfont/terminalfont.h b/src/modules/terminalfont/terminalfont.h index a538cd0d7e..ac5953a367 100644 --- a/src/modules/terminalfont/terminalfont.h +++ b/src/modules/terminalfont/terminalfont.h @@ -8,4 +8,4 @@ void ffPrintTerminalFont(FFTerminalFontOptions* options); void ffInitTerminalFontOptions(FFTerminalFontOptions* options); bool ffParseTerminalFontCommandOptions(FFTerminalFontOptions* options, const char* key, const char* value); void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options); -void ffParseTerminalFontJsonObject(yyjson_val* module); +void ffParseTerminalFontJsonObject(FFTerminalFontOptions* options, yyjson_val* module); diff --git a/src/modules/terminalsize/option.h b/src/modules/terminalsize/option.h index 16f4824665..7d584837f5 100644 --- a/src/modules/terminalsize/option.h +++ b/src/modules/terminalsize/option.h @@ -6,6 +6,6 @@ typedef struct FFTerminalSizeOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFTerminalSizeOptions; diff --git a/src/modules/terminalsize/terminalsize.c b/src/modules/terminalsize/terminalsize.c index 3a794cbfec..0f10f2c6c0 100644 --- a/src/modules/terminalsize/terminalsize.c +++ b/src/modules/terminalsize/terminalsize.c @@ -41,7 +41,7 @@ void ffPrintTerminalSize(FFTerminalSizeOptions* options) void ffInitTerminalSizeOptions(FFTerminalSizeOptions* options) { - options->moduleName = FF_TERMINALSIZE_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TERMINALSIZE_MODULE_NAME, ffParseTerminalSizeCommandOptions, ffParseTerminalSizeJsonObject, ffPrintTerminalSize); ffOptionInitModuleArg(&options->moduleArgs); } @@ -60,11 +60,8 @@ void ffDestroyTerminalSizeOptions(FFTerminalSizeOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseTerminalSizeJsonObject(yyjson_val* module) +void ffParseTerminalSizeJsonObject(FFTerminalSizeOptions* options, yyjson_val* module) { - FFTerminalSizeOptions __attribute__((__cleanup__(ffDestroyTerminalSizeOptions))) options; - ffInitTerminalSizeOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -75,12 +72,10 @@ void ffParseTerminalSizeJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintTerminalSize(&options); } diff --git a/src/modules/terminalsize/terminalsize.h b/src/modules/terminalsize/terminalsize.h index 0b1b37d32a..1703c5944a 100644 --- a/src/modules/terminalsize/terminalsize.h +++ b/src/modules/terminalsize/terminalsize.h @@ -8,4 +8,4 @@ void ffPrintTerminalSize(FFTerminalSizeOptions* options); void ffInitTerminalSizeOptions(FFTerminalSizeOptions* options); bool ffParseTerminalSizeCommandOptions(FFTerminalSizeOptions* options, const char* key, const char* value); void ffDestroyTerminalSizeOptions(FFTerminalSizeOptions* options); -void ffParseTerminalSizeJsonObject(yyjson_val* module); +void ffParseTerminalSizeJsonObject(FFTerminalSizeOptions* options, yyjson_val* module); diff --git a/src/modules/theme/option.h b/src/modules/theme/option.h index f322c3a62d..9c3b32a888 100644 --- a/src/modules/theme/option.h +++ b/src/modules/theme/option.h @@ -6,6 +6,6 @@ typedef struct FFThemeOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFThemeOptions; diff --git a/src/modules/theme/theme.c b/src/modules/theme/theme.c index 053c7cb57a..e54b33ed6a 100644 --- a/src/modules/theme/theme.c +++ b/src/modules/theme/theme.c @@ -32,7 +32,7 @@ void ffPrintTheme(FFThemeOptions* options) void ffInitThemeOptions(FFThemeOptions* options) { - options->moduleName = FF_THEME_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_THEME_MODULE_NAME, ffParseThemeCommandOptions, ffParseThemeJsonObject, ffPrintTheme); ffOptionInitModuleArg(&options->moduleArgs); } @@ -51,11 +51,8 @@ void ffDestroyThemeOptions(FFThemeOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseThemeJsonObject(yyjson_val* module) +void ffParseThemeJsonObject(FFThemeOptions* options, yyjson_val* module) { - FFThemeOptions __attribute__((__cleanup__(ffDestroyThemeOptions))) options; - ffInitThemeOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -66,12 +63,10 @@ void ffParseThemeJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_THEME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintTheme(&options); } diff --git a/src/modules/theme/theme.h b/src/modules/theme/theme.h index 37a006dd48..ef8f18a796 100644 --- a/src/modules/theme/theme.h +++ b/src/modules/theme/theme.h @@ -8,4 +8,4 @@ void ffPrintTheme(FFThemeOptions* options); void ffInitThemeOptions(FFThemeOptions* options); bool ffParseThemeCommandOptions(FFThemeOptions* options, const char* key, const char* value); void ffDestroyThemeOptions(FFThemeOptions* options); -void ffParseThemeJsonObject(yyjson_val* module); +void ffParseThemeJsonObject(FFThemeOptions* options, yyjson_val* module); diff --git a/src/modules/title/option.h b/src/modules/title/option.h index b44aef8ed5..9c3ea074bb 100644 --- a/src/modules/title/option.h +++ b/src/modules/title/option.h @@ -6,7 +6,7 @@ typedef struct FFTitleOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; bool fqdn; diff --git a/src/modules/title/title.c b/src/modules/title/title.c index 297b0a6bbb..b0730cab4b 100644 --- a/src/modules/title/title.c +++ b/src/modules/title/title.c @@ -51,7 +51,7 @@ void ffPrintTitle(FFTitleOptions* options) void ffInitTitleOptions(FFTitleOptions* options) { - options->moduleName = FF_TITLE_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_TITLE_MODULE_NAME, ffParseTitleCommandOptions, ffParseTitleJsonObject, ffPrintTitle); ffOptionInitModuleArg(&options->moduleArgs); options->fqdn = false; ffStrbufInit(&options->colorUser); @@ -101,11 +101,8 @@ void ffDestroyTitleOptions(FFTitleOptions* options) ffStrbufDestroy(&options->colorHost); } -void ffParseTitleJsonObject(yyjson_val* module) +void ffParseTitleJsonObject(FFTitleOptions* options, yyjson_val* module) { - FFTitleOptions __attribute__((__cleanup__(ffDestroyTitleOptions))) options; - ffInitTitleOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -116,12 +113,12 @@ void ffParseTitleJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "fqdn")) { - options.fqdn = yyjson_get_bool(val); + options->fqdn = yyjson_get_bool(val); continue; } @@ -132,19 +129,17 @@ void ffParseTitleJsonObject(yyjson_val* module) yyjson_val* color = yyjson_obj_get(val, "user"); if (color) - ffOptionParseColor(yyjson_get_str(color), &options.colorUser); + ffOptionParseColor(yyjson_get_str(color), &options->colorUser); color = yyjson_obj_get(val, "at"); if (color) - ffOptionParseColor(yyjson_get_str(color), &options.colorAt); + ffOptionParseColor(yyjson_get_str(color), &options->colorAt); color = yyjson_obj_get(val, "host"); if (color) - ffOptionParseColor(yyjson_get_str(color), &options.colorHost); + ffOptionParseColor(yyjson_get_str(color), &options->colorHost); continue; } ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } - - ffPrintTitle(&options); } diff --git a/src/modules/title/title.h b/src/modules/title/title.h index 7bd4072435..fd7ae5e689 100644 --- a/src/modules/title/title.h +++ b/src/modules/title/title.h @@ -8,4 +8,4 @@ void ffPrintTitle(FFTitleOptions* options); void ffInitTitleOptions(FFTitleOptions* options); bool ffParseTitleCommandOptions(FFTitleOptions* options, const char* key, const char* value); void ffDestroyTitleOptions(FFTitleOptions* options); -void ffParseTitleJsonObject(yyjson_val* module); +void ffParseTitleJsonObject(FFTitleOptions* options, yyjson_val* module); diff --git a/src/modules/uptime/option.h b/src/modules/uptime/option.h index 722d236d3f..f047db76c8 100644 --- a/src/modules/uptime/option.h +++ b/src/modules/uptime/option.h @@ -6,6 +6,6 @@ typedef struct FFUptimeOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFUptimeOptions; diff --git a/src/modules/uptime/uptime.c b/src/modules/uptime/uptime.c index 3de7d80f7b..9f96b6d167 100644 --- a/src/modules/uptime/uptime.c +++ b/src/modules/uptime/uptime.c @@ -81,7 +81,7 @@ void ffPrintUptime(FFUptimeOptions* options) void ffInitUptimeOptions(FFUptimeOptions* options) { - options->moduleName = FF_UPTIME_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_UPTIME_MODULE_NAME, ffParseUptimeCommandOptions, ffParseUptimeJsonObject, ffPrintUptime); ffOptionInitModuleArg(&options->moduleArgs); } @@ -100,11 +100,8 @@ void ffDestroyUptimeOptions(FFUptimeOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseUptimeJsonObject(yyjson_val* module) +void ffParseUptimeJsonObject(FFUptimeOptions* options, yyjson_val* module) { - FFUptimeOptions __attribute__((__cleanup__(ffDestroyUptimeOptions))) options; - ffInitUptimeOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -115,12 +112,10 @@ void ffParseUptimeJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintUptime(&options); } diff --git a/src/modules/uptime/uptime.h b/src/modules/uptime/uptime.h index 4708dbd39f..3bc1fd55f8 100644 --- a/src/modules/uptime/uptime.h +++ b/src/modules/uptime/uptime.h @@ -8,4 +8,4 @@ void ffPrintUptime(FFUptimeOptions* options); void ffInitUptimeOptions(FFUptimeOptions* options); bool ffParseUptimeCommandOptions(FFUptimeOptions* options, const char* key, const char* value); void ffDestroyUptimeOptions(FFUptimeOptions* options); -void ffParseUptimeJsonObject(yyjson_val* module); +void ffParseUptimeJsonObject(FFUptimeOptions* options, yyjson_val* module); diff --git a/src/modules/users/option.h b/src/modules/users/option.h index f7f0b099ee..80bf876985 100644 --- a/src/modules/users/option.h +++ b/src/modules/users/option.h @@ -6,6 +6,6 @@ typedef struct FFUsersOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFUsersOptions; diff --git a/src/modules/users/users.c b/src/modules/users/users.c index 260cd87d33..242566a0cb 100644 --- a/src/modules/users/users.c +++ b/src/modules/users/users.c @@ -45,7 +45,7 @@ void ffPrintUsers(FFUsersOptions* options) void ffInitUsersOptions(FFUsersOptions* options) { - options->moduleName = FF_USERS_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_USERS_MODULE_NAME, ffParseUsersCommandOptions, ffParseUsersJsonObject, ffPrintUsers); ffOptionInitModuleArg(&options->moduleArgs); } @@ -64,11 +64,8 @@ void ffDestroyUsersOptions(FFUsersOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseUsersJsonObject(yyjson_val* module) +void ffParseUsersJsonObject(FFUsersOptions* options, yyjson_val* module) { - FFUsersOptions __attribute__((__cleanup__(ffDestroyUsersOptions))) options; - ffInitUsersOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -79,12 +76,10 @@ void ffParseUsersJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_USERS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintUsers(&options); } diff --git a/src/modules/users/users.h b/src/modules/users/users.h index 64aab51b7b..86d5f66f48 100644 --- a/src/modules/users/users.h +++ b/src/modules/users/users.h @@ -8,4 +8,4 @@ void ffPrintUsers(FFUsersOptions* options); void ffInitUsersOptions(FFUsersOptions* options); bool ffParseUsersCommandOptions(FFUsersOptions* options, const char* key, const char* value); void ffDestroyUsersOptions(FFUsersOptions* options); -void ffParseUsersJsonObject(yyjson_val* module); +void ffParseUsersJsonObject(FFUsersOptions* options, yyjson_val* module); diff --git a/src/modules/vulkan/option.h b/src/modules/vulkan/option.h index c5efd077b1..132af5bbe8 100644 --- a/src/modules/vulkan/option.h +++ b/src/modules/vulkan/option.h @@ -6,6 +6,6 @@ typedef struct FFVulkanOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFVulkanOptions; diff --git a/src/modules/vulkan/vulkan.c b/src/modules/vulkan/vulkan.c index aa79c6ddfd..d24c82d04d 100644 --- a/src/modules/vulkan/vulkan.c +++ b/src/modules/vulkan/vulkan.c @@ -45,7 +45,7 @@ void ffPrintVulkan(FFVulkanOptions* options) void ffInitVulkanOptions(FFVulkanOptions* options) { - options->moduleName = FF_VULKAN_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_VULKAN_MODULE_NAME, ffParseVulkanCommandOptions, ffParseVulkanJsonObject, ffPrintVulkan); ffOptionInitModuleArg(&options->moduleArgs); } @@ -64,11 +64,8 @@ void ffDestroyVulkanOptions(FFVulkanOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseVulkanJsonObject(yyjson_val* module) +void ffParseVulkanJsonObject(FFVulkanOptions* options, yyjson_val* module) { - FFVulkanOptions __attribute__((__cleanup__(ffDestroyVulkanOptions))) options; - ffInitVulkanOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -79,12 +76,10 @@ void ffParseVulkanJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintVulkan(&options); } diff --git a/src/modules/vulkan/vulkan.h b/src/modules/vulkan/vulkan.h index 5b92ff850d..e9b7d3954e 100644 --- a/src/modules/vulkan/vulkan.h +++ b/src/modules/vulkan/vulkan.h @@ -8,4 +8,4 @@ void ffPrintVulkan(FFVulkanOptions* options); void ffInitVulkanOptions(FFVulkanOptions* options); bool ffParseVulkanCommandOptions(FFVulkanOptions* options, const char* key, const char* value); void ffDestroyVulkanOptions(FFVulkanOptions* options); -void ffParseVulkanJsonObject(yyjson_val* module); +void ffParseVulkanJsonObject(FFVulkanOptions* options, yyjson_val* module); diff --git a/src/modules/wallpaper/option.h b/src/modules/wallpaper/option.h index ff7aa55fef..539a57f9b7 100644 --- a/src/modules/wallpaper/option.h +++ b/src/modules/wallpaper/option.h @@ -6,6 +6,6 @@ typedef struct FFWallpaperOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFWallpaperOptions; diff --git a/src/modules/wallpaper/wallpaper.c b/src/modules/wallpaper/wallpaper.c index 08720f891a..03128c48c7 100644 --- a/src/modules/wallpaper/wallpaper.c +++ b/src/modules/wallpaper/wallpaper.c @@ -44,7 +44,7 @@ void ffPrintWallpaper(FFWallpaperOptions* options) void ffInitWallpaperOptions(FFWallpaperOptions* options) { - options->moduleName = FF_WALLPAPER_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperCommandOptions, ffParseWallpaperJsonObject, ffPrintWallpaper); ffOptionInitModuleArg(&options->moduleArgs); } @@ -63,11 +63,8 @@ void ffDestroyWallpaperOptions(FFWallpaperOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseWallpaperJsonObject(yyjson_val* module) +void ffParseWallpaperJsonObject(FFWallpaperOptions* options, yyjson_val* module) { - FFWallpaperOptions __attribute__((__cleanup__(ffDestroyWallpaperOptions))) options; - ffInitWallpaperOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -78,12 +75,10 @@ void ffParseWallpaperJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintWallpaper(&options); } diff --git a/src/modules/wallpaper/wallpaper.h b/src/modules/wallpaper/wallpaper.h index b274f037dd..244684fc4c 100644 --- a/src/modules/wallpaper/wallpaper.h +++ b/src/modules/wallpaper/wallpaper.h @@ -8,4 +8,4 @@ void ffPrintWallpaper(FFWallpaperOptions* options); void ffInitWallpaperOptions(FFWallpaperOptions* options); bool ffParseWallpaperCommandOptions(FFWallpaperOptions* options, const char* key, const char* value); void ffDestroyWallpaperOptions(FFWallpaperOptions* options); -void ffParseWallpaperJsonObject(yyjson_val* module); +void ffParseWallpaperJsonObject(FFWallpaperOptions* options, yyjson_val* module); diff --git a/src/modules/weather/option.h b/src/modules/weather/option.h index 6f82f53888..b8c7e7cade 100644 --- a/src/modules/weather/option.h +++ b/src/modules/weather/option.h @@ -6,7 +6,7 @@ typedef struct FFWeatherOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; FFstrbuf location; diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c index a32292f7d6..61e0bdeaaa 100644 --- a/src/modules/weather/weather.c +++ b/src/modules/weather/weather.c @@ -55,7 +55,7 @@ void ffPrintWeather(FFWeatherOptions* options) void ffInitWeatherOptions(FFWeatherOptions* options) { - options->moduleName = FF_WEATHER_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WEATHER_MODULE_NAME, ffParseWeatherCommandOptions, ffParseWeatherJsonObject, ffPrintWeather); ffOptionInitModuleArg(&options->moduleArgs); ffStrbufInit(&options->location); @@ -98,11 +98,8 @@ void ffDestroyWeatherOptions(FFWeatherOptions* options) ffStrbufDestroy(&options->outputFormat); } -void ffParseWeatherJsonObject(yyjson_val* module) +void ffParseWeatherJsonObject(FFWeatherOptions* options, yyjson_val* module) { - FFWeatherOptions __attribute__((__cleanup__(ffDestroyWeatherOptions))) options; - ffInitWeatherOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -113,30 +110,28 @@ void ffParseWeatherJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; if (ffStrEqualsIgnCase(key, "location")) { - ffStrbufSetS(&options.location, yyjson_get_str(val)); + ffStrbufSetS(&options->location, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "outputFormat")) { - ffStrbufSetS(&options.outputFormat, yyjson_get_str(val)); + ffStrbufSetS(&options->outputFormat, yyjson_get_str(val)); continue; } if (ffStrEqualsIgnCase(key, "timeout")) { - options.timeout = (uint32_t) yyjson_get_uint(val); + options->timeout = (uint32_t) yyjson_get_uint(val); continue; } - ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintWeather(&options); } diff --git a/src/modules/weather/weather.h b/src/modules/weather/weather.h index 640201176e..8886069577 100644 --- a/src/modules/weather/weather.h +++ b/src/modules/weather/weather.h @@ -10,4 +10,4 @@ void ffPrintWeather(FFWeatherOptions* options); void ffInitWeatherOptions(FFWeatherOptions* options); bool ffParseWeatherCommandOptions(FFWeatherOptions* options, const char* key, const char* value); void ffDestroyWeatherOptions(FFWeatherOptions* options); -void ffParseWeatherJsonObject(yyjson_val* module); +void ffParseWeatherJsonObject(FFWeatherOptions* options, yyjson_val* module); diff --git a/src/modules/wifi/option.h b/src/modules/wifi/option.h index 4d713b5d87..0dcad05fd2 100644 --- a/src/modules/wifi/option.h +++ b/src/modules/wifi/option.h @@ -6,6 +6,6 @@ typedef struct FFWifiOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFWifiOptions; diff --git a/src/modules/wifi/wifi.c b/src/modules/wifi/wifi.c index 6798c063ff..608ab86b05 100644 --- a/src/modules/wifi/wifi.c +++ b/src/modules/wifi/wifi.c @@ -72,7 +72,7 @@ void ffPrintWifi(FFWifiOptions* options) void ffInitWifiOptions(FFWifiOptions* options) { - options->moduleName = FF_WIFI_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WIFI_MODULE_NAME, ffParseWifiCommandOptions, ffParseWifiJsonObject, ffPrintWifi); ffOptionInitModuleArg(&options->moduleArgs); } @@ -91,11 +91,8 @@ void ffDestroyWifiOptions(FFWifiOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseWifiJsonObject(yyjson_val* module) +void ffParseWifiJsonObject(FFWifiOptions* options, yyjson_val* module) { - FFWifiOptions __attribute__((__cleanup__(ffDestroyWifiOptions))) options; - ffInitWifiOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -106,12 +103,10 @@ void ffParseWifiJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_WIFI_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintWifi(&options); } diff --git a/src/modules/wifi/wifi.h b/src/modules/wifi/wifi.h index b8291fdfc8..0a7b78e2d0 100644 --- a/src/modules/wifi/wifi.h +++ b/src/modules/wifi/wifi.h @@ -8,4 +8,4 @@ void ffPrintWifi(FFWifiOptions* options); void ffInitWifiOptions(FFWifiOptions* options); bool ffParseWifiCommandOptions(FFWifiOptions* options, const char* key, const char* value); void ffDestroyWifiOptions(FFWifiOptions* options); -void ffParseWifiJsonObject(yyjson_val* module); +void ffParseWifiJsonObject(FFWifiOptions* options, yyjson_val* module); diff --git a/src/modules/wm/option.h b/src/modules/wm/option.h index fcc7b0231f..24c16f3110 100644 --- a/src/modules/wm/option.h +++ b/src/modules/wm/option.h @@ -6,6 +6,6 @@ typedef struct FFWMOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFWMOptions; diff --git a/src/modules/wm/wm.c b/src/modules/wm/wm.c index 018bbee732..101d93d7b7 100644 --- a/src/modules/wm/wm.c +++ b/src/modules/wm/wm.c @@ -43,7 +43,7 @@ void ffPrintWM(FFWMOptions* options) void ffInitWMOptions(FFWMOptions* options) { - options->moduleName = FF_WM_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WM_MODULE_NAME, ffParseWMCommandOptions, ffParseWMJsonObject, ffPrintWM); ffOptionInitModuleArg(&options->moduleArgs); } @@ -62,11 +62,8 @@ void ffDestroyWMOptions(FFWMOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseWMJsonObject(yyjson_val* module) +void ffParseWMJsonObject(FFWMOptions* options, yyjson_val* module) { - FFWMOptions __attribute__((__cleanup__(ffDestroyWMOptions))) options; - ffInitWMOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -77,12 +74,10 @@ void ffParseWMJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_WM_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_WM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintWM(&options); } diff --git a/src/modules/wm/wm.h b/src/modules/wm/wm.h index 243d6a6472..607732d720 100644 --- a/src/modules/wm/wm.h +++ b/src/modules/wm/wm.h @@ -8,4 +8,4 @@ void ffPrintWM(FFWMOptions* options); void ffInitWMOptions(FFWMOptions* options); bool ffParseWMCommandOptions(FFWMOptions* options, const char* key, const char* value); void ffDestroyWMOptions(FFWMOptions* options); -void ffParseWMJsonObject(yyjson_val* module); +void ffParseWMJsonObject(FFWMOptions* options, yyjson_val* module); diff --git a/src/modules/wmtheme/option.h b/src/modules/wmtheme/option.h index 11b14458b4..b2b9fc5a8c 100644 --- a/src/modules/wmtheme/option.h +++ b/src/modules/wmtheme/option.h @@ -6,6 +6,6 @@ typedef struct FFWMThemeOptions { - const char* moduleName; + FFModuleBaseInfo moduleInfo; FFModuleArgs moduleArgs; } FFWMThemeOptions; diff --git a/src/modules/wmtheme/wmtheme.c b/src/modules/wmtheme/wmtheme.c index c61f216e64..9a4edb19f5 100644 --- a/src/modules/wmtheme/wmtheme.c +++ b/src/modules/wmtheme/wmtheme.c @@ -32,7 +32,7 @@ void ffPrintWMTheme(FFWMThemeOptions* options) void ffInitWMThemeOptions(FFWMThemeOptions* options) { - options->moduleName = FF_WMTHEME_MODULE_NAME; + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_WMTHEME_MODULE_NAME, ffParseWMThemeCommandOptions, ffParseWMThemeJsonObject, ffPrintWMTheme); ffOptionInitModuleArg(&options->moduleArgs); } @@ -51,11 +51,8 @@ void ffDestroyWMThemeOptions(FFWMThemeOptions* options) ffOptionDestroyModuleArg(&options->moduleArgs); } -void ffParseWMThemeJsonObject(yyjson_val* module) +void ffParseWMThemeJsonObject(FFWMThemeOptions* options, yyjson_val* module) { - FFWMThemeOptions __attribute__((__cleanup__(ffDestroyWMThemeOptions))) options; - ffInitWMThemeOptions(&options); - if (module) { yyjson_val *key_, *val; @@ -66,12 +63,10 @@ void ffParseWMThemeJsonObject(yyjson_val* module) if(ffStrEqualsIgnCase(key, "type")) continue; - if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs)) + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) continue; - ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key); + ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } - - ffPrintWMTheme(&options); } diff --git a/src/modules/wmtheme/wmtheme.h b/src/modules/wmtheme/wmtheme.h index 0214089453..216fdc7233 100644 --- a/src/modules/wmtheme/wmtheme.h +++ b/src/modules/wmtheme/wmtheme.h @@ -8,4 +8,4 @@ void ffPrintWMTheme(FFWMThemeOptions* options); void ffInitWMThemeOptions(FFWMThemeOptions* options); bool ffParseWMThemeCommandOptions(FFWMThemeOptions* options, const char* key, const char* value); void ffDestroyWMThemeOptions(FFWMThemeOptions* options); -void ffParseWMThemeJsonObject(yyjson_val* module); +void ffParseWMThemeJsonObject(FFWMThemeOptions* options, yyjson_val* module); From e5e4c8bf88cbb853aa29cd92246208afc8403842 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Thu, 17 Aug 2023 16:00:24 +0800 Subject: [PATCH 17/37] Fastfetch: refactor command line option parsing code 1. improve performance 2. remove `-c` 3. rename `--recache` to `--logo-recache`, and remove `-r` --- CHANGELOG.md | 2 + CMakeLists.txt | 1 + doc/json_schema.json | 5 + src/common/commandoption.c | 321 +++++++++++++++++++++++++++++++++++++ src/common/commandoption.h | 11 ++ src/common/init.c | 1 - src/common/option.h | 4 +- src/data/help.txt | 3 +- src/fastfetch.c | 321 ++++++++----------------------------- src/fastfetch.h | 1 - src/logo/image/image.c | 2 +- src/logo/option.c | 8 + src/logo/option.h | 1 + 13 files changed, 419 insertions(+), 262 deletions(-) create mode 100644 src/common/commandoption.c create mode 100644 src/common/commandoption.h diff --git a/CHANGELOG.md b/CHANGELOG.md index 13c92129af..ae3700a887 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ Changes: * Unescape strings only when parsing `.conf` files * Previously: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\: *`. Note the backslashs are unescaped twice (once by shell and once by fastfetch). * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *` +* Remove option shortcut `-c` (alias of `--color`), which is more commonly used as alias of `--config` +* Rename `--recache` to `--logo-recache` (which is used for regenerate image logo cache). Remove option shortcut `-r` (alias of `--recache`). Features: * Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width` diff --git a/CMakeLists.txt b/CMakeLists.txt index f8d3d3ca76..5e12d945f8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -253,6 +253,7 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}") set(LIBFASTFETCH_SRC src/3rdparty/yyjson/yyjson.c src/common/bar.c + src/common/commandoption.c src/common/font.c src/common/format.c src/common/init.c diff --git a/doc/json_schema.json b/doc/json_schema.json index 46991ab180..909145c9a3 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -161,6 +161,11 @@ "title": "Whether to preserve the aspect ratio of the logo. Supported by iTerm image protocol", "default": false }, + "recache": { + "type": "boolean", + "title": "If true, regenerate image logo cache", + "default": false + }, "chafa": { "type": "object", "title": "Chafa configuration. See chafa document for details", diff --git a/src/common/commandoption.c b/src/common/commandoption.c new file mode 100644 index 0000000000..a7c250f449 --- /dev/null +++ b/src/common/commandoption.c @@ -0,0 +1,321 @@ +#include "commandoption.h" +#include "util/stringUtils.h" + +#include + +static inline bool tryModule(const char* type, void* options) +{ + FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; + if (ffStrEqualsIgnCase(type, baseInfo->name)) + { + baseInfo->printModule(options); + return true; + } + return false; +} + +bool ffParseModuleCommand(const char* type) +{ + FFconfig* cfg = &instance.config; + switch (toupper(type[0])) + { + case 'B': { + return + tryModule(type, &cfg->battery) || + tryModule(type, &cfg->bios) || + tryModule(type, &cfg->bluetooth) || + tryModule(type, &cfg->board) || + tryModule(type, &cfg->break_) || + tryModule(type, &cfg->brightness) || + false; + } + + case 'C': { + return + tryModule(type, &cfg->chassis) || + tryModule(type, &cfg->command) || + tryModule(type, &cfg->colors) || + tryModule(type, &cfg->cpu) || + tryModule(type, &cfg->cpuUsage) || + tryModule(type, &cfg->cursor) || + tryModule(type, &cfg->custom) || + false; + } + + case 'D': { + return + tryModule(type, &cfg->dateTime) || + tryModule(type, &cfg->de) || + tryModule(type, &cfg->display) || + tryModule(type, &cfg->disk) || + false; + } + + case 'F': { + return + tryModule(type, &cfg->font) || + false; + } + + case 'G': { + return + tryModule(type, &cfg->gamepad) || + tryModule(type, &cfg->gpu) || + false; + } + + case 'H': { + return + tryModule(type, &cfg->host) || + false; + } + + case 'I': { + return + tryModule(type, &cfg->icons) || + false; + } + + case 'K': { + return + tryModule(type, &cfg->kernel) || + false; + } + + case 'L': { + return + tryModule(type, &cfg->lm) || + tryModule(type, &cfg->locale) || + tryModule(type, &cfg->localIP) || + false; + } + + case 'M': { + return + tryModule(type, &cfg->media) || + tryModule(type, &cfg->memory) || + tryModule(type, &cfg->monitor) || + false; + } + + case 'O': { + return + tryModule(type, &cfg->openCL) || + tryModule(type, &cfg->openGL) || + tryModule(type, &cfg->os) || + false; + } + + case 'P': { + return + tryModule(type, &cfg->packages) || + tryModule(type, &cfg->player) || + tryModule(type, &cfg->powerAdapter) || + tryModule(type, &cfg->processes) || + tryModule(type, &cfg->publicIP) || + false; + } + + case 'S': { + return + tryModule(type, &cfg->separator) || + tryModule(type, &cfg->shell) || + tryModule(type, &cfg->sound) || + tryModule(type, &cfg->swap) || + false; + } + + case 'T': { + return + tryModule(type, &cfg->terminal) || + tryModule(type, &cfg->terminalFont) || + tryModule(type, &cfg->terminalSize) || + tryModule(type, &cfg->title) || + tryModule(type, &cfg->theme) || + false; + } + + case 'U': { + return + tryModule(type, &cfg->uptime) || + tryModule(type, &cfg->users) || + false; + } + + case 'V': { + return + tryModule(type, &cfg->vulkan) || + false; + } + + case 'W': { + return + tryModule(type, &cfg->wallpaper) || + tryModule(type, &cfg->weather) || + tryModule(type, &cfg->wm) || + tryModule(type, &cfg->wifi) || + tryModule(type, &cfg->wmTheme) || + false; + } + + default: + return false; + } +} + +static inline bool tryModuleCommandOptions(const char* key, const char* value, void* options) +{ + FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; + return baseInfo->parseCommandOptions(options, key, value); +} + +bool ffParseModuleOptions(const char* key, const char* value) +{ + if (!ffStrStartsWith(key, "--")) return false; + FFconfig* cfg = &instance.config; + + switch (toupper(key[2])) + { + case 'B': { + return + tryModuleCommandOptions(key, value, &cfg->battery) || + tryModuleCommandOptions(key, value, &cfg->bios) || + tryModuleCommandOptions(key, value, &cfg->bluetooth) || + tryModuleCommandOptions(key, value, &cfg->board) || + tryModuleCommandOptions(key, value, &cfg->break_) || + tryModuleCommandOptions(key, value, &cfg->brightness) || + false; + } + + case 'C': { + return + tryModuleCommandOptions(key, value, &cfg->chassis) || + tryModuleCommandOptions(key, value, &cfg->command) || + tryModuleCommandOptions(key, value, &cfg->colors) || + tryModuleCommandOptions(key, value, &cfg->cpu) || + tryModuleCommandOptions(key, value, &cfg->cpuUsage) || + tryModuleCommandOptions(key, value, &cfg->cursor) || + tryModuleCommandOptions(key, value, &cfg->custom) || + false; + } + + case 'D': { + return + tryModuleCommandOptions(key, value, &cfg->dateTime) || + tryModuleCommandOptions(key, value, &cfg->de) || + tryModuleCommandOptions(key, value, &cfg->display) || + tryModuleCommandOptions(key, value, &cfg->disk) || + false; + } + + case 'F': { + return + tryModuleCommandOptions(key, value, &cfg->font) || + false; + } + + case 'G': { + return + tryModuleCommandOptions(key, value, &cfg->gamepad) || + tryModuleCommandOptions(key, value, &cfg->gpu) || + false; + } + + case 'H': { + return + tryModuleCommandOptions(key, value, &cfg->host) || + false; + } + + case 'I': { + return + tryModuleCommandOptions(key, value, &cfg->icons) || + false; + } + + case 'K': { + return + tryModuleCommandOptions(key, value, &cfg->kernel) || + false; + } + + case 'L': { + return + tryModuleCommandOptions(key, value, &cfg->lm) || + tryModuleCommandOptions(key, value, &cfg->locale) || + tryModuleCommandOptions(key, value, &cfg->localIP) || + false; + } + + case 'M': { + return + tryModuleCommandOptions(key, value, &cfg->media) || + tryModuleCommandOptions(key, value, &cfg->memory) || + tryModuleCommandOptions(key, value, &cfg->monitor) || + false; + } + + case 'O': { + return + tryModuleCommandOptions(key, value, &cfg->openCL) || + tryModuleCommandOptions(key, value, &cfg->openGL) || + tryModuleCommandOptions(key, value, &cfg->os) || + false; + } + + case 'P': { + return + tryModuleCommandOptions(key, value, &cfg->packages) || + tryModuleCommandOptions(key, value, &cfg->player) || + tryModuleCommandOptions(key, value, &cfg->powerAdapter) || + tryModuleCommandOptions(key, value, &cfg->processes) || + tryModuleCommandOptions(key, value, &cfg->publicIP) || + false; + } + + case 'S': { + return + tryModuleCommandOptions(key, value, &cfg->separator) || + tryModuleCommandOptions(key, value, &cfg->shell) || + tryModuleCommandOptions(key, value, &cfg->sound) || + tryModuleCommandOptions(key, value, &cfg->swap) || + false; + } + + case 'T': { + return + tryModuleCommandOptions(key, value, &cfg->terminal) || + tryModuleCommandOptions(key, value, &cfg->terminalFont) || + tryModuleCommandOptions(key, value, &cfg->terminalSize) || + tryModuleCommandOptions(key, value, &cfg->title) || + tryModuleCommandOptions(key, value, &cfg->theme) || + false; + } + + case 'U': { + return + tryModuleCommandOptions(key, value, &cfg->uptime) || + tryModuleCommandOptions(key, value, &cfg->users) || + false; + } + + case 'V': { + return + tryModuleCommandOptions(key, value, &cfg->vulkan) || + false; + } + + case 'W': { + return + tryModuleCommandOptions(key, value, &cfg->wallpaper) || + tryModuleCommandOptions(key, value, &cfg->weather) || + tryModuleCommandOptions(key, value, &cfg->wm) || + tryModuleCommandOptions(key, value, &cfg->wifi) || + tryModuleCommandOptions(key, value, &cfg->wmTheme) || + false; + } + + default: + return false; + } +} diff --git a/src/common/commandoption.h b/src/common/commandoption.h new file mode 100644 index 0000000000..3ae2a83111 --- /dev/null +++ b/src/common/commandoption.h @@ -0,0 +1,11 @@ +#pragma once + +#ifndef FF_INCLUDED_common_commandoption +#define FF_INCLUDED_common_commandoption + +#include "fastfetch.h" + +bool ffParseModuleCommand(const char* type); +bool ffParseModuleOptions(const char* key, const char* value); + +#endif diff --git a/src/common/init.c b/src/common/init.c index afd58bcc75..4ef61b7187 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -48,7 +48,6 @@ static void defaultConfig(void) #endif instance.config.showErrors = false; - instance.config.recache = false; instance.config.allowSlowOperations = false; instance.config.pipe = !isatty(STDOUT_FILENO); diff --git a/src/common/option.h b/src/common/option.h index 724ca7c5ac..690716924d 100644 --- a/src/common/option.h +++ b/src/common/option.h @@ -7,7 +7,7 @@ typedef struct FFModuleBaseInfo { const char* name; - void (*parseCommandOptions)(void* options, const char* key, const char* value); + bool (*parseCommandOptions)(void* options, const char* key, const char* value); void (*parseJsonObject)(void* options, yyjson_val *module); void (*printModule)(void* options); } FFModuleBaseInfo; @@ -15,7 +15,7 @@ typedef struct FFModuleBaseInfo static inline void ffOptionInitModuleBaseInfo( FFModuleBaseInfo* baseInfo, const char* name, - void* parseCommandOptions, // void (*const parseCommandOptions)(void* options, const char* key, const char* value) + void* parseCommandOptions, // bool (*const parseCommandOptions)(void* options, const char* key, const char* value) void* parseJsonObject, // void (*const parseJsonObject)(void* options, yyjson_val *module) void* printModule // void (*const printModule)(void* options) ) diff --git a/src/data/help.txt b/src/data/help.txt index 4cac377694..b008edf83e 100644 --- a/src/data/help.txt +++ b/src/data/help.txt @@ -40,6 +40,7 @@ Logo options: --logo-padding-right : Set the padding on the right of the logo --logo-padding-top : Set the padding on the top of the logo --logo-print-remaining : Whether to print the remaining logo, if it has more lines than modules to display + --logo-recache : If true, regenerate image logo cache --file : Short for --logo-type file --logo --file-raw : Short for --logo-type file-raw --logo --data : Short for --logo-type data --logo @@ -58,9 +59,9 @@ Display options: -s,--structure : Set the structure of the fetch. Must be a colon separated list of keys. Use "fastfetch --list-modules" to see the ones available. --color-keys : Set the color of the keys --color-title : Set the color of the title + --color : Set the color of both the keys and title --key-width : Align the width of keys to characters --bright-color : Set if the keys, title and ASCII logo should be printed in bright color. Default is true - -c,--color : Set the color of both the keys and title --separator : Set the separator between key and value. Default is a colon with a space --set : Hard set the value of a key --set-keyless : Hard set the value of a key, but don't print the key or the separator diff --git a/src/fastfetch.c b/src/fastfetch.c index 4f338f1169..6387b9738a 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -1,4 +1,5 @@ #include "fastfetch.h" +#include "common/commandoption.h" #include "common/printing.h" #include "common/parsing.h" #include "common/io/io.h" @@ -769,18 +770,7 @@ static inline void optionCheckString(const char* key, const char* value, FFstrbu ffStrbufEnsureFree(buffer, 63); //This is not needed, as ffStrbufSetS will resize capacity if needed, but giving a higher start should improve performance } -static void parseOption(FFdata* data, const char* key, const char* value) -{ - /////////////////////// - //Informative options// - /////////////////////// - - if(ffStrEqualsIgnCase(key, "-h") || ffStrEqualsIgnCase(key, "--help")) - { - printCommandHelp(value); - exit(0); - } - else if(ffStrEqualsIgnCase(key, "-v") || ffStrEqualsIgnCase(key, "--version")) +static void printVersion() { #ifndef NDEBUG #define FF_BUILD_TYPE "-debug" @@ -812,7 +802,22 @@ static void parseOption(FFdata* data, const char* key, const char* value) #undef FF_ARCHITECTURE #undef FF_BUILD_TYPE +} +static void parseOption(FFdata* data, const char* key, const char* value) +{ + /////////////////////// + //Informative options// + /////////////////////// + + if(ffStrEqualsIgnCase(key, "-h") || ffStrEqualsIgnCase(key, "--help")) + { + printCommandHelp(value); + exit(0); + } + else if(ffStrEqualsIgnCase(key, "-v") || ffStrEqualsIgnCase(key, "--version")) + { + printVersion(); exit(0); } else if(ffStrEqualsIgnCase(key, "--version-raw")) @@ -929,8 +934,6 @@ static void parseOption(FFdata* data, const char* key, const char* value) //General options// /////////////////// - else if(ffStrEqualsIgnCase(key, "-r") || ffStrEqualsIgnCase(key, "--recache")) - instance.config.recache = ffOptionParseBoolean(value); else if(ffStrEqualsIgnCase(key, "--load-config")) optionParseConfigFile(data, key, value); else if(ffStrEqualsIgnCase(key, "--gen-config")) @@ -987,26 +990,32 @@ static void parseOption(FFdata* data, const char* key, const char* value) ffOptionParseString(key, value, &data->structure); else if(ffStrEqualsIgnCase(key, "--separator")) ffOptionParseString(key, value, &instance.config.keyValueSeparator); - else if(ffStrEqualsIgnCase(key, "--color-keys")) - { - optionCheckString(key, value, &instance.config.colorKeys); - ffOptionParseColor(value, &instance.config.colorKeys); - } - else if(ffStrEqualsIgnCase(key, "--color-title")) + else if(ffStrStartsWith(key, "--color")) { - optionCheckString(key, value, &instance.config.colorTitle); - ffOptionParseColor(value, &instance.config.colorTitle); + const char* subkey = key + strlen("--color"); + if(*subkey == '\0') + { + optionCheckString(key, value, &instance.config.colorKeys); + ffOptionParseColor(value, &instance.config.colorKeys); + ffStrbufSet(&instance.config.colorTitle, &instance.config.colorKeys); + } + else if(ffStrEqualsIgnCase(subkey, "-keys")) + { + optionCheckString(key, value, &instance.config.colorKeys); + ffOptionParseColor(value, &instance.config.colorKeys); + } + else if(ffStrEqualsIgnCase(key, "-title")) + { + optionCheckString(key, value, &instance.config.colorTitle); + ffOptionParseColor(value, &instance.config.colorTitle); + } + else + goto error; } else if(ffStrEqualsIgnCase(key, "--key-width")) instance.config.keyWidth = ffOptionParseUInt32(key, value); else if(ffStrEqualsIgnCase(key, "--bright-color")) instance.config.brightColor = ffOptionParseBoolean(value); - else if(ffStrEqualsIgnCase(key, "-c") || ffStrEqualsIgnCase(key, "--color")) - { - optionCheckString(key, value, &instance.config.colorKeys); - ffOptionParseColor(value, &instance.config.colorKeys); - ffStrbufSet(&instance.config.colorTitle, &instance.config.colorKeys); - } else if(ffStrEqualsIgnCase(key, "--binary-prefix")) { instance.config.binaryPrefixType = (FFBinaryPrefixType) ffOptionParseEnum(key, value, (FFKeyValuePair[]) { @@ -1047,75 +1056,22 @@ static void parseOption(FFdata* data, const char* key, const char* value) } else if(ffStrEqualsIgnCase(key, "--percent-type")) instance.config.percentType = ffOptionParseUInt32(key, value); - else if(ffStrEqualsIgnCase(key, "--bar-char-elapsed")) - ffOptionParseString(key, value, &instance.config.barCharElapsed); - else if(ffStrEqualsIgnCase(key, "--bar-char-total")) - ffOptionParseString(key, value, &instance.config.barCharTotal); - else if(ffStrEqualsIgnCase(key, "--bar-width")) - instance.config.barWidth = (uint8_t) ffOptionParseUInt32(key, value); - else if(ffStrEqualsIgnCase(key, "--bar-border")) - instance.config.barBorder = ffOptionParseBoolean(value); else if(ffStrEqualsIgnCase(key, "--no-buffer")) instance.config.noBuffer = ffOptionParseBoolean(value); - - /////////////////////// - //Module args options// - /////////////////////// - - else if(ffParseBatteryCommandOptions(&instance.config.battery, key, value)) {} - else if(ffParseBiosCommandOptions(&instance.config.bios, key, value)) {} - else if(ffParseBluetoothCommandOptions(&instance.config.bluetooth, key, value)) {} - else if(ffParseBoardCommandOptions(&instance.config.board, key, value)) {} - else if(ffParseBreakCommandOptions(&instance.config.break_, key, value)) {} - else if(ffParseBrightnessCommandOptions(&instance.config.brightness, key, value)) {} - else if(ffParseCPUCommandOptions(&instance.config.cpu, key, value)) {} - else if(ffParseCPUUsageCommandOptions(&instance.config.cpuUsage, key, value)) {} - else if(ffParseChassisCommandOptions(&instance.config.chassis, key, value)) {} - else if(ffParseColorsCommandOptions(&instance.config.colors, key, value)) {} - else if(ffParseCommandCommandOptions(&instance.config.command, key, value)) {} - else if(ffParseCursorCommandOptions(&instance.config.cursor, key, value)) {} - else if(ffParseCustomCommandOptions(&instance.config.custom, key, value)) {} - else if(ffParseDECommandOptions(&instance.config.de, key, value)) {} - else if(ffParseDateTimeCommandOptions(&instance.config.dateTime, key, value)) {} - else if(ffParseDiskCommandOptions(&instance.config.disk, key, value)) {} - else if(ffParseDisplayCommandOptions(&instance.config.display, key, value)) {} - else if(ffParseFontCommandOptions(&instance.config.font, key, value)) {} - else if(ffParseGPUCommandOptions(&instance.config.gpu, key, value)) {} - else if(ffParseGamepadCommandOptions(&instance.config.gamepad, key, value)) {} - else if(ffParseHostCommandOptions(&instance.config.host, key, value)) {} - else if(ffParseIconsCommandOptions(&instance.config.icons, key, value)) {} - else if(ffParseKernelCommandOptions(&instance.config.kernel, key, value)) {} - else if(ffParseLocalIpCommandOptions(&instance.config.localIP, key, value)) {} - else if(ffParseLocaleCommandOptions(&instance.config.locale, key, value)) {} - else if(ffParseMediaCommandOptions(&instance.config.media, key, value)) {} - else if(ffParseMemoryCommandOptions(&instance.config.memory, key, value)) {} - else if(ffParseMonitorCommandOptions(&instance.config.monitor, key, value)) {} - else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} - else if(ffParseOSCommandOptions(&instance.config.os, key, value)) {} - else if(ffParseOpenCLCommandOptions(&instance.config.openCL, key, value)) {} - else if(ffParseOpenGLCommandOptions(&instance.config.openGL, key, value)) {} - else if(ffParsePackagesCommandOptions(&instance.config.packages, key, value)) {} - else if(ffParsePlayerCommandOptions(&instance.config.player, key, value)) {} - else if(ffParsePowerAdapterCommandOptions(&instance.config.powerAdapter, key, value)) {} - else if(ffParseProcessesCommandOptions(&instance.config.processes, key, value)) {} - else if(ffParsePublicIpCommandOptions(&instance.config.publicIP, key, value)) {} - else if(ffParseSeparatorCommandOptions(&instance.config.separator, key, value)) {} - else if(ffParseShellCommandOptions(&instance.config.shell, key, value)) {} - else if(ffParseSoundCommandOptions(&instance.config.sound, key, value)) {} - else if(ffParseSwapCommandOptions(&instance.config.swap, key, value)) {} - else if(ffParseTerminalCommandOptions(&instance.config.terminal, key, value)) {} - else if(ffParseTerminalFontCommandOptions(&instance.config.terminalFont, key, value)) {} - else if(ffParseTerminalSizeCommandOptions(&instance.config.terminalSize, key, value)) {} - else if(ffParseThemeCommandOptions(&instance.config.theme, key, value)) {} - else if(ffParseTitleCommandOptions(&instance.config.title, key, value)) {} - else if(ffParseUptimeCommandOptions(&instance.config.uptime, key, value)) {} - else if(ffParseUsersCommandOptions(&instance.config.users, key, value)) {} - else if(ffParseVulkanCommandOptions(&instance.config.vulkan, key, value)) {} - else if(ffParseWMCommandOptions(&instance.config.wm, key, value)) {} - else if(ffParseWMThemeCommandOptions(&instance.config.wmTheme, key, value)) {} - else if(ffParseWallpaperCommandOptions(&instance.config.wallpaper, key, value)) {} - else if(ffParseWeatherCommandOptions(&instance.config.weather, key, value)) {} - else if(ffParseWifiCommandOptions(&instance.config.wifi, key, value)) {} + else if(ffStrStartsWithIgnCase(key, "--bar")) + { + const char* subkey = key + strlen("--bar"); + if(ffStrEqualsIgnCase(subkey, "-char-elapsed")) + ffOptionParseString(key, value, &instance.config.barCharElapsed); + else if(ffStrEqualsIgnCase(subkey, "-char-total")) + ffOptionParseString(key, value, &instance.config.barCharTotal); + else if(ffStrEqualsIgnCase(subkey, "-width")) + instance.config.barWidth = (uint8_t) ffOptionParseUInt32(key, value); + else if(ffStrEqualsIgnCase(subkey, "-border")) + instance.config.barBorder = ffOptionParseBoolean(value); + else + goto error; + } /////////////////// //Library options// @@ -1176,6 +1132,12 @@ static void parseOption(FFdata* data, const char* key, const char* value) goto error; } + /////////////////////// + //Module args options// + /////////////////////// + + else if(ffParseModuleOptions(key, value)) {} + ////////////////// //Unknown option// ////////////////// @@ -1222,6 +1184,13 @@ static void parseArguments(FFdata* data, int argc, const char** argv) for(int i = 1; i < argc; i++) { + const char* key = argv[i]; + if(*key != '-') + { + fprintf(stderr, "Error: invalid option: %s. An option must start with `-`\n", key); + exit(400); + } + if(i == argc - 1 || ( *argv[i + 1] == '-' && strcasecmp(argv[i], "--separator-string") != 0 // Separator string can start with a - @@ -1236,166 +1205,6 @@ static void parseArguments(FFdata* data, int argc, const char** argv) } } -static inline bool tryModule(const char* type, void* options) -{ - FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; - if (ffStrEqualsIgnCase(type, baseInfo->name)) - { - baseInfo->printModule(options); - return true; - } - return false; -} - -static bool parseModuleCommand(const char* type) -{ - FFconfig* cfg = &instance.config; - switch (toupper(type[0])) - { - case 'B': { - return - tryModule(type, &cfg->battery) || - tryModule(type, &cfg->bios) || - tryModule(type, &cfg->bluetooth) || - tryModule(type, &cfg->board) || - tryModule(type, &cfg->break_) || - tryModule(type, &cfg->brightness) || - false; - } - - case 'C': { - return - tryModule(type, &cfg->chassis) || - tryModule(type, &cfg->command) || - tryModule(type, &cfg->colors) || - tryModule(type, &cfg->cpu) || - tryModule(type, &cfg->cpuUsage) || - tryModule(type, &cfg->cursor) || - tryModule(type, &cfg->custom) || - false; - } - - case 'D': { - return - tryModule(type, &cfg->dateTime) || - tryModule(type, &cfg->de) || - tryModule(type, &cfg->display) || - tryModule(type, &cfg->disk) || - false; - } - - case 'F': { - return - tryModule(type, &cfg->font) || - false; - } - - case 'G': { - return - tryModule(type, &cfg->gamepad) || - tryModule(type, &cfg->gpu) || - false; - } - - case 'H': { - return - tryModule(type, &cfg->host) || - false; - } - - case 'I': { - return - tryModule(type, &cfg->icons) || - false; - } - - case 'K': { - return - tryModule(type, &cfg->kernel) || - false; - } - - case 'L': { - return - tryModule(type, &cfg->lm) || - tryModule(type, &cfg->locale) || - tryModule(type, &cfg->localIP) || - false; - } - - case 'M': { - return - tryModule(type, &cfg->media) || - tryModule(type, &cfg->memory) || - tryModule(type, &cfg->monitor) || - false; - } - - case 'O': { - return - tryModule(type, &cfg->openCL) || - tryModule(type, &cfg->openGL) || - tryModule(type, &cfg->os) || - false; - } - - case 'P': { - return - tryModule(type, &cfg->packages) || - tryModule(type, &cfg->player) || - tryModule(type, &cfg->powerAdapter) || - tryModule(type, &cfg->processes) || - tryModule(type, &cfg->publicIP) || - false; - } - - case 'S': { - return - tryModule(type, &cfg->separator) || - tryModule(type, &cfg->shell) || - tryModule(type, &cfg->sound) || - tryModule(type, &cfg->swap) || - false; - } - - case 'T': { - return - tryModule(type, &cfg->terminal) || - tryModule(type, &cfg->terminalFont) || - tryModule(type, &cfg->terminalSize) || - tryModule(type, &cfg->title) || - tryModule(type, &cfg->theme) || - false; - } - - case 'U': { - return - tryModule(type, &cfg->uptime) || - tryModule(type, &cfg->users) || - false; - } - - case 'V': { - return - tryModule(type, &cfg->vulkan) || - false; - } - - case 'W': { - return - tryModule(type, &cfg->wallpaper) || - tryModule(type, &cfg->weather) || - tryModule(type, &cfg->wm) || - tryModule(type, &cfg->wifi) || - tryModule(type, &cfg->wmTheme) || - false; - } - - default: - return false; - } -} - static void parseStructureCommand(const char* line, FFlist* customValues) { // handle `--set` and `--set-keyless` @@ -1413,7 +1222,7 @@ static void parseStructureCommand(const char* line, FFlist* customValues) } } - if(!parseModuleCommand(line)) + if(!ffParseModuleCommand(line)) ffPrintErrorString(line, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, ""); } diff --git a/src/fastfetch.h b/src/fastfetch.h index 0cfa892875..ce68fd8730 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -45,7 +45,6 @@ typedef struct FFconfig FFstrbuf keyValueSeparator; bool showErrors; - bool recache; bool allowSlowOperations; bool disableLinewrap; bool hideCursor; diff --git a/src/logo/image/image.c b/src/logo/image/image.c index f50b734237..2c31b8acc4 100644 --- a/src/logo/image/image.c +++ b/src/logo/image/image.c @@ -698,7 +698,7 @@ static bool printImageIfExistsSlowPath(FFLogoType type, bool printError) ffStrbufAppendF(&requestData.cacheDir, "%u", requestData.logoPixelHeight); ffStrbufAppendC(&requestData.cacheDir, '/'); - if(!instance.config.recache && printCached(&requestData)) + if(!instance.config.logo.recache && printCached(&requestData)) { ffStrbufDestroy(&requestData.cacheDir); return true; diff --git a/src/logo/option.c b/src/logo/option.c index 96e9caed0b..6648a0d2a3 100644 --- a/src/logo/option.c +++ b/src/logo/option.c @@ -16,6 +16,7 @@ void ffInitLogoOptions(FFLogoOptions* options) options->paddingRight = 4; options->printRemaining = true; options->preserveAspectRadio = false; + options->recache = false; options->chafaFgOnly = false; ffStrbufInitStatic(&options->chafaSymbols, "block+border+space-wide-inverted"); // Chafa default @@ -113,6 +114,8 @@ bool ffParseLogoCommandOptions(FFLogoOptions* options, const char* key, const ch options->printRemaining = ffOptionParseBoolean(value); else if(strcasecmp(subKey, "preserve-aspect-radio") == 0) options->preserveAspectRadio = ffOptionParseBoolean(value); + else if(strcasecmp(subKey, "recache") == 0) + options->recache = ffOptionParseBoolean(value); else return false; } @@ -334,6 +337,11 @@ const char* ffParseLogoJsonConfig(void) options->preserveAspectRadio = yyjson_get_bool(val); continue; } + else if (strcasecmp(key, "recache") == 0) + { + options->recache = yyjson_get_bool(val); + continue; + } else if (strcasecmp(key, "chafa") == 0) { if (!yyjson_is_obj(val)) diff --git a/src/logo/option.h b/src/logo/option.h index e1073db370..1eb41c1e90 100644 --- a/src/logo/option.h +++ b/src/logo/option.h @@ -35,6 +35,7 @@ typedef struct FFLogoOptions uint32_t paddingRight; bool printRemaining; bool preserveAspectRadio; + bool recache; bool chafaFgOnly; FFstrbuf chafaSymbols; From 55b279ab096f990a5313754ca17d5b08042e8031 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Thu, 17 Aug 2023 16:09:41 +0800 Subject: [PATCH 18/37] JsonConfig: remove useless checks --- src/modules/battery/battery.c | 45 ++++----- src/modules/bios/bios.c | 21 ++-- src/modules/bluetooth/bluetooth.c | 31 +++--- src/modules/board/board.c | 21 ++-- src/modules/brightness/brightness.c | 21 ++-- src/modules/chassis/chassis.c | 21 ++-- src/modules/colors/colors.c | 65 ++++++------- src/modules/command/command.c | 45 ++++----- src/modules/cpu/cpu.c | 31 +++--- src/modules/cpuusage/cpuusage.c | 21 ++-- src/modules/cursor/cursor.c | 21 ++-- src/modules/custom/custom.c | 25 +++-- src/modules/datetime/datetime.c | 21 ++-- src/modules/de/de.c | 21 ++-- src/modules/disk/disk.c | 95 +++++++++---------- src/modules/display/display.c | 61 ++++++------ src/modules/font/font.c | 21 ++-- src/modules/gamepad/gamepad.c | 21 ++-- src/modules/gpu/gpu.c | 71 +++++++------- src/modules/host/host.c | 21 ++-- src/modules/icons/icons.c | 21 ++-- src/modules/kernel/kernel.c | 21 ++-- src/modules/lm/lm.c | 21 ++-- src/modules/locale/locale.c | 21 ++-- src/modules/localip/localip.c | 121 ++++++++++++------------ src/modules/media/media.c | 21 ++-- src/modules/memory/memory.c | 21 ++-- src/modules/monitor/monitor.c | 21 ++-- src/modules/opencl/opencl.c | 21 ++-- src/modules/opengl/opengl.c | 57 ++++++----- src/modules/os/os.c | 25 +++-- src/modules/packages/packages.c | 21 ++-- src/modules/player/player.c | 25 +++-- src/modules/poweradapter/poweradapter.c | 21 ++-- src/modules/processes/processes.c | 21 ++-- src/modules/publicip/publicip.c | 41 ++++---- src/modules/separator/separator.c | 27 +++--- src/modules/shell/shell.c | 21 ++-- src/modules/sound/sound.c | 53 +++++------ src/modules/swap/swap.c | 21 ++-- src/modules/terminal/terminal.c | 21 ++-- src/modules/terminalfont/terminalfont.c | 21 ++-- src/modules/terminalsize/terminalsize.c | 21 ++-- src/modules/theme/theme.c | 21 ++-- src/modules/title/title.c | 61 ++++++------ src/modules/uptime/uptime.c | 21 ++-- src/modules/users/users.c | 21 ++-- src/modules/vulkan/vulkan.c | 21 ++-- src/modules/wallpaper/wallpaper.c | 21 ++-- src/modules/weather/weather.c | 57 ++++++----- src/modules/wifi/wifi.c | 21 ++-- src/modules/wm/wm.c | 21 ++-- src/modules/wmtheme/wmtheme.c | 21 ++-- 53 files changed, 756 insertions(+), 915 deletions(-) diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c index 9a10d4973c..2161be6295 100644 --- a/src/modules/battery/battery.c +++ b/src/modules/battery/battery.c @@ -149,34 +149,31 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options) void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - #ifdef __linux__ - if (ffStrEqualsIgnCase(key, "dir")) - { - ffStrbufSetS(&options.dir, yyjson_get_str(val)); - continue; - } - #endif - - if (ffStrEqualsIgnCase(key, "temp")) - { - options->temp = yyjson_get_bool(val); - continue; - } + #ifdef __linux__ + if (ffStrEqualsIgnCase(key, "dir")) + { + ffStrbufSetS(&options.dir, yyjson_get_str(val)); + continue; + } + #endif - ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "temp")) + { + options->temp = yyjson_get_bool(val); + continue; } + + ffPrintError(FF_BATTERY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/bios/bios.c b/src/modules/bios/bios.c index d1c9bb6f08..ee42017955 100644 --- a/src/modules/bios/bios.c +++ b/src/modules/bios/bios.c @@ -76,20 +76,17 @@ void ffDestroyBiosOptions(FFBiosOptions* options) void ffParseBiosJsonObject(FFBiosOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_BIOS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/bluetooth/bluetooth.c b/src/modules/bluetooth/bluetooth.c index eed9d609bc..fa8b65d51b 100644 --- a/src/modules/bluetooth/bluetooth.c +++ b/src/modules/bluetooth/bluetooth.c @@ -103,26 +103,23 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options) void ffParseBluetoothJsonObject(FFBluetoothOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "showDisconnected")) - { - options->showDisconnected = yyjson_get_bool(val); - continue; - } - - ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "showDisconnected")) + { + options->showDisconnected = yyjson_get_bool(val); + continue; } + + ffPrintError(FF_BLUETOOTH_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/board/board.c b/src/modules/board/board.c index 6ce7a847a0..29a676ca83 100644 --- a/src/modules/board/board.c +++ b/src/modules/board/board.c @@ -72,20 +72,17 @@ void ffDestroyBoardOptions(FFBoardOptions* options) void ffParseBoardJsonObject(FFBoardOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_BOARD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/brightness/brightness.c b/src/modules/brightness/brightness.c index 4a29ae7512..24d31c5df8 100644 --- a/src/modules/brightness/brightness.c +++ b/src/modules/brightness/brightness.c @@ -101,20 +101,17 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options) void ffParseBrightnessJsonObject(FFBrightnessOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_BRIGHTNESS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/chassis/chassis.c b/src/modules/chassis/chassis.c index baf5a9ec4b..02cd3e97d9 100644 --- a/src/modules/chassis/chassis.c +++ b/src/modules/chassis/chassis.c @@ -73,20 +73,17 @@ void ffDestroyChassisOptions(FFChassisOptions* options) void ffParseChassisJsonObject(FFChassisOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_CHASSIS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/colors/colors.c b/src/modules/colors/colors.c index e1ec1a90ca..488413f214 100644 --- a/src/modules/colors/colors.c +++ b/src/modules/colors/colors.c @@ -96,42 +96,39 @@ void ffDestroyColorsOptions(FF_MAYBE_UNUSED FFColorsOptions* options) void ffParseColorsJsonObject(FFColorsOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffStrEqualsIgnCase(key, "symbol")) { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffStrEqualsIgnCase(key, "symbol")) - { - int value; - const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { - { "block", FF_COLORS_SYMBOL_BLOCK }, - { "circle", FF_COLORS_SYMBOL_CIRCLE }, - { "diamond", FF_COLORS_SYMBOL_DIAMOND }, - { "triangle", FF_COLORS_SYMBOL_TRIANGLE }, - { "square", FF_COLORS_SYMBOL_SQUARE }, - { "star", FF_COLORS_SYMBOL_STAR }, - {}, - }); - if (error) - ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error); - else - options->symbol = (FFColorsSymbol) value; - continue; - } - - if (ffStrEqualsIgnCase(key, "paddingLeft")) - { - options->paddingLeft = (uint32_t) yyjson_get_uint(val); - continue; - } - - ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); + int value; + const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { + { "block", FF_COLORS_SYMBOL_BLOCK }, + { "circle", FF_COLORS_SYMBOL_CIRCLE }, + { "diamond", FF_COLORS_SYMBOL_DIAMOND }, + { "triangle", FF_COLORS_SYMBOL_TRIANGLE }, + { "square", FF_COLORS_SYMBOL_SQUARE }, + { "star", FF_COLORS_SYMBOL_STAR }, + {}, + }); + if (error) + ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Invalid %s value: %s", key, error); + else + options->symbol = (FFColorsSymbol) value; + continue; } + + if (ffStrEqualsIgnCase(key, "paddingLeft")) + { + options->paddingLeft = (uint32_t) yyjson_get_uint(val); + continue; + } + + ffPrintErrorString(FF_COLORS_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/command/command.c b/src/modules/command/command.c index de25c50041..f19f1f27d9 100644 --- a/src/modules/command/command.c +++ b/src/modules/command/command.c @@ -81,32 +81,29 @@ void ffDestroyCommandOptions(FFCommandOptions* options) void ffParseCommandJsonObject(FFCommandOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + if (ffStrEqualsIgnCase(key, "shell")) + { + ffStrbufSetS(&options->shell, yyjson_get_str(val)); + continue; + } + + if (ffStrEqualsIgnCase(key, "text")) { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - if (ffStrEqualsIgnCase(key, "shell")) - { - ffStrbufSetS(&options->shell, yyjson_get_str(val)); - continue; - } - - if (ffStrEqualsIgnCase(key, "text")) - { - ffStrbufSetS(&options->text, yyjson_get_str(val)); - continue; - } - - ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + ffStrbufSetS(&options->text, yyjson_get_str(val)); + continue; } + + ffPrintError(FF_COMMAND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c index 5556c2e585..00aec6ba84 100644 --- a/src/modules/cpu/cpu.c +++ b/src/modules/cpu/cpu.c @@ -107,26 +107,23 @@ void ffDestroyCPUOptions(FFCPUOptions* options) void ffParseCPUJsonObject(FFCPUOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffStrEqualsIgnCase(key, "temp")) - { - options->temp = yyjson_get_bool(val); - continue; - } + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "temp")) + { + options->temp = yyjson_get_bool(val); + continue; } + + ffPrintError(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/cpuusage/cpuusage.c b/src/modules/cpuusage/cpuusage.c index 59a4ae3cc3..27a53d7760 100644 --- a/src/modules/cpuusage/cpuusage.c +++ b/src/modules/cpuusage/cpuusage.c @@ -65,20 +65,17 @@ void ffDestroyCPUUsageOptions(FFCPUUsageOptions* options) void ffParseCPUUsageJsonObject(FFCPUUsageOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_CPUUSAGE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/cursor/cursor.c b/src/modules/cursor/cursor.c index a011643e3c..ffe91f10fc 100644 --- a/src/modules/cursor/cursor.c +++ b/src/modules/cursor/cursor.c @@ -73,20 +73,17 @@ void ffDestroyCursorOptions(FFCursorOptions* options) void ffParseCursorJsonObject(FFCursorOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_CURSOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/custom/custom.c b/src/modules/custom/custom.c index f1f4a2d815..b9406dcd36 100644 --- a/src/modules/custom/custom.c +++ b/src/modules/custom/custom.c @@ -40,20 +40,17 @@ void ffDestroyCustomOptions(FFCustomOptions* options) void ffParseCustomJsonObject(FFCustomOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + ffPrintError(FF_CUSTOM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/datetime/datetime.c b/src/modules/datetime/datetime.c index a89d5238a9..9d6307a132 100644 --- a/src/modules/datetime/datetime.c +++ b/src/modules/datetime/datetime.c @@ -72,20 +72,17 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options) void ffParseDateTimeJsonObject(FFDateTimeOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_DATETIME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/de/de.c b/src/modules/de/de.c index e4abefd0bf..a44f437d7a 100644 --- a/src/modules/de/de.c +++ b/src/modules/de/de.c @@ -63,20 +63,17 @@ void ffDestroyDEOptions(FFDEOptions* options) void ffParseDEJsonObject(FFDEOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_DE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/disk/disk.c b/src/modules/disk/disk.c index a43a1537ea..199779f97f 100644 --- a/src/modules/disk/disk.c +++ b/src/modules/disk/disk.c @@ -261,62 +261,59 @@ void ffDestroyDiskOptions(FFDiskOptions* options) void ffParseDiskJsonObject(FFDiskOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffStrEqualsIgnCase(key, "folders")) - { - ffStrbufSetS(&options->folders, yyjson_get_str(val)); - continue; - } + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "showExternal")) - { - if (yyjson_get_bool(val)) - options->showTypes |= FF_DISK_TYPE_EXTERNAL_BIT; - else - options->showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "folders")) + { + ffStrbufSetS(&options->folders, yyjson_get_str(val)); + continue; + } - if (ffStrEqualsIgnCase(key, "showHidden")) - { - if (yyjson_get_bool(val)) - options->showTypes |= FF_DISK_TYPE_HIDDEN_BIT; - else - options->showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showExternal")) + { + if (yyjson_get_bool(val)) + options->showTypes |= FF_DISK_TYPE_EXTERNAL_BIT; + else + options->showTypes &= ~FF_DISK_TYPE_EXTERNAL_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "showSubvolumes")) - { - if (yyjson_get_bool(val)) - options->showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT; - else - options->showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showHidden")) + { + if (yyjson_get_bool(val)) + options->showTypes |= FF_DISK_TYPE_HIDDEN_BIT; + else + options->showTypes &= ~FF_DISK_TYPE_HIDDEN_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "showUnknown")) - { - if (yyjson_get_bool(val)) - options->showTypes |= FF_DISK_TYPE_UNKNOWN_BIT; - else - options->showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showSubvolumes")) + { + if (yyjson_get_bool(val)) + options->showTypes |= FF_DISK_TYPE_SUBVOLUME_BIT; + else + options->showTypes &= ~FF_DISK_TYPE_SUBVOLUME_BIT; + continue; + } - ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "showUnknown")) + { + if (yyjson_get_bool(val)) + options->showTypes |= FF_DISK_TYPE_UNKNOWN_BIT; + else + options->showTypes &= ~FF_DISK_TYPE_UNKNOWN_BIT; + continue; } + + ffPrintError(FF_DISK_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/display/display.c b/src/modules/display/display.c index 7c11267aa8..210d6861e3 100644 --- a/src/modules/display/display.c +++ b/src/modules/display/display.c @@ -149,42 +149,39 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options) void ffParseDisplayJsonObject(FFDisplayOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "compactType")) - { - int value; - const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { - { "none", FF_DISPLAY_COMPACT_TYPE_NONE }, - { "original", FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT }, - { "scaled", FF_DISPLAY_COMPACT_TYPE_SCALED_BIT }, - {}, - }); - if (error) - ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); - else - options->compactType = (FFDisplayCompactType) value; - continue; - } - - if (ffStrEqualsIgnCase(key, "preciseRefreshRate")) - { - options->preciseRefreshRate = yyjson_get_bool(val); - continue; - } + if (ffStrEqualsIgnCase(key, "compactType")) + { + int value; + const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { + { "none", FF_DISPLAY_COMPACT_TYPE_NONE }, + { "original", FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT }, + { "scaled", FF_DISPLAY_COMPACT_TYPE_SCALED_BIT }, + {}, + }); + if (error) + ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); + else + options->compactType = (FFDisplayCompactType) value; + continue; + } - ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "preciseRefreshRate")) + { + options->preciseRefreshRate = yyjson_get_bool(val); + continue; } + + ffPrintError(FF_DISPLAY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/font/font.c b/src/modules/font/font.c index dee13f91b2..97c77359bd 100644 --- a/src/modules/font/font.c +++ b/src/modules/font/font.c @@ -66,20 +66,17 @@ void ffDestroyFontOptions(FFFontOptions* options) void ffParseFontJsonObject(FFFontOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_FONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/gamepad/gamepad.c b/src/modules/gamepad/gamepad.c index e057d45c3c..3691b5ac87 100644 --- a/src/modules/gamepad/gamepad.c +++ b/src/modules/gamepad/gamepad.c @@ -72,20 +72,17 @@ void ffDestroyGamepadOptions(FFGamepadOptions* options) void ffParseGamepadJsonObject(FFGamepadOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_GAMEPAD_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c index 58c85648b0..5f71779a7d 100644 --- a/src/modules/gpu/gpu.c +++ b/src/modules/gpu/gpu.c @@ -168,48 +168,45 @@ void ffDestroyGPUOptions(FFGPUOptions* options) void ffParseGPUJsonObject(FFGPUOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffStrEqualsIgnCase(key, "temp")) - { - options->temp = yyjson_get_bool(val); - continue; - } + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "forceVulkan")) - { - options->forceVulkan = yyjson_get_bool(val); - continue; - } + if (ffStrEqualsIgnCase(key, "temp")) + { + options->temp = yyjson_get_bool(val); + continue; + } - if (ffStrEqualsIgnCase(key, "hideType")) - { - int value; - const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { - { "none", FF_GPU_TYPE_UNKNOWN }, - { "intergrated", FF_GPU_TYPE_INTEGRATED }, - { "discrete", FF_GPU_TYPE_DISCRETE }, - {}, - }); - if (error) - ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); - else - options->hideType = (FFGPUType) value; - continue; - } + if (ffStrEqualsIgnCase(key, "forceVulkan")) + { + options->forceVulkan = yyjson_get_bool(val); + continue; + } - ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "hideType")) + { + int value; + const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { + { "none", FF_GPU_TYPE_UNKNOWN }, + { "intergrated", FF_GPU_TYPE_INTEGRATED }, + { "discrete", FF_GPU_TYPE_DISCRETE }, + {}, + }); + if (error) + ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); + else + options->hideType = (FFGPUType) value; + continue; } + + ffPrintError(FF_GPU_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/host/host.c b/src/modules/host/host.c index b7033ec0bf..d281ece1b7 100644 --- a/src/modules/host/host.c +++ b/src/modules/host/host.c @@ -88,20 +88,17 @@ void ffDestroyHostOptions(FFHostOptions* options) void ffParseHostJsonObject(FFHostOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_HOST_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/icons/icons.c b/src/modules/icons/icons.c index ede179b66b..aa1827a5fe 100644 --- a/src/modules/icons/icons.c +++ b/src/modules/icons/icons.c @@ -53,20 +53,17 @@ void ffDestroyIconsOptions(FFIconsOptions* options) void ffParseIconsJsonObject(FFIconsOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_ICONS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/kernel/kernel.c b/src/modules/kernel/kernel.c index e830debe1f..bc1bd21a8f 100644 --- a/src/modules/kernel/kernel.c +++ b/src/modules/kernel/kernel.c @@ -53,20 +53,17 @@ void ffDestroyKernelOptions(FFKernelOptions* options) void ffParseKernelJsonObject(FFKernelOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_KERNEL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/lm/lm.c b/src/modules/lm/lm.c index 3c3053e8e7..afef101a03 100644 --- a/src/modules/lm/lm.c +++ b/src/modules/lm/lm.c @@ -72,20 +72,17 @@ void ffDestroyLMOptions(FFLMOptions* options) void ffParseLMJsonObject(FFLMOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_LM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/locale/locale.c b/src/modules/locale/locale.c index 10e00802ec..4fa037b15d 100644 --- a/src/modules/locale/locale.c +++ b/src/modules/locale/locale.c @@ -53,20 +53,17 @@ void ffDestroyLocaleOptions(FFLocaleOptions* options) void ffParseLocaleJsonObject(FFLocaleOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_LOCALE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/localip/localip.c b/src/modules/localip/localip.c index 95ed7b2561..74b61c5803 100644 --- a/src/modules/localip/localip.c +++ b/src/modules/localip/localip.c @@ -222,77 +222,74 @@ void ffDestroyLocalIpOptions(FFLocalIpOptions* options) void ffParseLocalIpJsonObject(FFLocalIpOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "showIpv4")) - { - if (yyjson_get_bool(val)) - options->showType |= FF_LOCALIP_TYPE_IPV4_BIT; - else - options->showType &= ~FF_LOCALIP_TYPE_IPV4_BIT; - continue; - } - - if (ffStrEqualsIgnCase(key, "showIpv6")) - { - if (yyjson_get_bool(val)) - options->showType |= FF_LOCALIP_TYPE_IPV6_BIT; - else - options->showType &= ~FF_LOCALIP_TYPE_IPV6_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showIpv4")) + { + if (yyjson_get_bool(val)) + options->showType |= FF_LOCALIP_TYPE_IPV4_BIT; + else + options->showType &= ~FF_LOCALIP_TYPE_IPV4_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "showMac")) - { - if (yyjson_get_bool(val)) - options->showType |= FF_LOCALIP_TYPE_MAC_BIT; - else - options->showType &= ~FF_LOCALIP_TYPE_MAC_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showIpv6")) + { + if (yyjson_get_bool(val)) + options->showType |= FF_LOCALIP_TYPE_IPV6_BIT; + else + options->showType &= ~FF_LOCALIP_TYPE_IPV6_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "showLoop")) - { - if (yyjson_get_bool(val)) - options->showType |= FF_LOCALIP_TYPE_LOOP_BIT; - else - options->showType &= ~FF_LOCALIP_TYPE_LOOP_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showMac")) + { + if (yyjson_get_bool(val)) + options->showType |= FF_LOCALIP_TYPE_MAC_BIT; + else + options->showType &= ~FF_LOCALIP_TYPE_MAC_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "compact")) - { - if (yyjson_get_bool(val)) - options->showType |= FF_LOCALIP_TYPE_COMPACT_BIT; - else - options->showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT; - continue; - } + if (ffStrEqualsIgnCase(key, "showLoop")) + { + if (yyjson_get_bool(val)) + options->showType |= FF_LOCALIP_TYPE_LOOP_BIT; + else + options->showType &= ~FF_LOCALIP_TYPE_LOOP_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "namePrefix")) - { - ffStrbufSetS(&options->namePrefix, yyjson_get_str(val)); - continue; - } + if (ffStrEqualsIgnCase(key, "compact")) + { + if (yyjson_get_bool(val)) + options->showType |= FF_LOCALIP_TYPE_COMPACT_BIT; + else + options->showType &= ~FF_LOCALIP_TYPE_COMPACT_BIT; + continue; + } - if (ffStrEqualsIgnCase(key, "defaultRouteOnly")) - { - options->defaultRouteOnly = yyjson_get_bool(val); - continue; - } + if (ffStrEqualsIgnCase(key, "namePrefix")) + { + ffStrbufSetS(&options->namePrefix, yyjson_get_str(val)); + continue; + } - ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "defaultRouteOnly")) + { + options->defaultRouteOnly = yyjson_get_bool(val); + continue; } + + ffPrintError(FF_LOCALIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/media/media.c b/src/modules/media/media.c index 10fcd66ffa..87b9b7f12c 100644 --- a/src/modules/media/media.c +++ b/src/modules/media/media.c @@ -128,20 +128,17 @@ void ffDestroyMediaOptions(FFMediaOptions* options) void ffParseMediaJsonObject(FFMediaOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_MEDIA_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/memory/memory.c b/src/modules/memory/memory.c index b5691e17e9..e19f61f592 100644 --- a/src/modules/memory/memory.c +++ b/src/modules/memory/memory.c @@ -87,20 +87,17 @@ void ffDestroyMemoryOptions(FFMemoryOptions* options) void ffParseMemoryJsonObject(FFMemoryOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_MEMORY_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/monitor/monitor.c b/src/modules/monitor/monitor.c index 406263c71c..688c62413f 100644 --- a/src/modules/monitor/monitor.c +++ b/src/modules/monitor/monitor.c @@ -98,20 +98,17 @@ void ffDestroyMonitorOptions(FFMonitorOptions* options) void ffParseMonitorJsonObject(FFMonitorOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_MONITOR_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/opencl/opencl.c b/src/modules/opencl/opencl.c index 0d06bd8847..6194b7a0b5 100644 --- a/src/modules/opencl/opencl.c +++ b/src/modules/opencl/opencl.c @@ -62,20 +62,17 @@ void ffDestroyOpenCLOptions(FFOpenCLOptions* options) void ffParseOpenCLJsonObject(FFOpenCLOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_OPENCL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/opengl/opengl.c b/src/modules/opengl/opengl.c index 94838b646d..81e960de9f 100644 --- a/src/modules/opengl/opengl.c +++ b/src/modules/opengl/opengl.c @@ -82,39 +82,36 @@ void ffDestroyOpenGLOptions(FFOpenGLOptions* options) void ffParseOpenGLJsonObject(FFOpenGLOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - #if defined(__linux__) || defined(__FreeBSD__) - if (ffStrEqualsIgnCase(key, "library")) - { - int value; - const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { - { "auto", FF_OPENGL_LIBRARY_AUTO }, - { "egl", FF_OPENGL_LIBRARY_EGL }, - { "glx", FF_OPENGL_LIBRARY_GLX }, - { "osmesa", FF_OPENGL_LIBRARY_OSMESA }, - {}, - }); - if (error) - ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); - else - options->library = (FFOpenGLLibrary) value; - continue; - } - #endif + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + #if defined(__linux__) || defined(__FreeBSD__) + if (ffStrEqualsIgnCase(key, "library")) + { + int value; + const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { + { "auto", FF_OPENGL_LIBRARY_AUTO }, + { "egl", FF_OPENGL_LIBRARY_EGL }, + { "glx", FF_OPENGL_LIBRARY_GLX }, + { "osmesa", FF_OPENGL_LIBRARY_OSMESA }, + {}, + }); + if (error) + ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); + else + options->library = (FFOpenGLLibrary) value; + continue; } + #endif + + ffPrintError(FF_OPENGL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/os/os.c b/src/modules/os/os.c index b0e9ac1fbf..e5e5d58ee3 100644 --- a/src/modules/os/os.c +++ b/src/modules/os/os.c @@ -160,20 +160,17 @@ void ffDestroyOSOptions(FFOSOptions* options) void ffParseOSJsonObject(FFOSOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - ffPrintError(FF_OS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + ffPrintError(FF_OS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/packages/packages.c b/src/modules/packages/packages.c index 6d9374f198..21599e07a0 100644 --- a/src/modules/packages/packages.c +++ b/src/modules/packages/packages.c @@ -120,20 +120,17 @@ void ffDestroyPackagesOptions(FFPackagesOptions* options) void ffParsePackagesJsonObject(FFPackagesOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_PACKAGES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/player/player.c b/src/modules/player/player.c index cca9a240f3..4dca659169 100644 --- a/src/modules/player/player.c +++ b/src/modules/player/player.c @@ -96,20 +96,17 @@ void ffDestroyPlayerOptions(FFPlayerOptions* options) void ffParsePlayerJsonObject(FFPlayerOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - ffPrintError(FF_PLAYER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + ffPrintError(FF_PLAYER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/poweradapter/poweradapter.c b/src/modules/poweradapter/poweradapter.c index c3babafbd3..7fcd772af4 100644 --- a/src/modules/poweradapter/poweradapter.c +++ b/src/modules/poweradapter/poweradapter.c @@ -86,20 +86,17 @@ void ffDestroyPowerAdapterOptions(FFPowerAdapterOptions* options) void ffParsePowerAdapterJsonObject(FFPowerAdapterOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_POWERADAPTER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_POWERADAPTER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/processes/processes.c b/src/modules/processes/processes.c index b759184c22..fa2fc89bd3 100644 --- a/src/modules/processes/processes.c +++ b/src/modules/processes/processes.c @@ -54,20 +54,17 @@ void ffDestroyProcessesOptions(FFProcessesOptions* options) void ffParseProcessesJsonObject(FFProcessesOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_PROCESSES_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c index 3c71b9b68a..3dbbc287c3 100644 --- a/src/modules/publicip/publicip.c +++ b/src/modules/publicip/publicip.c @@ -129,32 +129,29 @@ void ffDestroyPublicIpOptions(FFPublicIpOptions* options) void ffParsePublicIpJsonObject(FFPublicIpOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "url")) - { - ffStrbufSetS(&options->url, yyjson_get_str(val)); - continue; - } - - if (ffStrEqualsIgnCase(key, "timeout")) - { - options->timeout = (uint32_t) yyjson_get_uint(val); - continue; - } + if (ffStrEqualsIgnCase(key, "url")) + { + ffStrbufSetS(&options->url, yyjson_get_str(val)); + continue; + } - ffPrintError(FF_PUBLICIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "timeout")) + { + options->timeout = (uint32_t) yyjson_get_uint(val); + continue; } + + ffPrintError(FF_PUBLICIP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/separator/separator.c b/src/modules/separator/separator.c index dd860a3b03..0eaceff6a8 100644 --- a/src/modules/separator/separator.c +++ b/src/modules/separator/separator.c @@ -102,23 +102,20 @@ void ffDestroySeparatorOptions(FFSeparatorOptions* options) void ffParseSeparatorJsonObject(FFSeparatorOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffStrEqualsIgnCase(key, "string")) - { - ffStrbufSetS(&options->string, yyjson_get_str(val)); - continue; - } + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); + if (ffStrEqualsIgnCase(key, "string")) + { + ffStrbufSetS(&options->string, yyjson_get_str(val)); + continue; } + + ffPrintErrorString(FF_SEPARATOR_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/shell/shell.c b/src/modules/shell/shell.c index b9c7a4dae5..d7e2cfa6dd 100644 --- a/src/modules/shell/shell.c +++ b/src/modules/shell/shell.c @@ -66,20 +66,17 @@ void ffDestroyShellOptions(FFShellOptions* options) void ffParseShellJsonObject(FFShellOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_SHELL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/sound/sound.c b/src/modules/sound/sound.c index f206c2b184..707556360c 100644 --- a/src/modules/sound/sound.c +++ b/src/modules/sound/sound.c @@ -119,36 +119,33 @@ void ffDestroySoundOptions(FFSoundOptions* options) void ffParseSoundJsonObject(FFSoundOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + if (ffStrEqualsIgnCase(key, "soundType")) { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - if (ffStrEqualsIgnCase(key, "soundType")) - { - int value; - const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { - { "main", FF_SOUND_TYPE_MAIN }, - { "active", FF_SOUND_TYPE_ACTIVE }, - { "all", FF_SOUND_TYPE_ALL }, - {}, - }); - if (error) - ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); - else - options->soundType = (FFSoundType) value; - continue; - } - - ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + int value; + const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) { + { "main", FF_SOUND_TYPE_MAIN }, + { "active", FF_SOUND_TYPE_ACTIVE }, + { "all", FF_SOUND_TYPE_ALL }, + {}, + }); + if (error) + ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Invalid %s value: %s", key, error); + else + options->soundType = (FFSoundType) value; + continue; } + + ffPrintError(FF_SOUND_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/swap/swap.c b/src/modules/swap/swap.c index aa1b1b9a18..be23eefec2 100644 --- a/src/modules/swap/swap.c +++ b/src/modules/swap/swap.c @@ -94,20 +94,17 @@ void ffDestroySwapOptions(FFSwapOptions* options) void ffParseSwapJsonObject(FFSwapOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_SWAP_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/terminal/terminal.c b/src/modules/terminal/terminal.c index 2cba2e3022..5afa31c190 100644 --- a/src/modules/terminal/terminal.c +++ b/src/modules/terminal/terminal.c @@ -67,20 +67,17 @@ void ffDestroyTerminalOptions(FFTerminalOptions* options) void ffParseTerminalJsonObject(FFTerminalOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_TERMINAL_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/terminalfont/terminalfont.c b/src/modules/terminalfont/terminalfont.c index f0bb786c4b..755fc302dd 100644 --- a/src/modules/terminalfont/terminalfont.c +++ b/src/modules/terminalfont/terminalfont.c @@ -70,20 +70,17 @@ void ffDestroyTerminalFontOptions(FFTerminalFontOptions* options) void ffParseTerminalFontJsonObject(FFTerminalFontOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_TERMINALFONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_TERMINALFONT_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/terminalsize/terminalsize.c b/src/modules/terminalsize/terminalsize.c index 0f10f2c6c0..f1ad620bc2 100644 --- a/src/modules/terminalsize/terminalsize.c +++ b/src/modules/terminalsize/terminalsize.c @@ -62,20 +62,17 @@ void ffDestroyTerminalSizeOptions(FFTerminalSizeOptions* options) void ffParseTerminalSizeJsonObject(FFTerminalSizeOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_TERMINALSIZE_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/theme/theme.c b/src/modules/theme/theme.c index e54b33ed6a..025e2c78f6 100644 --- a/src/modules/theme/theme.c +++ b/src/modules/theme/theme.c @@ -53,20 +53,17 @@ void ffDestroyThemeOptions(FFThemeOptions* options) void ffParseThemeJsonObject(FFThemeOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_THEME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/title/title.c b/src/modules/title/title.c index b0730cab4b..8374cd10b5 100644 --- a/src/modules/title/title.c +++ b/src/modules/title/title.c @@ -103,43 +103,40 @@ void ffDestroyTitleOptions(FFTitleOptions* options) void ffParseTitleJsonObject(FFTitleOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - if (ffStrEqualsIgnCase(key, "fqdn")) - { - options->fqdn = yyjson_get_bool(val); - continue; - } - - if (ffStrEqualsIgnCase(key, "color")) - { - if (!yyjson_is_obj(val)) - continue; - - yyjson_val* color = yyjson_obj_get(val, "user"); - if (color) - ffOptionParseColor(yyjson_get_str(color), &options->colorUser); - color = yyjson_obj_get(val, "at"); - if (color) - ffOptionParseColor(yyjson_get_str(color), &options->colorAt); - color = yyjson_obj_get(val, "host"); - if (color) - ffOptionParseColor(yyjson_get_str(color), &options->colorHost); + if (ffStrEqualsIgnCase(key, "fqdn")) + { + options->fqdn = yyjson_get_bool(val); + continue; + } + + if (ffStrEqualsIgnCase(key, "color")) + { + if (!yyjson_is_obj(val)) continue; - } - ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); + yyjson_val* color = yyjson_obj_get(val, "user"); + if (color) + ffOptionParseColor(yyjson_get_str(color), &options->colorUser); + color = yyjson_obj_get(val, "at"); + if (color) + ffOptionParseColor(yyjson_get_str(color), &options->colorAt); + color = yyjson_obj_get(val, "host"); + if (color) + ffOptionParseColor(yyjson_get_str(color), &options->colorHost); + continue; } + + ffPrintErrorString(FF_TITLE_MODULE_NAME, 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "Unknown JSON key %s", key); } } diff --git a/src/modules/uptime/uptime.c b/src/modules/uptime/uptime.c index 9f96b6d167..1574209e0a 100644 --- a/src/modules/uptime/uptime.c +++ b/src/modules/uptime/uptime.c @@ -102,20 +102,17 @@ void ffDestroyUptimeOptions(FFUptimeOptions* options) void ffParseUptimeJsonObject(FFUptimeOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_UPTIME_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/users/users.c b/src/modules/users/users.c index 242566a0cb..0c12636208 100644 --- a/src/modules/users/users.c +++ b/src/modules/users/users.c @@ -66,20 +66,17 @@ void ffDestroyUsersOptions(FFUsersOptions* options) void ffParseUsersJsonObject(FFUsersOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_USERS_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/vulkan/vulkan.c b/src/modules/vulkan/vulkan.c index d24c82d04d..bb66ae6044 100644 --- a/src/modules/vulkan/vulkan.c +++ b/src/modules/vulkan/vulkan.c @@ -66,20 +66,17 @@ void ffDestroyVulkanOptions(FFVulkanOptions* options) void ffParseVulkanJsonObject(FFVulkanOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_VULKAN_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/wallpaper/wallpaper.c b/src/modules/wallpaper/wallpaper.c index 03128c48c7..e51ba590a0 100644 --- a/src/modules/wallpaper/wallpaper.c +++ b/src/modules/wallpaper/wallpaper.c @@ -65,20 +65,17 @@ void ffDestroyWallpaperOptions(FFWallpaperOptions* options) void ffParseWallpaperJsonObject(FFWallpaperOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_WALLPAPER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c index 61e0bdeaaa..8ed45a624c 100644 --- a/src/modules/weather/weather.c +++ b/src/modules/weather/weather.c @@ -100,38 +100,35 @@ void ffDestroyWeatherOptions(FFWeatherOptions* options) void ffParseWeatherJsonObject(FFWeatherOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + if (ffStrEqualsIgnCase(key, "location")) + { + ffStrbufSetS(&options->location, yyjson_get_str(val)); + continue; + } + + if (ffStrEqualsIgnCase(key, "outputFormat")) { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; - - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; - - if (ffStrEqualsIgnCase(key, "location")) - { - ffStrbufSetS(&options->location, yyjson_get_str(val)); - continue; - } - - if (ffStrEqualsIgnCase(key, "outputFormat")) - { - ffStrbufSetS(&options->outputFormat, yyjson_get_str(val)); - continue; - } - - if (ffStrEqualsIgnCase(key, "timeout")) - { - options->timeout = (uint32_t) yyjson_get_uint(val); - continue; - } - - ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + ffStrbufSetS(&options->outputFormat, yyjson_get_str(val)); + continue; } + + if (ffStrEqualsIgnCase(key, "timeout")) + { + options->timeout = (uint32_t) yyjson_get_uint(val); + continue; + } + + ffPrintError(FF_WEATHER_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/wifi/wifi.c b/src/modules/wifi/wifi.c index 608ab86b05..afa0269172 100644 --- a/src/modules/wifi/wifi.c +++ b/src/modules/wifi/wifi.c @@ -93,20 +93,17 @@ void ffDestroyWifiOptions(FFWifiOptions* options) void ffParseWifiJsonObject(FFWifiOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_WIFI_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/wm/wm.c b/src/modules/wm/wm.c index 101d93d7b7..f02efbf4e1 100644 --- a/src/modules/wm/wm.c +++ b/src/modules/wm/wm.c @@ -64,20 +64,17 @@ void ffDestroyWMOptions(FFWMOptions* options) void ffParseWMJsonObject(FFWMOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_WM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_WM_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } diff --git a/src/modules/wmtheme/wmtheme.c b/src/modules/wmtheme/wmtheme.c index 9a4edb19f5..438e7f8326 100644 --- a/src/modules/wmtheme/wmtheme.c +++ b/src/modules/wmtheme/wmtheme.c @@ -53,20 +53,17 @@ void ffDestroyWMThemeOptions(FFWMThemeOptions* options) void ffParseWMThemeJsonObject(FFWMThemeOptions* options, yyjson_val* module) { - if (module) + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) { - yyjson_val *key_, *val; - size_t idx, max; - yyjson_obj_foreach(module, idx, max, key_, val) - { - const char* key = yyjson_get_str(key_); - if(ffStrEqualsIgnCase(key, "type")) - continue; + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; - if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) - continue; + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; - ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); - } + ffPrintError(FF_WMTHEME_DISPLAY_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); } } From ea2a26bd5786cbd68ecba27c89ae8ecad5b349ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Thu, 17 Aug 2023 16:13:05 +0800 Subject: [PATCH 19/37] Battery (Linux): fix build --- src/modules/battery/battery.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c index 2161be6295..4ad2929435 100644 --- a/src/modules/battery/battery.c +++ b/src/modules/battery/battery.c @@ -163,7 +163,7 @@ void ffParseBatteryJsonObject(FFBatteryOptions* options, yyjson_val* module) #ifdef __linux__ if (ffStrEqualsIgnCase(key, "dir")) { - ffStrbufSetS(&options.dir, yyjson_get_str(val)); + ffStrbufSetS(&options->dir, yyjson_get_str(val)); continue; } #endif From 67fe1e66b515b9f4cf5b73f97082a20f0e5f544b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Thu, 17 Aug 2023 17:15:30 +0800 Subject: [PATCH 20/37] Windows: fix build --- src/common/option.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/common/option.h b/src/common/option.h index 690716924d..c773761884 100644 --- a/src/common/option.h +++ b/src/common/option.h @@ -21,9 +21,9 @@ static inline void ffOptionInitModuleBaseInfo( ) { baseInfo->name = name; - baseInfo->parseCommandOptions = parseCommandOptions; - baseInfo->parseJsonObject = parseJsonObject; - baseInfo->printModule = printModule; + baseInfo->parseCommandOptions = (__typeof__(baseInfo->parseCommandOptions)) parseCommandOptions; + baseInfo->parseJsonObject = (__typeof__(baseInfo->parseJsonObject)) parseJsonObject; + baseInfo->printModule = (__typeof__(baseInfo->printModule)) printModule; } typedef struct FFModuleArgs From 55b9e274b664a82f55fa4b47e00b017794d50bd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Fri, 18 Aug 2023 09:52:21 +0800 Subject: [PATCH 21/37] Disk (BSD): try detecting disk label --- src/detection/disk/disk_bsd.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/detection/disk/disk_bsd.c b/src/detection/disk/disk_bsd.c index 746a17052d..dd57f48648 100644 --- a/src/detection/disk/disk_bsd.c +++ b/src/detection/disk/disk_bsd.c @@ -3,6 +3,8 @@ #include #ifdef __FreeBSD__ +#include + static void detectFsInfo(struct statfs* fs, FFDisk* disk) { if( @@ -21,6 +23,9 @@ static void detectFsInfo(struct statfs* fs, FFDisk* disk) disk->type = FF_DISK_TYPE_REGULAR_BIT; ffStrbufInit(&disk->name); + struct disklabel* lab = getdiskbyname(fs->f_mntfromname); + if(lab) + ffStrbufSetS(&disk->name, lab->d_packname); } #else void detectFsInfo(struct statfs* fs, FFDisk* disk); From 77e0d9dba144d87ecc0fa1a787158c97e16d8da5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Fri, 18 Aug 2023 13:28:07 +0800 Subject: [PATCH 22/37] JsonConfig: prepare for module weather and public ip --- src/common/jsonconfig.c | 43 ++++++++++++++++++++++++++----- src/common/jsonconfig.h | 8 +++--- src/detection/cpuusage/cpuusage.c | 2 ++ src/fastfetch.c | 12 ++++++--- src/modules/publicip/publicip.c | 6 +++++ src/modules/weather/weather.c | 6 +++++ 6 files changed, 63 insertions(+), 14 deletions(-) diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index 8e1ecdaaf9..2c6b8c8d08 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -231,7 +231,36 @@ static bool parseModuleJsonObject(const char* type, yyjson_val* module) } } -static const char* printJsonConfig(void) +static void prepareModuleJsonObject(const char* type, yyjson_val* module) +{ + FFconfig* cfg = &instance.config; + switch (type[0]) + { + case 'b': case 'B': { + if (ffStrEqualsIgnCase(type, FF_CPUUSAGE_MODULE_NAME)) + ffPrepareCPUUsage(); + break; + } + case 'p': case 'P': { + if (ffStrEqualsIgnCase(type, FF_PUBLICIP_MODULE_NAME)) + { + if (module) ffParsePublicIpJsonObject(&cfg->publicIP, module); + ffPreparePublicIp(&cfg->publicIP); + } + break; + } + case 'w': case 'W': { + if (ffStrEqualsIgnCase(type, FF_WEATHER_MODULE_NAME)) + { + if (module) ffParseWeatherJsonObject(&cfg->weather, module); + ffPrepareWeather(&cfg->weather); + } + break; + } + } +} + +static const char* printJsonConfig(bool prepare) { yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc); assert(root); @@ -248,7 +277,7 @@ static const char* printJsonConfig(void) yyjson_arr_foreach(modules, idx, max, item) { uint64_t ms = 0; - if(__builtin_expect(instance.config.stat, false)) + if(!prepare && instance.config.stat) ms = ffTimeGetTick(); yyjson_val* module = item; @@ -265,10 +294,12 @@ static const char* printJsonConfig(void) else return "modules must be an array of strings or objects"; - if(!parseModuleJsonObject(type, module)) + if(prepare) + prepareModuleJsonObject(type, module); + else if(!parseModuleJsonObject(type, module)) return "Unknown module type"; - if(__builtin_expect(instance.config.stat, false)) + if(!prepare && instance.config.stat) { char str[32]; int len = snprintf(str, sizeof str, "%" PRIu64 "ms", ffTimeGetTick() - ms); @@ -548,9 +579,9 @@ const char* ffParseLibraryJsonConfig(void) return NULL; } -void ffPrintJsonConfig(void) +void ffPrintJsonConfig(bool prepare) { - const char* error = printJsonConfig(); + const char* error = printJsonConfig(prepare); if (error) ffPrintErrorString("JsonConfig", 0, NULL, FF_PRINT_TYPE_NO_CUSTOM_KEY, "%s", error); } diff --git a/src/common/jsonconfig.h b/src/common/jsonconfig.h index 7cf6a96e0c..e701cae864 100644 --- a/src/common/jsonconfig.h +++ b/src/common/jsonconfig.h @@ -4,7 +4,7 @@ bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs); const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[]); -void ffPrintJsonConfig(); -const char* ffParseGeneralJsonConfig(); -const char* ffParseDisplayJsonConfig(); -const char* ffParseLibraryJsonConfig(); +void ffPrintJsonConfig(bool prepare); +const char* ffParseGeneralJsonConfig(void); +const char* ffParseDisplayJsonConfig(void); +const char* ffParseLibraryJsonConfig(void); diff --git a/src/detection/cpuusage/cpuusage.c b/src/detection/cpuusage/cpuusage.c index f12cec2578..563c6fae52 100644 --- a/src/detection/cpuusage/cpuusage.c +++ b/src/detection/cpuusage/cpuusage.c @@ -35,6 +35,8 @@ const char* ffGetCpuUsageResult(double* result) if(inUseAll2 != inUseAll1) { *result = (double)(inUseAll2 - inUseAll1) / (double)(totalAll2 - totalAll1) * 100; + inUseAll1 = inUseAll2; + totalAll1 = totalAll2; return NULL; } else diff --git a/src/fastfetch.c b/src/fastfetch.c index 6387b9738a..0e95891605 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -564,7 +564,7 @@ static bool parseJsoncFile(const char* path) { if (error.code != YYJSON_READ_ERROR_FILE_OPEN) { - fprintf(stderr, "ERROR: failed to parse JSON config file `%s` at pos %zu: %s\n", path, error.pos, error.msg); + fprintf(stderr, "Error: failed to parse JSON config file `%s` at pos %zu: %s\n", path, error.pos, error.msg); exit(477); } return false; @@ -1256,7 +1256,11 @@ int main(int argc, const char** argv) } } - if(data.structure.length > 0 || !instance.state.configDoc) + const bool useJsonConfig = data.structure.length == 0 && instance.state.configDoc; + + if(useJsonConfig) + ffPrintJsonConfig(true); + else { //If we don't have a custom structure, use the default one if(data.structure.length == 0) @@ -1281,9 +1285,9 @@ int main(int argc, const char** argv) if (!instance.config.noBuffer) fflush(stdout); #endif - if (data.structure.length == 0 && instance.state.configDoc) + if (useJsonConfig) { - ffPrintJsonConfig(); + ffPrintJsonConfig(false); } else { diff --git a/src/modules/publicip/publicip.c b/src/modules/publicip/publicip.c index 3dbbc287c3..6097b54a38 100644 --- a/src/modules/publicip/publicip.c +++ b/src/modules/publicip/publicip.c @@ -19,6 +19,12 @@ static inline void wrapYyjsonFree(yyjson_doc** doc) void ffPreparePublicIp(FFPublicIpOptions* options) { + if (status != -1) + { + fputs("Error: " FF_PUBLICIP_DISPLAY_NAME " can only be used once due to internal limitations\n", stderr); + exit(1); + } + if (options->url.length == 0) status = ffNetworkingSendHttpRequest(&state, "ipinfo.io", "/json", NULL); else diff --git a/src/modules/weather/weather.c b/src/modules/weather/weather.c index 8ed45a624c..68d18d5507 100644 --- a/src/modules/weather/weather.c +++ b/src/modules/weather/weather.c @@ -11,6 +11,12 @@ static int status = -1; void ffPrepareWeather(FFWeatherOptions* options) { + if (status != -1) + { + fputs("Error: " FF_WEATHER_MODULE_NAME " can only be used once due to internal limitations\n", stderr); + exit(1); + } + FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/"); if (options->location.length) ffStrbufAppend(&path, &options->location); From 5ebdd9a989755b087e2de4097b8d3e0a90be2c04 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Fri, 18 Aug 2023 13:44:48 +0800 Subject: [PATCH 23/37] Logo (Builtin): add MOS Ref: https://github.com/dylanaraps/neofetch/pull/2364 --- README.md | 2 +- src/logo/ascii/mos.txt | 18 ++++++++++++++++++ src/logo/builtin.c | 9 +++++++++ 3 files changed, 28 insertions(+), 1 deletion(-) create mode 100644 src/logo/ascii/mos.txt diff --git a/README.md b/README.md index c5aabe6154..f0ea5755a3 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,7 @@ Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsa ``` -AIX, AlmaLinux, Alpine, Alpine2Small, AlpineSmall, Alter, Amazon, AmogOS, Anarchy, Android, AndroidSmall, Antergos, Antix, AoscOS, AoscOsRetro, AoscOsRetro_small, Aperture, Apple, AppleSmall, Apricity, Arch, Arch2, ArchBox, Archcraft, Archcraft2, Archlabs, ArchSmall, ArchStrike, ArcoLinux, ArcoLinuxSmall, ArseLinux, Artix, Artix2Small, ArtixSmall, Arya, Asahi, Aster, AsteroidOS, AstOS, Astra, Ataraxia, Athena, Bedrock, BigLinux, Bitrig, BlackArch, BlackPanther, BLAG, BlankOn, BlueLight, Bodhi, Bonsai, BSD, BunsenLabs, CachyOS, CachyOSSmall, Calculate, CalinixOS, CalinixOSSmall, Carbs, CBL-Mariner, CelOS, Center, CentOS, CentOSSmall, Chakra, ChaletOS, Chapeau, ChonkySealOS, Chrom, Cleanjaro, CleanjaroSmall, ClearLinux, ClearOS, Clover, Cobalt, Condres, ContainerLinux, CRUX, CRUXSmall, CrystalLinux, Cucumber, CutefishOS, CuteOS, CyberOS, Dahlia, DarkOS, Debian, DebianSmall, Deepin, DesaOS, Devuan, DevuanSmall, DietPi, DracOS, DragonFly, DragonFlyOld, DragonFlySmall, Drauger, Droidian, Elementary, ElementarySmall, Elive, EncryptOS, Endeavour, Endless, Enso, EuroLinux, EvolutionOS, Exherbo, ExodiaPredator, Fedora, FedoraOld, FedoraSmall, FemboyOS, Feren, Finnix, Floflis, FreeBSD, FreeBSDSmall, FreeMiNT, Frugalware, Funtoo, GalliumOS, Garuda, GarudaDragon, GarudaSmall, Gentoo, GentooSmall, GhostBSD, Glaucus, GNewSense, Gnome, GNU, GoboLinux, GrapheneOS, Grombyang, Guix, GuixSmall, Haiku, HaikuSmall, HamoniKR, HarDClanZ, HardenedBSD, Hash, Huayra, Hybrid, HydroOS, Hyperbola, HyperbolaSmall, Iglunix, InstantOS, IRIX, Itc, Januslinux, Kaisen, Kali, KaliSmall, KaOS, KDENeon, Kibojoe, KISSLinux, Kogaion, Korora, KrassOS, KSLinux, Kubuntu, LangitKetujuh, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, Laxeros, LEDE, LibreELEC, Linspire, Linux, LinuxLight, LinuxLightSmall, LinuxMint, LinuxMintOld, LinuxMintSmall, LinuxSmall, Live_Raizo, LMDE, Lunar, MacOS, MacOS2, MacOS2Small, MacOSSmall, Mageia, MageiaSmall, MagpieOS, Mandriva, Manjaro, ManjaroSmall, MassOS, MatuusOS, MaUI, Meowix, Mer, Minix, Mint, MintOld, MintSmall, MiracleLinux, Msys2, MX, MXSmall, Namib, Nekos, Neptune, NetBSD, NetRunner, Nitrux, NixOS, NixOS_small, NixOsOld, NixOsSmall, Nobara, NomadBSD, Nurunner, NuTyX, Obarun, OBRevenge, OmniOS, OpenBSD, OpenBSDSmall, OpenEuler, OpenIndiana, OpenKylin, OpenMamba, OpenMandriva, OpenStage, OpenSuse, OpenSuseLeap, OpenSuseSmall, OpenSuseTumbleweed, OpenWrt, OPNsense, Oracle, Orchid, OrchidSmall, OS_Elbrus, OSMC, OSX, OSXSmall, PacBSD, Panwah, Parabola, ParabolaSmall, Parch, Pardus, Parrot, Parsix, PCBSD, PCLinuxOS, PearOS, Pengwin, Pentoo, Peppermint, PhyOS, Pisi, PNMLinux, Pop, PopSmall, Porteus, PostMarketOS, PostMarketOSSmall, Proxmox, PuffOS, Puppy, PureOS, PureOSSmall, Q4OS, Qubes, Qubyt, Quibian, Radix, Raspbian, RaspbianSmall, RavynOS, Reborn, RebornSmall, RedCore, RedHatEnterpriseLinux, RedHatEnterpriseLinux_old, RedstarOS, Refracted Devuan, Regata, Regolith, RhaymOS, RockyLinux, RockyLinuxSmall, RosaLinux, Sabayon, Sabotage, Sailfish, SalentOS, SalientOS, Salix, SambaBOX, Sasanqua, Scientific, Semc, Septor, Serene, SharkLinux, ShastraOS, Siduction, SkiffOS, Slackel, Slackware, SlackwareSmall, Slitaz, SmartOS, Soda, Solaris, SolarisSmall, Solus, SourceMage, Sparky, Star, SteamOS, StockLinux, Sulin, Suse, SuseSmall, Swagarch, T2, Tails, TeArch, TorizonCore, Trisquel, Twister, Ubuntu, Ubuntu2Old, Ubuntu2Small, UbuntuBudgie, UbuntuCinnamon, UbuntuGnome, UbuntuKde, UbuntuKylin, UbuntuMate, UbuntuOld, UbuntuSmall, UbuntuStudio, UbuntuSway, UbuntuTouch, UbuntuUnity, Ultramarine, Univalent, Univention, UOS, UrukOS, Uwuntu, Vanilla, Venom, Vnux, Void, VoidSmall, Vzlinux, WiiLinuxNgx, Windows, Windows11, Windows11Small, Windows8, Windows95, Xferience, YiffOS, Zorin +AIX, AlmaLinux, Alpine, Alpine2Small, AlpineSmall, Alter, Amazon, AmogOS, Anarchy, Android, AndroidSmall, Antergos, Antix, AoscOS, AoscOsRetro, AoscOsRetro_small, Aperture, Apple, AppleSmall, Apricity, Arch, Arch2, ArchBox, Archcraft, Archcraft2, Archlabs, ArchSmall, ArchStrike, ArcoLinux, ArcoLinuxSmall, ArseLinux, Artix, Artix2Small, ArtixSmall, Arya, Asahi, Aster, AsteroidOS, AstOS, Astra, Ataraxia, Athena, Bedrock, BigLinux, Bitrig, BlackArch, BlackPanther, BLAG, BlankOn, BlueLight, Bodhi, Bonsai, BSD, BunsenLabs, CachyOS, CachyOSSmall, Calculate, CalinixOS, CalinixOSSmall, Carbs, CBL-Mariner, CelOS, Center, CentOS, CentOSSmall, Chakra, ChaletOS, Chapeau, ChonkySealOS, Chrom, Cleanjaro, CleanjaroSmall, ClearLinux, ClearOS, Clover, Cobalt, Condres, ContainerLinux, CRUX, CRUXSmall, CrystalLinux, Cucumber, CutefishOS, CuteOS, CyberOS, Dahlia, DarkOS, Debian, DebianSmall, Deepin, DesaOS, Devuan, DevuanSmall, DietPi, DracOS, DragonFly, DragonFlyOld, DragonFlySmall, Drauger, Droidian, Elementary, ElementarySmall, Elive, EncryptOS, Endeavour, Endless, Enso, EuroLinux, EvolutionOS, Exherbo, ExodiaPredator, Fedora, FedoraOld, FedoraSmall, FemboyOS, Feren, Finnix, Floflis, FreeBSD, FreeBSDSmall, FreeMiNT, Frugalware, Funtoo, GalliumOS, Garuda, GarudaDragon, GarudaSmall, Gentoo, GentooSmall, GhostBSD, Glaucus, GNewSense, Gnome, GNU, GoboLinux, GrapheneOS, Grombyang, Guix, GuixSmall, Haiku, HaikuSmall, HamoniKR, HarDClanZ, HardenedBSD, Hash, Huayra, Hybrid, HydroOS, Hyperbola, HyperbolaSmall, Iglunix, InstantOS, IRIX, Itc, Januslinux, Kaisen, Kali, KaliSmall, KaOS, KDENeon, Kibojoe, KISSLinux, Kogaion, Korora, KrassOS, KSLinux, Kubuntu, LangitKetujuh, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, Laxeros, LEDE, LibreELEC, Linspire, Linux, LinuxLight, LinuxLightSmall, LinuxMint, LinuxMintOld, LinuxMintSmall, LinuxSmall, Live_Raizo, LMDE, Lunar, MacOS, MacOS2, MacOS2Small, MacOSSmall, Mageia, MageiaSmall, MagpieOS, Mandriva, Manjaro, ManjaroSmall, MassOS, MatuusOS, MaUI, Meowix, Mer, Minix, Mint, MintOld, MintSmall, MiracleLinux, MOS, Msys2, MX, MXSmall, Namib, Nekos, Neptune, NetBSD, NetRunner, Nitrux, NixOS, NixOS_small, NixOsOld, NixOsSmall, Nobara, NomadBSD, Nurunner, NuTyX, Obarun, OBRevenge, OmniOS, OpenBSD, OpenBSDSmall, OpenEuler, OpenIndiana, OpenKylin, OpenMamba, OpenMandriva, OpenStage, OpenSuse, OpenSuseLeap, OpenSuseSmall, OpenSuseTumbleweed, OpenWrt, OPNsense, Oracle, Orchid, OrchidSmall, OS_Elbrus, OSMC, OSX, OSXSmall, PacBSD, Panwah, Parabola, ParabolaSmall, Parch, Pardus, Parrot, Parsix, PCBSD, PCLinuxOS, PearOS, Pengwin, Pentoo, Peppermint, PhyOS, Pisi, PNMLinux, Pop, PopSmall, Porteus, PostMarketOS, PostMarketOSSmall, Proxmox, PuffOS, Puppy, PureOS, PureOSSmall, Q4OS, Qubes, Qubyt, Quibian, Radix, Raspbian, RaspbianSmall, RavynOS, Reborn, RebornSmall, RedCore, RedHatEnterpriseLinux, RedHatEnterpriseLinux_old, RedstarOS, Refracted Devuan, Regata, Regolith, RhaymOS, RockyLinux, RockyLinuxSmall, RosaLinux, Sabayon, Sabotage, Sailfish, SalentOS, SalientOS, Salix, SambaBOX, Sasanqua, Scientific, Semc, Septor, Serene, SharkLinux, ShastraOS, Siduction, SkiffOS, Slackel, Slackware, SlackwareSmall, Slitaz, SmartOS, Soda, Solaris, SolarisSmall, Solus, SourceMage, Sparky, Star, SteamOS, StockLinux, Sulin, Suse, SuseSmall, Swagarch, T2, Tails, TeArch, TorizonCore, Trisquel, Twister, Ubuntu, Ubuntu2Old, Ubuntu2Small, UbuntuBudgie, UbuntuCinnamon, UbuntuGnome, UbuntuKde, UbuntuKylin, UbuntuMate, UbuntuOld, UbuntuSmall, UbuntuStudio, UbuntuSway, UbuntuTouch, UbuntuUnity, Ultramarine, Univalent, Univention, UOS, UrukOS, Uwuntu, Vanilla, Venom, Vnux, Void, VoidSmall, Vzlinux, WiiLinuxNgx, Windows, Windows11, Windows11Small, Windows8, Windows95, Xferience, YiffOS, Zorin ``` Run `fastfetch --print-logos` to print them diff --git a/src/logo/ascii/mos.txt b/src/logo/ascii/mos.txt new file mode 100644 index 0000000000..7ac5d6a3fe --- /dev/null +++ b/src/logo/ascii/mos.txt @@ -0,0 +1,18 @@ + :--==========================--: +.-=================================. +-==================================- +==================================== +=======-....:==========:....:======= +=======: -======-. .======= +=======: :====- .======= +=======: :==: .======= +=======: .. .======= +=======: .: .: .======= +=======: .=- :=: .======= +=======: .===. .-==: .======= +=======: .==========: .======= +=======: :==========: :======= +==================================== +-=================================== +.==================================: + :--===========================-:. diff --git a/src/logo/builtin.c b/src/logo/builtin.c index 22f2d44061..c196dfab6a 100644 --- a/src/logo/builtin.c +++ b/src/logo/builtin.c @@ -2332,6 +2332,15 @@ static const FFlogo M[] = { .colorKeys = FF_COLOR_FG_256 "29", .colorTitle = FF_COLOR_FG_WHITE, }, + // MOS + { + .names = {"MOS"}, + .lines = FASTFETCH_DATATEXT_LOGO_MOS, + .colors = { + FF_COLOR_FG_CYAN, + FF_COLOR_FG_BLUE, + }, + }, // Msys2 { .names = {"Msys2"}, From c70b9cb84ebccf1c7b1b10dbc28ac176f9a842ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Fri, 18 Aug 2023 21:21:34 +0800 Subject: [PATCH 24/37] Revert "Disk (BSD): try detecting disk label" Doesn't work This reverts commit 55b9e274b664a82f55fa4b47e00b017794d50bd5. --- src/detection/disk/disk_bsd.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/detection/disk/disk_bsd.c b/src/detection/disk/disk_bsd.c index dd57f48648..746a17052d 100644 --- a/src/detection/disk/disk_bsd.c +++ b/src/detection/disk/disk_bsd.c @@ -3,8 +3,6 @@ #include #ifdef __FreeBSD__ -#include - static void detectFsInfo(struct statfs* fs, FFDisk* disk) { if( @@ -23,9 +21,6 @@ static void detectFsInfo(struct statfs* fs, FFDisk* disk) disk->type = FF_DISK_TYPE_REGULAR_BIT; ffStrbufInit(&disk->name); - struct disklabel* lab = getdiskbyname(fs->f_mntfromname); - if(lab) - ffStrbufSetS(&disk->name, lab->d_packname); } #else void detectFsInfo(struct statfs* fs, FFDisk* disk); From f0a10fcc6d9365eadee0a967f1f2851e3135ab89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Fri, 18 Aug 2023 21:23:23 +0800 Subject: [PATCH 25/37] Disk (BSD): improve disk type detection --- src/detection/disk/disk_bsd.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/detection/disk/disk_bsd.c b/src/detection/disk/disk_bsd.c index 746a17052d..c4414d2a1e 100644 --- a/src/detection/disk/disk_bsd.c +++ b/src/detection/disk/disk_bsd.c @@ -3,19 +3,19 @@ #include #ifdef __FreeBSD__ +#include "util/stringUtils.h" + static void detectFsInfo(struct statfs* fs, FFDisk* disk) { - if( - ffStrbufStartsWithS(&disk->mountpoint, "/boot") || - ffStrbufStartsWithS(&disk->mountpoint, "/dev") || - ffStrbufStartsWithS(&disk->mountpoint, "/var") || - ffStrbufStartsWithS(&disk->mountpoint, "/tmp") || - ffStrbufStartsWithS(&disk->mountpoint, "/proc") || - ffStrbufStartsWithS(&disk->mountpoint, "/zroot") || - ffStrbufStartsWithS(&disk->mountpoint, "/compat/linux/") - ) + if(ffStrbufEqualS(&disk->filesystem, "zfs")) + { + disk->type = !ffStrStartsWith(fs->f_mntfromname, "zroot/") || ffStrStartsWith(fs->f_mntfromname, "zroot/ROOT/") + ? FF_DISK_TYPE_REGULAR_BIT + : FF_DISK_TYPE_SUBVOLUME_BIT; + } + else if(!ffStrStartsWith(fs->f_mntfromname, "/dev/")) disk->type = FF_DISK_TYPE_HIDDEN_BIT; - else if((fs->f_flags & MNT_NOSUID) || !(fs->f_flags & MNT_LOCAL)) + else if(!(fs->f_flags & MNT_LOCAL)) disk->type = FF_DISK_TYPE_EXTERNAL_BIT; else disk->type = FF_DISK_TYPE_REGULAR_BIT; From 125759dc75d30330f959a7c89a6a8932849a0523 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sat, 19 Aug 2023 10:02:07 +0800 Subject: [PATCH 26/37] Terminal: correctly detecting version and font on NixOS --- src/detection/terminalfont/terminalfont.c | 2 +- src/detection/terminalshell/terminalshell_linux.c | 13 ++++++++++--- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/src/detection/terminalfont/terminalfont.c b/src/detection/terminalfont/terminalfont.c index c080fdd7e0..8fcb7db6c7 100644 --- a/src/detection/terminalfont/terminalfont.c +++ b/src/detection/terminalfont/terminalfont.c @@ -354,7 +354,7 @@ static bool detectTerminalFontCommon(const FFTerminalShellResult* terminalShell, #ifndef _WIN32 else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalExe, "/dev/pts/")) ffStrbufAppendS(&terminalFont->error, "Terminal font detection is not supported on PTS"); - else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalPrettyName, "kitty")) + else if(ffStrbufIgnCaseEqualS(&terminalShell->terminalProcessName, "kitty")) detectKitty(terminalFont); else if(ffStrbufStartsWithIgnCaseS(&terminalShell->terminalExe, "/dev/tty")) detectTTY(terminalFont); diff --git a/src/detection/terminalshell/terminalshell_linux.c b/src/detection/terminalshell/terminalshell_linux.c index fa8be7e722..fb2f7d7558 100644 --- a/src/detection/terminalshell/terminalshell_linux.c +++ b/src/detection/terminalshell/terminalshell_linux.c @@ -375,12 +375,19 @@ const FFTerminalShellResult* ffDetectTerminalShell() ffStrbufInitS(&result.shellPrettyName, result.shellExeName); } + if(result.terminalExeName[0] == '.' && ffStrEndsWith(result.terminalExeName, "-wrapper")) + { + // For NixOS. Ref: #510 and https://github.com/NixOS/nixpkgs/pull/249428 + // We use terminalProcessName when detecting version and font, overriding it for simplication + ffStrbufSetNS( + &result.terminalProcessName, + (uint32_t) (strlen(result.terminalExeName) - strlen(".-wrapper")), + result.terminalExeName + 1); + } + if(ffStrbufEqualS(&result.terminalProcessName, "wezterm-gui")) ffStrbufInitStatic(&result.terminalPrettyName, "WezTerm"); - else if(ffStrbufEqualS(&result.terminalProcessName, ".kitty-wrapped")) - ffStrbufInitStatic(&result.terminalPrettyName, "kitty"); // #510 - #if defined(__linux__) || defined(__FreeBSD__) else if(ffStrbufStartsWithS(&result.terminalProcessName, "gnome-terminal-")) From c7f0172b256ea3f29e6e2ef25cd43fcc2c12614e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sat, 19 Aug 2023 11:10:14 +0800 Subject: [PATCH 27/37] CMake: Add option `ENABLE_SYSTEM_YYJSON` Fix: #525 --- CMakeLists.txt | 19 ++++++++++++++++++- src/common/option.h | 5 +++-- src/fastfetch.h | 6 +++++- 3 files changed, 26 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e12d945f8..1aa9041df0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -69,6 +69,7 @@ cmake_dependent_option(ENABLE_PULSE "Enable pulse" ON "LINUX OR BSD" OFF) cmake_dependent_option(ENABLE_DDCUTIL "Enable ddcutil" ON "LINUX" OFF) cmake_dependent_option(ENABLE_THREADS "Enable multithreading" ON "Threads_FOUND" OFF) cmake_dependent_option(ENABLE_PCI_MEMORY "Enable detecting GPU memory size with libpci" OFF "LINUX OR BSD" OFF) +cmake_dependent_option(ENABLE_SYSTEM_YYJSON "Use system provided (instead of fastfetch embeded) yyjson library" OFF "LINUX OR APPLE OR BSD OR WIN32 OR ANDROID" OFF) option(BUILD_TESTS "Build tests" OFF) # Also create test executables option(SET_TWEAK "Add tweak to project version" ON) # This is set to off by github actions for release builds @@ -251,7 +252,6 @@ file(GENERATE OUTPUT logo_builtin.h CONTENT "${LOGO_BUILTIN_H}") ####################### set(LIBFASTFETCH_SRC - src/3rdparty/yyjson/yyjson.c src/common/bar.c src/common/commandoption.c src/common/font.c @@ -605,9 +605,26 @@ if(NOT HAVE_WCWIDTH) list(APPEND LIBFASTFETCH_SRC src/3rdparty/mk_wcwidch/wcwidth.c) endif() +if(ENABLE_SYSTEM_YYJSON) + find_package(yyjson) + if(yyjson_FOUND) + message(STATUS "System provided yyjson is used") + else() + message(FATAL_ERROR "ENABLE_SYSTEM_YYJSON is set but system provided yyjson is not found") + endif() +else() + list(APPEND LIBFASTFETCH_SRC + src/3rdparty/yyjson/yyjson.c + ) +endif() + add_library(libfastfetch OBJECT ${LIBFASTFETCH_SRC} ) +if(yyjson_FOUND) + target_compile_definitions(libfastfetch PRIVATE FF_USE_SYSTEM_YYJSON) + target_link_libraries(libfastfetch PRIVATE yyjson) +endif() target_compile_definitions(libfastfetch PUBLIC _GNU_SOURCE _XOPEN_SOURCE) if(WIN32) diff --git a/src/common/option.h b/src/common/option.h index c773761884..342b48083e 100644 --- a/src/common/option.h +++ b/src/common/option.h @@ -1,14 +1,15 @@ #pragma once #include "util/FFstrbuf.h" -#include "3rdparty/yyjson/yyjson.h" + +struct yyjson_val; // Must be the first field of FFModuleOptions typedef struct FFModuleBaseInfo { const char* name; bool (*parseCommandOptions)(void* options, const char* key, const char* value); - void (*parseJsonObject)(void* options, yyjson_val *module); + void (*parseJsonObject)(void* options, struct yyjson_val *module); void (*printModule)(void* options); } FFModuleBaseInfo; diff --git a/src/fastfetch.h b/src/fastfetch.h index ce68fd8730..dd4b4a8214 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -8,7 +8,11 @@ #include #include -#include "3rdparty/yyjson/yyjson.h" +#ifdef FF_USE_SYSTEM_YYJSON + #include +#else + #include "3rdparty/yyjson/yyjson.h" +#endif #include "util/FFstrbuf.h" #include "util/FFlist.h" From 069c20be40b30ae3cc3fee5b51399ff2177b9b08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sat, 19 Aug 2023 02:16:04 -0400 Subject: [PATCH 28/37] Brightness: don't make DDC/CI a slow operation --- src/detection/brightness/brightness_apple.c | 4 +++- src/detection/brightness/brightness_linux.c | 9 +++------ src/detection/brightness/brightness_windows.cpp | 2 +- 3 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/detection/brightness/brightness_apple.c b/src/detection/brightness/brightness_apple.c index eaa21cdf06..e7e19fed2c 100644 --- a/src/detection/brightness/brightness_apple.c +++ b/src/detection/brightness/brightness_apple.c @@ -108,8 +108,10 @@ const char* ffDetectBrightness(FFlist* result) detectWithDisplayServices(displayServer, result); - if (instance.config.allowSlowOperations && displayServer->displays.length > result->length) + #ifdef __aarch64__ + if (displayServer->displays.length > result->length) detectWithDdcci(result); + #endif return NULL; } diff --git a/src/detection/brightness/brightness_linux.c b/src/detection/brightness/brightness_linux.c index 5168dd0d6e..8ab4e5f860 100644 --- a/src/detection/brightness/brightness_linux.c +++ b/src/detection/brightness/brightness_linux.c @@ -139,12 +139,9 @@ const char* ffDetectBrightness(FFlist* result) detectWithBacklight(result); #ifdef FF_HAVE_DDCUTIL - if (instance.config.allowSlowOperations) - { - const FFDisplayServerResult* displayServer = ffConnectDisplayServer(); - if (result->length < displayServer->displays.length) - detectWithDdcci(result); - } + const FFDisplayServerResult* displayServer = ffConnectDisplayServer(); + if (result->length < displayServer->displays.length) + detectWithDdcci(result); #endif return NULL; diff --git a/src/detection/brightness/brightness_windows.cpp b/src/detection/brightness/brightness_windows.cpp index dcde38502d..28f489b966 100644 --- a/src/detection/brightness/brightness_windows.cpp +++ b/src/detection/brightness/brightness_windows.cpp @@ -76,7 +76,7 @@ const char* ffDetectBrightness(FFlist* result) if (hasBuiltinDisplay(displayServer)) detectWithWmi(result); - if (instance.config.allowSlowOperations && result->length < displayServer->displays.length) + if (result->length < displayServer->displays.length) detectWithDdcci(displayServer, result); return NULL; } From 1a4a949dfec5175e1b05b5fa958792bdb80c5fef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sun, 20 Aug 2023 00:04:52 +0800 Subject: [PATCH 29/37] Logo (Builtin): add aerOS --- README.md | 2 +- src/logo/ascii/aeros.txt | 21 +++++++++++++++++++++ src/logo/builtin.c | 9 +++++++++ 3 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 src/logo/ascii/aeros.txt diff --git a/README.md b/README.md index f0ea5755a3..1b8f6f0673 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,7 @@ Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsa ``` -AIX, AlmaLinux, Alpine, Alpine2Small, AlpineSmall, Alter, Amazon, AmogOS, Anarchy, Android, AndroidSmall, Antergos, Antix, AoscOS, AoscOsRetro, AoscOsRetro_small, Aperture, Apple, AppleSmall, Apricity, Arch, Arch2, ArchBox, Archcraft, Archcraft2, Archlabs, ArchSmall, ArchStrike, ArcoLinux, ArcoLinuxSmall, ArseLinux, Artix, Artix2Small, ArtixSmall, Arya, Asahi, Aster, AsteroidOS, AstOS, Astra, Ataraxia, Athena, Bedrock, BigLinux, Bitrig, BlackArch, BlackPanther, BLAG, BlankOn, BlueLight, Bodhi, Bonsai, BSD, BunsenLabs, CachyOS, CachyOSSmall, Calculate, CalinixOS, CalinixOSSmall, Carbs, CBL-Mariner, CelOS, Center, CentOS, CentOSSmall, Chakra, ChaletOS, Chapeau, ChonkySealOS, Chrom, Cleanjaro, CleanjaroSmall, ClearLinux, ClearOS, Clover, Cobalt, Condres, ContainerLinux, CRUX, CRUXSmall, CrystalLinux, Cucumber, CutefishOS, CuteOS, CyberOS, Dahlia, DarkOS, Debian, DebianSmall, Deepin, DesaOS, Devuan, DevuanSmall, DietPi, DracOS, DragonFly, DragonFlyOld, DragonFlySmall, Drauger, Droidian, Elementary, ElementarySmall, Elive, EncryptOS, Endeavour, Endless, Enso, EuroLinux, EvolutionOS, Exherbo, ExodiaPredator, Fedora, FedoraOld, FedoraSmall, FemboyOS, Feren, Finnix, Floflis, FreeBSD, FreeBSDSmall, FreeMiNT, Frugalware, Funtoo, GalliumOS, Garuda, GarudaDragon, GarudaSmall, Gentoo, GentooSmall, GhostBSD, Glaucus, GNewSense, Gnome, GNU, GoboLinux, GrapheneOS, Grombyang, Guix, GuixSmall, Haiku, HaikuSmall, HamoniKR, HarDClanZ, HardenedBSD, Hash, Huayra, Hybrid, HydroOS, Hyperbola, HyperbolaSmall, Iglunix, InstantOS, IRIX, Itc, Januslinux, Kaisen, Kali, KaliSmall, KaOS, KDENeon, Kibojoe, KISSLinux, Kogaion, Korora, KrassOS, KSLinux, Kubuntu, LangitKetujuh, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, Laxeros, LEDE, LibreELEC, Linspire, Linux, LinuxLight, LinuxLightSmall, LinuxMint, LinuxMintOld, LinuxMintSmall, LinuxSmall, Live_Raizo, LMDE, Lunar, MacOS, MacOS2, MacOS2Small, MacOSSmall, Mageia, MageiaSmall, MagpieOS, Mandriva, Manjaro, ManjaroSmall, MassOS, MatuusOS, MaUI, Meowix, Mer, Minix, Mint, MintOld, MintSmall, MiracleLinux, MOS, Msys2, MX, MXSmall, Namib, Nekos, Neptune, NetBSD, NetRunner, Nitrux, NixOS, NixOS_small, NixOsOld, NixOsSmall, Nobara, NomadBSD, Nurunner, NuTyX, Obarun, OBRevenge, OmniOS, OpenBSD, OpenBSDSmall, OpenEuler, OpenIndiana, OpenKylin, OpenMamba, OpenMandriva, OpenStage, OpenSuse, OpenSuseLeap, OpenSuseSmall, OpenSuseTumbleweed, OpenWrt, OPNsense, Oracle, Orchid, OrchidSmall, OS_Elbrus, OSMC, OSX, OSXSmall, PacBSD, Panwah, Parabola, ParabolaSmall, Parch, Pardus, Parrot, Parsix, PCBSD, PCLinuxOS, PearOS, Pengwin, Pentoo, Peppermint, PhyOS, Pisi, PNMLinux, Pop, PopSmall, Porteus, PostMarketOS, PostMarketOSSmall, Proxmox, PuffOS, Puppy, PureOS, PureOSSmall, Q4OS, Qubes, Qubyt, Quibian, Radix, Raspbian, RaspbianSmall, RavynOS, Reborn, RebornSmall, RedCore, RedHatEnterpriseLinux, RedHatEnterpriseLinux_old, RedstarOS, Refracted Devuan, Regata, Regolith, RhaymOS, RockyLinux, RockyLinuxSmall, RosaLinux, Sabayon, Sabotage, Sailfish, SalentOS, SalientOS, Salix, SambaBOX, Sasanqua, Scientific, Semc, Septor, Serene, SharkLinux, ShastraOS, Siduction, SkiffOS, Slackel, Slackware, SlackwareSmall, Slitaz, SmartOS, Soda, Solaris, SolarisSmall, Solus, SourceMage, Sparky, Star, SteamOS, StockLinux, Sulin, Suse, SuseSmall, Swagarch, T2, Tails, TeArch, TorizonCore, Trisquel, Twister, Ubuntu, Ubuntu2Old, Ubuntu2Small, UbuntuBudgie, UbuntuCinnamon, UbuntuGnome, UbuntuKde, UbuntuKylin, UbuntuMate, UbuntuOld, UbuntuSmall, UbuntuStudio, UbuntuSway, UbuntuTouch, UbuntuUnity, Ultramarine, Univalent, Univention, UOS, UrukOS, Uwuntu, Vanilla, Venom, Vnux, Void, VoidSmall, Vzlinux, WiiLinuxNgx, Windows, Windows11, Windows11Small, Windows8, Windows95, Xferience, YiffOS, Zorin +AerOS, AIX, AlmaLinux, Alpine, Alpine2Small, AlpineSmall, Alter, Amazon, AmogOS, Anarchy, Android, AndroidSmall, Antergos, Antix, AoscOS, AoscOsRetro, AoscOsRetro_small, Aperture, Apple, AppleSmall, Apricity, Arch, Arch2, ArchBox, Archcraft, Archcraft2, Archlabs, ArchSmall, ArchStrike, ArcoLinux, ArcoLinuxSmall, ArseLinux, Artix, Artix2Small, ArtixSmall, Arya, Asahi, Aster, AsteroidOS, AstOS, Astra, Ataraxia, Athena, Bedrock, BigLinux, Bitrig, BlackArch, BlackPanther, BLAG, BlankOn, BlueLight, Bodhi, Bonsai, BSD, BunsenLabs, CachyOS, CachyOSSmall, Calculate, CalinixOS, CalinixOSSmall, Carbs, CBL-Mariner, CelOS, Center, CentOS, CentOSSmall, Chakra, ChaletOS, Chapeau, ChonkySealOS, Chrom, Cleanjaro, CleanjaroSmall, ClearLinux, ClearOS, Clover, Cobalt, Condres, ContainerLinux, CRUX, CRUXSmall, CrystalLinux, Cucumber, CutefishOS, CuteOS, CyberOS, Dahlia, DarkOS, Debian, DebianSmall, Deepin, DesaOS, Devuan, DevuanSmall, DietPi, DracOS, DragonFly, DragonFlyOld, DragonFlySmall, Drauger, Droidian, Elementary, ElementarySmall, Elive, EncryptOS, Endeavour, Endless, Enso, EuroLinux, EvolutionOS, Exherbo, ExodiaPredator, Fedora, FedoraOld, FedoraSmall, FemboyOS, Feren, Finnix, Floflis, FreeBSD, FreeBSDSmall, FreeMiNT, Frugalware, Funtoo, GalliumOS, Garuda, GarudaDragon, GarudaSmall, Gentoo, GentooSmall, GhostBSD, Glaucus, GNewSense, Gnome, GNU, GoboLinux, GrapheneOS, Grombyang, Guix, GuixSmall, Haiku, HaikuSmall, HamoniKR, HarDClanZ, HardenedBSD, Hash, Huayra, Hybrid, HydroOS, Hyperbola, HyperbolaSmall, Iglunix, InstantOS, IRIX, Itc, Januslinux, Kaisen, Kali, KaliSmall, KaOS, KDENeon, Kibojoe, KISSLinux, Kogaion, Korora, KrassOS, KSLinux, Kubuntu, LangitKetujuh, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, LAST, Laxeros, LEDE, LibreELEC, Linspire, Linux, LinuxLight, LinuxLightSmall, LinuxMint, LinuxMintOld, LinuxMintSmall, LinuxSmall, Live_Raizo, LMDE, Lunar, MacOS, MacOS2, MacOS2Small, MacOSSmall, Mageia, MageiaSmall, MagpieOS, Mandriva, Manjaro, ManjaroSmall, MassOS, MatuusOS, MaUI, Meowix, Mer, Minix, Mint, MintOld, MintSmall, MiracleLinux, MOS, Msys2, MX, MXSmall, Namib, Nekos, Neptune, NetBSD, NetRunner, Nitrux, NixOS, NixOS_small, NixOsOld, NixOsSmall, Nobara, NomadBSD, Nurunner, NuTyX, Obarun, OBRevenge, OmniOS, OpenBSD, OpenBSDSmall, OpenEuler, OpenIndiana, OpenKylin, OpenMamba, OpenMandriva, OpenStage, OpenSuse, OpenSuseLeap, OpenSuseSmall, OpenSuseTumbleweed, OpenWrt, OPNsense, Oracle, Orchid, OrchidSmall, OS_Elbrus, OSMC, OSX, OSXSmall, PacBSD, Panwah, Parabola, ParabolaSmall, Parch, Pardus, Parrot, Parsix, PCBSD, PCLinuxOS, PearOS, Pengwin, Pentoo, Peppermint, PhyOS, Pisi, PNMLinux, Pop, PopSmall, Porteus, PostMarketOS, PostMarketOSSmall, Proxmox, PuffOS, Puppy, PureOS, PureOSSmall, Q4OS, Qubes, Qubyt, Quibian, Radix, Raspbian, RaspbianSmall, RavynOS, Reborn, RebornSmall, RedCore, RedHatEnterpriseLinux, RedHatEnterpriseLinux_old, RedstarOS, Refracted Devuan, Regata, Regolith, RhaymOS, RockyLinux, RockyLinuxSmall, RosaLinux, Sabayon, Sabotage, Sailfish, SalentOS, SalientOS, Salix, SambaBOX, Sasanqua, Scientific, Semc, Septor, Serene, SharkLinux, ShastraOS, Siduction, SkiffOS, Slackel, Slackware, SlackwareSmall, Slitaz, SmartOS, Soda, Solaris, SolarisSmall, Solus, SourceMage, Sparky, Star, SteamOS, StockLinux, Sulin, Suse, SuseSmall, Swagarch, T2, Tails, TeArch, TorizonCore, Trisquel, Twister, Ubuntu, Ubuntu2Old, Ubuntu2Small, UbuntuBudgie, UbuntuCinnamon, UbuntuGnome, UbuntuKde, UbuntuKylin, UbuntuMate, UbuntuOld, UbuntuSmall, UbuntuStudio, UbuntuSway, UbuntuTouch, UbuntuUnity, Ultramarine, Univalent, Univention, UOS, UrukOS, Uwuntu, Vanilla, Venom, Vnux, Void, VoidSmall, Vzlinux, WiiLinuxNgx, Windows, Windows11, Windows11Small, Windows8, Windows95, Xferience, YiffOS, Zorin ``` Run `fastfetch --print-logos` to print them diff --git a/src/logo/ascii/aeros.txt b/src/logo/ascii/aeros.txt new file mode 100644 index 0000000000..b7d99524a7 --- /dev/null +++ b/src/logo/ascii/aeros.txt @@ -0,0 +1,21 @@ + ooo OOO OOO ooo + oOO OOo + oOO OOo + oOO OOo + oOO OOo + oOO OOo + oOO OOo + OOo + OOo + OOo + OOo + OOo + OOo +oOO OOo + oOO OOo + oOO OOo + oOO OOo + oO OOo + oOO OOo + oOO OOo + ooo OOO OOO ooo diff --git a/src/logo/builtin.c b/src/logo/builtin.c index c196dfab6a..0246a77be1 100644 --- a/src/logo/builtin.c +++ b/src/logo/builtin.c @@ -13,6 +13,15 @@ const FFlogo ffLogoUnknown = { }; static const FFlogo A[] = { + // AerOS + { + .names = {"aerOS"}, + .lines = FASTFETCH_DATATEXT_LOGO_AEROS, + .colors = { + FF_COLOR_FG_CYAN, + FF_COLOR_FG_CYAN, + }, + }, // AIX { .names = {"aix"}, From 5a43adb62b11aedb3760858b227f53a3028ae503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sun, 20 Aug 2023 00:09:48 +0800 Subject: [PATCH 30/37] Doc: update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ae3700a887..e1d677dc49 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,19 +1,24 @@ # 2.0.1 +First stable release of Fastfetch V2 + Changes: * Unescape strings only when parsing `.conf` files * Previously: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\: *`. Note the backslashs are unescaped twice (once by shell and once by fastfetch). * Now: `$ NO_CONFIG=1 fastfetch --os-key \\\\ -s os -l none` prints `\\: *` * Remove option shortcut `-c` (alias of `--color`), which is more commonly used as alias of `--config` * Rename `--recache` to `--logo-recache` (which is used for regenerate image logo cache). Remove option shortcut `-r` (alias of `--recache`). +* Detecting brightness of external displays with DDC/CI is no longer guarded behind `--allow-slow-operations` (Brightness) Features: * Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width` * Add `--bar-char-elapsed`, `--bar-char-total`, `--bar-width` and `--bar-border` options +* Add CMake option `ENABLE_SYSTEM_YYJSON`, which allow building fastfetch with system-provided yyjson (for package managers) Bugfixes: * Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux) * Fix some module options were not inited +* Fix terminal version and font detection on NixOS (Terminal, Linux) # 2.0.0-beta From 0b473e3bff29f77137c6343278eeab9c93d86e34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sun, 20 Aug 2023 20:51:55 +0800 Subject: [PATCH 31/37] Fastfetch: refactor the code of `--list-modules` --- CMakeLists.txt | 2 +- README.md | 2 +- src/common/modules.c | 163 ++++++++++++++++++++++++++++++++++++ src/data/modules.txt | 45 ---------- src/fastfetch.c | 15 +++- src/fastfetch.h | 79 ++++++++--------- src/fastfetch_datatext.h.in | 1 - 7 files changed, 219 insertions(+), 88 deletions(-) create mode 100644 src/common/modules.c delete mode 100644 src/data/modules.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 1aa9041df0..4dd0c06db9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -211,7 +211,6 @@ fastfetch_load_text(src/data/structure.txt DATATEXT_STRUCTURE) fastfetch_load_text(src/data/config_system.txt DATATEXT_CONFIG_SYSTEM) fastfetch_load_text(src/data/config_user.txt DATATEXT_CONFIG_USER) fastfetch_load_text(src/data/config_user.jsonc DATATEXT_CONFIG_USER_JSONC) -fastfetch_load_text(src/data/modules.txt DATATEXT_MODULES) fastfetch_load_text(src/data/help.txt DATATEXT_HELP) fastfetch_load_text(src/data/help_color.txt DATATEXT_HELP_COLOR) fastfetch_load_text(src/data/help_format.txt DATATEXT_HELP_FORMAT) @@ -259,6 +258,7 @@ set(LIBFASTFETCH_SRC src/common/init.c src/common/jsonconfig.c src/common/library.c + src/common/modules.c src/common/option.c src/common/parsing.c src/common/printing.c diff --git a/README.md b/README.md index 1b8f6f0673..61d2b0b15d 100644 --- a/README.md +++ b/README.md @@ -96,7 +96,7 @@ All categories not listed here should work without needing a specific implementa ##### Available Modules ``` -Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, Gamepad, GPU, Host, Icons, Kernel, LM, Locale, LocalIP, Media, Memory, Monitor, OpenCL, OpenGL, Packages, Player, Power Adapter, Processes, PublicIP, Separator, OS, Shell, Sound, Swap, Terminal, Terminal Font, Terminal Size, Theme, Time, Title, Uptime, Vulkan, Wallpaper, Wifi, WM, WMTheme +Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, Gamepad, GPU, Host, Icons, Kernel, LM, Locale, LocalIP, Media, Memory, Monitor, OpenCL, OpenGL, OS, Packages, Player, Power Adapter, Processes, PublicIP, Separator, Shell, Sound, Swap, Terminal, Terminal Font, Terminal Size, Theme, Time, Title, Uptime, Vulkan, Wallpaper, Weather, Wifi, WM, WMTheme ``` ##### Builtin logos diff --git a/src/common/modules.c b/src/common/modules.c new file mode 100644 index 0000000000..84d4cfb5cf --- /dev/null +++ b/src/common/modules.c @@ -0,0 +1,163 @@ +#include "fastfetch.h" + +static FFModuleBaseInfo* A[] = { + NULL, +}; + +static FFModuleBaseInfo* B[] = { + (void*) &instance.config.battery, + (void*) &instance.config.bios, + (void*) &instance.config.bluetooth, + (void*) &instance.config.board, + (void*) &instance.config.break_, + (void*) &instance.config.brightness, + NULL, +}; + +static FFModuleBaseInfo* C[] = { + (void*) &instance.config.chassis, + (void*) &instance.config.command, + (void*) &instance.config.colors, + (void*) &instance.config.cpu, + (void*) &instance.config.cpuUsage, + (void*) &instance.config.cursor, + (void*) &instance.config.custom, + NULL, +}; + +static FFModuleBaseInfo* D[] = { + (void*) &instance.config.dateTime, + (void*) &instance.config.de, + (void*) &instance.config.display, + (void*) &instance.config.disk, + NULL, +}; + +static FFModuleBaseInfo* E[] = { + NULL, +}; + +static FFModuleBaseInfo* F[] = { + (void*) &instance.config.font, + NULL, +}; + +static FFModuleBaseInfo* G[] = { + (void*) &instance.config.gamepad, + (void*) &instance.config.gpu, + NULL, +}; + +static FFModuleBaseInfo* H[] = { + (void*) &instance.config.host, + NULL, +}; + +static FFModuleBaseInfo* I[] = { + (void*) &instance.config.icons, + NULL, +}; + +static FFModuleBaseInfo* J[] = { + NULL, +}; + +static FFModuleBaseInfo* K[] = { + (void*) &instance.config.kernel, + NULL, +}; + +static FFModuleBaseInfo* L[] = { + (void*) &instance.config.lm, + (void*) &instance.config.locale, + (void*) &instance.config.localIP, + NULL, +}; + +static FFModuleBaseInfo* M[] = { + (void*) &instance.config.media, + (void*) &instance.config.memory, + (void*) &instance.config.monitor, + NULL, +}; + +static FFModuleBaseInfo* N[] = { + NULL, +}; + +static FFModuleBaseInfo* O[] = { + (void*) &instance.config.openCL, + (void*) &instance.config.openGL, + (void*) &instance.config.os, + NULL, +}; + +static FFModuleBaseInfo* P[] = { + (void*) &instance.config.packages, + (void*) &instance.config.player, + (void*) &instance.config.powerAdapter, + (void*) &instance.config.processes, + (void*) &instance.config.publicIP, + NULL, +}; + +static FFModuleBaseInfo* Q[] = { + NULL, +}; + +static FFModuleBaseInfo* R[] = { + NULL, +}; + +static FFModuleBaseInfo* S[] = { + (void*) &instance.config.separator, + (void*) &instance.config.shell, + (void*) &instance.config.sound, + (void*) &instance.config.swap, + NULL, +}; + +static FFModuleBaseInfo* T[] = { + (void*) &instance.config.terminal, + (void*) &instance.config.terminalFont, + (void*) &instance.config.terminalSize, + (void*) &instance.config.title, + (void*) &instance.config.theme, + NULL, +}; + +static FFModuleBaseInfo* U[] = { + (void*) &instance.config.uptime, + (void*) &instance.config.users, + NULL, +}; + +static FFModuleBaseInfo* V[] = { + (void*) &instance.config.vulkan, + NULL, +}; + +static FFModuleBaseInfo* W[] = { + (void*) &instance.config.wallpaper, + (void*) &instance.config.weather, + (void*) &instance.config.wm, + (void*) &instance.config.wifi, + (void*) &instance.config.wmTheme, + NULL, +}; + +static FFModuleBaseInfo* X[] = { + NULL, +}; + +static FFModuleBaseInfo* Y[] = { + NULL, +}; + +static FFModuleBaseInfo* Z[] = { + NULL, +}; + +FFModuleBaseInfo** ffModuleInfos[] = { + A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, +}; diff --git a/src/data/modules.txt b/src/data/modules.txt deleted file mode 100644 index e83353ec92..0000000000 --- a/src/data/modules.txt +++ /dev/null @@ -1,45 +0,0 @@ -Battery -Bios -Bluetooth -Board -Break -Chassis -Colors -CPU -CPUUsage -Cursor -Date -Datetime -DE -Disk -Display -Font -GPU -Host -Icons -Kernel -Locale -LocalIP -Media -Memory -OpenGL -OS -Packages -Player -PowerAdapter -Processes -PublicIP -Separator -Shell -Swap -Terminal -TerminalFont -Theme -Time -Title -Uptime -Vulkan -Weather -Wifi -WM -WMTheme diff --git a/src/fastfetch.c b/src/fastfetch.c index 0e95891605..b5c53f9a55 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -554,6 +554,19 @@ static void listDataPaths(void) } } +static void listModules() +{ + unsigned count = 0; + for (int i = 0; i <= 'Z' - 'A'; ++i) + { + for (FFModuleBaseInfo** modules = ffModuleInfos[i]; *modules; ++modules) + { + ++count; + printf("%d)%s%s\n", count, count > 9 ? " " : " ", (*modules)->name); + } + } +} + static void parseOption(FFdata* data, const char* key, const char* value); static bool parseJsoncFile(const char* path) @@ -856,7 +869,7 @@ static void parseOption(FFdata* data, const char* key, const char* value) const char* subkey = key + strlen("--list"); if(ffStrEqualsIgnCase(subkey, "-modules")) { - puts(FASTFETCH_DATATEXT_MODULES); + listModules(); exit(0); } else if(ffStrEqualsIgnCase(subkey, "-presets")) diff --git a/src/fastfetch.h b/src/fastfetch.h index dd4b4a8214..543c64b304 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -78,60 +78,60 @@ typedef struct FFconfig int32_t wmiTimeout; #endif - FFTitleOptions title; - FFOSOptions os; - FFHostOptions host; + FFBatteryOptions battery; FFBiosOptions bios; + FFBluetoothOptions bluetooth; FFBoardOptions board; + FFBreakOptions break_; FFBrightnessOptions brightness; + FFCPUOptions cpu; + FFCPUUsageOptions cpuUsage; FFChassisOptions chassis; + FFColorsOptions colors; FFCommandOptions command; - FFKernelOptions kernel; - FFUptimeOptions uptime; - FFProcessesOptions processes; - FFPackagesOptions packages; - FFShellOptions shell; - FFDisplayOptions display; - FFDEOptions de; - FFWallpaperOptions wallpaper; - FFWifiOptions wifi; - FFWMOptions wm; - FFWMThemeOptions wmTheme; - FFThemeOptions theme; - FFIconsOptions icons; - FFFontOptions font; FFCursorOptions cursor; - FFTerminalOptions terminal; - FFTerminalFontOptions terminalFont; - FFTerminalSizeOptions terminalSize; - FFCPUOptions cpu; - FFCPUUsageOptions cpuUsage; FFCustomOptions custom; - FFGPUOptions gpu; - FFMemoryOptions memory; - FFSwapOptions swap; + FFDEOptions de; + FFDateTimeOptions dateTime; FFDiskOptions disk; - FFBatteryOptions battery; - FFPowerAdapterOptions powerAdapter; + FFDisplayOptions display; + FFFontOptions font; + FFGPUOptions gpu; + FFGamepadOptions gamepad; + FFHostOptions host; + FFIconsOptions icons; + FFKernelOptions kernel; FFLMOptions lm; - FFLocaleOptions locale; FFLocalIpOptions localIP; - FFPublicIpOptions publicIP; - FFWeatherOptions weather; - FFPlayerOptions player; + FFLocaleOptions locale; FFMediaOptions media; + FFMemoryOptions memory; FFMonitorOptions monitor; - FFDateTimeOptions dateTime; - FFVulkanOptions vulkan; - FFOpenGLOptions openGL; + FFOSOptions os; FFOpenCLOptions openCL; - FFUsersOptions users; - FFBluetoothOptions bluetooth; + FFOpenGLOptions openGL; + FFPackagesOptions packages; + FFPlayerOptions player; + FFPowerAdapterOptions powerAdapter; + FFProcessesOptions processes; + FFPublicIpOptions publicIP; FFSeparatorOptions separator; + FFShellOptions shell; FFSoundOptions sound; - FFGamepadOptions gamepad; - FFBreakOptions break_; - FFColorsOptions colors; + FFSwapOptions swap; + FFTerminalFontOptions terminalFont; + FFTerminalOptions terminal; + FFTerminalSizeOptions terminalSize; + FFThemeOptions theme; + FFTitleOptions title; + FFUptimeOptions uptime; + FFUsersOptions users; + FFVulkanOptions vulkan; + FFWMOptions wm; + FFWMThemeOptions wmTheme; + FFWallpaperOptions wallpaper; + FFWeatherOptions weather; + FFWifiOptions wifi; FFstrbuf libPCI; FFstrbuf libVulkan; @@ -175,6 +175,7 @@ typedef struct FFinstance FFstate state; } FFinstance; extern FFinstance instance; // Defined in `common/init.c` +extern FFModuleBaseInfo** ffModuleInfos[]; ////////////////////// // Init functions // diff --git a/src/fastfetch_datatext.h.in b/src/fastfetch_datatext.h.in index f8a6994272..19a5328850 100644 --- a/src/fastfetch_datatext.h.in +++ b/src/fastfetch_datatext.h.in @@ -7,7 +7,6 @@ #define FASTFETCH_DATATEXT_CONFIG_SYSTEM "@DATATEXT_CONFIG_SYSTEM@" #define FASTFETCH_DATATEXT_CONFIG_USER "@DATATEXT_CONFIG_USER@" //Requires FASTFETCH_PROJECT_VERSION and FASTFETCH_DATATEXT_STRUCTURE to be set #define FASTFETCH_DATATEXT_CONFIG_USER_JSONC "@DATATEXT_CONFIG_USER_JSONC@" -#define FASTFETCH_DATATEXT_MODULES "@DATATEXT_MODULES@" #define FASTFETCH_DATATEXT_HELP "@DATATEXT_HELP@" #define FASTFETCH_DATATEXT_HELP_COLOR "@DATATEXT_HELP_COLOR@" #define FASTFETCH_DATATEXT_HELP_FORMAT "@DATATEXT_HELP_FORMAT@" From 970863e7df6377698014d1d2b882e598730a2b96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Sun, 20 Aug 2023 21:35:38 +0800 Subject: [PATCH 32/37] Global: simplify code of module matching --- src/common/commandoption.c | 317 ++----------------------------------- src/common/jsonconfig.c | 164 ++----------------- 2 files changed, 24 insertions(+), 457 deletions(-) diff --git a/src/common/commandoption.c b/src/common/commandoption.c index a7c250f449..510ac61a9e 100644 --- a/src/common/commandoption.c +++ b/src/common/commandoption.c @@ -3,319 +3,30 @@ #include -static inline bool tryModule(const char* type, void* options) -{ - FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; - if (ffStrEqualsIgnCase(type, baseInfo->name)) - { - baseInfo->printModule(options); - return true; - } - return false; -} - bool ffParseModuleCommand(const char* type) { - FFconfig* cfg = &instance.config; - switch (toupper(type[0])) - { - case 'B': { - return - tryModule(type, &cfg->battery) || - tryModule(type, &cfg->bios) || - tryModule(type, &cfg->bluetooth) || - tryModule(type, &cfg->board) || - tryModule(type, &cfg->break_) || - tryModule(type, &cfg->brightness) || - false; - } - - case 'C': { - return - tryModule(type, &cfg->chassis) || - tryModule(type, &cfg->command) || - tryModule(type, &cfg->colors) || - tryModule(type, &cfg->cpu) || - tryModule(type, &cfg->cpuUsage) || - tryModule(type, &cfg->cursor) || - tryModule(type, &cfg->custom) || - false; - } - - case 'D': { - return - tryModule(type, &cfg->dateTime) || - tryModule(type, &cfg->de) || - tryModule(type, &cfg->display) || - tryModule(type, &cfg->disk) || - false; - } - - case 'F': { - return - tryModule(type, &cfg->font) || - false; - } - - case 'G': { - return - tryModule(type, &cfg->gamepad) || - tryModule(type, &cfg->gpu) || - false; - } - - case 'H': { - return - tryModule(type, &cfg->host) || - false; - } - - case 'I': { - return - tryModule(type, &cfg->icons) || - false; - } + if(!isalpha(type[0])) return false; - case 'K': { - return - tryModule(type, &cfg->kernel) || - false; - } - - case 'L': { - return - tryModule(type, &cfg->lm) || - tryModule(type, &cfg->locale) || - tryModule(type, &cfg->localIP) || - false; - } - - case 'M': { - return - tryModule(type, &cfg->media) || - tryModule(type, &cfg->memory) || - tryModule(type, &cfg->monitor) || - false; - } - - case 'O': { - return - tryModule(type, &cfg->openCL) || - tryModule(type, &cfg->openGL) || - tryModule(type, &cfg->os) || - false; - } - - case 'P': { - return - tryModule(type, &cfg->packages) || - tryModule(type, &cfg->player) || - tryModule(type, &cfg->powerAdapter) || - tryModule(type, &cfg->processes) || - tryModule(type, &cfg->publicIP) || - false; - } - - case 'S': { - return - tryModule(type, &cfg->separator) || - tryModule(type, &cfg->shell) || - tryModule(type, &cfg->sound) || - tryModule(type, &cfg->swap) || - false; - } - - case 'T': { - return - tryModule(type, &cfg->terminal) || - tryModule(type, &cfg->terminalFont) || - tryModule(type, &cfg->terminalSize) || - tryModule(type, &cfg->title) || - tryModule(type, &cfg->theme) || - false; - } - - case 'U': { - return - tryModule(type, &cfg->uptime) || - tryModule(type, &cfg->users) || - false; - } - - case 'V': { - return - tryModule(type, &cfg->vulkan) || - false; - } - - case 'W': { - return - tryModule(type, &cfg->wallpaper) || - tryModule(type, &cfg->weather) || - tryModule(type, &cfg->wm) || - tryModule(type, &cfg->wifi) || - tryModule(type, &cfg->wmTheme) || - false; + for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(type[0]) - 'A']; *modules; ++modules) + { + FFModuleBaseInfo* baseInfo = *modules; + if (ffStrEqualsIgnCase(type, baseInfo->name)) + { + baseInfo->printModule(baseInfo); + return true; } - - default: - return false; } -} - -static inline bool tryModuleCommandOptions(const char* key, const char* value, void* options) -{ - FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; - return baseInfo->parseCommandOptions(options, key, value); + return false; } bool ffParseModuleOptions(const char* key, const char* value) { - if (!ffStrStartsWith(key, "--")) return false; - FFconfig* cfg = &instance.config; + if (!ffStrStartsWith(key, "--") || !isalpha(key[2])) return false; - switch (toupper(key[2])) + for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(key[2]) - 'A']; *modules; ++modules) { - case 'B': { - return - tryModuleCommandOptions(key, value, &cfg->battery) || - tryModuleCommandOptions(key, value, &cfg->bios) || - tryModuleCommandOptions(key, value, &cfg->bluetooth) || - tryModuleCommandOptions(key, value, &cfg->board) || - tryModuleCommandOptions(key, value, &cfg->break_) || - tryModuleCommandOptions(key, value, &cfg->brightness) || - false; - } - - case 'C': { - return - tryModuleCommandOptions(key, value, &cfg->chassis) || - tryModuleCommandOptions(key, value, &cfg->command) || - tryModuleCommandOptions(key, value, &cfg->colors) || - tryModuleCommandOptions(key, value, &cfg->cpu) || - tryModuleCommandOptions(key, value, &cfg->cpuUsage) || - tryModuleCommandOptions(key, value, &cfg->cursor) || - tryModuleCommandOptions(key, value, &cfg->custom) || - false; - } - - case 'D': { - return - tryModuleCommandOptions(key, value, &cfg->dateTime) || - tryModuleCommandOptions(key, value, &cfg->de) || - tryModuleCommandOptions(key, value, &cfg->display) || - tryModuleCommandOptions(key, value, &cfg->disk) || - false; - } - - case 'F': { - return - tryModuleCommandOptions(key, value, &cfg->font) || - false; - } - - case 'G': { - return - tryModuleCommandOptions(key, value, &cfg->gamepad) || - tryModuleCommandOptions(key, value, &cfg->gpu) || - false; - } - - case 'H': { - return - tryModuleCommandOptions(key, value, &cfg->host) || - false; - } - - case 'I': { - return - tryModuleCommandOptions(key, value, &cfg->icons) || - false; - } - - case 'K': { - return - tryModuleCommandOptions(key, value, &cfg->kernel) || - false; - } - - case 'L': { - return - tryModuleCommandOptions(key, value, &cfg->lm) || - tryModuleCommandOptions(key, value, &cfg->locale) || - tryModuleCommandOptions(key, value, &cfg->localIP) || - false; - } - - case 'M': { - return - tryModuleCommandOptions(key, value, &cfg->media) || - tryModuleCommandOptions(key, value, &cfg->memory) || - tryModuleCommandOptions(key, value, &cfg->monitor) || - false; - } - - case 'O': { - return - tryModuleCommandOptions(key, value, &cfg->openCL) || - tryModuleCommandOptions(key, value, &cfg->openGL) || - tryModuleCommandOptions(key, value, &cfg->os) || - false; - } - - case 'P': { - return - tryModuleCommandOptions(key, value, &cfg->packages) || - tryModuleCommandOptions(key, value, &cfg->player) || - tryModuleCommandOptions(key, value, &cfg->powerAdapter) || - tryModuleCommandOptions(key, value, &cfg->processes) || - tryModuleCommandOptions(key, value, &cfg->publicIP) || - false; - } - - case 'S': { - return - tryModuleCommandOptions(key, value, &cfg->separator) || - tryModuleCommandOptions(key, value, &cfg->shell) || - tryModuleCommandOptions(key, value, &cfg->sound) || - tryModuleCommandOptions(key, value, &cfg->swap) || - false; - } - - case 'T': { - return - tryModuleCommandOptions(key, value, &cfg->terminal) || - tryModuleCommandOptions(key, value, &cfg->terminalFont) || - tryModuleCommandOptions(key, value, &cfg->terminalSize) || - tryModuleCommandOptions(key, value, &cfg->title) || - tryModuleCommandOptions(key, value, &cfg->theme) || - false; - } - - case 'U': { - return - tryModuleCommandOptions(key, value, &cfg->uptime) || - tryModuleCommandOptions(key, value, &cfg->users) || - false; - } - - case 'V': { - return - tryModuleCommandOptions(key, value, &cfg->vulkan) || - false; - } - - case 'W': { - return - tryModuleCommandOptions(key, value, &cfg->wallpaper) || - tryModuleCommandOptions(key, value, &cfg->weather) || - tryModuleCommandOptions(key, value, &cfg->wm) || - tryModuleCommandOptions(key, value, &cfg->wifi) || - tryModuleCommandOptions(key, value, &cfg->wmTheme) || - false; - } - - default: - return false; + FFModuleBaseInfo* baseInfo = *modules; + if (baseInfo->parseCommandOptions(baseInfo, key, value)) return true; } + return false; } diff --git a/src/common/jsonconfig.c b/src/common/jsonconfig.c index 2c6b8c8d08..1cfbb9606f 100644 --- a/src/common/jsonconfig.c +++ b/src/common/jsonconfig.c @@ -70,165 +70,21 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p return "Invalid enum value type; must be a string or integer"; } -static inline bool tryModule(const char* type, yyjson_val* module, void* options) +static bool parseModuleJsonObject(const char* type, yyjson_val* jsonVal) { - FFModuleBaseInfo* baseInfo = (FFModuleBaseInfo*) options; - if (ffStrEqualsIgnCase(type, baseInfo->name)) - { - if (module) baseInfo->parseJsonObject(options, module); - baseInfo->printModule(options); - return true; - } - return false; -} + if(!isalpha(type[0])) return false; -static bool parseModuleJsonObject(const char* type, yyjson_val* module) -{ - FFconfig* cfg = &instance.config; - switch (toupper(type[0])) + for (FFModuleBaseInfo** modules = ffModuleInfos[toupper(type[0]) - 'A']; *modules; ++modules) { - case 'B': { - return - tryModule(type, module, &cfg->battery) || - tryModule(type, module, &cfg->bios) || - tryModule(type, module, &cfg->bluetooth) || - tryModule(type, module, &cfg->board) || - tryModule(type, module, &cfg->break_) || - tryModule(type, module, &cfg->brightness) || - false; - } - - case 'C': { - return - tryModule(type, module, &cfg->chassis) || - tryModule(type, module, &cfg->command) || - tryModule(type, module, &cfg->colors) || - tryModule(type, module, &cfg->cpu) || - tryModule(type, module, &cfg->cpuUsage) || - tryModule(type, module, &cfg->cursor) || - tryModule(type, module, &cfg->custom) || - false; - } - - case 'D': { - return - tryModule(type, module, &cfg->dateTime) || - tryModule(type, module, &cfg->de) || - tryModule(type, module, &cfg->display) || - tryModule(type, module, &cfg->disk) || - false; - } - - case 'F': { - return - tryModule(type, module, &cfg->font) || - false; - } - - case 'G': { - return - tryModule(type, module, &cfg->gamepad) || - tryModule(type, module, &cfg->gpu) || - false; - } - - case 'H': { - return - tryModule(type, module, &cfg->host) || - false; - } - - case 'I': { - return - tryModule(type, module, &cfg->icons) || - false; - } - - case 'K': { - return - tryModule(type, module, &cfg->kernel) || - false; - } - - case 'L': { - return - tryModule(type, module, &cfg->lm) || - tryModule(type, module, &cfg->locale) || - tryModule(type, module, &cfg->localIP) || - false; - } - - case 'M': { - return - tryModule(type, module, &cfg->media) || - tryModule(type, module, &cfg->memory) || - tryModule(type, module, &cfg->monitor) || - false; - } - - case 'O': { - return - tryModule(type, module, &cfg->openCL) || - tryModule(type, module, &cfg->openGL) || - tryModule(type, module, &cfg->os) || - false; - } - - case 'P': { - return - tryModule(type, module, &cfg->packages) || - tryModule(type, module, &cfg->player) || - tryModule(type, module, &cfg->powerAdapter) || - tryModule(type, module, &cfg->processes) || - tryModule(type, module, &cfg->publicIP) || - false; - } - - case 'S': { - return - tryModule(type, module, &cfg->separator) || - tryModule(type, module, &cfg->shell) || - tryModule(type, module, &cfg->sound) || - tryModule(type, module, &cfg->swap) || - false; - } - - case 'T': { - return - tryModule(type, module, &cfg->terminal) || - tryModule(type, module, &cfg->terminalFont) || - tryModule(type, module, &cfg->terminalSize) || - tryModule(type, module, &cfg->title) || - tryModule(type, module, &cfg->theme) || - false; - } - - case 'U': { - return - tryModule(type, module, &cfg->uptime) || - tryModule(type, module, &cfg->users) || - false; - } - - case 'V': { - return - tryModule(type, module, &cfg->vulkan) || - false; - } - - case 'W': { - return - tryModule(type, module, &cfg->wallpaper) || - tryModule(type, module, &cfg->weather) || - tryModule(type, module, &cfg->wm) || - tryModule(type, module, &cfg->wifi) || - tryModule(type, module, &cfg->wmTheme) || - false; + FFModuleBaseInfo* baseInfo = *modules; + if (ffStrEqualsIgnCase(type, baseInfo->name)) + { + if (jsonVal) baseInfo->parseJsonObject(baseInfo, jsonVal); + baseInfo->printModule(baseInfo); + return true; } - - default: - return false; } + return false; } static void prepareModuleJsonObject(const char* type, yyjson_val* module) From f23384725fcb8cf396cac2ce34245eb4512a1930 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 21 Aug 2023 09:19:16 +0800 Subject: [PATCH 33/37] Version: add new module --- CHANGELOG.md | 1 + CMakeLists.txt | 2 + README.md | 2 +- doc/json_schema.json | 2 + presets/all | 2 +- presets/all.jsonc | 1 + src/common/init.c | 2 + src/common/modules.c | 1 + src/data/config_user.txt | 3 ++ src/detection/version/version.c | 35 +++++++++++++++++ src/detection/version/version.h | 20 ++++++++++ src/fastfetch.c | 11 ++++++ src/fastfetch.h | 1 + src/fastfetch_config.h.in | 1 + src/modules/modules.h | 1 + src/modules/options.h | 1 + src/modules/version/option.h | 11 ++++++ src/modules/version/version.c | 68 +++++++++++++++++++++++++++++++++ src/modules/version/version.h | 11 ++++++ 19 files changed, 174 insertions(+), 2 deletions(-) create mode 100644 src/detection/version/version.c create mode 100644 src/detection/version/version.h create mode 100644 src/modules/version/option.h create mode 100644 src/modules/version/version.c create mode 100644 src/modules/version/version.h diff --git a/CHANGELOG.md b/CHANGELOG.md index e1d677dc49..b9cf6773e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ Features: * Add `--key-width` for aligning the left edge of values, supported both for global `--key-width` and specific module `--module-key-width` * Add `--bar-char-elapsed`, `--bar-char-total`, `--bar-width` and `--bar-border` options * Add CMake option `ENABLE_SYSTEM_YYJSON`, which allow building fastfetch with system-provided yyjson (for package managers) +* Add new module `Version`, which prints fastfetch version (like `fastfetch --version`) Bugfixes: * Fix label detection. Use `--disk-key 'Disk ({2})'` to display it (Disk, Linux) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4dd0c06db9..723b6cb0b2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -279,6 +279,7 @@ set(LIBFASTFETCH_SRC src/detection/packages/packages.c src/detection/terminalfont/terminalfont.c src/detection/terminalshell/terminalshell.c + src/detection/version/version.c src/detection/vulkan/vulkan.c src/logo/builtin.c src/logo/image/im6.c @@ -334,6 +335,7 @@ set(LIBFASTFETCH_SRC src/modules/title/title.c src/modules/uptime/uptime.c src/modules/users/users.c + src/modules/version/version.c src/modules/vulkan/vulkan.c src/modules/wallpaper/wallpaper.c src/modules/weather/weather.c diff --git a/README.md b/README.md index 61d2b0b15d..271a91afd9 100644 --- a/README.md +++ b/README.md @@ -96,7 +96,7 @@ All categories not listed here should work without needing a specific implementa ##### Available Modules ``` -Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, Gamepad, GPU, Host, Icons, Kernel, LM, Locale, LocalIP, Media, Memory, Monitor, OpenCL, OpenGL, OS, Packages, Player, Power Adapter, Processes, PublicIP, Separator, Shell, Sound, Swap, Terminal, Terminal Font, Terminal Size, Theme, Time, Title, Uptime, Vulkan, Wallpaper, Weather, Wifi, WM, WMTheme +Battery, Bios, Bluetooth, Board, Break, Brightness, Colors, Command, CPU, CPUUsage, Cursor, Custom, Date, DateTime, DE, Disk, Display, Font, Gamepad, GPU, Host, Icons, Kernel, LM, Locale, LocalIP, Media, Memory, Monitor, OpenCL, OpenGL, OS, Packages, Player, Power Adapter, Processes, PublicIP, Separator, Shell, Sound, Swap, Terminal, Terminal Font, Terminal Size, Theme, Time, Title, Uptime, Version, Vulkan, Wallpaper, Weather, Wifi, WM, WMTheme ``` ##### Builtin logos diff --git a/doc/json_schema.json b/doc/json_schema.json index 909145c9a3..4baa74a2dd 100644 --- a/doc/json_schema.json +++ b/doc/json_schema.json @@ -558,6 +558,7 @@ "theme", "uptime", "users", + "version", "vulkan", "wallpaper", "weather", @@ -626,6 +627,7 @@ "theme", "uptime", "users", + "version", "vulkan", "wallpaper", "wm", diff --git a/presets/all b/presets/all index 48d24b4a78..1841c47ca6 100644 --- a/presets/all +++ b/presets/all @@ -1 +1 @@ ---structure Title:Separator:OS:Host:Bios:Board:Chassis:Kernel:Uptime:Processes:Packages:Shell:Display:Brightness:Monitor:LM:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Wallpaper:Terminal:TerminalFont:TerminalSize:CPU:CPUUsage:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Media:PublicIP:LocalIP:Wifi:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Bluetooth:Sound:Gamepad:Weather:Break:Colors +--structure Title:Separator:OS:Host:Bios:Board:Chassis:Kernel:Uptime:Processes:Packages:Shell:Display:Brightness:Monitor:LM:DE:WM:WMTheme:Theme:Icons:Font:Cursor:Wallpaper:Terminal:TerminalFont:TerminalSize:CPU:CPUUsage:GPU:Memory:Swap:Disk:Battery:PowerAdapter:Player:Media:PublicIP:LocalIP:Wifi:DateTime:Locale:Vulkan:OpenGL:OpenCL:Users:Bluetooth:Sound:Gamepad:Weather:Version:Break:Colors diff --git a/presets/all.jsonc b/presets/all.jsonc index a1e722fae1..b3e9c30d95 100644 --- a/presets/all.jsonc +++ b/presets/all.jsonc @@ -51,6 +51,7 @@ "sound", "gamepad", "weather", + "version", "break", "colors" ] diff --git a/src/common/init.c b/src/common/init.c index 4ef61b7187..2f277ddfba 100644 --- a/src/common/init.c +++ b/src/common/init.c @@ -123,6 +123,7 @@ static void defaultConfig(void) ffInitTitleOptions(&instance.config.title); ffInitUptimeOptions(&instance.config.uptime); ffInitUsersOptions(&instance.config.users); + ffInitVersionOptions(&instance.config.version); ffInitVulkanOptions(&instance.config.vulkan); ffInitWMOptions(&instance.config.wm); ffInitWMThemeOptions(&instance.config.wmTheme); @@ -335,6 +336,7 @@ static void destroyConfig(void) ffDestroyTitleOptions(&instance.config.title); ffDestroyUptimeOptions(&instance.config.uptime); ffDestroyUsersOptions(&instance.config.users); + ffDestroyVersionOptions(&instance.config.version); ffDestroyVulkanOptions(&instance.config.vulkan); ffDestroyWMOptions(&instance.config.wm); ffDestroyWMThemeOptions(&instance.config.wmTheme); diff --git a/src/common/modules.c b/src/common/modules.c index 84d4cfb5cf..1c4cd108aa 100644 --- a/src/common/modules.c +++ b/src/common/modules.c @@ -133,6 +133,7 @@ static FFModuleBaseInfo* U[] = { }; static FFModuleBaseInfo* V[] = { + (void*) &instance.config.version, (void*) &instance.config.vulkan, NULL, }; diff --git a/src/data/config_user.txt b/src/data/config_user.txt index 619bdfdc35..7bd07a49e0 100644 --- a/src/data/config_user.txt +++ b/src/data/config_user.txt @@ -376,6 +376,7 @@ #--player-key Media Player #--media-key Media #--datetime-key Date Time +#--version-key Version #--vulkan-key Vulkan #--opengl-key OpenGL #--opencl-key OpenCL @@ -426,6 +427,7 @@ #--player-format #--media-format #--datetime-format +#--version-format #--vulkan-format #--opengl-format #--opencl-format @@ -473,6 +475,7 @@ #--player-key-color #--media-key-color #--datetime-key-color +#--version-key-color #--vulkan-key-color #--opengl-key-color #--opencl-key-color diff --git a/src/detection/version/version.c b/src/detection/version/version.c new file mode 100644 index 0000000000..4a8eb420c4 --- /dev/null +++ b/src/detection/version/version.c @@ -0,0 +1,35 @@ +#include "version.h" + +#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) || defined(__amd64) + #define FF_ARCHITECTURE "x86_64" +#elif defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(__i586__) || defined(__i586) || defined(__i686__) || defined(__i686) + #define FF_ARCHITECTURE "i386" +#elif defined(__aarch64__) + #define FF_ARCHITECTURE "aarch64" +#elif defined(__arm__) + #define FF_ARCHITECTURE "arm" +#elif defined(__mips__) + #define FF_ARCHITECTURE "mips" +#elif defined(__powerpc__) || defined(__powerpc) + #define FF_ARCHITECTURE "powerpc" +#elif defined(__riscv__) || defined(__riscv) + #define FF_ARCHITECTURE "riscv" +#elif defined(__s390x__) + #define FF_ARCHITECTURE "s390x" +#else + #define FF_ARCHITECTURE "unknown" +#endif + +void ffDetectVersion(FFVersionResult* version) +{ + version->projectName = FASTFETCH_PROJECT_NAME; + version->architecture = FF_ARCHITECTURE; + version->version = FASTFETCH_PROJECT_VERSION; + version->versionTweak = FASTFETCH_PROJECT_VERSION_TWEAK; + version->cmakeBuiltType = FASTFETCH_PROJECT_CMAKE_BUILD_TYPE; + #ifndef NDEBUG + version->debugMode = true; + #else + version->debugMode = false; + #endif +} diff --git a/src/detection/version/version.h b/src/detection/version/version.h new file mode 100644 index 0000000000..bdb11aa3a1 --- /dev/null +++ b/src/detection/version/version.h @@ -0,0 +1,20 @@ +#pragma once + +#ifndef FF_INCLUDED_detection_version_version +#define FF_INCLUDED_detection_version_version + +#include "fastfetch.h" + +typedef struct FFVersionResult +{ + const char* projectName; + const char* architecture; + const char* version; + const char* versionTweak; + const char* cmakeBuiltType; + bool debugMode; +} FFVersionResult; + +void ffDetectVersion(FFVersionResult* version); + +#endif diff --git a/src/fastfetch.c b/src/fastfetch.c index b5c53f9a55..8d485bf82c 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -456,6 +456,17 @@ static inline void printCommandHelp(const char* command) "second with leading zero" ); } + else if(ffStrEqualsIgnCase(command, "version-format")) + { + constructAndPrintCommandHelpFormat("version", "{1} {2}{3} (5)", 6, + "Project name", + "Version", + "Version tweak", + "Build type (debug or release)", + "Architecture", + "CMake build type (Debug, Release, RelWithDebInfo, MinSizeRel)" + ); + } else if(ffStrEqualsIgnCase(command, "vulkan-format")) { constructAndPrintCommandHelpFormat("vulkan", "{} (driver), {} (api version)", 3, diff --git a/src/fastfetch.h b/src/fastfetch.h index 543c64b304..6dfa675fa1 100644 --- a/src/fastfetch.h +++ b/src/fastfetch.h @@ -126,6 +126,7 @@ typedef struct FFconfig FFTitleOptions title; FFUptimeOptions uptime; FFUsersOptions users; + FFVersionOptions version; FFVulkanOptions vulkan; FFWMOptions wm; FFWMThemeOptions wmTheme; diff --git a/src/fastfetch_config.h.in b/src/fastfetch_config.h.in index f913973899..2092c91d3a 100644 --- a/src/fastfetch_config.h.in +++ b/src/fastfetch_config.h.in @@ -10,6 +10,7 @@ #define FASTFETCH_PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH@ #define FASTFETCH_PROJECT_VERSION_TWEAK "@PROJECT_VERSION_TWEAK@" #define FASTFETCH_PROJECT_VERSION_TWEAK_NUM @PROJECT_VERSION_TWEAK_NUM@ +#define FASTFETCH_PROJECT_CMAKE_BUILD_TYPE "@CMAKE_BUILD_TYPE@" #define FASTFETCH_PROJECT_HOMEPAGE_URL "@PROJECT_HOMEPAGE_URL@" #define FASTFETCH_PROJECT_DESCRIPTION "@PROJECT_DESCRIPTION@" #define FASTFETCH_PROJECT_LICENSE "@PROJECT_LICENSE@" diff --git a/src/modules/modules.h b/src/modules/modules.h index c5e75e525c..1f7669c102 100644 --- a/src/modules/modules.h +++ b/src/modules/modules.h @@ -50,6 +50,7 @@ #include "modules/title/title.h" #include "modules/uptime/uptime.h" #include "modules/users/users.h" +#include "modules/version/version.h" #include "modules/vulkan/vulkan.h" #include "modules/wallpaper/wallpaper.h" #include "modules/weather/weather.h" diff --git a/src/modules/options.h b/src/modules/options.h index 84bc4764b6..12041ce5b6 100644 --- a/src/modules/options.h +++ b/src/modules/options.h @@ -50,6 +50,7 @@ #include "modules/title/option.h" #include "modules/uptime/option.h" #include "modules/users/option.h" +#include "modules/version/option.h" #include "modules/vulkan/option.h" #include "modules/wallpaper/option.h" #include "modules/weather/option.h" diff --git a/src/modules/version/option.h b/src/modules/version/option.h new file mode 100644 index 0000000000..12c151be0f --- /dev/null +++ b/src/modules/version/option.h @@ -0,0 +1,11 @@ +#pragma once + +// This file will be included in "fastfetch.h", do NOT put unnecessary things here + +#include "common/option.h" + +typedef struct FFVersionOptions +{ + FFModuleBaseInfo moduleInfo; + FFModuleArgs moduleArgs; +} FFVersionOptions; diff --git a/src/modules/version/version.c b/src/modules/version/version.c new file mode 100644 index 0000000000..9cef899d24 --- /dev/null +++ b/src/modules/version/version.c @@ -0,0 +1,68 @@ +#include "common/printing.h" +#include "common/jsonconfig.h" +#include "detection/version/version.h" +#include "modules/version/version.h" +#include "util/stringUtils.h" + +#define FF_VERSION_NUM_FORMAT_ARGS 6 + +void ffPrintVersion(FFVersionOptions* options) +{ + FFVersionResult result = {}; + ffDetectVersion(&result); + + if(options->moduleArgs.outputFormat.length == 0) + { + ffPrintLogoAndKey(FF_VERSION_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT); + printf("%s %s%s%s (%s)\n", result.projectName, result.version, result.versionTweak, result.debugMode ? "-debug" : "", result.architecture); + } + else + { + ffPrintFormat(FF_VERSION_MODULE_NAME, 0, &options->moduleArgs, FF_VERSION_NUM_FORMAT_ARGS, (FFformatarg[]){ + {FF_FORMAT_ARG_TYPE_STRING, result.projectName}, + {FF_FORMAT_ARG_TYPE_STRING, result.version}, + {FF_FORMAT_ARG_TYPE_STRING, result.versionTweak}, + {FF_FORMAT_ARG_TYPE_STRING, result.debugMode ? "debug" : "release"}, + {FF_FORMAT_ARG_TYPE_STRING, result.architecture}, + {FF_FORMAT_ARG_TYPE_STRING, result.cmakeBuiltType}, + }); + } +} + +void ffInitVersionOptions(FFVersionOptions* options) +{ + ffOptionInitModuleBaseInfo(&options->moduleInfo, FF_VERSION_MODULE_NAME, ffParseVersionCommandOptions, ffParseVersionJsonObject, ffPrintVersion); + ffOptionInitModuleArg(&options->moduleArgs); +} + +bool ffParseVersionCommandOptions(FFVersionOptions* options, const char* key, const char* value) +{ + const char* subKey = ffOptionTestPrefix(key, FF_VERSION_MODULE_NAME); + if (!subKey) return false; + if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs)) + return true; + + return false; +} + +void ffDestroyVersionOptions(FFVersionOptions* options) +{ + ffOptionDestroyModuleArg(&options->moduleArgs); +} + +void ffParseVersionJsonObject(FFVersionOptions* options, yyjson_val* module) +{ + yyjson_val *key_, *val; + size_t idx, max; + yyjson_obj_foreach(module, idx, max, key_, val) + { + const char* key = yyjson_get_str(key_); + if(ffStrEqualsIgnCase(key, "type")) + continue; + + if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs)) + continue; + + ffPrintError(FF_VERSION_MODULE_NAME, 0, &options->moduleArgs, "Unknown JSON key %s", key); + } +} diff --git a/src/modules/version/version.h b/src/modules/version/version.h new file mode 100644 index 0000000000..ef423b36ed --- /dev/null +++ b/src/modules/version/version.h @@ -0,0 +1,11 @@ +#pragma once + +#include "fastfetch.h" + +#define FF_VERSION_MODULE_NAME "Version" + +void ffPrintVersion(FFVersionOptions* options); +void ffInitVersionOptions(FFVersionOptions* options); +bool ffParseVersionCommandOptions(FFVersionOptions* options, const char* key, const char* value); +void ffDestroyVersionOptions(FFVersionOptions* options); +void ffParseVersionJsonObject(FFVersionOptions* options, yyjson_val* module); From c6eff111cc233ebb4621ee5dd98428e095e38910 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 21 Aug 2023 09:22:03 +0800 Subject: [PATCH 34/37] Fastfetch: refactor `printVersion()` --- src/fastfetch.c | 36 +++++------------------------------- 1 file changed, 5 insertions(+), 31 deletions(-) diff --git a/src/fastfetch.c b/src/fastfetch.c index 8d485bf82c..213d37ec1e 100644 --- a/src/fastfetch.c +++ b/src/fastfetch.c @@ -5,6 +5,7 @@ #include "common/io/io.h" #include "common/time.h" #include "common/jsonconfig.h" +#include "detection/version/version.h" #include "util/stringUtils.h" #include "logo/logo.h" #include "fastfetch_datatext.h" @@ -795,37 +796,10 @@ static inline void optionCheckString(const char* key, const char* value, FFstrbu } static void printVersion() - { - #ifndef NDEBUG - #define FF_BUILD_TYPE "-debug" - #else - #define FF_BUILD_TYPE - #endif - - #if defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) || defined(__amd64) - #define FF_ARCHITECTURE "x86_64" - #elif defined(__i386__) || defined(__i386) || defined(__i486__) || defined(__i486) || defined(__i586__) || defined(__i586) || defined(__i686__) || defined(__i686) - #define FF_ARCHITECTURE "i386" - #elif defined(__aarch64__) - #define FF_ARCHITECTURE "aarch64" - #elif defined(__arm__) - #define FF_ARCHITECTURE "arm" - #elif defined(__mips__) - #define FF_ARCHITECTURE "mips" - #elif defined(__powerpc__) || defined(__powerpc) - #define FF_ARCHITECTURE "powerpc" - #elif defined(__riscv__) || defined(__riscv) - #define FF_ARCHITECTURE "riscv" - #elif defined(__s390x__) - #define FF_ARCHITECTURE "s390x" - #else - #define FF_ARCHITECTURE "unknown" - #endif - - puts("fastfetch " FASTFETCH_PROJECT_VERSION FASTFETCH_PROJECT_VERSION_TWEAK FF_BUILD_TYPE " (" FF_ARCHITECTURE ")"); - - #undef FF_ARCHITECTURE - #undef FF_BUILD_TYPE +{ + FFVersionResult result = {}; + ffDetectVersion(&result); + printf("%s %s%s%s (%s)\n", result.projectName, result.version, result.versionTweak, result.debugMode ? "-debug" : "", result.architecture); } static void parseOption(FFdata* data, const char* key, const char* value) From 7b6e157a4ddd1be328f5ef2bbdd60eae23a581e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 21 Aug 2023 09:26:07 +0800 Subject: [PATCH 35/37] Doc: update `bug_report.md` --- .github/ISSUE_TEMPLATE/bug_report.md | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index f70839bb64..3a9df9a7ca 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -19,11 +19,6 @@ assignees: '' # Often helpful information: -Output of `fastfetch --version`: -``` -//paste here -``` - The content of the configuration file you use (if any) ``` //paste here @@ -34,7 +29,7 @@ Output of `env NO_CONFIG=1 fastfetch --load-config all --show-errors --stat --mu Note that this output will contain you public IP. If it is not relevant for the issue, feel free to remove it before uploading. If you get the following error: `Error: couldn't find config: [...]`, copy the files in [presets](../../presets/) to `/usr/share/fastfetch/presets/` or `~/.local/share/fastfetch/presets/`. -If this isn't possible (or too much work) for you, post the output of `env NO_CONFIG=1 fastfetch --show-errors --stat --multithreading false --disable-linewrap false --hide-cursor false`. +If this isn't possible (or too much work) for you, post the output of `env NO_CONFIG=1 fastfetch --show-errors --stat --multithreading false --disable-linewrap false --hide-cursor false && fastfetch --version`. --> ``` From 159122eb980bf607bcb3e5f645638f6e603f1d41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 21 Aug 2023 09:38:20 +0800 Subject: [PATCH 36/37] Brightness (macOS): silence compiler warnings --- src/detection/brightness/brightness_apple.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/detection/brightness/brightness_apple.c b/src/detection/brightness/brightness_apple.c index e7e19fed2c..ecbe604787 100644 --- a/src/detection/brightness/brightness_apple.c +++ b/src/detection/brightness/brightness_apple.c @@ -31,7 +31,7 @@ static const char* detectWithDisplayServices(const FFDisplayServerResult* displa // https://github.com/waydabber/m1ddc // Works for Apple Silicon and USB-C adapter connection ( but not HTMI ) -static const char* detectWithDdcci(FFlist* result) +FF_MAYBE_UNUSED static const char* detectWithDdcci(FFlist* result) { if (!IOAVServiceCreate || !IOAVServiceReadI2C) return "IOAVService is not available"; From 154e15e88fd21bc638953cf9d40f30dd2be6d6bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=8E=E9=80=9A=E6=B4=B2?= Date: Mon, 21 Aug 2023 10:05:41 +0800 Subject: [PATCH 37/37] Release: v2.0.1 --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 723b6cb0b2..0ede8fc716 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.12.0) # target_link_libraries with OBJECT libs & project homepage url project(fastfetch - VERSION 2.0.0 + VERSION 2.0.1 LANGUAGES C DESCRIPTION "Fast system information tool" HOMEPAGE_URL "https://github.com/fastfetch-cli/fastfetch"