CToon C 0.9.0
A C99 TOON/JSON serialization library
Loading...
Searching...
No Matches
ctoon.h
Go to the documentation of this file.
1/*==============================================================================
2 Copyright (c) 2026 Mohammad Raziei <mohammadraziei1375@gmail.com>
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in all
12 copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 SOFTWARE.
21 *============================================================================*/
22
29#ifndef CTOON_H
30#define CTOON_H
31
32
33
34/*==============================================================================
35 * MARK: - Header Files
36 *============================================================================*/
37
38#include <stdio.h>
39#include <stdlib.h>
40#include <stddef.h>
41#include <limits.h>
42#include <string.h>
43#include <float.h>
44
45
46
47/*==============================================================================
48 * MARK: - Compile-time Options
49 *============================================================================*/
50
51/*
52 Define as 1 to disable TOON reader at compile-time.
53 This disables functions with "read" in their name.
54 Reduces binary size by about 60%.
55 */
56#ifndef CTOON_DISABLE_READER
57#endif
58
59/*
60 Define as 1 to disable TOON writer at compile-time.
61 This disables functions with "write" in their name.
62 Reduces binary size by about 30%.
63 */
64#ifndef CTOON_DISABLE_WRITER
65#endif
66
67/*
68 Define as 1 to disable TOON incremental reader at compile-time.
69 This disables functions with "incr" in their name.
70 */
71#ifndef CTOON_DISABLE_INCR_READER
72#endif
73
74/*
75 Define as 1 to disable TOON Pointer, TOON Patch and TOON Merge Patch supports.
76 This disables functions with "ptr" or "patch" in their name.
77 */
78#ifndef CTOON_DISABLE_UTILS
79#endif
80
81/*
82 JSON support (ctoon_read_json*, ctoon_write_json* functions) is on by
83 default. Define CTOON_DISABLE_JSON (to anything, or nothing at all -
84 only its presence is checked) to turn it off.
85 */
86#ifndef CTOON_DISABLE_JSON
87#define CTOON_ENABLE_JSON 1
88#endif
89
90/*
91 Define as 1 to disable the fast floating-point number conversion in ctoon.
92 Libc's `strtod/snprintf` will be used instead.
93
94 This reduces binary size by about 30%, but significantly slows down the
95 floating-point read/write speed.
96 */
97#ifndef CTOON_DISABLE_FAST_FP_CONV
98#endif
99
100/*
101 Define as 1 to disable non-standard TOON features support at compile-time,
102 such as CTOON_READ_ALLOW_XXX and CTOON_WRITE_ALLOW_XXX.
103
104 This reduces binary size by about 10%, and slightly improves performance.
105 */
106#ifndef CTOON_DISABLE_NON_STANDARD
107#endif
108
109/*
110 Define as 1 to disable UTF-8 validation at compile-time.
111
112 Use this if all input strings are guaranteed to be valid UTF-8
113 (e.g. language-level String types are already validated).
114
115 Disabling UTF-8 validation improves performance for non-ASCII strings by about
116 3% to 7%.
117
118 Note: If this flag is enabled while passing illegal UTF-8 strings,
119 the following errors may occur:
120 - Escaped characters may be ignored when parsing TOON strings.
121 - Ending quotes may be ignored when parsing TOON strings, causing the
122 string to merge with the next value.
123 - When serializing with `ctoon_mut_val`, the string's end may be accessed
124 out of bounds, potentially causing a segmentation fault.
125 */
126#ifndef CTOON_DISABLE_UTF8_VALIDATION
127#endif
128
129/*
130 Define as 1 to improve performance on architectures that do not support
131 unaligned memory access.
132
133 Normally, this does not need to be set manually. See the C file for details.
134 */
135#ifndef CTOON_DISABLE_UNALIGNED_MEMORY_ACCESS
136#endif
137
138/* Define as 1 to export symbols when building this library as a Windows DLL. */
139#ifndef CTOON_EXPORTS
140#endif
141
142/* Define as 1 to import symbols when using this library as a Windows DLL. */
143#ifndef CTOON_IMPORTS
144#endif
145
146/* Define as 1 to include <stdint.h> for compilers without C99 support. */
147#ifndef CTOON_HAS_STDINT_H
148#endif
149
150/* Define as 1 to include <stdbool.h> for compilers without C99 support. */
151#ifndef CTOON_HAS_STDBOOL_H
152#endif
153
154/* Define to an integer to set a depth limit for containers (arrays, objects). */
155#ifndef CTOON_READER_DEPTH_LIMIT
156#endif
157
158
159/*==============================================================================
160 * MARK: - Compiler Macros
161 *============================================================================*/
162
164#ifdef _MSC_VER
165# define CTOON_MSC_VER _MSC_VER
166#else
167# define CTOON_MSC_VER 0
168#endif
169
171#ifdef __GNUC__
172# define CTOON_GCC_VER __GNUC__
173# if defined(__GNUC_PATCHLEVEL__)
174# define ctoon_gcc_available(major, minor, patch) \
175 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) \
176 >= (major * 10000 + minor * 100 + patch))
177# else
178# define ctoon_gcc_available(major, minor, patch) \
179 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) \
180 >= (major * 10000 + minor * 100 + patch))
181# endif
182#else
183# define CTOON_GCC_VER 0
184# define ctoon_gcc_available(major, minor, patch) 0
185#endif
186
188#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
189 !defined(__clang__) && !defined(__llvm__) && \
190 !defined(__INTEL_COMPILER) && !defined(__ICC) && \
191 !defined(__NVCC__) && !defined(__PGI) && !defined(__TINYC__)
192# define CTOON_IS_REAL_GCC 1
193#else
194# define CTOON_IS_REAL_GCC 0
195#endif
196
198#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__)
199# define CTOON_STDC_VER __STDC_VERSION__
200#else
201# define CTOON_STDC_VER 0
202#endif
203
205#if defined(__cplusplus)
206# define CTOON_CPP_VER __cplusplus
207#else
208# define CTOON_CPP_VER 0
209#endif
210
212#ifndef ctoon_has_builtin
213# ifdef __has_builtin
214# define ctoon_has_builtin(x) __has_builtin(x)
215# else
216# define ctoon_has_builtin(x) 0
217# endif
218#endif
219
221#ifndef ctoon_has_attribute
222# ifdef __has_attribute
223# define ctoon_has_attribute(x) __has_attribute(x)
224# else
225# define ctoon_has_attribute(x) 0
226# endif
227#endif
228
230#ifndef ctoon_has_feature
231# ifdef __has_feature
232# define ctoon_has_feature(x) __has_feature(x)
233# else
234# define ctoon_has_feature(x) 0
235# endif
236#endif
237
239#ifndef ctoon_has_include
240# ifdef __has_include
241# define ctoon_has_include(x) __has_include(x)
242# else
243# define ctoon_has_include(x) 0
244# endif
245#endif
246
248#ifndef ctoon_inline
249# if CTOON_MSC_VER >= 1200
250# define ctoon_inline __forceinline
251# elif defined(_MSC_VER)
252# define ctoon_inline __inline
253# elif ctoon_has_attribute(always_inline) || CTOON_GCC_VER >= 4
254# define ctoon_inline __inline__ __attribute__((always_inline))
255# elif defined(__clang__) || defined(__GNUC__)
256# define ctoon_inline __inline__
257# elif defined(__cplusplus) || CTOON_STDC_VER >= 199901L
258# define ctoon_inline inline
259# else
260# define ctoon_inline
261# endif
262#endif
263
265#ifndef ctoon_noinline
266# if CTOON_MSC_VER >= 1400
267# define ctoon_noinline __declspec(noinline)
268# elif ctoon_has_attribute(noinline) || CTOON_GCC_VER >= 4
269# define ctoon_noinline __attribute__((noinline))
270# else
271# define ctoon_noinline
272# endif
273#endif
274
276#ifndef ctoon_align
277# if CTOON_MSC_VER >= 1300
278# define ctoon_align(x) __declspec(align(x))
279# elif ctoon_has_attribute(aligned) || defined(__GNUC__)
280# define ctoon_align(x) __attribute__((aligned(x)))
281# elif CTOON_CPP_VER >= 201103L
282# define ctoon_align(x) alignas(x)
283# else
284# define ctoon_align(x)
285# endif
286#endif
287
289#ifndef ctoon_likely
290# if ctoon_has_builtin(__builtin_expect) || \
291 (CTOON_GCC_VER >= 4 && CTOON_GCC_VER != 5)
292# define ctoon_likely(expr) __builtin_expect(!!(expr), 1)
293# else
294# define ctoon_likely(expr) (expr)
295# endif
296#endif
297
299#ifndef ctoon_unlikely
300# if ctoon_has_builtin(__builtin_expect) || \
301 (CTOON_GCC_VER >= 4 && CTOON_GCC_VER != 5)
302# define ctoon_unlikely(expr) __builtin_expect(!!(expr), 0)
303# else
304# define ctoon_unlikely(expr) (expr)
305# endif
306#endif
307
309#ifndef ctoon_constant_p
310# if ctoon_has_builtin(__builtin_constant_p) || (CTOON_GCC_VER >= 3)
311# define CTOON_HAS_CONSTANT_P 1
312# define ctoon_constant_p(value) __builtin_constant_p(value)
313# else
314# define CTOON_HAS_CONSTANT_P 0
315# define ctoon_constant_p(value) 0
316# endif
317#endif
318
320#ifndef ctoon_deprecated
321# if CTOON_MSC_VER >= 1400
322# define ctoon_deprecated(msg) __declspec(deprecated(msg))
323# elif ctoon_has_feature(attribute_deprecated_with_message) || \
324 (CTOON_GCC_VER > 4 || (CTOON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
325# define ctoon_deprecated(msg) __attribute__((deprecated(msg)))
326# elif CTOON_GCC_VER >= 3
327# define ctoon_deprecated(msg) __attribute__((deprecated))
328# else
329# define ctoon_deprecated(msg)
330# endif
331#endif
332
334#ifndef ctoon_api
335# if defined(_WIN32)
336# if defined(CTOON_EXPORTS) && CTOON_EXPORTS
337# define ctoon_api __declspec(dllexport)
338# elif defined(CTOON_IMPORTS) && CTOON_IMPORTS
339# define ctoon_api __declspec(dllimport)
340# else
341# define ctoon_api
342# endif
343# elif ctoon_has_attribute(visibility) || CTOON_GCC_VER >= 4
344# define ctoon_api __attribute__((visibility("default")))
345# else
346# define ctoon_api
347# endif
348#endif
349
351#ifndef ctoon_api_inline
352# define ctoon_api_inline static ctoon_inline
353#endif
354
356#if (defined(CTOON_HAS_STDINT_H) && CTOON_HAS_STDINT_H) || \
357 CTOON_MSC_VER >= 1600 || CTOON_STDC_VER >= 199901L || \
358 defined(_STDINT_H) || defined(_STDINT_H_) || \
359 defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \
360 ctoon_has_include(<stdint.h>)
361# include <stdint.h>
362#elif defined(_MSC_VER)
363# if _MSC_VER < 1300
364 typedef signed char int8_t;
365 typedef signed short int16_t;
366 typedef signed int int32_t;
367 typedef unsigned char uint8_t;
368 typedef unsigned short uint16_t;
369 typedef unsigned int uint32_t;
370 typedef signed __int64 int64_t;
371 typedef unsigned __int64 uint64_t;
372# else
373 typedef signed __int8 int8_t;
374 typedef signed __int16 int16_t;
375 typedef signed __int32 int32_t;
376 typedef unsigned __int8 uint8_t;
377 typedef unsigned __int16 uint16_t;
378 typedef unsigned __int32 uint32_t;
379 typedef signed __int64 int64_t;
380 typedef unsigned __int64 uint64_t;
381# endif
382#else
383# if UCHAR_MAX == 0xFFU
384 typedef signed char int8_t;
385 typedef unsigned char uint8_t;
386# else
387# error cannot find 8-bit integer type
388# endif
389# if USHRT_MAX == 0xFFFFU
390 typedef unsigned short uint16_t;
391 typedef signed short int16_t;
392# elif UINT_MAX == 0xFFFFU
393 typedef unsigned int uint16_t;
394 typedef signed int int16_t;
395# else
396# error cannot find 16-bit integer type
397# endif
398# if UINT_MAX == 0xFFFFFFFFUL
399 typedef unsigned int uint32_t;
400 typedef signed int int32_t;
401# elif ULONG_MAX == 0xFFFFFFFFUL
402 typedef unsigned long uint32_t;
403 typedef signed long int32_t;
404# elif USHRT_MAX == 0xFFFFFFFFUL
405 typedef unsigned short uint32_t;
406 typedef signed short int32_t;
407# else
408# error cannot find 32-bit integer type
409# endif
410# if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__)
411 typedef __INT64_TYPE__ int64_t;
412 typedef __UINT64_TYPE__ uint64_t;
413# elif defined(__GNUC__) || defined(__clang__)
414# if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined)
415 __extension__ typedef long long int64_t;
416# endif
417 __extension__ typedef unsigned long long uint64_t;
418# elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
419 defined(__SUNPRO_C) || defined(__SUNPRO_CC)
420 typedef long long int64_t;
421 typedef unsigned long long uint64_t;
422# elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
423 defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC)
424 typedef __int64 int64_t;
425 typedef unsigned __int64 uint64_t;
426# else
427# error cannot find 64-bit integer type
428# endif
429#endif
430
432#if (defined(CTOON_HAS_STDBOOL_H) && CTOON_HAS_STDBOOL_H) || \
433 CTOON_MSC_VER >= 1800 || CTOON_STDC_VER >= 199901L || \
434 (ctoon_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__))
435# include <stdbool.h>
436#elif !defined(__bool_true_false_are_defined)
437# define __bool_true_false_are_defined 1
438# if defined(__cplusplus)
439# if defined(__GNUC__) && !defined(__STRICT_ANSI__)
440# define _Bool bool
441# if __cplusplus < 201103L
442# define bool bool
443# define false false
444# define true true
445# endif
446# endif
447# else
448# define bool unsigned char
449# define true 1
450# define false 0
451# endif
452#endif
453
455#if defined(CHAR_BIT)
456# if CHAR_BIT != 8
457# error non 8-bit char is not supported
458# endif
459#endif
460
465#ifndef CTOON_U64_TO_F64_NO_IMPL
466# if (0 < CTOON_MSC_VER) && (CTOON_MSC_VER <= 1200)
467# define CTOON_U64_TO_F64_NO_IMPL 1
468# else
469# define CTOON_U64_TO_F64_NO_IMPL 0
470# endif
471#endif
472
473
474
475/*==============================================================================
476 * MARK: - Compile Hint Begin
477 *============================================================================*/
478
479/* extern "C" begin */
480#ifdef __cplusplus
481extern "C" {
482#endif
483
484/*==============================================================================
485 * MARK: - Version
486 *============================================================================*/
487
489#define CTOON_VERSION_MAJOR 0
490
492#define CTOON_VERSION_MINOR 9
493
495#define CTOON_VERSION_PATCH 0
496
497#define CTOON_VERSION_ENCODE(maj,min,pat) (((maj)*10000)+((min)*100)+(pat))
498#define CTOON_VERSION \
499 CTOON_VERSION_ENCODE(CTOON_VERSION_MAJOR,CTOON_VERSION_MINOR,CTOON_VERSION_PATCH)
500
502#define CTOON_VERSION_HEX \
503 ((CTOON_VERSION_MAJOR << 16) | (CTOON_VERSION_MINOR << 8) | CTOON_VERSION_PATCH)
504
505/* Internal helpers for CTOON_VERSION_STRING */
506#define _CTOON_VERSION_XSTR(a,b,c) #a"."#b"."#c
507#define _CTOON_VERSION_STR(a,b,c) _CTOON_VERSION_XSTR(a,b,c)
508
510#define CTOON_VERSION_STRING \
511 _CTOON_VERSION_STR(CTOON_VERSION_MAJOR,CTOON_VERSION_MINOR,CTOON_VERSION_PATCH)
512
514ctoon_api uint32_t ctoon_version(void);
515
516
517/*==============================================================================
518 * MARK: - TOON Spec
519 *
520 * The toon-format/spec release this build targets (spec §13: implementations
521 * SHOULD declare the specification version they target).
522 *
523 * The CTOON_SPEC_* block below is generated by CMake (cmake/SpecVersion.cmake)
524 * at the same moment it creates supported_spec.conf. Do not edit it manually.
525 * Other languages read the same values at runtime via the ctoon_spec_*()
526 * functions declared below (ctoon.h macros are not reachable over FFI).
527 *============================================================================*/
528
529/* BEGIN CTOON_SPEC (generated by cmake/SpecVersion.cmake -- do not edit) */
530#define CTOON_SPEC_VERSION_STRING "4.4"
531#define CTOON_SPEC_DATE_STRING "2026-10-08"
532#define CTOON_SPEC_TAG_MAJOR 4
533#define CTOON_SPEC_TAG_MINOR 4
534#define CTOON_SPEC_TAG_PATCH 0
535/* END CTOON_SPEC */
536
538#define CTOON_SPEC_TAG_STRING \
539 "v" _CTOON_VERSION_STR(CTOON_SPEC_TAG_MAJOR,CTOON_SPEC_TAG_MINOR,CTOON_SPEC_TAG_PATCH)
540
542#define CTOON_SPEC_TAG_HEX \
543 ((CTOON_SPEC_TAG_MAJOR << 16) | (CTOON_SPEC_TAG_MINOR << 8) | CTOON_SPEC_TAG_PATCH)
544
546ctoon_api uint32_t ctoon_spec_tag_hex(void);
547
549ctoon_api const char *ctoon_spec_version_string(void);
550
552ctoon_api const char *ctoon_spec_date_string(void);
553
554
555
556/*==============================================================================
557 * MARK: - TOON Types
558 *============================================================================*/
559
561typedef uint8_t ctoon_type;
563#define CTOON_TYPE_NONE ((uint8_t)0) /* _____000 */
565#define CTOON_TYPE_RAW ((uint8_t)1) /* _____001 */
567#define CTOON_TYPE_NULL ((uint8_t)2) /* _____010 */
569#define CTOON_TYPE_BOOL ((uint8_t)3) /* _____011 */
571#define CTOON_TYPE_NUM ((uint8_t)4) /* _____100 */
573#define CTOON_TYPE_STR ((uint8_t)5) /* _____101 */
575#define CTOON_TYPE_ARR ((uint8_t)6) /* _____110 */
577#define CTOON_TYPE_OBJ ((uint8_t)7) /* _____111 */
578
580typedef uint8_t ctoon_subtype;
582#define CTOON_SUBTYPE_NONE ((uint8_t)(0 << 3)) /* ___00___ */
584#define CTOON_SUBTYPE_FALSE ((uint8_t)(0 << 3)) /* ___00___ */
586#define CTOON_SUBTYPE_TRUE ((uint8_t)(1 << 3)) /* ___01___ */
588#define CTOON_SUBTYPE_UINT ((uint8_t)(0 << 3)) /* ___00___ */
590#define CTOON_SUBTYPE_SINT ((uint8_t)(1 << 3)) /* ___01___ */
592#define CTOON_SUBTYPE_REAL ((uint8_t)(2 << 3)) /* ___10___ */
594#define CTOON_SUBTYPE_NOESC ((uint8_t)(1 << 3)) /* ___01___ */
595
597#define CTOON_TYPE_MASK ((uint8_t)0x07) /* _____111 */
599#define CTOON_TYPE_BIT ((uint8_t)3)
601#define CTOON_SUBTYPE_MASK ((uint8_t)0x18) /* ___11___ */
603#define CTOON_SUBTYPE_BIT ((uint8_t)2)
605#define CTOON_RESERVED_MASK ((uint8_t)0xE0) /* 111_____ */
607#define CTOON_RESERVED_BIT ((uint8_t)3)
609#define CTOON_TAG_MASK ((uint8_t)0xFF) /* 11111111 */
611#define CTOON_TAG_BIT ((uint8_t)8)
612
614#define CTOON_PADDING_SIZE 4
615
616
617
618/*==============================================================================
619 * MARK: - Allocator
620 *============================================================================*/
621
628typedef struct ctoon_alc {
630 void *(*malloc)(void *ctx, size_t size);
632 void *(*realloc)(void *ctx, void *ptr, size_t old_size, size_t size);
634 void (*free)(void *ctx, void *ptr);
636 void *ctx;
637} ctoon_alc;
638
678ctoon_api bool ctoon_alc_pool_init(ctoon_alc *alc, void *buf, size_t size);
679
692ctoon_api ctoon_alc *ctoon_alc_dyn_new(void);
693
698ctoon_api void ctoon_alc_dyn_free(ctoon_alc *alc);
699
700
701
702/*==============================================================================
703 * MARK: - Text Locating
704 *============================================================================*/
705
721ctoon_api bool ctoon_locate_pos(const char *str, size_t len, size_t pos,
722 size_t *line, size_t *col, size_t *chr);
723
724
725
726/*==============================================================================
727 * MARK: - TOON Structure
728 *============================================================================*/
729
735typedef struct ctoon_doc ctoon_doc;
736
742typedef struct ctoon_val ctoon_val;
743
749typedef struct ctoon_mut_doc ctoon_mut_doc;
750
756typedef struct ctoon_mut_val ctoon_mut_val;
757
758
759
760/*==============================================================================
761 * MARK: - TOON Reader API
762 *============================================================================*/
763
765typedef uint32_t ctoon_read_flag;
766
775static const ctoon_read_flag CTOON_READ_NOFLAG = 0;
776
783static const ctoon_read_flag CTOON_READ_INSITU = 1 << 0;
784
788static const ctoon_read_flag CTOON_READ_STOP_WHEN_DONE = 1 << 1;
789
792static const ctoon_read_flag CTOON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
793
795static const ctoon_read_flag CTOON_READ_ALLOW_COMMENTS = 1 << 3;
796
804static const ctoon_read_flag CTOON_READ_ALLOW_INF_AND_NAN = 1 << 4;
805
808static const ctoon_read_flag CTOON_READ_NUMBER_AS_RAW = 1 << 5;
809
818static const ctoon_read_flag CTOON_READ_ALLOW_INVALID_UNICODE = 1 << 6;
819
824static const ctoon_read_flag CTOON_READ_BIGNUM_AS_RAW = 1 << 7;
825
827static const ctoon_read_flag CTOON_READ_ALLOW_BOM = 1 << 8;
828
833static const ctoon_read_flag CTOON_READ_ALLOW_EXT_NUMBER = 1 << 9;
834
842static const ctoon_read_flag CTOON_READ_ALLOW_EXT_ESCAPE = 1 << 10;
843
850static const ctoon_read_flag CTOON_READ_ALLOW_EXT_WHITESPACE = 1 << 11;
851
853static const ctoon_read_flag CTOON_READ_ALLOW_SINGLE_QUOTED_STR = 1 << 12;
854
858static const ctoon_read_flag CTOON_READ_ALLOW_UNQUOTED_KEY = 1 << 13;
859
867static const ctoon_read_flag CTOON_READ_NON_STRICT = 1 << 14;
868
874static const ctoon_read_flag CTOON_READ_TOON5 =
875 (1 << 2) | /* CTOON_READ_ALLOW_TRAILING_COMMAS */
876 (1 << 3) | /* CTOON_READ_ALLOW_COMMENTS */
877 (1 << 4) | /* CTOON_READ_ALLOW_INF_AND_NAN */
878 (1 << 9) | /* CTOON_READ_ALLOW_EXT_NUMBER */
879 (1 << 10) | /* CTOON_READ_ALLOW_EXT_ESCAPE */
880 (1 << 11) | /* CTOON_READ_ALLOW_EXT_WHITESPACE */
881 (1 << 12) | /* CTOON_READ_ALLOW_SINGLE_QUOTED_STR */
882 (1 << 13); /* CTOON_READ_ALLOW_UNQUOTED_KEY */
883
884
885
887typedef uint32_t ctoon_read_code;
888
890static const ctoon_read_code CTOON_READ_SUCCESS = 0;
891
893static const ctoon_read_code CTOON_READ_ERROR_INVALID_PARAMETER = 1;
894
896static const ctoon_read_code CTOON_READ_ERROR_MEMORY_ALLOCATION = 2;
897
899static const ctoon_read_code CTOON_READ_ERROR_EMPTY_CONTENT = 3;
900
902static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CONTENT = 4;
903
905static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_END = 5;
906
908static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CHARACTER = 6;
909
911static const ctoon_read_code CTOON_READ_ERROR_TOON_STRUCTURE = 7;
912
914static const ctoon_read_code CTOON_READ_ERROR_INVALID_COMMENT = 8;
915
917static const ctoon_read_code CTOON_READ_ERROR_INVALID_NUMBER = 9;
918
920static const ctoon_read_code CTOON_READ_ERROR_INVALID_STRING = 10;
921
923static const ctoon_read_code CTOON_READ_ERROR_LITERAL = 11;
924
926static const ctoon_read_code CTOON_READ_ERROR_FILE_OPEN = 12;
927
929static const ctoon_read_code CTOON_READ_ERROR_FILE_READ = 13;
930
932static const ctoon_read_code CTOON_READ_ERROR_MORE = 14;
933
935static const ctoon_read_code CTOON_READ_ERROR_DEPTH = 15;
936
946
947
948
949#if !defined(CTOON_DISABLE_READER) || !CTOON_DISABLE_READER
950
974ctoon_api ctoon_doc *ctoon_read_opts(char *dat,
975 size_t len,
976 ctoon_read_flag flg,
977 const ctoon_alc *alc,
978 ctoon_read_err *err);
979
1008ctoon_api ctoon_doc *ctoon_read_opts_indent(char *dat,
1009 size_t len,
1010 ctoon_read_flag flg,
1011 int indent_size,
1012 const ctoon_alc *alc,
1013 ctoon_read_err *err);
1014
1036ctoon_api ctoon_doc *ctoon_read_file(const char *path,
1037 ctoon_read_flag flg,
1038 const ctoon_alc *alc,
1039 ctoon_read_err *err);
1040
1058ctoon_api ctoon_doc *ctoon_read_fp(FILE *fp,
1059 ctoon_read_flag flg,
1060 const ctoon_alc *alc,
1061 ctoon_read_err *err);
1062
1077ctoon_api_inline ctoon_doc *ctoon_read(const char *dat,
1078 size_t len,
1079 ctoon_read_flag flg) {
1080 flg &= ~CTOON_READ_INSITU; /* const string cannot be modified */
1081 return ctoon_read_opts((char *)(void *)(size_t)(const void *)dat,
1082 len, flg, NULL, NULL);
1083}
1084
1085
1086
1087#if !defined(CTOON_DISABLE_INCR_READER) || !CTOON_DISABLE_INCR_READER
1088
1090typedef struct ctoon_incr_state ctoon_incr_state;
1091
1115ctoon_api ctoon_incr_state *ctoon_incr_new(char *buf, size_t buf_len,
1116 ctoon_read_flag flg,
1117 const ctoon_alc *alc);
1118
1139ctoon_api ctoon_doc *ctoon_incr_read(ctoon_incr_state *state, size_t len,
1140 ctoon_read_err *err);
1141
1143ctoon_api void ctoon_incr_free(ctoon_incr_state *state);
1144
1145#endif /* CTOON_DISABLE_INCR_READER */
1146
1184ctoon_api_inline size_t ctoon_read_max_memory_usage(size_t len,
1185 ctoon_read_flag flg) {
1186 /*
1187 1. The max value count is (json_size / 2 + 1),
1188 for example: "[1,2,3,4]" size is 9, value count is 5.
1189 2. Some broken TOON may cost more memory during reading, but fail at end,
1190 for example: "[[[[[[[[".
1191 3. ctoon use 16 bytes per value, see struct ctoon_val.
1192 4. ctoon use dynamic memory with a growth factor of 1.5.
1193
1194 The max memory size is (json_size / 2 * 16 * 1.5 + padding).
1195 */
1196 size_t mul = (size_t)12 + !(flg & CTOON_READ_INSITU);
1197 size_t pad = 256;
1198 size_t max = (size_t)(~(size_t)0);
1199 if (flg & CTOON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
1200 if (len >= (max - pad - mul) / mul) return 0;
1201 return len * mul + pad;
1202}
1203
1225ctoon_api const char *ctoon_read_number(const char *dat,
1226 ctoon_val *val,
1227 ctoon_read_flag flg,
1228 const ctoon_alc *alc,
1229 ctoon_read_err *err);
1230
1232ctoon_api_inline const char *ctoon_mut_read_number(const char *dat,
1233 ctoon_mut_val *val,
1234 ctoon_read_flag flg,
1235 const ctoon_alc *alc,
1236 ctoon_read_err *err) {
1237 return ctoon_read_number(dat, (ctoon_val *)val, flg, alc, err);
1238}
1239
1240#endif /* CTOON_DISABLE_READER */
1241
1242
1243
1244/*==============================================================================
1245 * MARK: - TOON Writer API
1246 *============================================================================*/
1247
1249typedef uint32_t ctoon_write_flag;
1250
1252static const ctoon_write_flag CTOON_WRITE_NOFLAG = 0;
1253
1255static const ctoon_write_flag CTOON_WRITE_ESCAPE_UNICODE = 1 << 1;
1256
1258static const ctoon_write_flag CTOON_WRITE_ESCAPE_SLASHES = 1 << 2;
1259
1261static const ctoon_write_flag CTOON_WRITE_ALLOW_INF_AND_NAN = 1 << 3;
1262
1264static const ctoon_write_flag CTOON_WRITE_INF_AND_NAN_AS_NULL = 1 << 4;
1265
1267static const ctoon_write_flag CTOON_WRITE_ALLOW_INVALID_UNICODE = 1 << 5;
1268
1270static const ctoon_write_flag CTOON_WRITE_LENGTH_MARKER = 1 << 6;
1271
1273static const ctoon_write_flag CTOON_WRITE_NEWLINE_AT_END = 1 << 7;
1274
1279#define CTOON_WRITE_FP_FLAG_BITS 8
1280#define CTOON_WRITE_FP_PREC_BITS 4
1281
1283#define CTOON_WRITE_FP_TO_FIXED(prec) ((ctoon_write_flag)( \
1284 (uint32_t)((uint32_t)(prec)) << (32 - 4) ))
1285
1287#define CTOON_WRITE_FP_TO_FLOAT ((ctoon_write_flag)(1 << (32 - 5)))
1288
1289
1296
1298typedef uint32_t ctoon_write_code;
1299static const ctoon_write_code CTOON_WRITE_SUCCESS = 0;
1300static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_PARAMETER = 1;
1301static const ctoon_write_code CTOON_WRITE_ERROR_MEMORY_ALLOCATION = 2;
1302static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_VALUE_TYPE = 3;
1303static const ctoon_write_code CTOON_WRITE_ERROR_NAN_OR_INF = 4;
1304static const ctoon_write_code CTOON_WRITE_ERROR_FILE_OPEN = 5;
1305static const ctoon_write_code CTOON_WRITE_ERROR_FILE_WRITE = 6;
1306static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_STRING = 7;
1307
1313
1320
1321
1322#if !defined(CTOON_DISABLE_WRITER) || !CTOON_DISABLE_WRITER
1323
1334ctoon_api char *ctoon_write_opts(const ctoon_doc *doc,
1335 const ctoon_write_options *opts,
1336 const ctoon_alc *alc,
1337 size_t *len,
1338 ctoon_write_err *err);
1339
1341ctoon_api_inline char *ctoon_write(const ctoon_doc *doc, size_t *len) {
1342 return ctoon_write_opts(doc, NULL, NULL, len, NULL);
1343}
1344
1346ctoon_api bool ctoon_write_file(const char *path,
1347 const ctoon_doc *doc,
1348 const ctoon_write_options *opts,
1349 const ctoon_alc *alc,
1350 ctoon_write_err *err);
1351
1353ctoon_api bool ctoon_write_fp(FILE *fp,
1354 const ctoon_doc *doc,
1355 const ctoon_write_options *opts,
1356 const ctoon_alc *alc,
1357 ctoon_write_err *err);
1358
1360ctoon_api char *ctoon_val_write_opts(const ctoon_val *val,
1361 const ctoon_write_options *opts,
1362 const ctoon_alc *alc,
1363 size_t *len,
1364 ctoon_write_err *err);
1365
1366ctoon_api_inline char *ctoon_val_write(const ctoon_val *val, size_t *len) {
1367 return ctoon_val_write_opts(val, NULL, NULL, len, NULL);
1368}
1369
1371ctoon_api char *ctoon_mut_write_opts(const ctoon_mut_doc *doc,
1372 const ctoon_write_options *opts,
1373 const ctoon_alc *alc,
1374 size_t *len,
1375 ctoon_write_err *err);
1376
1377ctoon_api_inline char *ctoon_mut_write(const ctoon_mut_doc *doc, size_t *len) {
1378 return ctoon_mut_write_opts(doc, NULL, NULL, len, NULL);
1379}
1380
1381ctoon_api bool ctoon_mut_write_file(const char *path,
1382 const ctoon_mut_doc *doc,
1383 const ctoon_write_options *opts,
1384 const ctoon_alc *alc,
1385 ctoon_write_err *err);
1386
1387ctoon_api bool ctoon_mut_write_fp(FILE *fp,
1388 const ctoon_mut_doc *doc,
1389 const ctoon_write_options *opts,
1390 const ctoon_alc *alc,
1391 ctoon_write_err *err);
1392
1393ctoon_api char *ctoon_mut_val_write_opts(const ctoon_mut_val *val,
1394 const ctoon_write_options *opts,
1395 const ctoon_alc *alc,
1396 size_t *len,
1397 ctoon_write_err *err);
1398
1399ctoon_api_inline char *ctoon_mut_val_write(const ctoon_mut_val *val,
1400 size_t *len) {
1401 return ctoon_mut_val_write_opts(val, NULL, NULL, len, NULL);
1402}
1403
1405ctoon_api char *ctoon_write_number(const ctoon_val *val, char *buf);
1406
1426ctoon_api char *ctoon_doc_to_json(const ctoon_doc *doc,
1427 int indent,
1428 ctoon_write_flag flags,
1429 const ctoon_alc *alc,
1430 size_t *len,
1431 ctoon_write_err *err);
1432
1451ctoon_api char *ctoon_mut_doc_to_json(const ctoon_mut_doc *doc,
1452 int indent,
1453 ctoon_write_flag flags,
1454 const ctoon_alc *alc,
1455 size_t *len,
1456 ctoon_write_err *err);
1457
1458#endif /* CTOON_DISABLE_WRITER */
1459
1460
1461
1462/*==============================================================================
1463 * MARK: - JSON API
1464 *============================================================================*/
1465
1466#if defined(CTOON_ENABLE_JSON) && CTOON_ENABLE_JSON
1467
1484ctoon_api ctoon_doc *ctoon_read_json(char *dat, size_t len,
1485 ctoon_read_flag flg,
1486 const ctoon_alc *alc,
1487 ctoon_read_err *err);
1488
1506ctoon_api_inline ctoon_doc *ctoon_read_json_const(const char *dat,
1507 size_t len,
1508 ctoon_read_flag flg) {
1509 flg &= ~CTOON_READ_INSITU; /* const string cannot be modified */
1510 return ctoon_read_json((char *)(void *)(size_t)(const void *)dat,
1511 len, flg, NULL, NULL);
1512}
1513
1515ctoon_api ctoon_doc *ctoon_read_json_file(const char *path,
1516 ctoon_read_flag flg,
1517 const ctoon_alc *alc,
1518 ctoon_read_err *err);
1519
1521ctoon_api ctoon_doc *ctoon_read_json_fp(FILE *fp,
1522 ctoon_read_flag flg,
1523 const ctoon_alc *alc,
1524 ctoon_read_err *err);
1525
1539ctoon_api char *ctoon_write_json(const ctoon_doc *doc,
1540 int indent,
1541 ctoon_write_flag flg,
1542 const ctoon_alc *alc,
1543 size_t *len,
1544 ctoon_write_err *err);
1545
1547ctoon_api char *ctoon_write_json_mut(const ctoon_mut_doc *doc,
1548 int indent,
1549 ctoon_write_flag flg,
1550 const ctoon_alc *alc,
1551 size_t *len,
1552 ctoon_write_err *err);
1553
1554#endif /* CTOON_ENABLE_JSON */
1555
1556/*==============================================================================
1557 * MARK: - JSON <-> TOON direct conversion
1558 *
1559 * One call, text in, text out. No language-level intermediate value is built:
1560 * the only thing allocated besides the result is a temporary flat ctoon_doc
1561 * arena that is freed before the function returns.
1562 *============================================================================*/
1563
1564#if defined(CTOON_ENABLE_JSON) && CTOON_ENABLE_JSON && \
1565 (!defined(CTOON_DISABLE_READER) || !CTOON_DISABLE_READER) && \
1566 (!defined(CTOON_DISABLE_WRITER) || !CTOON_DISABLE_WRITER)
1567
1579ctoon_api char *ctoon_json_to_toon(const char *json, size_t len,
1580 size_t *out_len);
1581
1592ctoon_api char *ctoon_json_to_toon_opts(const char *json, size_t len,
1593 ctoon_read_flag rflg,
1594 const ctoon_write_options *wopts,
1595 const ctoon_alc *alc,
1596 size_t *out_len,
1597 ctoon_read_err *rerr,
1598 ctoon_write_err *werr);
1599
1609ctoon_api bool ctoon_json_to_toon_file(const char *json_path,
1610 const char *toon_path);
1611
1613ctoon_api bool ctoon_json_to_toon_file_opts(const char *json_path,
1614 const char *toon_path,
1615 ctoon_read_flag rflg,
1616 const ctoon_write_options *wopts,
1617 const ctoon_alc *alc,
1618 ctoon_read_err *rerr,
1619 ctoon_write_err *werr);
1620
1625ctoon_api char *ctoon_toon_to_json(const char *toon, size_t len,
1626 size_t *out_len);
1627
1635ctoon_api char *ctoon_toon_to_json_opts(const char *toon, size_t len,
1636 ctoon_read_flag rflg,
1637 int indent,
1638 ctoon_write_flag wflg,
1639 const ctoon_alc *alc,
1640 size_t *out_len,
1641 ctoon_read_err *rerr,
1642 ctoon_write_err *werr);
1643
1645ctoon_api bool ctoon_toon_to_json_file(const char *toon_path,
1646 const char *json_path);
1647
1649ctoon_api bool ctoon_toon_to_json_file_opts(const char *toon_path,
1650 const char *json_path,
1651 ctoon_read_flag rflg,
1652 int indent,
1653 ctoon_write_flag wflg,
1654 const ctoon_alc *alc,
1655 ctoon_read_err *rerr,
1656 ctoon_write_err *werr);
1657
1658#endif /* JSON <-> TOON conversion */
1659
1660
1661
1662
1663/*==============================================================================
1664 * MARK: - TOON Document API
1665 *============================================================================*/
1666
1669ctoon_api_inline ctoon_val *ctoon_doc_get_root(ctoon_doc *doc);
1670
1674ctoon_api_inline size_t ctoon_doc_get_read_size(ctoon_doc *doc);
1675
1679ctoon_api_inline size_t ctoon_doc_get_val_count(ctoon_doc *doc);
1680
1684ctoon_api_inline void ctoon_doc_free(ctoon_doc *doc);
1685
1686
1687
1688/*==============================================================================
1689 * MARK: - TOON Value Type API
1690 *============================================================================*/
1691
1694ctoon_api_inline bool ctoon_is_raw(ctoon_val *val);
1695
1698ctoon_api_inline bool ctoon_is_null(ctoon_val *val);
1699
1702ctoon_api_inline bool ctoon_is_true(ctoon_val *val);
1703
1706ctoon_api_inline bool ctoon_is_false(ctoon_val *val);
1707
1710ctoon_api_inline bool ctoon_is_bool(ctoon_val *val);
1711
1714ctoon_api_inline bool ctoon_is_uint(ctoon_val *val);
1715
1718ctoon_api_inline bool ctoon_is_sint(ctoon_val *val);
1719
1722ctoon_api_inline bool ctoon_is_int(ctoon_val *val);
1723
1726ctoon_api_inline bool ctoon_is_real(ctoon_val *val);
1727
1730ctoon_api_inline bool ctoon_is_num(ctoon_val *val);
1731
1734ctoon_api_inline bool ctoon_is_str(ctoon_val *val);
1735
1738ctoon_api_inline bool ctoon_is_arr(ctoon_val *val);
1739
1742ctoon_api_inline bool ctoon_is_obj(ctoon_val *val);
1743
1746ctoon_api_inline bool ctoon_is_ctn(ctoon_val *val);
1747
1748
1749
1750/*==============================================================================
1751 * MARK: - TOON Value Content API
1752 *============================================================================*/
1753
1756ctoon_api_inline ctoon_type ctoon_get_type(ctoon_val *val);
1757
1760ctoon_api_inline ctoon_subtype ctoon_get_subtype(ctoon_val *val);
1761
1764ctoon_api_inline uint8_t ctoon_get_tag(ctoon_val *val);
1765
1769ctoon_api_inline const char *ctoon_get_type_desc(ctoon_val *val);
1770
1773ctoon_api_inline const char *ctoon_get_raw(ctoon_val *val);
1774
1777ctoon_api_inline bool ctoon_get_bool(ctoon_val *val);
1778
1781ctoon_api_inline uint64_t ctoon_get_uint(ctoon_val *val);
1782
1785ctoon_api_inline int64_t ctoon_get_sint(ctoon_val *val);
1786
1789ctoon_api_inline int ctoon_get_int(ctoon_val *val);
1790
1793ctoon_api_inline double ctoon_get_real(ctoon_val *val);
1794
1797ctoon_api_inline double ctoon_get_num(ctoon_val *val);
1798
1801ctoon_api_inline const char *ctoon_get_str(ctoon_val *val);
1802
1805ctoon_api_inline size_t ctoon_get_len(ctoon_val *val);
1806
1809ctoon_api_inline bool ctoon_equals_str(ctoon_val *val, const char *str);
1810
1814ctoon_api_inline bool ctoon_equals_strn(ctoon_val *val, const char *str,
1815 size_t len);
1816
1822ctoon_api_inline bool ctoon_equals(ctoon_val *lhs, ctoon_val *rhs);
1823
1827ctoon_api_inline bool ctoon_set_raw(ctoon_val *val,
1828 const char *raw, size_t len);
1829
1833ctoon_api_inline bool ctoon_set_null(ctoon_val *val);
1834
1838ctoon_api_inline bool ctoon_set_bool(ctoon_val *val, bool num);
1839
1843ctoon_api_inline bool ctoon_set_uint(ctoon_val *val, uint64_t num);
1844
1848ctoon_api_inline bool ctoon_set_sint(ctoon_val *val, int64_t num);
1849
1853ctoon_api_inline bool ctoon_set_int(ctoon_val *val, int num);
1854
1858ctoon_api_inline bool ctoon_set_float(ctoon_val *val, float num);
1859
1863ctoon_api_inline bool ctoon_set_double(ctoon_val *val, double num);
1864
1868ctoon_api_inline bool ctoon_set_real(ctoon_val *val, double num);
1869
1874ctoon_api_inline bool ctoon_set_fp_to_fixed(ctoon_val *val, int prec);
1875
1880ctoon_api_inline bool ctoon_set_fp_to_float(ctoon_val *val, bool flt);
1881
1885ctoon_api_inline bool ctoon_set_str(ctoon_val *val, const char *str);
1886
1890ctoon_api_inline bool ctoon_set_strn(ctoon_val *val,
1891 const char *str, size_t len);
1892
1899ctoon_api_inline bool ctoon_set_str_noesc(ctoon_val *val, bool noesc);
1900
1901
1902
1903/*==============================================================================
1904 * MARK: - TOON Array API
1905 *============================================================================*/
1906
1909ctoon_api_inline size_t ctoon_arr_size(ctoon_val *arr);
1910
1915ctoon_api_inline ctoon_val *ctoon_arr_get(ctoon_val *arr, size_t idx);
1916
1919ctoon_api_inline ctoon_val *ctoon_arr_get_first(ctoon_val *arr);
1920
1925ctoon_api_inline ctoon_val *ctoon_arr_get_last(ctoon_val *arr);
1926
1927
1928
1929/*==============================================================================
1930 * MARK: - TOON Array Iterator API
1931 *============================================================================*/
1932
1950
1962ctoon_api_inline bool ctoon_arr_iter_init(ctoon_val *arr,
1963 ctoon_arr_iter *iter);
1964
1974ctoon_api_inline ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr);
1975
1980ctoon_api_inline bool ctoon_arr_iter_has_next(ctoon_arr_iter *iter);
1981
1986ctoon_api_inline ctoon_val *ctoon_arr_iter_next(ctoon_arr_iter *iter);
1987
2001#define ctoon_arr_foreach(arr, idx, max, val) \
2002 for ((idx) = 0, \
2003 (max) = ctoon_arr_size(arr), \
2004 (val) = ctoon_arr_get_first(arr); \
2005 (idx) < (max); \
2006 (idx)++, \
2007 (val) = unsafe_ctoon_get_next(val))
2008
2009
2010
2011/*==============================================================================
2012 * MARK: - TOON Object API
2013 *============================================================================*/
2014
2017ctoon_api_inline size_t ctoon_obj_size(ctoon_val *obj);
2018
2026ctoon_api_inline ctoon_val *ctoon_obj_get(ctoon_val *obj, const char *key);
2027
2036ctoon_api_inline ctoon_val *ctoon_obj_getn(ctoon_val *obj, const char *key,
2037 size_t key_len);
2038
2039
2040
2041/*==============================================================================
2042 * MARK: - TOON Object Iterator API
2043 *============================================================================*/
2044
2075
2087ctoon_api_inline bool ctoon_obj_iter_init(ctoon_val *obj,
2088 ctoon_obj_iter *iter);
2089
2099ctoon_api_inline ctoon_obj_iter ctoon_obj_iter_with(ctoon_val *obj);
2100
2105ctoon_api_inline bool ctoon_obj_iter_has_next(ctoon_obj_iter *iter);
2106
2111ctoon_api_inline ctoon_val *ctoon_obj_iter_next(ctoon_obj_iter *iter);
2112
2117ctoon_api_inline ctoon_val *ctoon_obj_iter_get_val(ctoon_val *key);
2118
2135ctoon_api_inline ctoon_val *ctoon_obj_iter_get(ctoon_obj_iter *iter,
2136 const char *key);
2137
2155ctoon_api_inline ctoon_val *ctoon_obj_iter_getn(ctoon_obj_iter *iter,
2156 const char *key,
2157 size_t key_len);
2158
2172#define ctoon_obj_foreach(obj, idx, max, key, val) \
2173 for ((idx) = 0, \
2174 (max) = ctoon_obj_size(obj), \
2175 (key) = (obj) ? unsafe_ctoon_get_first(obj) : NULL, \
2176 (val) = (key) + 1; \
2177 (idx) < (max); \
2178 (idx)++, \
2179 (key) = unsafe_ctoon_get_next(val), \
2180 (val) = (key) + 1)
2181
2182
2183
2184/*==============================================================================
2185 * MARK: - Mutable TOON Document API
2186 *============================================================================*/
2187
2190ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_root(ctoon_mut_doc *doc);
2191
2194ctoon_api_inline void ctoon_mut_doc_set_root(ctoon_mut_doc *doc,
2195 ctoon_mut_val *root);
2196
2210ctoon_api bool ctoon_mut_doc_set_str_pool_size(ctoon_mut_doc *doc,
2211 size_t len);
2212
2226ctoon_api bool ctoon_mut_doc_set_val_pool_size(ctoon_mut_doc *doc,
2227 size_t count);
2228
2232ctoon_api void ctoon_mut_doc_free(ctoon_mut_doc *doc);
2233
2236ctoon_api ctoon_mut_doc *ctoon_mut_doc_new(const ctoon_alc *alc);
2237
2242ctoon_api ctoon_mut_doc *ctoon_doc_mut_copy(ctoon_doc *doc,
2243 const ctoon_alc *alc);
2244
2249ctoon_api ctoon_mut_doc *ctoon_mut_doc_mut_copy(ctoon_mut_doc *doc,
2250 const ctoon_alc *alc);
2251
2256ctoon_api ctoon_mut_val *ctoon_val_mut_copy(ctoon_mut_doc *doc,
2257 ctoon_val *val);
2258
2265ctoon_api ctoon_mut_val *ctoon_mut_val_mut_copy(ctoon_mut_doc *doc,
2266 ctoon_mut_val *val);
2267
2274ctoon_api ctoon_doc *ctoon_mut_doc_imut_copy(ctoon_mut_doc *doc,
2275 const ctoon_alc *alc);
2276
2283ctoon_api ctoon_doc *ctoon_mut_val_imut_copy(ctoon_mut_val *val,
2284 const ctoon_alc *alc);
2285
2286
2287
2288/*==============================================================================
2289 * MARK: - Mutable TOON Value Type API
2290 *============================================================================*/
2291
2294ctoon_api_inline bool ctoon_mut_is_raw(ctoon_mut_val *val);
2295
2298ctoon_api_inline bool ctoon_mut_is_null(ctoon_mut_val *val);
2299
2302ctoon_api_inline bool ctoon_mut_is_true(ctoon_mut_val *val);
2303
2306ctoon_api_inline bool ctoon_mut_is_false(ctoon_mut_val *val);
2307
2310ctoon_api_inline bool ctoon_mut_is_bool(ctoon_mut_val *val);
2311
2314ctoon_api_inline bool ctoon_mut_is_uint(ctoon_mut_val *val);
2315
2318ctoon_api_inline bool ctoon_mut_is_sint(ctoon_mut_val *val);
2319
2322ctoon_api_inline bool ctoon_mut_is_int(ctoon_mut_val *val);
2323
2326ctoon_api_inline bool ctoon_mut_is_real(ctoon_mut_val *val);
2327
2330ctoon_api_inline bool ctoon_mut_is_num(ctoon_mut_val *val);
2331
2334ctoon_api_inline bool ctoon_mut_is_str(ctoon_mut_val *val);
2335
2338ctoon_api_inline bool ctoon_mut_is_arr(ctoon_mut_val *val);
2339
2342ctoon_api_inline bool ctoon_mut_is_obj(ctoon_mut_val *val);
2343
2346ctoon_api_inline bool ctoon_mut_is_ctn(ctoon_mut_val *val);
2347
2348
2349
2350/*==============================================================================
2351 * MARK: - Mutable TOON Value Content API
2352 *============================================================================*/
2353
2356ctoon_api_inline ctoon_type ctoon_mut_get_type(ctoon_mut_val *val);
2357
2360ctoon_api_inline ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val);
2361
2364ctoon_api_inline uint8_t ctoon_mut_get_tag(ctoon_mut_val *val);
2365
2369ctoon_api_inline const char *ctoon_mut_get_type_desc(ctoon_mut_val *val);
2370
2373ctoon_api_inline const char *ctoon_mut_get_raw(ctoon_mut_val *val);
2374
2377ctoon_api_inline bool ctoon_mut_get_bool(ctoon_mut_val *val);
2378
2381ctoon_api_inline uint64_t ctoon_mut_get_uint(ctoon_mut_val *val);
2382
2385ctoon_api_inline int64_t ctoon_mut_get_sint(ctoon_mut_val *val);
2386
2389ctoon_api_inline int ctoon_mut_get_int(ctoon_mut_val *val);
2390
2393ctoon_api_inline double ctoon_mut_get_real(ctoon_mut_val *val);
2394
2397ctoon_api_inline double ctoon_mut_get_num(ctoon_mut_val *val);
2398
2401ctoon_api_inline const char *ctoon_mut_get_str(ctoon_mut_val *val);
2402
2405ctoon_api_inline size_t ctoon_mut_get_len(ctoon_mut_val *val);
2406
2410ctoon_api_inline bool ctoon_mut_equals_str(ctoon_mut_val *val,
2411 const char *str);
2412
2416ctoon_api_inline bool ctoon_mut_equals_strn(ctoon_mut_val *val,
2417 const char *str, size_t len);
2418
2424ctoon_api_inline bool ctoon_mut_equals(ctoon_mut_val *lhs,
2425 ctoon_mut_val *rhs);
2426
2430ctoon_api_inline bool ctoon_mut_set_raw(ctoon_mut_val *val,
2431 const char *raw, size_t len);
2432
2436ctoon_api_inline bool ctoon_mut_set_null(ctoon_mut_val *val);
2437
2441ctoon_api_inline bool ctoon_mut_set_bool(ctoon_mut_val *val, bool num);
2442
2446ctoon_api_inline bool ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num);
2447
2451ctoon_api_inline bool ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num);
2452
2456ctoon_api_inline bool ctoon_mut_set_int(ctoon_mut_val *val, int num);
2457
2461ctoon_api_inline bool ctoon_mut_set_float(ctoon_mut_val *val, float num);
2462
2466ctoon_api_inline bool ctoon_mut_set_double(ctoon_mut_val *val, double num);
2467
2471ctoon_api_inline bool ctoon_mut_set_real(ctoon_mut_val *val, double num);
2472
2477ctoon_api_inline bool ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val,
2478 int prec);
2479
2484ctoon_api_inline bool ctoon_mut_set_fp_to_float(ctoon_mut_val *val,
2485 bool flt);
2486
2490ctoon_api_inline bool ctoon_mut_set_str(ctoon_mut_val *val, const char *str);
2491
2495ctoon_api_inline bool ctoon_mut_set_strn(ctoon_mut_val *val,
2496 const char *str, size_t len);
2497
2504ctoon_api_inline bool ctoon_mut_set_str_noesc(ctoon_mut_val *val,
2505 bool noesc);
2506
2510ctoon_api_inline bool ctoon_mut_set_arr(ctoon_mut_val *val);
2511
2515ctoon_api_inline bool ctoon_mut_set_obj(ctoon_mut_val *val);
2516
2517
2518
2519/*==============================================================================
2520 * MARK: - Mutable TOON Value Creation API
2521 *============================================================================*/
2522
2528ctoon_api_inline ctoon_mut_val *ctoon_mut_raw(ctoon_mut_doc *doc,
2529 const char *str);
2530
2536ctoon_api_inline ctoon_mut_val *ctoon_mut_rawn(ctoon_mut_doc *doc,
2537 const char *str,
2538 size_t len);
2539
2543ctoon_api_inline ctoon_mut_val *ctoon_mut_rawcpy(ctoon_mut_doc *doc,
2544 const char *str);
2545
2549ctoon_api_inline ctoon_mut_val *ctoon_mut_rawncpy(ctoon_mut_doc *doc,
2550 const char *str,
2551 size_t len);
2552
2554ctoon_api_inline ctoon_mut_val *ctoon_mut_null(ctoon_mut_doc *doc);
2555
2557ctoon_api_inline ctoon_mut_val *ctoon_mut_true(ctoon_mut_doc *doc);
2558
2560ctoon_api_inline ctoon_mut_val *ctoon_mut_false(ctoon_mut_doc *doc);
2561
2563ctoon_api_inline ctoon_mut_val *ctoon_mut_bool(ctoon_mut_doc *doc,
2564 bool val);
2565
2567ctoon_api_inline ctoon_mut_val *ctoon_mut_uint(ctoon_mut_doc *doc,
2568 uint64_t num);
2569
2571ctoon_api_inline ctoon_mut_val *ctoon_mut_sint(ctoon_mut_doc *doc,
2572 int64_t num);
2573
2575ctoon_api_inline ctoon_mut_val *ctoon_mut_int(ctoon_mut_doc *doc,
2576 int64_t num);
2577
2579ctoon_api_inline ctoon_mut_val *ctoon_mut_float(ctoon_mut_doc *doc,
2580 float num);
2581
2583ctoon_api_inline ctoon_mut_val *ctoon_mut_double(ctoon_mut_doc *doc,
2584 double num);
2585
2587ctoon_api_inline ctoon_mut_val *ctoon_mut_real(ctoon_mut_doc *doc,
2588 double num);
2589
2594ctoon_api_inline ctoon_mut_val *ctoon_mut_str(ctoon_mut_doc *doc,
2595 const char *str);
2596
2601ctoon_api_inline ctoon_mut_val *ctoon_mut_strn(ctoon_mut_doc *doc,
2602 const char *str,
2603 size_t len);
2604
2608ctoon_api_inline ctoon_mut_val *ctoon_mut_strcpy(ctoon_mut_doc *doc,
2609 const char *str);
2610
2614ctoon_api_inline ctoon_mut_val *ctoon_mut_strncpy(ctoon_mut_doc *doc,
2615 const char *str,
2616 size_t len);
2617
2618
2619
2620/*==============================================================================
2621 * MARK: - Mutable TOON Array API
2622 *============================================================================*/
2623
2626ctoon_api_inline size_t ctoon_mut_arr_size(ctoon_mut_val *arr);
2627
2631ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get(ctoon_mut_val *arr,
2632 size_t idx);
2633
2636ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_first(ctoon_mut_val *arr);
2637
2640ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_last(ctoon_mut_val *arr);
2641
2642
2643
2644/*==============================================================================
2645 * MARK: - Mutable TOON Array Iterator API
2646 *============================================================================*/
2647
2673
2685ctoon_api_inline bool ctoon_mut_arr_iter_init(ctoon_mut_val *arr,
2686 ctoon_mut_arr_iter *iter);
2687
2697ctoon_api_inline ctoon_mut_arr_iter ctoon_mut_arr_iter_with(
2698 ctoon_mut_val *arr);
2699
2704ctoon_api_inline bool ctoon_mut_arr_iter_has_next(
2705 ctoon_mut_arr_iter *iter);
2706
2711ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_next(
2712 ctoon_mut_arr_iter *iter);
2713
2718ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_remove(
2719 ctoon_mut_arr_iter *iter);
2720
2736#define ctoon_mut_arr_foreach(arr, idx, max, val) \
2737 for ((idx) = 0, \
2738 (max) = ctoon_mut_arr_size(arr), \
2739 (val) = ctoon_mut_arr_get_first(arr); \
2740 (idx) < (max); \
2741 (idx)++, \
2742 (val) = (val)->next)
2743
2744
2745
2746/*==============================================================================
2747 * MARK: - Mutable TOON Array Creation API
2748 *============================================================================*/
2749
2755ctoon_api_inline ctoon_mut_val *ctoon_mut_arr(ctoon_mut_doc *doc);
2756
2772ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_bool(
2773 ctoon_mut_doc *doc, const bool *vals, size_t count);
2774
2790ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint(
2791 ctoon_mut_doc *doc, const int64_t *vals, size_t count);
2792
2808ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint(
2809 ctoon_mut_doc *doc, const uint64_t *vals, size_t count);
2810
2826ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_real(
2827 ctoon_mut_doc *doc, const double *vals, size_t count);
2828
2844ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint8(
2845 ctoon_mut_doc *doc, const int8_t *vals, size_t count);
2846
2862ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint16(
2863 ctoon_mut_doc *doc, const int16_t *vals, size_t count);
2864
2880ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint32(
2881 ctoon_mut_doc *doc, const int32_t *vals, size_t count);
2882
2898ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint64(
2899 ctoon_mut_doc *doc, const int64_t *vals, size_t count);
2900
2916ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint8(
2917 ctoon_mut_doc *doc, const uint8_t *vals, size_t count);
2918
2934ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint16(
2935 ctoon_mut_doc *doc, const uint16_t *vals, size_t count);
2936
2952ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint32(
2953 ctoon_mut_doc *doc, const uint32_t *vals, size_t count);
2954
2970ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint64(
2971 ctoon_mut_doc *doc, const uint64_t *vals, size_t count);
2972
2988ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_float(
2989 ctoon_mut_doc *doc, const float *vals, size_t count);
2990
3006ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_double(
3007 ctoon_mut_doc *doc, const double *vals, size_t count);
3008
3031ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_str(
3032 ctoon_mut_doc *doc, const char **vals, size_t count);
3033
3058ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strn(
3059 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
3060
3079ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strcpy(
3080 ctoon_mut_doc *doc, const char **vals, size_t count);
3081
3102ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strncpy(
3103 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
3104
3105
3106
3107/*==============================================================================
3108 * MARK: - Mutable TOON Array Modification API
3109 *============================================================================*/
3110
3121ctoon_api_inline bool ctoon_mut_arr_insert(ctoon_mut_val *arr,
3122 ctoon_mut_val *val, size_t idx);
3123
3131ctoon_api_inline bool ctoon_mut_arr_append(ctoon_mut_val *arr,
3132 ctoon_mut_val *val);
3133
3141ctoon_api_inline bool ctoon_mut_arr_prepend(ctoon_mut_val *arr,
3142 ctoon_mut_val *val);
3143
3154ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_replace(ctoon_mut_val *arr,
3155 size_t idx,
3156 ctoon_mut_val *val);
3157
3167ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove(ctoon_mut_val *arr,
3168 size_t idx);
3169
3176ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_first(
3177 ctoon_mut_val *arr);
3178
3185ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_last(
3186 ctoon_mut_val *arr);
3187
3197ctoon_api_inline bool ctoon_mut_arr_remove_range(ctoon_mut_val *arr,
3198 size_t idx, size_t len);
3199
3206ctoon_api_inline bool ctoon_mut_arr_clear(ctoon_mut_val *arr);
3207
3215ctoon_api_inline bool ctoon_mut_arr_rotate(ctoon_mut_val *arr,
3216 size_t idx);
3217
3218
3219
3220/*==============================================================================
3221 * MARK: - Mutable TOON Array Modification Convenience API
3222 *============================================================================*/
3223
3231ctoon_api_inline bool ctoon_mut_arr_add_val(ctoon_mut_val *arr,
3232 ctoon_mut_val *val);
3233
3241ctoon_api_inline bool ctoon_mut_arr_add_null(ctoon_mut_doc *doc,
3242 ctoon_mut_val *arr);
3243
3251ctoon_api_inline bool ctoon_mut_arr_add_true(ctoon_mut_doc *doc,
3252 ctoon_mut_val *arr);
3253
3261ctoon_api_inline bool ctoon_mut_arr_add_false(ctoon_mut_doc *doc,
3262 ctoon_mut_val *arr);
3263
3272ctoon_api_inline bool ctoon_mut_arr_add_bool(ctoon_mut_doc *doc,
3273 ctoon_mut_val *arr,
3274 bool val);
3275
3284ctoon_api_inline bool ctoon_mut_arr_add_uint(ctoon_mut_doc *doc,
3285 ctoon_mut_val *arr,
3286 uint64_t num);
3287
3296ctoon_api_inline bool ctoon_mut_arr_add_sint(ctoon_mut_doc *doc,
3297 ctoon_mut_val *arr,
3298 int64_t num);
3299
3308ctoon_api_inline bool ctoon_mut_arr_add_int(ctoon_mut_doc *doc,
3309 ctoon_mut_val *arr,
3310 int64_t num);
3311
3320ctoon_api_inline bool ctoon_mut_arr_add_float(ctoon_mut_doc *doc,
3321 ctoon_mut_val *arr,
3322 float num);
3323
3332ctoon_api_inline bool ctoon_mut_arr_add_double(ctoon_mut_doc *doc,
3333 ctoon_mut_val *arr,
3334 double num);
3335
3344ctoon_api_inline bool ctoon_mut_arr_add_real(ctoon_mut_doc *doc,
3345 ctoon_mut_val *arr,
3346 double num);
3347
3358ctoon_api_inline bool ctoon_mut_arr_add_str(ctoon_mut_doc *doc,
3359 ctoon_mut_val *arr,
3360 const char *str);
3361
3373ctoon_api_inline bool ctoon_mut_arr_add_strn(ctoon_mut_doc *doc,
3374 ctoon_mut_val *arr,
3375 const char *str,
3376 size_t len);
3377
3386ctoon_api_inline bool ctoon_mut_arr_add_strcpy(ctoon_mut_doc *doc,
3387 ctoon_mut_val *arr,
3388 const char *str);
3389
3399ctoon_api_inline bool ctoon_mut_arr_add_strncpy(ctoon_mut_doc *doc,
3400 ctoon_mut_val *arr,
3401 const char *str,
3402 size_t len);
3403
3411ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_arr(ctoon_mut_doc *doc,
3412 ctoon_mut_val *arr);
3413
3421ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_obj(ctoon_mut_doc *doc,
3422 ctoon_mut_val *arr);
3423
3424
3425
3426/*==============================================================================
3427 * MARK: - Mutable TOON Object API
3428 *============================================================================*/
3429
3432ctoon_api_inline size_t ctoon_mut_obj_size(ctoon_mut_val *obj);
3433
3441ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_get(ctoon_mut_val *obj,
3442 const char *key);
3443
3452ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_getn(ctoon_mut_val *obj,
3453 const char *key,
3454 size_t key_len);
3455
3456
3457
3458/*==============================================================================
3459 * MARK: - Mutable TOON Object Iterator API
3460 *============================================================================*/
3461
3499
3511ctoon_api_inline bool ctoon_mut_obj_iter_init(ctoon_mut_val *obj,
3512 ctoon_mut_obj_iter *iter);
3513
3523ctoon_api_inline ctoon_mut_obj_iter ctoon_mut_obj_iter_with(
3524 ctoon_mut_val *obj);
3525
3530ctoon_api_inline bool ctoon_mut_obj_iter_has_next(
3531 ctoon_mut_obj_iter *iter);
3532
3537ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_next(
3538 ctoon_mut_obj_iter *iter);
3539
3544ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get_val(
3545 ctoon_mut_val *key);
3546
3551ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_remove(
3552 ctoon_mut_obj_iter *iter);
3553
3570ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get(
3571 ctoon_mut_obj_iter *iter, const char *key);
3572
3590ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_getn(
3591 ctoon_mut_obj_iter *iter, const char *key, size_t key_len);
3592
3608#define ctoon_mut_obj_foreach(obj, idx, max, key, val) \
3609 for ((idx) = 0, \
3610 (max) = ctoon_mut_obj_size(obj), \
3611 (key) = (max) ? ((ctoon_mut_val *)(obj)->uni.ptr)->next->next : NULL, \
3612 (val) = (key) ? (key)->next : NULL; \
3613 (idx) < (max); \
3614 (idx)++, \
3615 (key) = (val)->next, \
3616 (val) = (key)->next)
3617
3618
3619
3620/*==============================================================================
3621 * MARK: - Mutable TOON Object Creation API
3622 *============================================================================*/
3623
3625ctoon_api_inline ctoon_mut_val *ctoon_mut_obj(ctoon_mut_doc *doc);
3626
3642ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_str(ctoon_mut_doc *doc,
3643 const char **keys,
3644 const char **vals,
3645 size_t count);
3646
3661ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_kv(ctoon_mut_doc *doc,
3662 const char **kv_pairs,
3663 size_t pair_count);
3664
3665
3666
3667/*==============================================================================
3668 * MARK: - Mutable TOON Object Modification API
3669 *============================================================================*/
3670
3680ctoon_api_inline bool ctoon_mut_obj_add(ctoon_mut_val *obj,
3681 ctoon_mut_val *key,
3682 ctoon_mut_val *val);
3693ctoon_api_inline bool ctoon_mut_obj_put(ctoon_mut_val *obj,
3694 ctoon_mut_val *key,
3695 ctoon_mut_val *val);
3696
3707ctoon_api_inline bool ctoon_mut_obj_insert(ctoon_mut_val *obj,
3708 ctoon_mut_val *key,
3709 ctoon_mut_val *val,
3710 size_t idx);
3711
3719ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove(ctoon_mut_val *obj,
3720 ctoon_mut_val *key);
3721
3729ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_key(
3730 ctoon_mut_val *obj, const char *key);
3731
3740ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_keyn(
3741 ctoon_mut_val *obj, const char *key, size_t key_len);
3742
3748ctoon_api_inline bool ctoon_mut_obj_clear(ctoon_mut_val *obj);
3749
3759ctoon_api_inline bool ctoon_mut_obj_replace(ctoon_mut_val *obj,
3760 ctoon_mut_val *key,
3761 ctoon_mut_val *val);
3762
3772ctoon_api_inline bool ctoon_mut_obj_rotate(ctoon_mut_val *obj,
3773 size_t idx);
3774
3775
3776
3777/*==============================================================================
3778 * MARK: - Mutable TOON Object Modification Convenience API
3779 *============================================================================*/
3780
3787ctoon_api_inline bool ctoon_mut_obj_add_null(ctoon_mut_doc *doc,
3788 ctoon_mut_val *obj,
3789 const char *key);
3790
3797ctoon_api_inline bool ctoon_mut_obj_add_true(ctoon_mut_doc *doc,
3798 ctoon_mut_val *obj,
3799 const char *key);
3800
3807ctoon_api_inline bool ctoon_mut_obj_add_false(ctoon_mut_doc *doc,
3808 ctoon_mut_val *obj,
3809 const char *key);
3810
3817ctoon_api_inline bool ctoon_mut_obj_add_bool(ctoon_mut_doc *doc,
3818 ctoon_mut_val *obj,
3819 const char *key, bool val);
3820
3827ctoon_api_inline bool ctoon_mut_obj_add_uint(ctoon_mut_doc *doc,
3828 ctoon_mut_val *obj,
3829 const char *key, uint64_t val);
3830
3837ctoon_api_inline bool ctoon_mut_obj_add_sint(ctoon_mut_doc *doc,
3838 ctoon_mut_val *obj,
3839 const char *key, int64_t val);
3840
3847ctoon_api_inline bool ctoon_mut_obj_add_int(ctoon_mut_doc *doc,
3848 ctoon_mut_val *obj,
3849 const char *key, int64_t val);
3850
3857ctoon_api_inline bool ctoon_mut_obj_add_float(ctoon_mut_doc *doc,
3858 ctoon_mut_val *obj,
3859 const char *key, float val);
3860
3867ctoon_api_inline bool ctoon_mut_obj_add_double(ctoon_mut_doc *doc,
3868 ctoon_mut_val *obj,
3869 const char *key, double val);
3870
3877ctoon_api_inline bool ctoon_mut_obj_add_real(ctoon_mut_doc *doc,
3878 ctoon_mut_val *obj,
3879 const char *key, double val);
3880
3887ctoon_api_inline bool ctoon_mut_obj_add_str(ctoon_mut_doc *doc,
3888 ctoon_mut_val *obj,
3889 const char *key, const char *val);
3890
3899ctoon_api_inline bool ctoon_mut_obj_add_strn(ctoon_mut_doc *doc,
3900 ctoon_mut_val *obj,
3901 const char *key,
3902 const char *val, size_t len);
3903
3911ctoon_api_inline bool ctoon_mut_obj_add_strcpy(ctoon_mut_doc *doc,
3912 ctoon_mut_val *obj,
3913 const char *key,
3914 const char *val);
3915
3924ctoon_api_inline bool ctoon_mut_obj_add_strncpy(ctoon_mut_doc *doc,
3925 ctoon_mut_val *obj,
3926 const char *key,
3927 const char *val, size_t len);
3928
3938ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_arr(ctoon_mut_doc *doc,
3939 ctoon_mut_val *obj,
3940 const char *key);
3941
3951ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_obj(ctoon_mut_doc *doc,
3952 ctoon_mut_val *obj,
3953 const char *key);
3954
3961ctoon_api_inline bool ctoon_mut_obj_add_val(ctoon_mut_doc *doc,
3962 ctoon_mut_val *obj,
3963 const char *key,
3964 ctoon_mut_val *val);
3965
3972ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_str(
3973 ctoon_mut_val *obj, const char *key);
3974
3982ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_strn(
3983 ctoon_mut_val *obj, const char *key, size_t len);
3984
3993ctoon_api_inline bool ctoon_mut_obj_rename_key(ctoon_mut_doc *doc,
3994 ctoon_mut_val *obj,
3995 const char *key,
3996 const char *new_key);
3997
4006ctoon_api_inline bool ctoon_mut_obj_rename_keyn(ctoon_mut_doc *doc,
4007 ctoon_mut_val *obj,
4008 const char *key,
4009 size_t len,
4010 const char *new_key,
4011 size_t new_len);
4012
4013
4014
4015#if !defined(CTOON_DISABLE_UTILS) || !CTOON_DISABLE_UTILS
4016
4017/*==============================================================================
4018 * MARK: - TOON Pointer API (RFC 6901)
4019 * https://tools.ietf.org/html/rfc6901
4020 *============================================================================*/
4021
4023typedef uint32_t ctoon_ptr_code;
4024
4026static const ctoon_ptr_code CTOON_PTR_ERR_NONE = 0;
4027
4029static const ctoon_ptr_code CTOON_PTR_ERR_PARAMETER = 1;
4030
4032static const ctoon_ptr_code CTOON_PTR_ERR_SYNTAX = 2;
4033
4035static const ctoon_ptr_code CTOON_PTR_ERR_RESOLVE = 3;
4036
4038static const ctoon_ptr_code CTOON_PTR_ERR_NULL_ROOT = 4;
4039
4041static const ctoon_ptr_code CTOON_PTR_ERR_SET_ROOT = 5;
4042
4044static const ctoon_ptr_code CTOON_PTR_ERR_MEMORY_ALLOCATION = 6;
4045
4055
4099
4107ctoon_api_inline ctoon_val *ctoon_doc_ptr_get(ctoon_doc *doc,
4108 const char *ptr);
4109
4118ctoon_api_inline ctoon_val *ctoon_doc_ptr_getn(ctoon_doc *doc,
4119 const char *ptr, size_t len);
4120
4130ctoon_api_inline ctoon_val *ctoon_doc_ptr_getx(ctoon_doc *doc,
4131 const char *ptr, size_t len,
4132 ctoon_ptr_err *err);
4133
4141ctoon_api_inline ctoon_val *ctoon_ptr_get(ctoon_val *val,
4142 const char *ptr);
4143
4152ctoon_api_inline ctoon_val *ctoon_ptr_getn(ctoon_val *val,
4153 const char *ptr, size_t len);
4154
4164ctoon_api_inline ctoon_val *ctoon_ptr_getx(ctoon_val *val,
4165 const char *ptr, size_t len,
4166 ctoon_ptr_err *err);
4167
4175ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_get(ctoon_mut_doc *doc,
4176 const char *ptr);
4177
4186ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getn(ctoon_mut_doc *doc,
4187 const char *ptr,
4188 size_t len);
4189
4200ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getx(ctoon_mut_doc *doc,
4201 const char *ptr,
4202 size_t len,
4203 ctoon_ptr_ctx *ctx,
4204 ctoon_ptr_err *err);
4205
4213ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_get(ctoon_mut_val *val,
4214 const char *ptr);
4215
4224ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getn(ctoon_mut_val *val,
4225 const char *ptr,
4226 size_t len);
4227
4238ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getx(ctoon_mut_val *val,
4239 const char *ptr,
4240 size_t len,
4241 ctoon_ptr_ctx *ctx,
4242 ctoon_ptr_err *err);
4243
4252ctoon_api_inline bool ctoon_mut_doc_ptr_add(ctoon_mut_doc *doc,
4253 const char *ptr,
4254 ctoon_mut_val *new_val);
4255
4265ctoon_api_inline bool ctoon_mut_doc_ptr_addn(ctoon_mut_doc *doc,
4266 const char *ptr, size_t len,
4267 ctoon_mut_val *new_val);
4268
4280ctoon_api_inline bool ctoon_mut_doc_ptr_addx(ctoon_mut_doc *doc,
4281 const char *ptr, size_t len,
4282 ctoon_mut_val *new_val,
4283 bool create_parent,
4284 ctoon_ptr_ctx *ctx,
4285 ctoon_ptr_err *err);
4286
4296ctoon_api_inline bool ctoon_mut_ptr_add(ctoon_mut_val *val,
4297 const char *ptr,
4298 ctoon_mut_val *new_val,
4299 ctoon_mut_doc *doc);
4300
4311ctoon_api_inline bool ctoon_mut_ptr_addn(ctoon_mut_val *val,
4312 const char *ptr, size_t len,
4313 ctoon_mut_val *new_val,
4314 ctoon_mut_doc *doc);
4315
4328ctoon_api_inline bool ctoon_mut_ptr_addx(ctoon_mut_val *val,
4329 const char *ptr, size_t len,
4330 ctoon_mut_val *new_val,
4331 ctoon_mut_doc *doc,
4332 bool create_parent,
4333 ctoon_ptr_ctx *ctx,
4334 ctoon_ptr_err *err);
4335
4345ctoon_api_inline bool ctoon_mut_doc_ptr_set(ctoon_mut_doc *doc,
4346 const char *ptr,
4347 ctoon_mut_val *new_val);
4348
4359ctoon_api_inline bool ctoon_mut_doc_ptr_setn(ctoon_mut_doc *doc,
4360 const char *ptr, size_t len,
4361 ctoon_mut_val *new_val);
4362
4375ctoon_api_inline bool ctoon_mut_doc_ptr_setx(ctoon_mut_doc *doc,
4376 const char *ptr, size_t len,
4377 ctoon_mut_val *new_val,
4378 bool create_parent,
4379 ctoon_ptr_ctx *ctx,
4380 ctoon_ptr_err *err);
4381
4392ctoon_api_inline bool ctoon_mut_ptr_set(ctoon_mut_val *val,
4393 const char *ptr,
4394 ctoon_mut_val *new_val,
4395 ctoon_mut_doc *doc);
4396
4408ctoon_api_inline bool ctoon_mut_ptr_setn(ctoon_mut_val *val,
4409 const char *ptr, size_t len,
4410 ctoon_mut_val *new_val,
4411 ctoon_mut_doc *doc);
4412
4426ctoon_api_inline bool ctoon_mut_ptr_setx(ctoon_mut_val *val,
4427 const char *ptr, size_t len,
4428 ctoon_mut_val *new_val,
4429 ctoon_mut_doc *doc,
4430 bool create_parent,
4431 ctoon_ptr_ctx *ctx,
4432 ctoon_ptr_err *err);
4433
4441ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replace(
4442 ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val);
4443
4452ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacen(
4453 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val);
4454
4465ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacex(
4466 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val,
4467 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4468
4476ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replace(
4477 ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val);
4478
4487ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacen(
4488 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val);
4489
4500ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacex(
4501 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
4502 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4503
4510ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_remove(
4511 ctoon_mut_doc *doc, const char *ptr);
4512
4520ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removen(
4521 ctoon_mut_doc *doc, const char *ptr, size_t len);
4522
4532ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removex(
4533 ctoon_mut_doc *doc, const char *ptr, size_t len,
4534 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4535
4542ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_remove(ctoon_mut_val *val,
4543 const char *ptr);
4544
4552ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removen(ctoon_mut_val *val,
4553 const char *ptr,
4554 size_t len);
4555
4565ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removex(ctoon_mut_val *val,
4566 const char *ptr,
4567 size_t len,
4568 ctoon_ptr_ctx *ctx,
4569 ctoon_ptr_err *err);
4570
4578ctoon_api_inline bool ctoon_ptr_ctx_append(ctoon_ptr_ctx *ctx,
4579 ctoon_mut_val *key,
4580 ctoon_mut_val *val);
4581
4589ctoon_api_inline bool ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx,
4590 ctoon_mut_val *val);
4591
4598ctoon_api_inline bool ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx);
4599
4600
4601
4602/*==============================================================================
4603 * MARK: - TOON Patch API (RFC 6902)
4604 * https://tools.ietf.org/html/rfc6902
4605 *============================================================================*/
4606
4608typedef uint32_t ctoon_patch_code;
4609
4611static const ctoon_patch_code CTOON_PATCH_SUCCESS = 0;
4612
4614static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_PARAMETER = 1;
4615
4617static const ctoon_patch_code CTOON_PATCH_ERROR_MEMORY_ALLOCATION = 2;
4618
4620static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_OPERATION = 3;
4621
4623static const ctoon_patch_code CTOON_PATCH_ERROR_MISSING_KEY = 4;
4624
4626static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_MEMBER = 5;
4627
4629static const ctoon_patch_code CTOON_PATCH_ERROR_EQUAL = 6;
4630
4632static const ctoon_patch_code CTOON_PATCH_ERROR_POINTER = 7;
4633
4645
4652ctoon_api ctoon_mut_val *ctoon_patch(ctoon_mut_doc *doc,
4653 ctoon_val *orig,
4654 ctoon_val *patch,
4655 ctoon_patch_err *err);
4656
4663ctoon_api ctoon_mut_val *ctoon_mut_patch(ctoon_mut_doc *doc,
4664 ctoon_mut_val *orig,
4665 ctoon_mut_val *patch,
4666 ctoon_patch_err *err);
4667
4668
4669
4670/*==============================================================================
4671 * MARK: - TOON Merge-Patch API (RFC 7386)
4672 * https://tools.ietf.org/html/rfc7386
4673 *============================================================================*/
4674
4683ctoon_api ctoon_mut_val *ctoon_merge_patch(ctoon_mut_doc *doc,
4684 ctoon_val *orig,
4685 ctoon_val *patch);
4686
4695ctoon_api ctoon_mut_val *ctoon_mut_merge_patch(ctoon_mut_doc *doc,
4696 ctoon_mut_val *orig,
4697 ctoon_mut_val *patch);
4698
4699#endif /* CTOON_DISABLE_UTILS */
4700
4701
4702
4703/*==============================================================================
4704 * MARK: - TOON Structure (Implementation)
4705 *============================================================================*/
4706
4708typedef union ctoon_val_uni {
4709 uint64_t u64;
4710 int64_t i64;
4711 double f64;
4712 const char *str;
4713 void *ptr;
4714 size_t ofs;
4715} ctoon_val_uni;
4716
4720struct ctoon_val {
4721 uint64_t tag;
4722 ctoon_val_uni uni;
4723};
4724
4737
4738
4739
4740/*==============================================================================
4741 * MARK: - Unsafe TOON Value API (Implementation)
4742 *============================================================================*/
4743
4744/*
4745 Whether the string does not need to be escaped for serialization.
4746 This function is used to optimize the writing speed of small constant strings.
4747 This function works only if the compiler can evaluate it at compile time.
4748
4749 Clang supports it since v8.0,
4750 earlier versions do not support constant_p(strlen) and return false.
4751 GCC supports it since at least v4.4,
4752 earlier versions may compile it as run-time instructions.
4753 ICC supports it since at least v16,
4754 earlier versions are uncertain.
4755
4756 @param str The C string.
4757 @param len The returnd value from strlen(str).
4758 */
4759ctoon_api_inline bool unsafe_ctoon_is_str_noesc(const char *str, size_t len) {
4760#if CTOON_HAS_CONSTANT_P && \
4761 (!CTOON_IS_REAL_GCC || ctoon_gcc_available(4, 4, 0))
4762 if (ctoon_constant_p(len) && len <= 32) {
4763 /*
4764 Same as the following loop:
4765
4766 for (size_t i = 0; i < len; i++) {
4767 char c = str[i];
4768 if (c < ' ' || c > '~' || c == '"' || c == '\\') return false;
4769 }
4770
4771 GCC evaluates it at compile time only if the string length is within 17
4772 and -O3 (which turns on the -fpeel-loops flag) is used.
4773 So the loop is unrolled for GCC.
4774 */
4775# define ctoon_repeat32_incr(x) \
4776 x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \
4777 x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) \
4778 x(16) x(17) x(18) x(19) x(20) x(21) x(22) x(23) \
4779 x(24) x(25) x(26) x(27) x(28) x(29) x(30) x(31)
4780# define ctoon_check_char_noesc(i) \
4781 if (i < len) { \
4782 char c = str[i]; \
4783 if (c < ' ' || c > '~' || c == '"' || c == '\\') return false; }
4784 ctoon_repeat32_incr(ctoon_check_char_noesc)
4785# undef ctoon_repeat32_incr
4786# undef ctoon_check_char_noesc
4787 return true;
4788 }
4789#else
4790 (void)str;
4791 (void)len;
4792#endif
4793 return false;
4794}
4795
4796ctoon_api_inline double unsafe_ctoon_u64_to_f64(uint64_t num) {
4797#if CTOON_U64_TO_F64_NO_IMPL
4798 uint64_t msb = ((uint64_t)1) << 63;
4799 if ((num & msb) == 0) {
4800 return (double)(int64_t)num;
4801 } else {
4802 return ((double)(int64_t)((num >> 1) | (num & 1))) * (double)2.0;
4803 }
4804#else
4805 return (double)num;
4806#endif
4807}
4808
4809ctoon_api_inline ctoon_type unsafe_ctoon_get_type(void *val) {
4810 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4811 return (ctoon_type)(tag & CTOON_TYPE_MASK);
4812}
4813
4814ctoon_api_inline ctoon_subtype unsafe_ctoon_get_subtype(void *val) {
4815 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4816 return (ctoon_subtype)(tag & CTOON_SUBTYPE_MASK);
4817}
4818
4819ctoon_api_inline uint8_t unsafe_ctoon_get_tag(void *val) {
4820 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4821 return (uint8_t)(tag & CTOON_TAG_MASK);
4822}
4823
4824ctoon_api_inline bool unsafe_ctoon_is_raw(void *val) {
4825 return unsafe_ctoon_get_type(val) == CTOON_TYPE_RAW;
4826}
4827
4828ctoon_api_inline bool unsafe_ctoon_is_null(void *val) {
4829 return unsafe_ctoon_get_type(val) == CTOON_TYPE_NULL;
4830}
4831
4832ctoon_api_inline bool unsafe_ctoon_is_bool(void *val) {
4833 return unsafe_ctoon_get_type(val) == CTOON_TYPE_BOOL;
4834}
4835
4836ctoon_api_inline bool unsafe_ctoon_is_num(void *val) {
4837 return unsafe_ctoon_get_type(val) == CTOON_TYPE_NUM;
4838}
4839
4840ctoon_api_inline bool unsafe_ctoon_is_str(void *val) {
4841 return unsafe_ctoon_get_type(val) == CTOON_TYPE_STR;
4842}
4843
4844ctoon_api_inline bool unsafe_ctoon_is_arr(void *val) {
4845 return unsafe_ctoon_get_type(val) == CTOON_TYPE_ARR;
4846}
4847
4848ctoon_api_inline bool unsafe_ctoon_is_obj(void *val) {
4849 return unsafe_ctoon_get_type(val) == CTOON_TYPE_OBJ;
4850}
4851
4852ctoon_api_inline bool unsafe_ctoon_is_ctn(void *val) {
4853 uint8_t mask = CTOON_TYPE_ARR & CTOON_TYPE_OBJ;
4854 return (unsafe_ctoon_get_tag(val) & mask) == mask;
4855}
4856
4857ctoon_api_inline bool unsafe_ctoon_is_uint(void *val) {
4858 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT;
4859 return unsafe_ctoon_get_tag(val) == patt;
4860}
4861
4862ctoon_api_inline bool unsafe_ctoon_is_sint(void *val) {
4863 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT;
4864 return unsafe_ctoon_get_tag(val) == patt;
4865}
4866
4867ctoon_api_inline bool unsafe_ctoon_is_int(void *val) {
4868 const uint8_t mask = CTOON_TAG_MASK & (~CTOON_SUBTYPE_SINT);
4869 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT;
4870 return (unsafe_ctoon_get_tag(val) & mask) == patt;
4871}
4872
4873ctoon_api_inline bool unsafe_ctoon_is_real(void *val) {
4874 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL;
4875 return unsafe_ctoon_get_tag(val) == patt;
4876}
4877
4878ctoon_api_inline bool unsafe_ctoon_is_true(void *val) {
4879 const uint8_t patt = CTOON_TYPE_BOOL | CTOON_SUBTYPE_TRUE;
4880 return unsafe_ctoon_get_tag(val) == patt;
4881}
4882
4883ctoon_api_inline bool unsafe_ctoon_is_false(void *val) {
4884 const uint8_t patt = CTOON_TYPE_BOOL | CTOON_SUBTYPE_FALSE;
4885 return unsafe_ctoon_get_tag(val) == patt;
4886}
4887
4888ctoon_api_inline bool unsafe_ctoon_arr_is_flat(ctoon_val *val) {
4889 size_t ofs = val->uni.ofs;
4890 size_t len = (size_t)(val->tag >> CTOON_TAG_BIT);
4891 return len * sizeof(ctoon_val) + sizeof(ctoon_val) == ofs;
4892}
4893
4894ctoon_api_inline const char *unsafe_ctoon_get_raw(void *val) {
4895 return ((ctoon_val *)val)->uni.str;
4896}
4897
4898ctoon_api_inline bool unsafe_ctoon_get_bool(void *val) {
4899 uint8_t tag = unsafe_ctoon_get_tag(val);
4900 return (bool)((tag & CTOON_SUBTYPE_MASK) >> CTOON_TYPE_BIT);
4901}
4902
4903ctoon_api_inline uint64_t unsafe_ctoon_get_uint(void *val) {
4904 return ((ctoon_val *)val)->uni.u64;
4905}
4906
4907ctoon_api_inline int64_t unsafe_ctoon_get_sint(void *val) {
4908 return ((ctoon_val *)val)->uni.i64;
4909}
4910
4911ctoon_api_inline int unsafe_ctoon_get_int(void *val) {
4912 return (int)((ctoon_val *)val)->uni.i64;
4913}
4914
4915ctoon_api_inline double unsafe_ctoon_get_real(void *val) {
4916 return ((ctoon_val *)val)->uni.f64;
4917}
4918
4919ctoon_api_inline double unsafe_ctoon_get_num(void *val) {
4920 uint8_t tag = unsafe_ctoon_get_tag(val);
4921 if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL)) {
4922 return ((ctoon_val *)val)->uni.f64;
4923 } else if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT)) {
4924 return (double)((ctoon_val *)val)->uni.i64;
4925 } else if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT)) {
4926 return unsafe_ctoon_u64_to_f64(((ctoon_val *)val)->uni.u64);
4927 }
4928 return 0.0;
4929}
4930
4931ctoon_api_inline const char *unsafe_ctoon_get_str(void *val) {
4932 return ((ctoon_val *)val)->uni.str;
4933}
4934
4935ctoon_api_inline size_t unsafe_ctoon_get_len(void *val) {
4936 return (size_t)(((ctoon_val *)val)->tag >> CTOON_TAG_BIT);
4937}
4938
4939ctoon_api_inline ctoon_val *unsafe_ctoon_get_first(ctoon_val *ctn) {
4940 return ctn + 1;
4941}
4942
4943ctoon_api_inline ctoon_val *unsafe_ctoon_get_next(ctoon_val *val) {
4944 bool is_ctn = unsafe_ctoon_is_ctn(val);
4945 size_t ctn_ofs = val->uni.ofs;
4946 size_t ofs = (is_ctn ? ctn_ofs : sizeof(ctoon_val));
4947 return (ctoon_val *)(void *)((uint8_t *)val + ofs);
4948}
4949
4950ctoon_api_inline bool unsafe_ctoon_equals_strn(void *val, const char *str,
4951 size_t len) {
4952 return unsafe_ctoon_get_len(val) == len &&
4953 memcmp(((ctoon_val *)val)->uni.str, str, len) == 0;
4954}
4955
4956ctoon_api_inline bool unsafe_ctoon_equals_str(void *val, const char *str) {
4957 return unsafe_ctoon_equals_strn(val, str, strlen(str));
4958}
4959
4960ctoon_api_inline void unsafe_ctoon_set_type(void *val, ctoon_type type,
4961 ctoon_subtype subtype) {
4962 uint8_t tag = (type | subtype);
4963 uint64_t new_tag = ((ctoon_val *)val)->tag;
4964 new_tag = (new_tag & (~(uint64_t)CTOON_TAG_MASK)) | (uint64_t)tag;
4965 ((ctoon_val *)val)->tag = new_tag;
4966}
4967
4968ctoon_api_inline void unsafe_ctoon_set_len(void *val, size_t len) {
4969 uint64_t tag = ((ctoon_val *)val)->tag & CTOON_TAG_MASK;
4970 tag |= (uint64_t)len << CTOON_TAG_BIT;
4971 ((ctoon_val *)val)->tag = tag;
4972}
4973
4974ctoon_api_inline void unsafe_ctoon_set_tag(void *val, ctoon_type type,
4975 ctoon_subtype subtype,
4976 size_t len) {
4977 uint64_t tag = (uint64_t)len << CTOON_TAG_BIT;
4978 tag |= (type | subtype);
4979 ((ctoon_val *)val)->tag = tag;
4980}
4981
4982ctoon_api_inline void unsafe_ctoon_inc_len(void *val) {
4983 uint64_t tag = ((ctoon_val *)val)->tag;
4984 tag += (uint64_t)(1 << CTOON_TAG_BIT);
4985 ((ctoon_val *)val)->tag = tag;
4986}
4987
4988ctoon_api_inline void unsafe_ctoon_set_raw(void *val, const char *raw,
4989 size_t len) {
4990 unsafe_ctoon_set_tag(val, CTOON_TYPE_RAW, CTOON_SUBTYPE_NONE, len);
4991 ((ctoon_val *)val)->uni.str = raw;
4992}
4993
4994ctoon_api_inline void unsafe_ctoon_set_null(void *val) {
4995 unsafe_ctoon_set_tag(val, CTOON_TYPE_NULL, CTOON_SUBTYPE_NONE, 0);
4996}
4997
4998ctoon_api_inline void unsafe_ctoon_set_bool(void *val, bool num) {
4999 ctoon_subtype subtype = num ? CTOON_SUBTYPE_TRUE : CTOON_SUBTYPE_FALSE;
5000 unsafe_ctoon_set_tag(val, CTOON_TYPE_BOOL, subtype, 0);
5001}
5002
5003ctoon_api_inline void unsafe_ctoon_set_uint(void *val, uint64_t num) {
5004 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_UINT, 0);
5005 ((ctoon_val *)val)->uni.u64 = num;
5006}
5007
5008ctoon_api_inline void unsafe_ctoon_set_sint(void *val, int64_t num) {
5009 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_SINT, 0);
5010 ((ctoon_val *)val)->uni.i64 = num;
5011}
5012
5013ctoon_api_inline void unsafe_ctoon_set_fp_to_fixed(void *val, int prec) {
5014 ((ctoon_val *)val)->tag &= ~((uint64_t)CTOON_WRITE_FP_TO_FIXED(15) << 32);
5015 ((ctoon_val *)val)->tag |= (uint64_t)CTOON_WRITE_FP_TO_FIXED(prec) << 32;
5016}
5017
5018ctoon_api_inline void unsafe_ctoon_set_fp_to_float(void *val, bool flt) {
5019 uint64_t flag = (uint64_t)CTOON_WRITE_FP_TO_FLOAT << 32;
5020 if (flt) ((ctoon_val *)val)->tag |= flag;
5021 else ((ctoon_val *)val)->tag &= ~flag;
5022}
5023
5024ctoon_api_inline void unsafe_ctoon_set_float(void *val, float num) {
5025 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
5026 ((ctoon_val *)val)->tag |= (uint64_t)CTOON_WRITE_FP_TO_FLOAT << 32;
5027 ((ctoon_val *)val)->uni.f64 = (double)num;
5028}
5029
5030ctoon_api_inline void unsafe_ctoon_set_double(void *val, double num) {
5031 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
5032 ((ctoon_val *)val)->uni.f64 = num;
5033}
5034
5035ctoon_api_inline void unsafe_ctoon_set_real(void *val, double num) {
5036 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
5037 ((ctoon_val *)val)->uni.f64 = num;
5038}
5039
5040ctoon_api_inline void unsafe_ctoon_set_str_noesc(void *val, bool noesc) {
5041 ((ctoon_val *)val)->tag &= ~(uint64_t)CTOON_SUBTYPE_MASK;
5042 if (noesc) ((ctoon_val *)val)->tag |= (uint64_t)CTOON_SUBTYPE_NOESC;
5043}
5044
5045ctoon_api_inline void unsafe_ctoon_set_strn(void *val, const char *str,
5046 size_t len) {
5047 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, CTOON_SUBTYPE_NONE, len);
5048 ((ctoon_val *)val)->uni.str = str;
5049}
5050
5051ctoon_api_inline void unsafe_ctoon_set_str(void *val, const char *str) {
5052 size_t len = strlen(str);
5053 bool noesc = unsafe_ctoon_is_str_noesc(str, len);
5054 ctoon_subtype subtype = noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
5055 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, subtype, len);
5056 ((ctoon_val *)val)->uni.str = str;
5057}
5058
5059ctoon_api_inline void unsafe_ctoon_set_arr(void *val, size_t size) {
5060 unsafe_ctoon_set_tag(val, CTOON_TYPE_ARR, CTOON_SUBTYPE_NONE, size);
5061}
5062
5063ctoon_api_inline void unsafe_ctoon_set_obj(void *val, size_t size) {
5064 unsafe_ctoon_set_tag(val, CTOON_TYPE_OBJ, CTOON_SUBTYPE_NONE, size);
5065}
5066
5067
5068
5069/*==============================================================================
5070 * MARK: - TOON Document API (Implementation)
5071 *============================================================================*/
5072
5073ctoon_api_inline ctoon_val *ctoon_doc_get_root(ctoon_doc *doc) {
5074 return doc ? doc->root : NULL;
5075}
5076
5077ctoon_api_inline size_t ctoon_doc_get_read_size(ctoon_doc *doc) {
5078 return doc ? doc->dat_read : 0;
5079}
5080
5081ctoon_api_inline size_t ctoon_doc_get_val_count(ctoon_doc *doc) {
5082 return doc ? doc->val_read : 0;
5083}
5084
5085ctoon_api_inline void ctoon_doc_free(ctoon_doc *doc) {
5086 if (doc) {
5087 ctoon_alc alc = doc->alc;
5088 memset(&doc->alc, 0, sizeof(alc));
5089 if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
5090 alc.free(alc.ctx, doc);
5091 }
5092}
5093
5094
5095
5096/*==============================================================================
5097 * MARK: - TOON Value Type API (Implementation)
5098 *============================================================================*/
5099
5100ctoon_api_inline bool ctoon_is_raw(ctoon_val *val) {
5101 return val ? unsafe_ctoon_is_raw(val) : false;
5102}
5103
5104ctoon_api_inline bool ctoon_is_null(ctoon_val *val) {
5105 return val ? unsafe_ctoon_is_null(val) : false;
5106}
5107
5108ctoon_api_inline bool ctoon_is_true(ctoon_val *val) {
5109 return val ? unsafe_ctoon_is_true(val) : false;
5110}
5111
5112ctoon_api_inline bool ctoon_is_false(ctoon_val *val) {
5113 return val ? unsafe_ctoon_is_false(val) : false;
5114}
5115
5116ctoon_api_inline bool ctoon_is_bool(ctoon_val *val) {
5117 return val ? unsafe_ctoon_is_bool(val) : false;
5118}
5119
5120ctoon_api_inline bool ctoon_is_uint(ctoon_val *val) {
5121 return val ? unsafe_ctoon_is_uint(val) : false;
5122}
5123
5124ctoon_api_inline bool ctoon_is_sint(ctoon_val *val) {
5125 return val ? unsafe_ctoon_is_sint(val) : false;
5126}
5127
5128ctoon_api_inline bool ctoon_is_int(ctoon_val *val) {
5129 return val ? unsafe_ctoon_is_int(val) : false;
5130}
5131
5132ctoon_api_inline bool ctoon_is_real(ctoon_val *val) {
5133 return val ? unsafe_ctoon_is_real(val) : false;
5134}
5135
5136ctoon_api_inline bool ctoon_is_num(ctoon_val *val) {
5137 return val ? unsafe_ctoon_is_num(val) : false;
5138}
5139
5140ctoon_api_inline bool ctoon_is_str(ctoon_val *val) {
5141 return val ? unsafe_ctoon_is_str(val) : false;
5142}
5143
5144ctoon_api_inline bool ctoon_is_arr(ctoon_val *val) {
5145 return val ? unsafe_ctoon_is_arr(val) : false;
5146}
5147
5148ctoon_api_inline bool ctoon_is_obj(ctoon_val *val) {
5149 return val ? unsafe_ctoon_is_obj(val) : false;
5150}
5151
5152ctoon_api_inline bool ctoon_is_ctn(ctoon_val *val) {
5153 return val ? unsafe_ctoon_is_ctn(val) : false;
5154}
5155
5156
5157
5158/*==============================================================================
5159 * MARK: - TOON Value Content API (Implementation)
5160 *============================================================================*/
5161
5162ctoon_api_inline ctoon_type ctoon_get_type(ctoon_val *val) {
5163 return val ? unsafe_ctoon_get_type(val) : CTOON_TYPE_NONE;
5164}
5165
5166ctoon_api_inline ctoon_subtype ctoon_get_subtype(ctoon_val *val) {
5167 return val ? unsafe_ctoon_get_subtype(val) : CTOON_SUBTYPE_NONE;
5168}
5169
5170ctoon_api_inline uint8_t ctoon_get_tag(ctoon_val *val) {
5171 return val ? unsafe_ctoon_get_tag(val) : 0;
5172}
5173
5174ctoon_api_inline const char *ctoon_get_type_desc(ctoon_val *val) {
5175 switch (ctoon_get_tag(val)) {
5176 case CTOON_TYPE_RAW | CTOON_SUBTYPE_NONE: return "raw";
5177 case CTOON_TYPE_NULL | CTOON_SUBTYPE_NONE: return "null";
5178 case CTOON_TYPE_STR | CTOON_SUBTYPE_NONE: return "string";
5179 case CTOON_TYPE_STR | CTOON_SUBTYPE_NOESC: return "string";
5180 case CTOON_TYPE_ARR | CTOON_SUBTYPE_NONE: return "array";
5181 case CTOON_TYPE_OBJ | CTOON_SUBTYPE_NONE: return "object";
5182 case CTOON_TYPE_BOOL | CTOON_SUBTYPE_TRUE: return "true";
5183 case CTOON_TYPE_BOOL | CTOON_SUBTYPE_FALSE: return "false";
5184 case CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT: return "uint";
5185 case CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT: return "sint";
5186 case CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL: return "real";
5187 default: return "unknown";
5188 }
5189}
5190
5191ctoon_api_inline const char *ctoon_get_raw(ctoon_val *val) {
5192 return ctoon_is_raw(val) ? unsafe_ctoon_get_raw(val) : NULL;
5193}
5194
5195ctoon_api_inline bool ctoon_get_bool(ctoon_val *val) {
5196 return ctoon_is_bool(val) ? unsafe_ctoon_get_bool(val) : false;
5197}
5198
5199ctoon_api_inline uint64_t ctoon_get_uint(ctoon_val *val) {
5200 return ctoon_is_int(val) ? unsafe_ctoon_get_uint(val) : 0;
5201}
5202
5203ctoon_api_inline int64_t ctoon_get_sint(ctoon_val *val) {
5204 return ctoon_is_int(val) ? unsafe_ctoon_get_sint(val) : 0;
5205}
5206
5207ctoon_api_inline int ctoon_get_int(ctoon_val *val) {
5208 return ctoon_is_int(val) ? unsafe_ctoon_get_int(val) : 0;
5209}
5210
5211ctoon_api_inline double ctoon_get_real(ctoon_val *val) {
5212 return ctoon_is_real(val) ? unsafe_ctoon_get_real(val) : 0.0;
5213}
5214
5215ctoon_api_inline double ctoon_get_num(ctoon_val *val) {
5216 return val ? unsafe_ctoon_get_num(val) : 0.0;
5217}
5218
5219ctoon_api_inline const char *ctoon_get_str(ctoon_val *val) {
5220 return ctoon_is_str(val) ? unsafe_ctoon_get_str(val) : NULL;
5221}
5222
5223ctoon_api_inline size_t ctoon_get_len(ctoon_val *val) {
5224 return val ? unsafe_ctoon_get_len(val) : 0;
5225}
5226
5227ctoon_api_inline bool ctoon_equals_str(ctoon_val *val, const char *str) {
5228 if (ctoon_likely(val && str)) {
5229 return unsafe_ctoon_is_str(val) &&
5230 unsafe_ctoon_equals_str(val, str);
5231 }
5232 return false;
5233}
5234
5235ctoon_api_inline bool ctoon_equals_strn(ctoon_val *val, const char *str,
5236 size_t len) {
5237 if (ctoon_likely(val && str)) {
5238 return unsafe_ctoon_is_str(val) &&
5239 unsafe_ctoon_equals_strn(val, str, len);
5240 }
5241 return false;
5242}
5243
5244ctoon_api bool unsafe_ctoon_equals(ctoon_val *lhs, ctoon_val *rhs);
5245
5246ctoon_api_inline bool ctoon_equals(ctoon_val *lhs, ctoon_val *rhs) {
5247 if (ctoon_unlikely(!lhs || !rhs)) return false;
5248 return unsafe_ctoon_equals(lhs, rhs);
5249}
5250
5251ctoon_api_inline bool ctoon_set_raw(ctoon_val *val,
5252 const char *raw, size_t len) {
5253 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5254 unsafe_ctoon_set_raw(val, raw, len);
5255 return true;
5256}
5257
5258ctoon_api_inline bool ctoon_set_null(ctoon_val *val) {
5259 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5260 unsafe_ctoon_set_null(val);
5261 return true;
5262}
5263
5264ctoon_api_inline bool ctoon_set_bool(ctoon_val *val, bool num) {
5265 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5266 unsafe_ctoon_set_bool(val, num);
5267 return true;
5268}
5269
5270ctoon_api_inline bool ctoon_set_uint(ctoon_val *val, uint64_t num) {
5271 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5272 unsafe_ctoon_set_uint(val, num);
5273 return true;
5274}
5275
5276ctoon_api_inline bool ctoon_set_sint(ctoon_val *val, int64_t num) {
5277 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5278 unsafe_ctoon_set_sint(val, num);
5279 return true;
5280}
5281
5282ctoon_api_inline bool ctoon_set_int(ctoon_val *val, int num) {
5283 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5284 unsafe_ctoon_set_sint(val, (int64_t)num);
5285 return true;
5286}
5287
5288ctoon_api_inline bool ctoon_set_float(ctoon_val *val, float num) {
5289 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5290 unsafe_ctoon_set_float(val, num);
5291 return true;
5292}
5293
5294ctoon_api_inline bool ctoon_set_double(ctoon_val *val, double num) {
5295 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5296 unsafe_ctoon_set_double(val, num);
5297 return true;
5298}
5299
5300ctoon_api_inline bool ctoon_set_real(ctoon_val *val, double num) {
5301 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5302 unsafe_ctoon_set_real(val, num);
5303 return true;
5304}
5305
5306ctoon_api_inline bool ctoon_set_fp_to_fixed(ctoon_val *val, int prec) {
5307 if (ctoon_unlikely(!ctoon_is_real(val))) return false;
5308 unsafe_ctoon_set_fp_to_fixed(val, prec);
5309 return true;
5310}
5311
5312ctoon_api_inline bool ctoon_set_fp_to_float(ctoon_val *val, bool flt) {
5313 if (ctoon_unlikely(!ctoon_is_real(val))) return false;
5314 unsafe_ctoon_set_fp_to_float(val, flt);
5315 return true;
5316}
5317
5318ctoon_api_inline bool ctoon_set_str(ctoon_val *val, const char *str) {
5319 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5320 if (ctoon_unlikely(!str)) return false;
5321 unsafe_ctoon_set_str(val, str);
5322 return true;
5323}
5324
5325ctoon_api_inline bool ctoon_set_strn(ctoon_val *val,
5326 const char *str, size_t len) {
5327 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5328 if (ctoon_unlikely(!str)) return false;
5329 unsafe_ctoon_set_strn(val, str, len);
5330 return true;
5331}
5332
5333ctoon_api_inline bool ctoon_set_str_noesc(ctoon_val *val, bool noesc) {
5334 if (ctoon_unlikely(!ctoon_is_str(val))) return false;
5335 unsafe_ctoon_set_str_noesc(val, noesc);
5336 return true;
5337}
5338
5339
5340
5341/*==============================================================================
5342 * MARK: - TOON Array API (Implementation)
5343 *============================================================================*/
5344
5345ctoon_api_inline size_t ctoon_arr_size(ctoon_val *arr) {
5346 return ctoon_is_arr(arr) ? unsafe_ctoon_get_len(arr) : 0;
5347}
5348
5349ctoon_api_inline ctoon_val *ctoon_arr_get(ctoon_val *arr, size_t idx) {
5350 if (ctoon_likely(ctoon_is_arr(arr))) {
5351 if (ctoon_likely(unsafe_ctoon_get_len(arr) > idx)) {
5352 ctoon_val *val = unsafe_ctoon_get_first(arr);
5353 if (unsafe_ctoon_arr_is_flat(arr)) {
5354 return val + idx;
5355 } else {
5356 while (idx-- > 0) val = unsafe_ctoon_get_next(val);
5357 return val;
5358 }
5359 }
5360 }
5361 return NULL;
5362}
5363
5364ctoon_api_inline ctoon_val *ctoon_arr_get_first(ctoon_val *arr) {
5365 if (ctoon_likely(ctoon_is_arr(arr))) {
5366 if (ctoon_likely(unsafe_ctoon_get_len(arr) > 0)) {
5367 return unsafe_ctoon_get_first(arr);
5368 }
5369 }
5370 return NULL;
5371}
5372
5373ctoon_api_inline ctoon_val *ctoon_arr_get_last(ctoon_val *arr) {
5374 if (ctoon_likely(ctoon_is_arr(arr))) {
5375 size_t len = unsafe_ctoon_get_len(arr);
5376 if (ctoon_likely(len > 0)) {
5377 ctoon_val *val = unsafe_ctoon_get_first(arr);
5378 if (unsafe_ctoon_arr_is_flat(arr)) {
5379 return val + (len - 1);
5380 } else {
5381 while (len-- > 1) val = unsafe_ctoon_get_next(val);
5382 return val;
5383 }
5384 }
5385 }
5386 return NULL;
5387}
5388
5389
5390
5391/*==============================================================================
5392 * MARK: - TOON Array Iterator API (Implementation)
5393 *============================================================================*/
5394
5395ctoon_api_inline bool ctoon_arr_iter_init(ctoon_val *arr,
5396 ctoon_arr_iter *iter) {
5397 if (ctoon_likely(ctoon_is_arr(arr) && iter)) {
5398 iter->idx = 0;
5399 iter->max = unsafe_ctoon_get_len(arr);
5400 iter->cur = unsafe_ctoon_get_first(arr);
5401 return true;
5402 }
5403 if (iter) memset(iter, 0, sizeof(ctoon_arr_iter));
5404 return false;
5405}
5406
5407ctoon_api_inline ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr) {
5408 ctoon_arr_iter iter;
5409 ctoon_arr_iter_init(arr, &iter);
5410 return iter;
5411}
5412
5413ctoon_api_inline bool ctoon_arr_iter_has_next(ctoon_arr_iter *iter) {
5414 return iter ? iter->idx < iter->max : false;
5415}
5416
5417ctoon_api_inline ctoon_val *ctoon_arr_iter_next(ctoon_arr_iter *iter) {
5418 ctoon_val *val;
5419 if (iter && iter->idx < iter->max) {
5420 val = iter->cur;
5421 iter->cur = unsafe_ctoon_get_next(val);
5422 iter->idx++;
5423 return val;
5424 }
5425 return NULL;
5426}
5427
5428
5429
5430/*==============================================================================
5431 * MARK: - TOON Object API (Implementation)
5432 *============================================================================*/
5433
5434ctoon_api_inline size_t ctoon_obj_size(ctoon_val *obj) {
5435 return ctoon_is_obj(obj) ? unsafe_ctoon_get_len(obj) : 0;
5436}
5437
5438ctoon_api_inline ctoon_val *ctoon_obj_get(ctoon_val *obj,
5439 const char *key) {
5440 return ctoon_obj_getn(obj, key, key ? strlen(key) : 0);
5441}
5442
5443ctoon_api_inline ctoon_val *ctoon_obj_getn(ctoon_val *obj,
5444 const char *_key,
5445 size_t key_len) {
5446 if (ctoon_likely(ctoon_is_obj(obj) && _key)) {
5447 size_t len = unsafe_ctoon_get_len(obj);
5448 ctoon_val *key = unsafe_ctoon_get_first(obj);
5449 while (len-- > 0) {
5450 if (unsafe_ctoon_equals_strn(key, _key, key_len)) return key + 1;
5451 key = unsafe_ctoon_get_next(key + 1);
5452 }
5453 }
5454 return NULL;
5455}
5456
5457
5458
5459/*==============================================================================
5460 * MARK: - TOON Object Iterator API (Implementation)
5461 *============================================================================*/
5462
5463ctoon_api_inline bool ctoon_obj_iter_init(ctoon_val *obj,
5464 ctoon_obj_iter *iter) {
5465 if (ctoon_likely(ctoon_is_obj(obj) && iter)) {
5466 iter->idx = 0;
5467 iter->max = unsafe_ctoon_get_len(obj);
5468 iter->cur = unsafe_ctoon_get_first(obj);
5469 iter->obj = obj;
5470 return true;
5471 }
5472 if (iter) memset(iter, 0, sizeof(ctoon_obj_iter));
5473 return false;
5474}
5475
5476ctoon_api_inline ctoon_obj_iter ctoon_obj_iter_with(ctoon_val *obj) {
5477 ctoon_obj_iter iter;
5478 ctoon_obj_iter_init(obj, &iter);
5479 return iter;
5480}
5481
5482ctoon_api_inline bool ctoon_obj_iter_has_next(ctoon_obj_iter *iter) {
5483 return iter ? iter->idx < iter->max : false;
5484}
5485
5486ctoon_api_inline ctoon_val *ctoon_obj_iter_next(ctoon_obj_iter *iter) {
5487 if (iter && iter->idx < iter->max) {
5488 ctoon_val *key = iter->cur;
5489 iter->idx++;
5490 iter->cur = unsafe_ctoon_get_next(key + 1);
5491 return key;
5492 }
5493 return NULL;
5494}
5495
5496ctoon_api_inline ctoon_val *ctoon_obj_iter_get_val(ctoon_val *key) {
5497 return key ? key + 1 : NULL;
5498}
5499
5500ctoon_api_inline ctoon_val *ctoon_obj_iter_get(ctoon_obj_iter *iter,
5501 const char *key) {
5502 return ctoon_obj_iter_getn(iter, key, key ? strlen(key) : 0);
5503}
5504
5505ctoon_api_inline ctoon_val *ctoon_obj_iter_getn(ctoon_obj_iter *iter,
5506 const char *key,
5507 size_t key_len) {
5508 if (iter && key) {
5509 size_t idx = iter->idx;
5510 size_t max = iter->max;
5511 ctoon_val *cur = iter->cur;
5512 if (ctoon_unlikely(idx == max)) {
5513 idx = 0;
5514 cur = unsafe_ctoon_get_first(iter->obj);
5515 }
5516 while (idx++ < max) {
5517 ctoon_val *next = unsafe_ctoon_get_next(cur + 1);
5518 if (unsafe_ctoon_equals_strn(cur, key, key_len)) {
5519 iter->idx = idx;
5520 iter->cur = next;
5521 return cur + 1;
5522 }
5523 cur = next;
5524 if (idx == iter->max && iter->idx < iter->max) {
5525 idx = 0;
5526 max = iter->idx;
5527 cur = unsafe_ctoon_get_first(iter->obj);
5528 }
5529 }
5530 }
5531 return NULL;
5532}
5533
5534
5535
5536/*==============================================================================
5537 * MARK: - Mutable TOON Structure (Implementation)
5538 *============================================================================*/
5539
5545struct ctoon_mut_val {
5546 uint64_t tag; /**< type, subtype and length */
5547 ctoon_val_uni uni; /**< payload */
5548 ctoon_mut_val *next; /**< the next value in circular linked list */
5549};
5550
5554typedef struct ctoon_str_chunk {
5555 struct ctoon_str_chunk *next; /* next chunk linked list */
5556 size_t chunk_size; /* chunk size in bytes */
5557 /* char str[]; flexible array member */
5558} ctoon_str_chunk;
5559
5563typedef struct ctoon_str_pool {
5564 char *cur; /* cursor inside current chunk */
5565 char *end; /* the end of current chunk */
5566 size_t chunk_size; /* chunk size in bytes while creating new chunk */
5567 size_t chunk_size_max; /* maximum chunk size in bytes */
5568 ctoon_str_chunk *chunks; /* a linked list of chunks, nullable */
5569} ctoon_str_pool;
5570
5575typedef struct ctoon_val_chunk {
5576 struct ctoon_val_chunk *next; /* next chunk linked list */
5577 size_t chunk_size; /* chunk size in bytes */
5578 /* char pad[sizeof(ctoon_mut_val) - sizeof(ctoon_val_chunk)]; padding */
5579 /* ctoon_mut_val vals[]; flexible array member */
5580} ctoon_val_chunk;
5581
5585typedef struct ctoon_val_pool {
5586 ctoon_mut_val *cur; /* cursor inside current chunk */
5587 ctoon_mut_val *end; /* the end of current chunk */
5588 size_t chunk_size; /* chunk size in bytes while creating new chunk */
5589 size_t chunk_size_max; /* maximum chunk size in bytes */
5590 ctoon_val_chunk *chunks; /* a linked list of chunks, nullable */
5591} ctoon_val_pool;
5592
5593struct ctoon_mut_doc {
5594 ctoon_mut_val *root; /**< root value of the TOON document, nullable */
5595 ctoon_alc alc; /**< a valid allocator, nonnull */
5596 ctoon_str_pool str_pool; /**< string memory pool */
5597 ctoon_val_pool val_pool; /**< value memory pool */
5598};
5599
5600/* Ensures the capacity to at least equal to the specified byte length. */
5601ctoon_api bool unsafe_ctoon_str_pool_grow(ctoon_str_pool *pool,
5602 const ctoon_alc *alc,
5603 size_t len);
5604
5605/* Ensures the capacity to at least equal to the specified value count. */
5606ctoon_api bool unsafe_ctoon_val_pool_grow(ctoon_val_pool *pool,
5607 const ctoon_alc *alc,
5608 size_t count);
5609
5610/* Allocate memory for string. */
5611ctoon_api_inline char *unsafe_ctoon_mut_str_alc(ctoon_mut_doc *doc,
5612 size_t len) {
5613 char *mem;
5614 const ctoon_alc *alc = &doc->alc;
5615 ctoon_str_pool *pool = &doc->str_pool;
5616 if (ctoon_unlikely((size_t)(pool->end - pool->cur) <= len)) {
5617 if (ctoon_unlikely(!unsafe_ctoon_str_pool_grow(pool, alc, len + 1))) {
5618 return NULL;
5619 }
5620 }
5621 mem = pool->cur;
5622 pool->cur = mem + len + 1;
5623 return mem;
5624}
5625
5626ctoon_api_inline char *unsafe_ctoon_mut_strncpy(ctoon_mut_doc *doc,
5627 const char *str, size_t len) {
5628 char *mem = unsafe_ctoon_mut_str_alc(doc, len);
5629 if (ctoon_unlikely(!mem)) return NULL;
5630 memcpy((void *)mem, (const void *)str, len);
5631 mem[len] = '\0';
5632 return mem;
5633}
5634
5635ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_val(ctoon_mut_doc *doc,
5636 size_t count) {
5637 ctoon_mut_val *val;
5638 ctoon_alc *alc = &doc->alc;
5639 ctoon_val_pool *pool = &doc->val_pool;
5640 if (ctoon_unlikely((size_t)(pool->end - pool->cur) < count)) {
5641 if (ctoon_unlikely(!unsafe_ctoon_val_pool_grow(pool, alc, count))) {
5642 return NULL;
5643 }
5644 }
5645 val = pool->cur;
5646 pool->cur += count;
5647 return val;
5648}
5649
5650
5651
5652/*==============================================================================
5653 * MARK: - Mutable TOON Document API (Implementation)
5654 *============================================================================*/
5655
5656ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_root(ctoon_mut_doc *doc) {
5657 return doc ? doc->root : NULL;
5658}
5659
5660ctoon_api_inline void ctoon_mut_doc_set_root(ctoon_mut_doc *doc,
5661 ctoon_mut_val *root) {
5662 if (doc) doc->root = root;
5663}
5664
5665
5666
5667/*==============================================================================
5668 * MARK: - Mutable TOON Value Type API (Implementation)
5669 *============================================================================*/
5670
5671ctoon_api_inline bool ctoon_mut_is_raw(ctoon_mut_val *val) {
5672 return val ? unsafe_ctoon_is_raw(val) : false;
5673}
5674
5675ctoon_api_inline bool ctoon_mut_is_null(ctoon_mut_val *val) {
5676 return val ? unsafe_ctoon_is_null(val) : false;
5677}
5678
5679ctoon_api_inline bool ctoon_mut_is_true(ctoon_mut_val *val) {
5680 return val ? unsafe_ctoon_is_true(val) : false;
5681}
5682
5683ctoon_api_inline bool ctoon_mut_is_false(ctoon_mut_val *val) {
5684 return val ? unsafe_ctoon_is_false(val) : false;
5685}
5686
5687ctoon_api_inline bool ctoon_mut_is_bool(ctoon_mut_val *val) {
5688 return val ? unsafe_ctoon_is_bool(val) : false;
5689}
5690
5691ctoon_api_inline bool ctoon_mut_is_uint(ctoon_mut_val *val) {
5692 return val ? unsafe_ctoon_is_uint(val) : false;
5693}
5694
5695ctoon_api_inline bool ctoon_mut_is_sint(ctoon_mut_val *val) {
5696 return val ? unsafe_ctoon_is_sint(val) : false;
5697}
5698
5699ctoon_api_inline bool ctoon_mut_is_int(ctoon_mut_val *val) {
5700 return val ? unsafe_ctoon_is_int(val) : false;
5701}
5702
5703ctoon_api_inline bool ctoon_mut_is_real(ctoon_mut_val *val) {
5704 return val ? unsafe_ctoon_is_real(val) : false;
5705}
5706
5707ctoon_api_inline bool ctoon_mut_is_num(ctoon_mut_val *val) {
5708 return val ? unsafe_ctoon_is_num(val) : false;
5709}
5710
5711ctoon_api_inline bool ctoon_mut_is_str(ctoon_mut_val *val) {
5712 return val ? unsafe_ctoon_is_str(val) : false;
5713}
5714
5715ctoon_api_inline bool ctoon_mut_is_arr(ctoon_mut_val *val) {
5716 return val ? unsafe_ctoon_is_arr(val) : false;
5717}
5718
5719ctoon_api_inline bool ctoon_mut_is_obj(ctoon_mut_val *val) {
5720 return val ? unsafe_ctoon_is_obj(val) : false;
5721}
5722
5723ctoon_api_inline bool ctoon_mut_is_ctn(ctoon_mut_val *val) {
5724 return val ? unsafe_ctoon_is_ctn(val) : false;
5725}
5726
5727
5728
5729/*==============================================================================
5730 * MARK: - Mutable TOON Value Content API (Implementation)
5731 *============================================================================*/
5732
5733ctoon_api_inline ctoon_type ctoon_mut_get_type(ctoon_mut_val *val) {
5734 return ctoon_get_type((ctoon_val *)val);
5735}
5736
5737ctoon_api_inline ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val) {
5738 return ctoon_get_subtype((ctoon_val *)val);
5739}
5740
5741ctoon_api_inline uint8_t ctoon_mut_get_tag(ctoon_mut_val *val) {
5742 return ctoon_get_tag((ctoon_val *)val);
5743}
5744
5745ctoon_api_inline const char *ctoon_mut_get_type_desc(ctoon_mut_val *val) {
5746 return ctoon_get_type_desc((ctoon_val *)val);
5747}
5748
5749ctoon_api_inline const char *ctoon_mut_get_raw(ctoon_mut_val *val) {
5750 return ctoon_get_raw((ctoon_val *)val);
5751}
5752
5753ctoon_api_inline bool ctoon_mut_get_bool(ctoon_mut_val *val) {
5754 return ctoon_get_bool((ctoon_val *)val);
5755}
5756
5757ctoon_api_inline uint64_t ctoon_mut_get_uint(ctoon_mut_val *val) {
5758 return ctoon_get_uint((ctoon_val *)val);
5759}
5760
5761ctoon_api_inline int64_t ctoon_mut_get_sint(ctoon_mut_val *val) {
5762 return ctoon_get_sint((ctoon_val *)val);
5763}
5764
5765ctoon_api_inline int ctoon_mut_get_int(ctoon_mut_val *val) {
5766 return ctoon_get_int((ctoon_val *)val);
5767}
5768
5769ctoon_api_inline double ctoon_mut_get_real(ctoon_mut_val *val) {
5770 return ctoon_get_real((ctoon_val *)val);
5771}
5772
5773ctoon_api_inline double ctoon_mut_get_num(ctoon_mut_val *val) {
5774 return ctoon_get_num((ctoon_val *)val);
5775}
5776
5777ctoon_api_inline const char *ctoon_mut_get_str(ctoon_mut_val *val) {
5778 return ctoon_get_str((ctoon_val *)val);
5779}
5780
5781ctoon_api_inline size_t ctoon_mut_get_len(ctoon_mut_val *val) {
5782 return ctoon_get_len((ctoon_val *)val);
5783}
5784
5785ctoon_api_inline bool ctoon_mut_equals_str(ctoon_mut_val *val,
5786 const char *str) {
5787 return ctoon_equals_str((ctoon_val *)val, str);
5788}
5789
5790ctoon_api_inline bool ctoon_mut_equals_strn(ctoon_mut_val *val,
5791 const char *str, size_t len) {
5792 return ctoon_equals_strn((ctoon_val *)val, str, len);
5793}
5794
5795ctoon_api bool unsafe_ctoon_mut_equals(ctoon_mut_val *lhs,
5796 ctoon_mut_val *rhs);
5797
5798ctoon_api_inline bool ctoon_mut_equals(ctoon_mut_val *lhs,
5799 ctoon_mut_val *rhs) {
5800 if (ctoon_unlikely(!lhs || !rhs)) return false;
5801 return unsafe_ctoon_mut_equals(lhs, rhs);
5802}
5803
5804ctoon_api_inline bool ctoon_mut_set_raw(ctoon_mut_val *val,
5805 const char *raw, size_t len) {
5806 if (ctoon_unlikely(!val || !raw)) return false;
5807 unsafe_ctoon_set_raw(val, raw, len);
5808 return true;
5809}
5810
5811ctoon_api_inline bool ctoon_mut_set_null(ctoon_mut_val *val) {
5812 if (ctoon_unlikely(!val)) return false;
5813 unsafe_ctoon_set_null(val);
5814 return true;
5815}
5816
5817ctoon_api_inline bool ctoon_mut_set_bool(ctoon_mut_val *val, bool num) {
5818 if (ctoon_unlikely(!val)) return false;
5819 unsafe_ctoon_set_bool(val, num);
5820 return true;
5821}
5822
5823ctoon_api_inline bool ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num) {
5824 if (ctoon_unlikely(!val)) return false;
5825 unsafe_ctoon_set_uint(val, num);
5826 return true;
5827}
5828
5829ctoon_api_inline bool ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num) {
5830 if (ctoon_unlikely(!val)) return false;
5831 unsafe_ctoon_set_sint(val, num);
5832 return true;
5833}
5834
5835ctoon_api_inline bool ctoon_mut_set_int(ctoon_mut_val *val, int num) {
5836 if (ctoon_unlikely(!val)) return false;
5837 unsafe_ctoon_set_sint(val, (int64_t)num);
5838 return true;
5839}
5840
5841ctoon_api_inline bool ctoon_mut_set_float(ctoon_mut_val *val, float num) {
5842 if (ctoon_unlikely(!val)) return false;
5843 unsafe_ctoon_set_float(val, num);
5844 return true;
5845}
5846
5847ctoon_api_inline bool ctoon_mut_set_double(ctoon_mut_val *val, double num) {
5848 if (ctoon_unlikely(!val)) return false;
5849 unsafe_ctoon_set_double(val, num);
5850 return true;
5851}
5852
5853ctoon_api_inline bool ctoon_mut_set_real(ctoon_mut_val *val, double num) {
5854 if (ctoon_unlikely(!val)) return false;
5855 unsafe_ctoon_set_real(val, num);
5856 return true;
5857}
5858
5859ctoon_api_inline bool ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val,
5860 int prec) {
5861 if (ctoon_unlikely(!ctoon_mut_is_real(val))) return false;
5862 unsafe_ctoon_set_fp_to_fixed(val, prec);
5863 return true;
5864}
5865
5866ctoon_api_inline bool ctoon_mut_set_fp_to_float(ctoon_mut_val *val,
5867 bool flt) {
5868 if (ctoon_unlikely(!ctoon_mut_is_real(val))) return false;
5869 unsafe_ctoon_set_fp_to_float(val, flt);
5870 return true;
5871}
5872
5873ctoon_api_inline bool ctoon_mut_set_str(ctoon_mut_val *val,
5874 const char *str) {
5875 if (ctoon_unlikely(!val || !str)) return false;
5876 unsafe_ctoon_set_str(val, str);
5877 return true;
5878}
5879
5880ctoon_api_inline bool ctoon_mut_set_strn(ctoon_mut_val *val,
5881 const char *str, size_t len) {
5882 if (ctoon_unlikely(!val || !str)) return false;
5883 unsafe_ctoon_set_strn(val, str, len);
5884 return true;
5885}
5886
5887ctoon_api_inline bool ctoon_mut_set_str_noesc(ctoon_mut_val *val,
5888 bool noesc) {
5889 if (ctoon_unlikely(!ctoon_mut_is_str(val))) return false;
5890 unsafe_ctoon_set_str_noesc(val, noesc);
5891 return true;
5892}
5893
5894ctoon_api_inline bool ctoon_mut_set_arr(ctoon_mut_val *val) {
5895 if (ctoon_unlikely(!val)) return false;
5896 unsafe_ctoon_set_arr(val, 0);
5897 return true;
5898}
5899
5900ctoon_api_inline bool ctoon_mut_set_obj(ctoon_mut_val *val) {
5901 if (ctoon_unlikely(!val)) return false;
5902 unsafe_ctoon_set_obj(val, 0);
5903 return true;
5904}
5905
5906
5907
5908/*==============================================================================
5909 * MARK: - Mutable TOON Value Creation API (Implementation)
5910 *============================================================================*/
5911
5912#define ctoon_mut_val_one(func) \
5913 if (ctoon_likely(doc)) { \
5914 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1); \
5915 if (ctoon_likely(val)) { \
5916 func \
5917 return val; \
5918 } \
5919 } \
5920 return NULL
5921
5922#define ctoon_mut_val_one_str(func) \
5923 if (ctoon_likely(doc && str)) { \
5924 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1); \
5925 if (ctoon_likely(val)) { \
5926 func \
5927 return val; \
5928 } \
5929 } \
5930 return NULL
5931
5932ctoon_api_inline ctoon_mut_val *ctoon_mut_raw(ctoon_mut_doc *doc,
5933 const char *str) {
5934 ctoon_mut_val_one_str({ unsafe_ctoon_set_raw(val, str, strlen(str)); });
5935}
5936
5937ctoon_api_inline ctoon_mut_val *ctoon_mut_rawn(ctoon_mut_doc *doc,
5938 const char *str,
5939 size_t len) {
5940 ctoon_mut_val_one_str({ unsafe_ctoon_set_raw(val, str, len); });
5941}
5942
5943ctoon_api_inline ctoon_mut_val *ctoon_mut_rawcpy(ctoon_mut_doc *doc,
5944 const char *str) {
5945 ctoon_mut_val_one_str({
5946 size_t len = strlen(str);
5947 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5948 if (ctoon_unlikely(!new_str)) return NULL;
5949 unsafe_ctoon_set_raw(val, new_str, len);
5950 });
5951}
5952
5953ctoon_api_inline ctoon_mut_val *ctoon_mut_rawncpy(ctoon_mut_doc *doc,
5954 const char *str,
5955 size_t len) {
5956 ctoon_mut_val_one_str({
5957 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5958 if (ctoon_unlikely(!new_str)) return NULL;
5959 unsafe_ctoon_set_raw(val, new_str, len);
5960 });
5961}
5962
5963ctoon_api_inline ctoon_mut_val *ctoon_mut_null(ctoon_mut_doc *doc) {
5964 ctoon_mut_val_one({ unsafe_ctoon_set_null(val); });
5965}
5966
5967ctoon_api_inline ctoon_mut_val *ctoon_mut_true(ctoon_mut_doc *doc) {
5968 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, true); });
5969}
5970
5971ctoon_api_inline ctoon_mut_val *ctoon_mut_false(ctoon_mut_doc *doc) {
5972 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, false); });
5973}
5974
5975ctoon_api_inline ctoon_mut_val *ctoon_mut_bool(ctoon_mut_doc *doc,
5976 bool _val) {
5977 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, _val); });
5978}
5979
5980ctoon_api_inline ctoon_mut_val *ctoon_mut_uint(ctoon_mut_doc *doc,
5981 uint64_t num) {
5982 ctoon_mut_val_one({ unsafe_ctoon_set_uint(val, num); });
5983}
5984
5985ctoon_api_inline ctoon_mut_val *ctoon_mut_sint(ctoon_mut_doc *doc,
5986 int64_t num) {
5987 ctoon_mut_val_one({ unsafe_ctoon_set_sint(val, num); });
5988}
5989
5990ctoon_api_inline ctoon_mut_val *ctoon_mut_int(ctoon_mut_doc *doc,
5991 int64_t num) {
5992 ctoon_mut_val_one({ unsafe_ctoon_set_sint(val, num); });
5993}
5994
5995ctoon_api_inline ctoon_mut_val *ctoon_mut_float(ctoon_mut_doc *doc,
5996 float num) {
5997 ctoon_mut_val_one({ unsafe_ctoon_set_float(val, num); });
5998}
5999
6000ctoon_api_inline ctoon_mut_val *ctoon_mut_double(ctoon_mut_doc *doc,
6001 double num) {
6002 ctoon_mut_val_one({ unsafe_ctoon_set_double(val, num); });
6003}
6004
6005ctoon_api_inline ctoon_mut_val *ctoon_mut_real(ctoon_mut_doc *doc,
6006 double num) {
6007 ctoon_mut_val_one({ unsafe_ctoon_set_real(val, num); });
6008}
6009
6010ctoon_api_inline ctoon_mut_val *ctoon_mut_str(ctoon_mut_doc *doc,
6011 const char *str) {
6012 ctoon_mut_val_one_str({ unsafe_ctoon_set_str(val, str); });
6013}
6014
6015ctoon_api_inline ctoon_mut_val *ctoon_mut_strn(ctoon_mut_doc *doc,
6016 const char *str,
6017 size_t len) {
6018 ctoon_mut_val_one_str({ unsafe_ctoon_set_strn(val, str, len); });
6019}
6020
6021ctoon_api_inline ctoon_mut_val *ctoon_mut_strcpy(ctoon_mut_doc *doc,
6022 const char *str) {
6023 ctoon_mut_val_one_str({
6024 size_t len = strlen(str);
6025 bool noesc = unsafe_ctoon_is_str_noesc(str, len);
6026 ctoon_subtype sub = noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
6027 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6028 if (ctoon_unlikely(!new_str)) return NULL;
6029 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, sub, len);
6030 val->uni.str = new_str;
6031 });
6032}
6033
6034ctoon_api_inline ctoon_mut_val *ctoon_mut_strncpy(ctoon_mut_doc *doc,
6035 const char *str,
6036 size_t len) {
6037 ctoon_mut_val_one_str({
6038 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6039 if (ctoon_unlikely(!new_str)) return NULL;
6040 unsafe_ctoon_set_strn(val, new_str, len);
6041 });
6042}
6043
6044#undef ctoon_mut_val_one
6045#undef ctoon_mut_val_one_str
6046
6047
6048
6049/*==============================================================================
6050 * MARK: - Mutable TOON Array API (Implementation)
6051 *============================================================================*/
6052
6053ctoon_api_inline size_t ctoon_mut_arr_size(ctoon_mut_val *arr) {
6054 return ctoon_mut_is_arr(arr) ? unsafe_ctoon_get_len(arr) : 0;
6055}
6056
6057ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get(ctoon_mut_val *arr,
6058 size_t idx) {
6059 if (ctoon_likely(idx < ctoon_mut_arr_size(arr))) {
6060 ctoon_mut_val *val = (ctoon_mut_val *)arr->uni.ptr;
6061 while (idx-- > 0) val = val->next;
6062 return val->next;
6063 }
6064 return NULL;
6065}
6066
6067ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_first(
6068 ctoon_mut_val *arr) {
6069 if (ctoon_likely(ctoon_mut_arr_size(arr) > 0)) {
6070 return ((ctoon_mut_val *)arr->uni.ptr)->next;
6071 }
6072 return NULL;
6073}
6074
6075ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_last(
6076 ctoon_mut_val *arr) {
6077 if (ctoon_likely(ctoon_mut_arr_size(arr) > 0)) {
6078 return ((ctoon_mut_val *)arr->uni.ptr);
6079 }
6080 return NULL;
6081}
6082
6083
6084
6085/*==============================================================================
6086 * MARK: - Mutable TOON Array Iterator API (Implementation)
6087 *============================================================================*/
6088
6089ctoon_api_inline bool ctoon_mut_arr_iter_init(ctoon_mut_val *arr,
6090 ctoon_mut_arr_iter *iter) {
6091 if (ctoon_likely(ctoon_mut_is_arr(arr) && iter)) {
6092 iter->idx = 0;
6093 iter->max = unsafe_ctoon_get_len(arr);
6094 iter->cur = iter->max ? (ctoon_mut_val *)arr->uni.ptr : NULL;
6095 iter->pre = NULL;
6096 iter->arr = arr;
6097 return true;
6098 }
6099 if (iter) memset(iter, 0, sizeof(ctoon_mut_arr_iter));
6100 return false;
6101}
6102
6103ctoon_api_inline ctoon_mut_arr_iter ctoon_mut_arr_iter_with(
6104 ctoon_mut_val *arr) {
6105 ctoon_mut_arr_iter iter;
6106 ctoon_mut_arr_iter_init(arr, &iter);
6107 return iter;
6108}
6109
6110ctoon_api_inline bool ctoon_mut_arr_iter_has_next(ctoon_mut_arr_iter *iter) {
6111 return iter ? iter->idx < iter->max : false;
6112}
6113
6114ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_next(
6115 ctoon_mut_arr_iter *iter) {
6116 if (iter && iter->idx < iter->max) {
6117 ctoon_mut_val *val = iter->cur;
6118 iter->pre = val;
6119 iter->cur = val->next;
6120 iter->idx++;
6121 return iter->cur;
6122 }
6123 return NULL;
6124}
6125
6126ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_remove(
6127 ctoon_mut_arr_iter *iter) {
6128 if (ctoon_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
6129 ctoon_mut_val *prev = iter->pre;
6130 ctoon_mut_val *cur = iter->cur;
6131 ctoon_mut_val *next = cur->next;
6132 if (ctoon_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
6133 iter->idx--;
6134 iter->max--;
6135 unsafe_ctoon_set_len(iter->arr, iter->max);
6136 prev->next = next;
6137 iter->cur = prev;
6138 return cur;
6139 }
6140 return NULL;
6141}
6142
6143
6144
6145/*==============================================================================
6146 * MARK: - Mutable TOON Array Creation API (Implementation)
6147 *============================================================================*/
6148
6149ctoon_api_inline ctoon_mut_val *ctoon_mut_arr(ctoon_mut_doc *doc) {
6150 if (ctoon_likely(doc)) {
6151 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1);
6152 if (ctoon_likely(val)) {
6153 val->tag = CTOON_TYPE_ARR | CTOON_SUBTYPE_NONE;
6154 return val;
6155 }
6156 }
6157 return NULL;
6158}
6159
6160#define ctoon_mut_arr_with_func(func) \
6161 if (ctoon_likely(doc && ((0 < count && count < \
6162 (~(size_t)0) / sizeof(ctoon_mut_val) && vals) || count == 0))) { \
6163 ctoon_mut_val *arr = unsafe_ctoon_mut_val(doc, 1 + count); \
6164 if (ctoon_likely(arr)) { \
6165 arr->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_ARR; \
6166 if (count > 0) { \
6167 size_t i; \
6168 for (i = 0; i < count; i++) { \
6169 ctoon_mut_val *val = arr + i + 1; \
6170 func \
6171 val->next = val + 1; \
6172 } \
6173 arr[count].next = arr + 1; \
6174 arr->uni.ptr = arr + count; \
6175 } \
6176 return arr; \
6177 } \
6178 } \
6179 return NULL
6180
6181ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_bool(
6182 ctoon_mut_doc *doc, const bool *vals, size_t count) {
6183 ctoon_mut_arr_with_func({
6184 unsafe_ctoon_set_bool(val, vals[i]);
6185 });
6186}
6187
6188ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint(
6189 ctoon_mut_doc *doc, const int64_t *vals, size_t count) {
6190 return ctoon_mut_arr_with_sint64(doc, vals, count);
6191}
6192
6193ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint(
6194 ctoon_mut_doc *doc, const uint64_t *vals, size_t count) {
6195 return ctoon_mut_arr_with_uint64(doc, vals, count);
6196}
6197
6198ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_real(
6199 ctoon_mut_doc *doc, const double *vals, size_t count) {
6200 ctoon_mut_arr_with_func({
6201 unsafe_ctoon_set_real(val, vals[i]);
6202 });
6203}
6204
6205ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint8(
6206 ctoon_mut_doc *doc, const int8_t *vals, size_t count) {
6207 ctoon_mut_arr_with_func({
6208 unsafe_ctoon_set_sint(val, vals[i]);
6209 });
6210}
6211
6212ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint16(
6213 ctoon_mut_doc *doc, const int16_t *vals, size_t count) {
6214 ctoon_mut_arr_with_func({
6215 unsafe_ctoon_set_sint(val, vals[i]);
6216 });
6217}
6218
6219ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint32(
6220 ctoon_mut_doc *doc, const int32_t *vals, size_t count) {
6221 ctoon_mut_arr_with_func({
6222 unsafe_ctoon_set_sint(val, vals[i]);
6223 });
6224}
6225
6226ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint64(
6227 ctoon_mut_doc *doc, const int64_t *vals, size_t count) {
6228 ctoon_mut_arr_with_func({
6229 unsafe_ctoon_set_sint(val, vals[i]);
6230 });
6231}
6232
6233ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint8(
6234 ctoon_mut_doc *doc, const uint8_t *vals, size_t count) {
6235 ctoon_mut_arr_with_func({
6236 unsafe_ctoon_set_uint(val, vals[i]);
6237 });
6238}
6239
6240ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint16(
6241 ctoon_mut_doc *doc, const uint16_t *vals, size_t count) {
6242 ctoon_mut_arr_with_func({
6243 unsafe_ctoon_set_uint(val, vals[i]);
6244 });
6245}
6246
6247ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint32(
6248 ctoon_mut_doc *doc, const uint32_t *vals, size_t count) {
6249 ctoon_mut_arr_with_func({
6250 unsafe_ctoon_set_uint(val, vals[i]);
6251 });
6252}
6253
6254ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint64(
6255 ctoon_mut_doc *doc, const uint64_t *vals, size_t count) {
6256 ctoon_mut_arr_with_func({
6257 unsafe_ctoon_set_uint(val, vals[i]);
6258 });
6259}
6260
6261ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_float(
6262 ctoon_mut_doc *doc, const float *vals, size_t count) {
6263 ctoon_mut_arr_with_func({
6264 unsafe_ctoon_set_float(val, vals[i]);
6265 });
6266}
6267
6268ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_double(
6269 ctoon_mut_doc *doc, const double *vals, size_t count) {
6270 ctoon_mut_arr_with_func({
6271 unsafe_ctoon_set_double(val, vals[i]);
6272 });
6273}
6274
6275ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_str(
6276 ctoon_mut_doc *doc, const char **vals, size_t count) {
6277 ctoon_mut_arr_with_func({
6278 if (ctoon_unlikely(!vals[i])) return NULL;
6279 unsafe_ctoon_set_str(val, vals[i]);
6280 });
6281}
6282
6283ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strn(
6284 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
6285 if (ctoon_unlikely(count > 0 && !lens)) return NULL;
6286 ctoon_mut_arr_with_func({
6287 if (ctoon_unlikely(!vals[i])) return NULL;
6288 unsafe_ctoon_set_strn(val, vals[i], lens[i]);
6289 });
6290}
6291
6292ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strcpy(
6293 ctoon_mut_doc *doc, const char **vals, size_t count) {
6294 size_t len;
6295 const char *str, *new_str;
6296 ctoon_mut_arr_with_func({
6297 str = vals[i];
6298 if (ctoon_unlikely(!str)) return NULL;
6299 len = strlen(str);
6300 new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6301 if (ctoon_unlikely(!new_str)) return NULL;
6302 unsafe_ctoon_set_strn(val, new_str, len);
6303 });
6304}
6305
6306ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strncpy(
6307 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
6308 size_t len;
6309 const char *str, *new_str;
6310 if (ctoon_unlikely(count > 0 && !lens)) return NULL;
6311 ctoon_mut_arr_with_func({
6312 str = vals[i];
6313 if (ctoon_unlikely(!str)) return NULL;
6314 len = lens[i];
6315 new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6316 if (ctoon_unlikely(!new_str)) return NULL;
6317 unsafe_ctoon_set_strn(val, new_str, len);
6318 });
6319}
6320
6321#undef ctoon_mut_arr_with_func
6322
6323
6324
6325/*==============================================================================
6326 * MARK: - Mutable TOON Array Modification API (Implementation)
6327 *============================================================================*/
6328
6329ctoon_api_inline bool ctoon_mut_arr_insert(ctoon_mut_val *arr,
6330 ctoon_mut_val *val, size_t idx) {
6331 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6332 size_t len = unsafe_ctoon_get_len(arr);
6333 if (ctoon_likely(idx <= len)) {
6334 unsafe_ctoon_set_len(arr, len + 1);
6335 if (len == 0) {
6336 val->next = val;
6337 arr->uni.ptr = val;
6338 } else {
6339 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6340 ctoon_mut_val *next = prev->next;
6341 if (idx == len) {
6342 prev->next = val;
6343 val->next = next;
6344 arr->uni.ptr = val;
6345 } else {
6346 while (idx-- > 0) {
6347 prev = next;
6348 next = next->next;
6349 }
6350 prev->next = val;
6351 val->next = next;
6352 }
6353 }
6354 return true;
6355 }
6356 }
6357 return false;
6358}
6359
6360ctoon_api_inline bool ctoon_mut_arr_append(ctoon_mut_val *arr,
6361 ctoon_mut_val *val) {
6362 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6363 size_t len = unsafe_ctoon_get_len(arr);
6364 unsafe_ctoon_set_len(arr, len + 1);
6365 if (len == 0) {
6366 val->next = val;
6367 } else {
6368 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6369 ctoon_mut_val *next = prev->next;
6370 prev->next = val;
6371 val->next = next;
6372 }
6373 arr->uni.ptr = val;
6374 return true;
6375 }
6376 return false;
6377}
6378
6379ctoon_api_inline bool ctoon_mut_arr_prepend(ctoon_mut_val *arr,
6380 ctoon_mut_val *val) {
6381 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6382 size_t len = unsafe_ctoon_get_len(arr);
6383 unsafe_ctoon_set_len(arr, len + 1);
6384 if (len == 0) {
6385 val->next = val;
6386 arr->uni.ptr = val;
6387 } else {
6388 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6389 ctoon_mut_val *next = prev->next;
6390 prev->next = val;
6391 val->next = next;
6392 }
6393 return true;
6394 }
6395 return false;
6396}
6397
6398ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_replace(ctoon_mut_val *arr,
6399 size_t idx,
6400 ctoon_mut_val *val) {
6401 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6402 size_t len = unsafe_ctoon_get_len(arr);
6403 if (ctoon_likely(idx < len)) {
6404 if (ctoon_likely(len > 1)) {
6405 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6406 ctoon_mut_val *next = prev->next;
6407 while (idx-- > 0) {
6408 prev = next;
6409 next = next->next;
6410 }
6411 prev->next = val;
6412 val->next = next->next;
6413 if ((void *)next == arr->uni.ptr) arr->uni.ptr = val;
6414 return next;
6415 } else {
6416 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6417 val->next = val;
6418 arr->uni.ptr = val;
6419 return prev;
6420 }
6421 }
6422 }
6423 return NULL;
6424}
6425
6426ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove(ctoon_mut_val *arr,
6427 size_t idx) {
6428 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6429 size_t len = unsafe_ctoon_get_len(arr);
6430 if (ctoon_likely(idx < len)) {
6431 unsafe_ctoon_set_len(arr, len - 1);
6432 if (ctoon_likely(len > 1)) {
6433 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6434 ctoon_mut_val *next = prev->next;
6435 while (idx-- > 0) {
6436 prev = next;
6437 next = next->next;
6438 }
6439 prev->next = next->next;
6440 if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev;
6441 return next;
6442 } else {
6443 return ((ctoon_mut_val *)arr->uni.ptr);
6444 }
6445 }
6446 }
6447 return NULL;
6448}
6449
6450ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_first(
6451 ctoon_mut_val *arr) {
6452 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6453 size_t len = unsafe_ctoon_get_len(arr);
6454 if (len > 1) {
6455 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6456 ctoon_mut_val *next = prev->next;
6457 prev->next = next->next;
6458 unsafe_ctoon_set_len(arr, len - 1);
6459 return next;
6460 } else if (len == 1) {
6461 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6462 unsafe_ctoon_set_len(arr, 0);
6463 return prev;
6464 }
6465 }
6466 return NULL;
6467}
6468
6469ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_last(
6470 ctoon_mut_val *arr) {
6471 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6472 size_t len = unsafe_ctoon_get_len(arr);
6473 if (ctoon_likely(len > 1)) {
6474 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6475 ctoon_mut_val *next = prev->next;
6476 unsafe_ctoon_set_len(arr, len - 1);
6477 while (--len > 0) prev = prev->next;
6478 prev->next = next;
6479 next = (ctoon_mut_val *)arr->uni.ptr;
6480 arr->uni.ptr = prev;
6481 return next;
6482 } else if (len == 1) {
6483 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6484 unsafe_ctoon_set_len(arr, 0);
6485 return prev;
6486 }
6487 }
6488 return NULL;
6489}
6490
6491ctoon_api_inline bool ctoon_mut_arr_remove_range(ctoon_mut_val *arr,
6492 size_t _idx, size_t _len) {
6493 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6494 ctoon_mut_val *prev, *next;
6495 bool tail_removed;
6496 size_t len = unsafe_ctoon_get_len(arr);
6497 if (ctoon_unlikely(_idx + _len > len)) return false;
6498 if (ctoon_unlikely(_len == 0)) return true;
6499 unsafe_ctoon_set_len(arr, len - _len);
6500 if (ctoon_unlikely(len == _len)) return true;
6501 tail_removed = (_idx + _len == len);
6502 prev = ((ctoon_mut_val *)arr->uni.ptr);
6503 while (_idx-- > 0) prev = prev->next;
6504 next = prev->next;
6505 while (_len-- > 0) next = next->next;
6506 prev->next = next;
6507 if (ctoon_unlikely(tail_removed)) arr->uni.ptr = prev;
6508 return true;
6509 }
6510 return false;
6511}
6512
6513ctoon_api_inline bool ctoon_mut_arr_clear(ctoon_mut_val *arr) {
6514 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6515 unsafe_ctoon_set_len(arr, 0);
6516 return true;
6517 }
6518 return false;
6519}
6520
6521ctoon_api_inline bool ctoon_mut_arr_rotate(ctoon_mut_val *arr,
6522 size_t idx) {
6523 if (ctoon_likely(ctoon_mut_is_arr(arr) &&
6524 unsafe_ctoon_get_len(arr) > idx)) {
6525 ctoon_mut_val *val = (ctoon_mut_val *)arr->uni.ptr;
6526 while (idx-- > 0) val = val->next;
6527 arr->uni.ptr = (void *)val;
6528 return true;
6529 }
6530 return false;
6531}
6532
6533
6534
6535/*==============================================================================
6536 * MARK: - Mutable TOON Array Modification Convenience API (Implementation)
6537 *============================================================================*/
6538
6539ctoon_api_inline bool ctoon_mut_arr_add_val(ctoon_mut_val *arr,
6540 ctoon_mut_val *val) {
6541 return ctoon_mut_arr_append(arr, val);
6542}
6543
6544ctoon_api_inline bool ctoon_mut_arr_add_null(ctoon_mut_doc *doc,
6545 ctoon_mut_val *arr) {
6546 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6547 ctoon_mut_val *val = ctoon_mut_null(doc);
6548 return ctoon_mut_arr_append(arr, val);
6549 }
6550 return false;
6551}
6552
6553ctoon_api_inline bool ctoon_mut_arr_add_true(ctoon_mut_doc *doc,
6554 ctoon_mut_val *arr) {
6555 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6556 ctoon_mut_val *val = ctoon_mut_true(doc);
6557 return ctoon_mut_arr_append(arr, val);
6558 }
6559 return false;
6560}
6561
6562ctoon_api_inline bool ctoon_mut_arr_add_false(ctoon_mut_doc *doc,
6563 ctoon_mut_val *arr) {
6564 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6565 ctoon_mut_val *val = ctoon_mut_false(doc);
6566 return ctoon_mut_arr_append(arr, val);
6567 }
6568 return false;
6569}
6570
6571ctoon_api_inline bool ctoon_mut_arr_add_bool(ctoon_mut_doc *doc,
6572 ctoon_mut_val *arr,
6573 bool _val) {
6574 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6575 ctoon_mut_val *val = ctoon_mut_bool(doc, _val);
6576 return ctoon_mut_arr_append(arr, val);
6577 }
6578 return false;
6579}
6580
6581ctoon_api_inline bool ctoon_mut_arr_add_uint(ctoon_mut_doc *doc,
6582 ctoon_mut_val *arr,
6583 uint64_t num) {
6584 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6585 ctoon_mut_val *val = ctoon_mut_uint(doc, num);
6586 return ctoon_mut_arr_append(arr, val);
6587 }
6588 return false;
6589}
6590
6591ctoon_api_inline bool ctoon_mut_arr_add_sint(ctoon_mut_doc *doc,
6592 ctoon_mut_val *arr,
6593 int64_t num) {
6594 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6595 ctoon_mut_val *val = ctoon_mut_sint(doc, num);
6596 return ctoon_mut_arr_append(arr, val);
6597 }
6598 return false;
6599}
6600
6601ctoon_api_inline bool ctoon_mut_arr_add_int(ctoon_mut_doc *doc,
6602 ctoon_mut_val *arr,
6603 int64_t num) {
6604 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6605 ctoon_mut_val *val = ctoon_mut_sint(doc, num);
6606 return ctoon_mut_arr_append(arr, val);
6607 }
6608 return false;
6609}
6610
6611ctoon_api_inline bool ctoon_mut_arr_add_float(ctoon_mut_doc *doc,
6612 ctoon_mut_val *arr,
6613 float num) {
6614 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6615 ctoon_mut_val *val = ctoon_mut_float(doc, num);
6616 return ctoon_mut_arr_append(arr, val);
6617 }
6618 return false;
6619}
6620
6621ctoon_api_inline bool ctoon_mut_arr_add_double(ctoon_mut_doc *doc,
6622 ctoon_mut_val *arr,
6623 double num) {
6624 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6625 ctoon_mut_val *val = ctoon_mut_double(doc, num);
6626 return ctoon_mut_arr_append(arr, val);
6627 }
6628 return false;
6629}
6630
6631ctoon_api_inline bool ctoon_mut_arr_add_real(ctoon_mut_doc *doc,
6632 ctoon_mut_val *arr,
6633 double num) {
6634 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6635 ctoon_mut_val *val = ctoon_mut_real(doc, num);
6636 return ctoon_mut_arr_append(arr, val);
6637 }
6638 return false;
6639}
6640
6641ctoon_api_inline bool ctoon_mut_arr_add_str(ctoon_mut_doc *doc,
6642 ctoon_mut_val *arr,
6643 const char *str) {
6644 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6645 ctoon_mut_val *val = ctoon_mut_str(doc, str);
6646 return ctoon_mut_arr_append(arr, val);
6647 }
6648 return false;
6649}
6650
6651ctoon_api_inline bool ctoon_mut_arr_add_strn(ctoon_mut_doc *doc,
6652 ctoon_mut_val *arr,
6653 const char *str, size_t len) {
6654 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6655 ctoon_mut_val *val = ctoon_mut_strn(doc, str, len);
6656 return ctoon_mut_arr_append(arr, val);
6657 }
6658 return false;
6659}
6660
6661ctoon_api_inline bool ctoon_mut_arr_add_strcpy(ctoon_mut_doc *doc,
6662 ctoon_mut_val *arr,
6663 const char *str) {
6664 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6665 ctoon_mut_val *val = ctoon_mut_strcpy(doc, str);
6666 return ctoon_mut_arr_append(arr, val);
6667 }
6668 return false;
6669}
6670
6671ctoon_api_inline bool ctoon_mut_arr_add_strncpy(ctoon_mut_doc *doc,
6672 ctoon_mut_val *arr,
6673 const char *str, size_t len) {
6674 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6675 ctoon_mut_val *val = ctoon_mut_strncpy(doc, str, len);
6676 return ctoon_mut_arr_append(arr, val);
6677 }
6678 return false;
6679}
6680
6681ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_arr(ctoon_mut_doc *doc,
6682 ctoon_mut_val *arr) {
6683 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6684 ctoon_mut_val *val = ctoon_mut_arr(doc);
6685 return ctoon_mut_arr_append(arr, val) ? val : NULL;
6686 }
6687 return NULL;
6688}
6689
6690ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_obj(ctoon_mut_doc *doc,
6691 ctoon_mut_val *arr) {
6692 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6693 ctoon_mut_val *val = ctoon_mut_obj(doc);
6694 return ctoon_mut_arr_append(arr, val) ? val : NULL;
6695 }
6696 return NULL;
6697}
6698
6699
6700
6701/*==============================================================================
6702 * MARK: - Mutable TOON Object API (Implementation)
6703 *============================================================================*/
6704
6705ctoon_api_inline size_t ctoon_mut_obj_size(ctoon_mut_val *obj) {
6706 return ctoon_mut_is_obj(obj) ? unsafe_ctoon_get_len(obj) : 0;
6707}
6708
6709ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_get(ctoon_mut_val *obj,
6710 const char *key) {
6711 return ctoon_mut_obj_getn(obj, key, key ? strlen(key) : 0);
6712}
6713
6714ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_getn(ctoon_mut_val *obj,
6715 const char *_key,
6716 size_t key_len) {
6717 size_t len = ctoon_mut_obj_size(obj);
6718 if (ctoon_likely(len && _key)) {
6719 ctoon_mut_val *key = ((ctoon_mut_val *)obj->uni.ptr)->next->next;
6720 while (len-- > 0) {
6721 if (unsafe_ctoon_equals_strn(key, _key, key_len)) return key->next;
6722 key = key->next->next;
6723 }
6724 }
6725 return NULL;
6726}
6727
6728
6729
6730/*==============================================================================
6731 * MARK: - Mutable TOON Object Iterator API (Implementation)
6732 *============================================================================*/
6733
6734ctoon_api_inline bool ctoon_mut_obj_iter_init(ctoon_mut_val *obj,
6735 ctoon_mut_obj_iter *iter) {
6736 if (ctoon_likely(ctoon_mut_is_obj(obj) && iter)) {
6737 iter->idx = 0;
6738 iter->max = unsafe_ctoon_get_len(obj);
6739 iter->cur = iter->max ? (ctoon_mut_val *)obj->uni.ptr : NULL;
6740 iter->pre = NULL;
6741 iter->obj = obj;
6742 return true;
6743 }
6744 if (iter) memset(iter, 0, sizeof(ctoon_mut_obj_iter));
6745 return false;
6746}
6747
6748ctoon_api_inline ctoon_mut_obj_iter ctoon_mut_obj_iter_with(
6749 ctoon_mut_val *obj) {
6750 ctoon_mut_obj_iter iter;
6751 ctoon_mut_obj_iter_init(obj, &iter);
6752 return iter;
6753}
6754
6755ctoon_api_inline bool ctoon_mut_obj_iter_has_next(ctoon_mut_obj_iter *iter) {
6756 return iter ? iter->idx < iter->max : false;
6757}
6758
6759ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_next(
6760 ctoon_mut_obj_iter *iter) {
6761 if (iter && iter->idx < iter->max) {
6762 ctoon_mut_val *key = iter->cur;
6763 iter->pre = key;
6764 iter->cur = key->next->next;
6765 iter->idx++;
6766 return iter->cur;
6767 }
6768 return NULL;
6769}
6770
6771ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get_val(
6772 ctoon_mut_val *key) {
6773 return key ? key->next : NULL;
6774}
6775
6776ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_remove(
6777 ctoon_mut_obj_iter *iter) {
6778 if (ctoon_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
6779 ctoon_mut_val *prev = iter->pre;
6780 ctoon_mut_val *cur = iter->cur;
6781 ctoon_mut_val *next = cur->next->next;
6782 if (ctoon_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
6783 iter->idx--;
6784 iter->max--;
6785 unsafe_ctoon_set_len(iter->obj, iter->max);
6786 prev->next->next = next;
6787 iter->cur = prev;
6788 return cur->next;
6789 }
6790 return NULL;
6791}
6792
6793ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get(
6794 ctoon_mut_obj_iter *iter, const char *key) {
6795 return ctoon_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
6796}
6797
6798ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_getn(
6799 ctoon_mut_obj_iter *iter, const char *key, size_t key_len) {
6800 if (iter && key) {
6801 size_t idx = 0;
6802 size_t max = iter->max;
6803 ctoon_mut_val *pre, *cur = iter->cur;
6804 while (idx++ < max) {
6805 pre = cur;
6806 cur = cur->next->next;
6807 if (unsafe_ctoon_equals_strn(cur, key, key_len)) {
6808 iter->idx += idx;
6809 if (iter->idx > max) iter->idx -= max + 1;
6810 iter->pre = pre;
6811 iter->cur = cur;
6812 return cur->next;
6813 }
6814 }
6815 }
6816 return NULL;
6817}
6818
6819
6820
6821/*==============================================================================
6822 * MARK: - Mutable TOON Object Creation API (Implementation)
6823 *============================================================================*/
6824
6825ctoon_api_inline ctoon_mut_val *ctoon_mut_obj(ctoon_mut_doc *doc) {
6826 if (ctoon_likely(doc)) {
6827 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1);
6828 if (ctoon_likely(val)) {
6829 val->tag = CTOON_TYPE_OBJ | CTOON_SUBTYPE_NONE;
6830 return val;
6831 }
6832 }
6833 return NULL;
6834}
6835
6836ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_str(ctoon_mut_doc *doc,
6837 const char **keys,
6838 const char **vals,
6839 size_t count) {
6840 if (ctoon_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
6841 ctoon_mut_val *obj = unsafe_ctoon_mut_val(doc, 1 + count * 2);
6842 if (ctoon_likely(obj)) {
6843 obj->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_OBJ;
6844 if (count > 0) {
6845 size_t i;
6846 for (i = 0; i < count; i++) {
6847 ctoon_mut_val *key = obj + (i * 2 + 1);
6848 ctoon_mut_val *val = obj + (i * 2 + 2);
6849 uint64_t key_len = (uint64_t)strlen(keys[i]);
6850 uint64_t val_len = (uint64_t)strlen(vals[i]);
6851 key->tag = (key_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6852 val->tag = (val_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6853 key->uni.str = keys[i];
6854 val->uni.str = vals[i];
6855 key->next = val;
6856 val->next = val + 1;
6857 }
6858 obj[count * 2].next = obj + 1;
6859 obj->uni.ptr = obj + (count * 2 - 1);
6860 }
6861 return obj;
6862 }
6863 }
6864 return NULL;
6865}
6866
6867ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_kv(ctoon_mut_doc *doc,
6868 const char **pairs,
6869 size_t count) {
6870 if (ctoon_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
6871 ctoon_mut_val *obj = unsafe_ctoon_mut_val(doc, 1 + count * 2);
6872 if (ctoon_likely(obj)) {
6873 obj->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_OBJ;
6874 if (count > 0) {
6875 size_t i;
6876 for (i = 0; i < count; i++) {
6877 ctoon_mut_val *key = obj + (i * 2 + 1);
6878 ctoon_mut_val *val = obj + (i * 2 + 2);
6879 const char *key_str = pairs[i * 2 + 0];
6880 const char *val_str = pairs[i * 2 + 1];
6881 uint64_t key_len = (uint64_t)strlen(key_str);
6882 uint64_t val_len = (uint64_t)strlen(val_str);
6883 key->tag = (key_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6884 val->tag = (val_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6885 key->uni.str = key_str;
6886 val->uni.str = val_str;
6887 key->next = val;
6888 val->next = val + 1;
6889 }
6890 obj[count * 2].next = obj + 1;
6891 obj->uni.ptr = obj + (count * 2 - 1);
6892 }
6893 return obj;
6894 }
6895 }
6896 return NULL;
6897}
6898
6899
6900
6901/*==============================================================================
6902 * MARK: - Mutable TOON Object Modification API (Implementation)
6903 *============================================================================*/
6904
6905ctoon_api_inline void unsafe_ctoon_mut_obj_add(ctoon_mut_val *obj,
6906 ctoon_mut_val *key,
6907 ctoon_mut_val *val,
6908 size_t len) {
6909 if (ctoon_likely(len)) {
6910 ctoon_mut_val *prev_val = ((ctoon_mut_val *)obj->uni.ptr)->next;
6911 ctoon_mut_val *next_key = prev_val->next;
6912 prev_val->next = key;
6913 val->next = next_key;
6914 } else {
6915 val->next = key;
6916 }
6917 key->next = val;
6918 obj->uni.ptr = (void *)key;
6919 unsafe_ctoon_set_len(obj, len + 1);
6920}
6921
6922ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_obj_remove(
6923 ctoon_mut_val *obj, const char *key, size_t key_len) {
6924 size_t obj_len = unsafe_ctoon_get_len(obj);
6925 if (obj_len) {
6926 ctoon_mut_val *pre_key = (ctoon_mut_val *)obj->uni.ptr;
6927 ctoon_mut_val *cur_key = pre_key->next->next;
6928 ctoon_mut_val *removed_item = NULL;
6929 size_t i;
6930 for (i = 0; i < obj_len; i++) {
6931 if (unsafe_ctoon_equals_strn(cur_key, key, key_len)) {
6932 if (!removed_item) removed_item = cur_key->next;
6933 cur_key = cur_key->next->next;
6934 pre_key->next->next = cur_key;
6935 if (i + 1 == obj_len) obj->uni.ptr = pre_key;
6936 i--;
6937 obj_len--;
6938 } else {
6939 pre_key = cur_key;
6940 cur_key = cur_key->next->next;
6941 }
6942 }
6943 unsafe_ctoon_set_len(obj, obj_len);
6944 return removed_item;
6945 } else {
6946 return NULL;
6947 }
6948}
6949
6950ctoon_api_inline bool unsafe_ctoon_mut_obj_replace(ctoon_mut_val *obj,
6951 ctoon_mut_val *key,
6952 ctoon_mut_val *val) {
6953 size_t key_len = unsafe_ctoon_get_len(key);
6954 size_t obj_len = unsafe_ctoon_get_len(obj);
6955 if (obj_len) {
6956 ctoon_mut_val *pre_key = (ctoon_mut_val *)obj->uni.ptr;
6957 ctoon_mut_val *cur_key = pre_key->next->next;
6958 size_t i;
6959 for (i = 0; i < obj_len; i++) {
6960 if (unsafe_ctoon_equals_strn(cur_key, key->uni.str, key_len)) {
6961 cur_key->next->tag = val->tag;
6962 cur_key->next->uni.u64 = val->uni.u64;
6963 return true;
6964 } else {
6965 cur_key = cur_key->next->next;
6966 }
6967 }
6968 }
6969 return false;
6970}
6971
6972ctoon_api_inline void unsafe_ctoon_mut_obj_rotate(ctoon_mut_val *obj,
6973 size_t idx) {
6974 ctoon_mut_val *key = (ctoon_mut_val *)obj->uni.ptr;
6975 while (idx-- > 0) key = key->next->next;
6976 obj->uni.ptr = (void *)key;
6977}
6978
6979ctoon_api_inline bool ctoon_mut_obj_add(ctoon_mut_val *obj,
6980 ctoon_mut_val *key,
6981 ctoon_mut_val *val) {
6982 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
6983 ctoon_mut_is_str(key) && val)) {
6984 unsafe_ctoon_mut_obj_add(obj, key, val, unsafe_ctoon_get_len(obj));
6985 return true;
6986 }
6987 return false;
6988}
6989
6990ctoon_api_inline bool ctoon_mut_obj_put(ctoon_mut_val *obj,
6991 ctoon_mut_val *key,
6992 ctoon_mut_val *val) {
6993 bool replaced = false;
6994 size_t key_len;
6995 ctoon_mut_obj_iter iter;
6996 ctoon_mut_val *cur_key;
6997 if (ctoon_unlikely(!ctoon_mut_is_obj(obj) ||
6998 !ctoon_mut_is_str(key))) return false;
6999 key_len = unsafe_ctoon_get_len(key);
7000 ctoon_mut_obj_iter_init(obj, &iter);
7001 while ((cur_key = ctoon_mut_obj_iter_next(&iter)) != 0) {
7002 if (unsafe_ctoon_equals_strn(cur_key, key->uni.str, key_len)) {
7003 if (!replaced && val) {
7004 replaced = true;
7005 val->next = cur_key->next->next;
7006 cur_key->next = val;
7007 } else {
7008 ctoon_mut_obj_iter_remove(&iter);
7009 }
7010 }
7011 }
7012 if (!replaced && val) unsafe_ctoon_mut_obj_add(obj, key, val, iter.max);
7013 return true;
7014}
7015
7016ctoon_api_inline bool ctoon_mut_obj_insert(ctoon_mut_val *obj,
7017 ctoon_mut_val *key,
7018 ctoon_mut_val *val,
7019 size_t idx) {
7020 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
7021 ctoon_mut_is_str(key) && val)) {
7022 size_t len = unsafe_ctoon_get_len(obj);
7023 if (ctoon_likely(len >= idx)) {
7024 if (len > idx) {
7025 void *ptr = obj->uni.ptr;
7026 unsafe_ctoon_mut_obj_rotate(obj, idx);
7027 unsafe_ctoon_mut_obj_add(obj, key, val, len);
7028 obj->uni.ptr = ptr;
7029 } else {
7030 unsafe_ctoon_mut_obj_add(obj, key, val, len);
7031 }
7032 return true;
7033 }
7034 }
7035 return false;
7036}
7037
7038ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove(ctoon_mut_val *obj,
7039 ctoon_mut_val *key) {
7040 if (ctoon_likely(ctoon_mut_is_obj(obj) && ctoon_mut_is_str(key))) {
7041 return unsafe_ctoon_mut_obj_remove(obj, key->uni.str,
7042 unsafe_ctoon_get_len(key));
7043 }
7044 return NULL;
7045}
7046
7047ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_key(
7048 ctoon_mut_val *obj, const char *key) {
7049 if (ctoon_likely(ctoon_mut_is_obj(obj) && key)) {
7050 size_t key_len = strlen(key);
7051 return unsafe_ctoon_mut_obj_remove(obj, key, key_len);
7052 }
7053 return NULL;
7054}
7055
7056ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_keyn(
7057 ctoon_mut_val *obj, const char *key, size_t key_len) {
7058 if (ctoon_likely(ctoon_mut_is_obj(obj) && key)) {
7059 return unsafe_ctoon_mut_obj_remove(obj, key, key_len);
7060 }
7061 return NULL;
7062}
7063
7064ctoon_api_inline bool ctoon_mut_obj_clear(ctoon_mut_val *obj) {
7065 if (ctoon_likely(ctoon_mut_is_obj(obj))) {
7066 unsafe_ctoon_set_len(obj, 0);
7067 return true;
7068 }
7069 return false;
7070}
7071
7072ctoon_api_inline bool ctoon_mut_obj_replace(ctoon_mut_val *obj,
7073 ctoon_mut_val *key,
7074 ctoon_mut_val *val) {
7075 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
7076 ctoon_mut_is_str(key) && val)) {
7077 return unsafe_ctoon_mut_obj_replace(obj, key, val);
7078 }
7079 return false;
7080}
7081
7082ctoon_api_inline bool ctoon_mut_obj_rotate(ctoon_mut_val *obj,
7083 size_t idx) {
7084 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
7085 unsafe_ctoon_get_len(obj) > idx)) {
7086 unsafe_ctoon_mut_obj_rotate(obj, idx);
7087 return true;
7088 }
7089 return false;
7090}
7091
7092
7093
7094/*==============================================================================
7095 * MARK: - Mutable TOON Object Modification Convenience API (Implementation)
7096 *============================================================================*/
7097
7098#define ctoon_mut_obj_add_func(func) \
7099 if (ctoon_likely(doc && ctoon_mut_is_obj(obj) && _key)) { \
7100 ctoon_mut_val *key = unsafe_ctoon_mut_val(doc, 2); \
7101 if (ctoon_likely(key)) { \
7102 size_t len = unsafe_ctoon_get_len(obj); \
7103 ctoon_mut_val *val = key + 1; \
7104 size_t key_len = strlen(_key); \
7105 bool noesc = unsafe_ctoon_is_str_noesc(_key, key_len); \
7106 key->tag = CTOON_TYPE_STR; \
7107 key->tag |= noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE; \
7108 key->tag |= (uint64_t)strlen(_key) << CTOON_TAG_BIT; \
7109 key->uni.str = _key; \
7110 func \
7111 unsafe_ctoon_mut_obj_add(obj, key, val, len); \
7112 return true; \
7113 } \
7114 } \
7115 return false
7116
7117ctoon_api_inline bool ctoon_mut_obj_add_null(ctoon_mut_doc *doc,
7118 ctoon_mut_val *obj,
7119 const char *_key) {
7120 ctoon_mut_obj_add_func({ unsafe_ctoon_set_null(val); });
7121}
7122
7123ctoon_api_inline bool ctoon_mut_obj_add_true(ctoon_mut_doc *doc,
7124 ctoon_mut_val *obj,
7125 const char *_key) {
7126 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, true); });
7127}
7128
7129ctoon_api_inline bool ctoon_mut_obj_add_false(ctoon_mut_doc *doc,
7130 ctoon_mut_val *obj,
7131 const char *_key) {
7132 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, false); });
7133}
7134
7135ctoon_api_inline bool ctoon_mut_obj_add_bool(ctoon_mut_doc *doc,
7136 ctoon_mut_val *obj,
7137 const char *_key,
7138 bool _val) {
7139 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, _val); });
7140}
7141
7142ctoon_api_inline bool ctoon_mut_obj_add_uint(ctoon_mut_doc *doc,
7143 ctoon_mut_val *obj,
7144 const char *_key,
7145 uint64_t _val) {
7146 ctoon_mut_obj_add_func({ unsafe_ctoon_set_uint(val, _val); });
7147}
7148
7149ctoon_api_inline bool ctoon_mut_obj_add_sint(ctoon_mut_doc *doc,
7150 ctoon_mut_val *obj,
7151 const char *_key,
7152 int64_t _val) {
7153 ctoon_mut_obj_add_func({ unsafe_ctoon_set_sint(val, _val); });
7154}
7155
7156ctoon_api_inline bool ctoon_mut_obj_add_int(ctoon_mut_doc *doc,
7157 ctoon_mut_val *obj,
7158 const char *_key,
7159 int64_t _val) {
7160 ctoon_mut_obj_add_func({ unsafe_ctoon_set_sint(val, _val); });
7161}
7162
7163ctoon_api_inline bool ctoon_mut_obj_add_float(ctoon_mut_doc *doc,
7164 ctoon_mut_val *obj,
7165 const char *_key,
7166 float _val) {
7167 ctoon_mut_obj_add_func({ unsafe_ctoon_set_float(val, _val); });
7168}
7169
7170ctoon_api_inline bool ctoon_mut_obj_add_double(ctoon_mut_doc *doc,
7171 ctoon_mut_val *obj,
7172 const char *_key,
7173 double _val) {
7174 ctoon_mut_obj_add_func({ unsafe_ctoon_set_double(val, _val); });
7175}
7176
7177ctoon_api_inline bool ctoon_mut_obj_add_real(ctoon_mut_doc *doc,
7178 ctoon_mut_val *obj,
7179 const char *_key,
7180 double _val) {
7181 ctoon_mut_obj_add_func({ unsafe_ctoon_set_real(val, _val); });
7182}
7183
7184ctoon_api_inline bool ctoon_mut_obj_add_str(ctoon_mut_doc *doc,
7185 ctoon_mut_val *obj,
7186 const char *_key,
7187 const char *_val) {
7188 if (ctoon_unlikely(!_val)) return false;
7189 ctoon_mut_obj_add_func({
7190 size_t val_len = strlen(_val);
7191 bool val_noesc = unsafe_ctoon_is_str_noesc(_val, val_len);
7192 val->tag = ((uint64_t)strlen(_val) << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7193 val->tag |= val_noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
7194 val->uni.str = _val;
7195 });
7196}
7197
7198ctoon_api_inline bool ctoon_mut_obj_add_strn(ctoon_mut_doc *doc,
7199 ctoon_mut_val *obj,
7200 const char *_key,
7201 const char *_val,
7202 size_t _len) {
7203 if (ctoon_unlikely(!_val)) return false;
7204 ctoon_mut_obj_add_func({
7205 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7206 val->uni.str = _val;
7207 });
7208}
7209
7210ctoon_api_inline bool ctoon_mut_obj_add_strcpy(ctoon_mut_doc *doc,
7211 ctoon_mut_val *obj,
7212 const char *_key,
7213 const char *_val) {
7214 if (ctoon_unlikely(!_val)) return false;
7215 ctoon_mut_obj_add_func({
7216 size_t _len = strlen(_val);
7217 val->uni.str = unsafe_ctoon_mut_strncpy(doc, _val, _len);
7218 if (ctoon_unlikely(!val->uni.str)) return false;
7219 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7220 });
7221}
7222
7223ctoon_api_inline bool ctoon_mut_obj_add_strncpy(ctoon_mut_doc *doc,
7224 ctoon_mut_val *obj,
7225 const char *_key,
7226 const char *_val,
7227 size_t _len) {
7228 if (ctoon_unlikely(!_val)) return false;
7229 ctoon_mut_obj_add_func({
7230 val->uni.str = unsafe_ctoon_mut_strncpy(doc, _val, _len);
7231 if (ctoon_unlikely(!val->uni.str)) return false;
7232 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7233 });
7234}
7235
7236ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_arr(ctoon_mut_doc *doc,
7237 ctoon_mut_val *obj,
7238 const char *_key) {
7239 ctoon_mut_val *key = ctoon_mut_str(doc, _key);
7240 ctoon_mut_val *val = ctoon_mut_arr(doc);
7241 return ctoon_mut_obj_add(obj, key, val) ? val : NULL;
7242}
7243
7244ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_obj(ctoon_mut_doc *doc,
7245 ctoon_mut_val *obj,
7246 const char *_key) {
7247 ctoon_mut_val *key = ctoon_mut_str(doc, _key);
7248 ctoon_mut_val *val = ctoon_mut_obj(doc);
7249 return ctoon_mut_obj_add(obj, key, val) ? val : NULL;
7250}
7251
7252ctoon_api_inline bool ctoon_mut_obj_add_val(ctoon_mut_doc *doc,
7253 ctoon_mut_val *obj,
7254 const char *_key,
7255 ctoon_mut_val *_val) {
7256 if (ctoon_unlikely(!_val)) return false;
7257 ctoon_mut_obj_add_func({
7258 val = _val;
7259 });
7260}
7261
7262ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_str(ctoon_mut_val *obj,
7263 const char *key) {
7264 return ctoon_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
7265}
7266
7267ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_strn(
7268 ctoon_mut_val *obj, const char *_key, size_t _len) {
7269 if (ctoon_likely(ctoon_mut_is_obj(obj) && _key)) {
7270 ctoon_mut_val *key;
7271 ctoon_mut_obj_iter iter;
7272 ctoon_mut_val *val_removed = NULL;
7273 ctoon_mut_obj_iter_init(obj, &iter);
7274 while ((key = ctoon_mut_obj_iter_next(&iter)) != NULL) {
7275 if (unsafe_ctoon_equals_strn(key, _key, _len)) {
7276 if (!val_removed) val_removed = key->next;
7277 ctoon_mut_obj_iter_remove(&iter);
7278 }
7279 }
7280 return val_removed;
7281 }
7282 return NULL;
7283}
7284
7285ctoon_api_inline bool ctoon_mut_obj_rename_key(ctoon_mut_doc *doc,
7286 ctoon_mut_val *obj,
7287 const char *key,
7288 const char *new_key) {
7289 if (!key || !new_key) return false;
7290 return ctoon_mut_obj_rename_keyn(doc, obj, key, strlen(key),
7291 new_key, strlen(new_key));
7292}
7293
7294ctoon_api_inline bool ctoon_mut_obj_rename_keyn(ctoon_mut_doc *doc,
7295 ctoon_mut_val *obj,
7296 const char *key,
7297 size_t len,
7298 const char *new_key,
7299 size_t new_len) {
7300 char *cpy_key = NULL;
7301 ctoon_mut_val *old_key;
7302 ctoon_mut_obj_iter iter;
7303 if (!doc || !obj || !key || !new_key) return false;
7304 ctoon_mut_obj_iter_init(obj, &iter);
7305 while ((old_key = ctoon_mut_obj_iter_next(&iter))) {
7306 if (unsafe_ctoon_equals_strn((void *)old_key, key, len)) {
7307 if (!cpy_key) {
7308 cpy_key = unsafe_ctoon_mut_strncpy(doc, new_key, new_len);
7309 if (!cpy_key) return false;
7310 }
7311 ctoon_mut_set_strn(old_key, cpy_key, new_len);
7312 }
7313 }
7314 return cpy_key != NULL;
7315}
7316
7317
7318
7319#if !defined(CTOON_DISABLE_UTILS) || !CTOON_DISABLE_UTILS
7320
7321/*==============================================================================
7322 * MARK: - TOON Pointer API (Implementation)
7323 *============================================================================*/
7324
7325#define ctoon_ptr_set_err(_code, _msg) do { \
7326 if (err) { \
7327 err->code = CTOON_PTR_ERR_##_code; \
7328 err->msg = _msg; \
7329 err->pos = 0; \
7330 } \
7331} while(false)
7332
7333/* require: val != NULL, *ptr == '/', len > 0 */
7334ctoon_api ctoon_val *unsafe_ctoon_ptr_getx(ctoon_val *val,
7335 const char *ptr, size_t len,
7336 ctoon_ptr_err *err);
7337
7338/* require: val != NULL, *ptr == '/', len > 0 */
7339ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_getx(ctoon_mut_val *val,
7340 const char *ptr,
7341 size_t len,
7342 ctoon_ptr_ctx *ctx,
7343 ctoon_ptr_err *err);
7344
7345/* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */
7346ctoon_api bool unsafe_ctoon_mut_ptr_putx(ctoon_mut_val *val,
7347 const char *ptr, size_t len,
7348 ctoon_mut_val *new_val,
7349 ctoon_mut_doc *doc,
7350 bool create_parent, bool insert_new,
7351 ctoon_ptr_ctx *ctx,
7352 ctoon_ptr_err *err);
7353
7354/* require: val/err != NULL, *ptr == '/', len > 0 */
7355ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_replacex(
7356 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
7357 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
7358
7359/* require: val/err != NULL, *ptr == '/', len > 0 */
7360ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_removex(ctoon_mut_val *val,
7361 const char *ptr,
7362 size_t len,
7363 ctoon_ptr_ctx *ctx,
7364 ctoon_ptr_err *err);
7365
7366ctoon_api_inline ctoon_val *ctoon_doc_ptr_get(ctoon_doc *doc,
7367 const char *ptr) {
7368 if (ctoon_unlikely(!ptr)) return NULL;
7369 return ctoon_doc_ptr_getn(doc, ptr, strlen(ptr));
7370}
7371
7372ctoon_api_inline ctoon_val *ctoon_doc_ptr_getn(ctoon_doc *doc,
7373 const char *ptr, size_t len) {
7374 return ctoon_doc_ptr_getx(doc, ptr, len, NULL);
7375}
7376
7377ctoon_api_inline ctoon_val *ctoon_doc_ptr_getx(ctoon_doc *doc,
7378 const char *ptr, size_t len,
7379 ctoon_ptr_err *err) {
7380 ctoon_ptr_set_err(NONE, NULL);
7381 if (ctoon_unlikely(!doc || !ptr)) {
7382 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7383 return NULL;
7384 }
7385 if (ctoon_unlikely(!doc->root)) {
7386 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7387 return NULL;
7388 }
7389 if (ctoon_unlikely(len == 0)) {
7390 return doc->root;
7391 }
7392 if (ctoon_unlikely(*ptr != '/')) {
7393 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7394 return NULL;
7395 }
7396 return unsafe_ctoon_ptr_getx(doc->root, ptr, len, err);
7397}
7398
7399ctoon_api_inline ctoon_val *ctoon_ptr_get(ctoon_val *val,
7400 const char *ptr) {
7401 if (ctoon_unlikely(!ptr)) return NULL;
7402 return ctoon_ptr_getn(val, ptr, strlen(ptr));
7403}
7404
7405ctoon_api_inline ctoon_val *ctoon_ptr_getn(ctoon_val *val,
7406 const char *ptr, size_t len) {
7407 return ctoon_ptr_getx(val, ptr, len, NULL);
7408}
7409
7410ctoon_api_inline ctoon_val *ctoon_ptr_getx(ctoon_val *val,
7411 const char *ptr, size_t len,
7412 ctoon_ptr_err *err) {
7413 ctoon_ptr_set_err(NONE, NULL);
7414 if (ctoon_unlikely(!val || !ptr)) {
7415 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7416 return NULL;
7417 }
7418 if (ctoon_unlikely(len == 0)) {
7419 return val;
7420 }
7421 if (ctoon_unlikely(*ptr != '/')) {
7422 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7423 return NULL;
7424 }
7425 return unsafe_ctoon_ptr_getx(val, ptr, len, err);
7426}
7427
7428ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_get(ctoon_mut_doc *doc,
7429 const char *ptr) {
7430 if (!ptr) return NULL;
7431 return ctoon_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
7432}
7433
7434ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getn(ctoon_mut_doc *doc,
7435 const char *ptr,
7436 size_t len) {
7437 return ctoon_mut_doc_ptr_getx(doc, ptr, len, NULL, NULL);
7438}
7439
7440ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getx(ctoon_mut_doc *doc,
7441 const char *ptr,
7442 size_t len,
7443 ctoon_ptr_ctx *ctx,
7444 ctoon_ptr_err *err) {
7445 ctoon_ptr_set_err(NONE, NULL);
7446 if (ctx) memset(ctx, 0, sizeof(*ctx));
7447
7448 if (ctoon_unlikely(!doc || !ptr)) {
7449 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7450 return NULL;
7451 }
7452 if (ctoon_unlikely(!doc->root)) {
7453 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7454 return NULL;
7455 }
7456 if (ctoon_unlikely(len == 0)) {
7457 return doc->root;
7458 }
7459 if (ctoon_unlikely(*ptr != '/')) {
7460 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7461 return NULL;
7462 }
7463 return unsafe_ctoon_mut_ptr_getx(doc->root, ptr, len, ctx, err);
7464}
7465
7466ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_get(ctoon_mut_val *val,
7467 const char *ptr) {
7468 if (!ptr) return NULL;
7469 return ctoon_mut_ptr_getn(val, ptr, strlen(ptr));
7470}
7471
7472ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getn(ctoon_mut_val *val,
7473 const char *ptr,
7474 size_t len) {
7475 return ctoon_mut_ptr_getx(val, ptr, len, NULL, NULL);
7476}
7477
7478ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getx(ctoon_mut_val *val,
7479 const char *ptr,
7480 size_t len,
7481 ctoon_ptr_ctx *ctx,
7482 ctoon_ptr_err *err) {
7483 ctoon_ptr_set_err(NONE, NULL);
7484 if (ctx) memset(ctx, 0, sizeof(*ctx));
7485
7486 if (ctoon_unlikely(!val || !ptr)) {
7487 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7488 return NULL;
7489 }
7490 if (ctoon_unlikely(len == 0)) {
7491 return val;
7492 }
7493 if (ctoon_unlikely(*ptr != '/')) {
7494 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7495 return NULL;
7496 }
7497 return unsafe_ctoon_mut_ptr_getx(val, ptr, len, ctx, err);
7498}
7499
7500ctoon_api_inline bool ctoon_mut_doc_ptr_add(ctoon_mut_doc *doc,
7501 const char *ptr,
7502 ctoon_mut_val *new_val) {
7503 if (ctoon_unlikely(!ptr)) return false;
7504 return ctoon_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
7505}
7506
7507ctoon_api_inline bool ctoon_mut_doc_ptr_addn(ctoon_mut_doc *doc,
7508 const char *ptr,
7509 size_t len,
7510 ctoon_mut_val *new_val) {
7511 return ctoon_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL);
7512}
7513
7514ctoon_api_inline bool ctoon_mut_doc_ptr_addx(ctoon_mut_doc *doc,
7515 const char *ptr, size_t len,
7516 ctoon_mut_val *new_val,
7517 bool create_parent,
7518 ctoon_ptr_ctx *ctx,
7519 ctoon_ptr_err *err) {
7520 ctoon_ptr_set_err(NONE, NULL);
7521 if (ctx) memset(ctx, 0, sizeof(*ctx));
7522
7523 if (ctoon_unlikely(!doc || !ptr || !new_val)) {
7524 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7525 return false;
7526 }
7527 if (ctoon_unlikely(len == 0)) {
7528 if (doc->root) {
7529 ctoon_ptr_set_err(SET_ROOT, "cannot set document's root");
7530 return false;
7531 } else {
7532 doc->root = new_val;
7533 return true;
7534 }
7535 }
7536 if (ctoon_unlikely(*ptr != '/')) {
7537 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7538 return false;
7539 }
7540 if (ctoon_unlikely(!doc->root && !create_parent)) {
7541 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7542 return false;
7543 }
7544 if (ctoon_unlikely(!doc->root)) {
7545 ctoon_mut_val *root = ctoon_mut_obj(doc);
7546 if (ctoon_unlikely(!root)) {
7547 ctoon_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
7548 return false;
7549 }
7550 if (unsafe_ctoon_mut_ptr_putx(root, ptr, len, new_val, doc,
7551 create_parent, true, ctx, err)) {
7552 doc->root = root;
7553 return true;
7554 }
7555 return false;
7556 }
7557 return unsafe_ctoon_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
7558 create_parent, true, ctx, err);
7559}
7560
7561ctoon_api_inline bool ctoon_mut_ptr_add(ctoon_mut_val *val,
7562 const char *ptr,
7563 ctoon_mut_val *new_val,
7564 ctoon_mut_doc *doc) {
7565 if (ctoon_unlikely(!ptr)) return false;
7566 return ctoon_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc);
7567}
7568
7569ctoon_api_inline bool ctoon_mut_ptr_addn(ctoon_mut_val *val,
7570 const char *ptr, size_t len,
7571 ctoon_mut_val *new_val,
7572 ctoon_mut_doc *doc) {
7573 return ctoon_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL);
7574}
7575
7576ctoon_api_inline bool ctoon_mut_ptr_addx(ctoon_mut_val *val,
7577 const char *ptr, size_t len,
7578 ctoon_mut_val *new_val,
7579 ctoon_mut_doc *doc,
7580 bool create_parent,
7581 ctoon_ptr_ctx *ctx,
7582 ctoon_ptr_err *err) {
7583 ctoon_ptr_set_err(NONE, NULL);
7584 if (ctx) memset(ctx, 0, sizeof(*ctx));
7585
7586 if (ctoon_unlikely(!val || !ptr || !new_val || !doc)) {
7587 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7588 return false;
7589 }
7590 if (ctoon_unlikely(len == 0)) {
7591 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7592 return false;
7593 }
7594 if (ctoon_unlikely(*ptr != '/')) {
7595 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7596 return false;
7597 }
7598 return unsafe_ctoon_mut_ptr_putx(val, ptr, len, new_val,
7599 doc, create_parent, true, ctx, err);
7600}
7601
7602ctoon_api_inline bool ctoon_mut_doc_ptr_set(ctoon_mut_doc *doc,
7603 const char *ptr,
7604 ctoon_mut_val *new_val) {
7605 if (ctoon_unlikely(!ptr)) return false;
7606 return ctoon_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
7607}
7608
7609ctoon_api_inline bool ctoon_mut_doc_ptr_setn(ctoon_mut_doc *doc,
7610 const char *ptr, size_t len,
7611 ctoon_mut_val *new_val) {
7612 return ctoon_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL);
7613}
7614
7615ctoon_api_inline bool ctoon_mut_doc_ptr_setx(ctoon_mut_doc *doc,
7616 const char *ptr, size_t len,
7617 ctoon_mut_val *new_val,
7618 bool create_parent,
7619 ctoon_ptr_ctx *ctx,
7620 ctoon_ptr_err *err) {
7621 ctoon_ptr_set_err(NONE, NULL);
7622 if (ctx) memset(ctx, 0, sizeof(*ctx));
7623
7624 if (ctoon_unlikely(!doc || !ptr)) {
7625 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7626 return false;
7627 }
7628 if (ctoon_unlikely(len == 0)) {
7629 if (ctx) ctx->old = doc->root;
7630 doc->root = new_val;
7631 return true;
7632 }
7633 if (ctoon_unlikely(*ptr != '/')) {
7634 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7635 return false;
7636 }
7637 if (!new_val) {
7638 if (!doc->root) {
7639 ctoon_ptr_set_err(RESOLVE, "TOON pointer cannot be resolved");
7640 return false;
7641 }
7642 return !!unsafe_ctoon_mut_ptr_removex(doc->root, ptr, len, ctx, err);
7643 }
7644 if (ctoon_unlikely(!doc->root && !create_parent)) {
7645 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7646 return false;
7647 }
7648 if (ctoon_unlikely(!doc->root)) {
7649 ctoon_mut_val *root = ctoon_mut_obj(doc);
7650 if (ctoon_unlikely(!root)) {
7651 ctoon_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
7652 return false;
7653 }
7654 if (unsafe_ctoon_mut_ptr_putx(root, ptr, len, new_val, doc,
7655 create_parent, false, ctx, err)) {
7656 doc->root = root;
7657 return true;
7658 }
7659 return false;
7660 }
7661 return unsafe_ctoon_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
7662 create_parent, false, ctx, err);
7663}
7664
7665ctoon_api_inline bool ctoon_mut_ptr_set(ctoon_mut_val *val,
7666 const char *ptr,
7667 ctoon_mut_val *new_val,
7668 ctoon_mut_doc *doc) {
7669 if (ctoon_unlikely(!ptr)) return false;
7670 return ctoon_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc);
7671}
7672
7673ctoon_api_inline bool ctoon_mut_ptr_setn(ctoon_mut_val *val,
7674 const char *ptr, size_t len,
7675 ctoon_mut_val *new_val,
7676 ctoon_mut_doc *doc) {
7677 return ctoon_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL);
7678}
7679
7680ctoon_api_inline bool ctoon_mut_ptr_setx(ctoon_mut_val *val,
7681 const char *ptr, size_t len,
7682 ctoon_mut_val *new_val,
7683 ctoon_mut_doc *doc,
7684 bool create_parent,
7685 ctoon_ptr_ctx *ctx,
7686 ctoon_ptr_err *err) {
7687 ctoon_ptr_set_err(NONE, NULL);
7688 if (ctx) memset(ctx, 0, sizeof(*ctx));
7689
7690 if (ctoon_unlikely(!val || !ptr || !doc)) {
7691 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7692 return false;
7693 }
7694 if (ctoon_unlikely(len == 0)) {
7695 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7696 return false;
7697 }
7698 if (ctoon_unlikely(*ptr != '/')) {
7699 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7700 return false;
7701 }
7702 if (!new_val) {
7703 return !!unsafe_ctoon_mut_ptr_removex(val, ptr, len, ctx, err);
7704 }
7705 return unsafe_ctoon_mut_ptr_putx(val, ptr, len, new_val, doc,
7706 create_parent, false, ctx, err);
7707}
7708
7709ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replace(
7710 ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val) {
7711 if (!ptr) return NULL;
7712 return ctoon_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
7713}
7714
7715ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacen(
7716 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val) {
7717 return ctoon_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL);
7718}
7719
7720ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacex(
7721 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val,
7722 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7723
7724 ctoon_ptr_set_err(NONE, NULL);
7725 if (ctx) memset(ctx, 0, sizeof(*ctx));
7726
7727 if (ctoon_unlikely(!doc || !ptr || !new_val)) {
7728 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7729 return NULL;
7730 }
7731 if (ctoon_unlikely(len == 0)) {
7732 ctoon_mut_val *root = doc->root;
7733 if (ctoon_unlikely(!root)) {
7734 ctoon_ptr_set_err(RESOLVE, "TOON pointer cannot be resolved");
7735 return NULL;
7736 }
7737 if (ctx) ctx->old = root;
7738 doc->root = new_val;
7739 return root;
7740 }
7741 if (ctoon_unlikely(!doc->root)) {
7742 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7743 return NULL;
7744 }
7745 if (ctoon_unlikely(*ptr != '/')) {
7746 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7747 return NULL;
7748 }
7749 return unsafe_ctoon_mut_ptr_replacex(doc->root, ptr, len, new_val,
7750 ctx, err);
7751}
7752
7753ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replace(
7754 ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val) {
7755 if (!ptr) return NULL;
7756 return ctoon_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
7757}
7758
7759ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacen(
7760 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val) {
7761 return ctoon_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL);
7762}
7763
7764ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacex(
7765 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
7766 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7767
7768 ctoon_ptr_set_err(NONE, NULL);
7769 if (ctx) memset(ctx, 0, sizeof(*ctx));
7770
7771 if (ctoon_unlikely(!val || !ptr || !new_val)) {
7772 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7773 return NULL;
7774 }
7775 if (ctoon_unlikely(len == 0)) {
7776 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7777 return NULL;
7778 }
7779 if (ctoon_unlikely(*ptr != '/')) {
7780 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7781 return NULL;
7782 }
7783 return unsafe_ctoon_mut_ptr_replacex(val, ptr, len, new_val, ctx, err);
7784}
7785
7786ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_remove(
7787 ctoon_mut_doc *doc, const char *ptr) {
7788 if (!ptr) return NULL;
7789 return ctoon_mut_doc_ptr_removen(doc, ptr, strlen(ptr));
7790}
7791
7792ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removen(
7793 ctoon_mut_doc *doc, const char *ptr, size_t len) {
7794 return ctoon_mut_doc_ptr_removex(doc, ptr, len, NULL, NULL);
7795}
7796
7797ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removex(
7798 ctoon_mut_doc *doc, const char *ptr, size_t len,
7799 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7800
7801 ctoon_ptr_set_err(NONE, NULL);
7802 if (ctx) memset(ctx, 0, sizeof(*ctx));
7803
7804 if (ctoon_unlikely(!doc || !ptr)) {
7805 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7806 return NULL;
7807 }
7808 if (ctoon_unlikely(!doc->root)) {
7809 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7810 return NULL;
7811 }
7812 if (ctoon_unlikely(len == 0)) {
7813 ctoon_mut_val *root = doc->root;
7814 if (ctx) ctx->old = root;
7815 doc->root = NULL;
7816 return root;
7817 }
7818 if (ctoon_unlikely(*ptr != '/')) {
7819 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7820 return NULL;
7821 }
7822 return unsafe_ctoon_mut_ptr_removex(doc->root, ptr, len, ctx, err);
7823}
7824
7825ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_remove(ctoon_mut_val *val,
7826 const char *ptr) {
7827 if (!ptr) return NULL;
7828 return ctoon_mut_ptr_removen(val, ptr, strlen(ptr));
7829}
7830
7831ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removen(ctoon_mut_val *val,
7832 const char *ptr,
7833 size_t len) {
7834 return ctoon_mut_ptr_removex(val, ptr, len, NULL, NULL);
7835}
7836
7837ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removex(ctoon_mut_val *val,
7838 const char *ptr,
7839 size_t len,
7840 ctoon_ptr_ctx *ctx,
7841 ctoon_ptr_err *err) {
7842 ctoon_ptr_set_err(NONE, NULL);
7843 if (ctx) memset(ctx, 0, sizeof(*ctx));
7844
7845 if (ctoon_unlikely(!val || !ptr)) {
7846 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7847 return NULL;
7848 }
7849 if (ctoon_unlikely(len == 0)) {
7850 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7851 return NULL;
7852 }
7853 if (ctoon_unlikely(*ptr != '/')) {
7854 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7855 return NULL;
7856 }
7857 return unsafe_ctoon_mut_ptr_removex(val, ptr, len, ctx, err);
7858}
7859
7860ctoon_api_inline bool ctoon_ptr_ctx_append(ctoon_ptr_ctx *ctx,
7861 ctoon_mut_val *key,
7862 ctoon_mut_val *val) {
7863 ctoon_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
7864 if (!ctx || !ctx->ctn || !val) return false;
7865 ctn = ctx->ctn;
7866
7867 if (ctoon_mut_is_obj(ctn)) {
7868 if (!key) return false;
7869 key->next = val;
7870 pre_key = ctx->pre;
7871 if (unsafe_ctoon_get_len(ctn) == 0) {
7872 val->next = key;
7873 ctn->uni.ptr = key;
7874 ctx->pre = key;
7875 } else if (!pre_key) {
7876 pre_key = (ctoon_mut_val *)ctn->uni.ptr;
7877 pre_val = pre_key->next;
7878 val->next = pre_val->next;
7879 pre_val->next = key;
7880 ctn->uni.ptr = key;
7881 ctx->pre = pre_key;
7882 } else {
7883 cur_key = pre_key->next->next;
7884 cur_val = cur_key->next;
7885 val->next = cur_val->next;
7886 cur_val->next = key;
7887 if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key;
7888 ctx->pre = cur_key;
7889 }
7890 } else {
7891 pre_val = ctx->pre;
7892 if (unsafe_ctoon_get_len(ctn) == 0) {
7893 val->next = val;
7894 ctn->uni.ptr = val;
7895 ctx->pre = val;
7896 } else if (!pre_val) {
7897 pre_val = (ctoon_mut_val *)ctn->uni.ptr;
7898 val->next = pre_val->next;
7899 pre_val->next = val;
7900 ctn->uni.ptr = val;
7901 ctx->pre = pre_val;
7902 } else {
7903 cur_val = pre_val->next;
7904 val->next = cur_val->next;
7905 cur_val->next = val;
7906 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
7907 ctx->pre = cur_val;
7908 }
7909 }
7910 unsafe_ctoon_inc_len(ctn);
7911 return true;
7912}
7913
7914ctoon_api_inline bool ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx,
7915 ctoon_mut_val *val) {
7916 ctoon_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
7917 if (!ctx || !ctx->ctn || !ctx->pre || !val) return false;
7918 ctn = ctx->ctn;
7919 if (ctoon_mut_is_obj(ctn)) {
7920 pre_key = ctx->pre;
7921 pre_val = pre_key->next;
7922 cur_key = pre_val->next;
7923 cur_val = cur_key->next;
7924 /* replace current value */
7925 cur_key->next = val;
7926 val->next = cur_val->next;
7927 ctx->old = cur_val;
7928 } else {
7929 pre_val = ctx->pre;
7930 cur_val = pre_val->next;
7931 /* replace current value */
7932 if (pre_val != cur_val) {
7933 val->next = cur_val->next;
7934 pre_val->next = val;
7935 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
7936 } else {
7937 val->next = val;
7938 ctn->uni.ptr = val;
7939 ctx->pre = val;
7940 }
7941 ctx->old = cur_val;
7942 }
7943 return true;
7944}
7945
7946ctoon_api_inline bool ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx) {
7947 ctoon_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
7948 size_t len;
7949 if (!ctx || !ctx->ctn || !ctx->pre) return false;
7950 ctn = ctx->ctn;
7951 if (ctoon_mut_is_obj(ctn)) {
7952 pre_key = ctx->pre;
7953 pre_val = pre_key->next;
7954 cur_key = pre_val->next;
7955 cur_val = cur_key->next;
7956 /* remove current key-value */
7957 pre_val->next = cur_val->next;
7958 if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key;
7959 ctx->pre = NULL;
7960 ctx->old = cur_val;
7961 } else {
7962 pre_val = ctx->pre;
7963 cur_val = pre_val->next;
7964 /* remove current key-value */
7965 pre_val->next = cur_val->next;
7966 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val;
7967 ctx->pre = NULL;
7968 ctx->old = cur_val;
7969 }
7970 len = unsafe_ctoon_get_len(ctn) - 1;
7971 if (len == 0) ctn->uni.ptr = NULL;
7972 unsafe_ctoon_set_len(ctn, len);
7973 return true;
7974}
7975
7976#undef ctoon_ptr_set_err
7977
7978
7979
7980/*==============================================================================
7981 * MARK: - TOON Value at Pointer API (Implementation)
7982 *============================================================================*/
7983
7988ctoon_api_inline bool ctoon_ptr_get_bool(
7989 ctoon_val *root, const char *ptr, bool *value) {
7990 ctoon_val *val = ctoon_ptr_get(root, ptr);
7991 if (value && ctoon_is_bool(val)) {
7992 *value = unsafe_ctoon_get_bool(val);
7993 return true;
7994 } else {
7995 return false;
7996 }
7997}
7998
8003ctoon_api_inline bool ctoon_ptr_get_uint(
8004 ctoon_val *root, const char *ptr, uint64_t *value) {
8005 ctoon_val *val = ctoon_ptr_get(root, ptr);
8006 if (value && val) {
8007 uint64_t ret = val->uni.u64;
8008 if (unsafe_ctoon_is_uint(val) ||
8009 (unsafe_ctoon_is_sint(val) && !(ret >> 63))) {
8010 *value = ret;
8011 return true;
8012 }
8013 }
8014 return false;
8015}
8016
8021ctoon_api_inline bool ctoon_ptr_get_sint(
8022 ctoon_val *root, const char *ptr, int64_t *value) {
8023 ctoon_val *val = ctoon_ptr_get(root, ptr);
8024 if (value && val) {
8025 int64_t ret = val->uni.i64;
8026 if (unsafe_ctoon_is_sint(val) ||
8027 (unsafe_ctoon_is_uint(val) && ret >= 0)) {
8028 *value = ret;
8029 return true;
8030 }
8031 }
8032 return false;
8033}
8034
8039ctoon_api_inline bool ctoon_ptr_get_real(
8040 ctoon_val *root, const char *ptr, double *value) {
8041 ctoon_val *val = ctoon_ptr_get(root, ptr);
8042 if (value && ctoon_is_real(val)) {
8043 *value = unsafe_ctoon_get_real(val);
8044 return true;
8045 } else {
8046 return false;
8047 }
8048}
8049
8055ctoon_api_inline bool ctoon_ptr_get_num(
8056 ctoon_val *root, const char *ptr, double *value) {
8057 ctoon_val *val = ctoon_ptr_get(root, ptr);
8058 if (value && ctoon_is_num(val)) {
8059 *value = unsafe_ctoon_get_num(val);
8060 return true;
8061 } else {
8062 return false;
8063 }
8064}
8065
8070ctoon_api_inline bool ctoon_ptr_get_str(
8071 ctoon_val *root, const char *ptr, const char **value) {
8072 ctoon_val *val = ctoon_ptr_get(root, ptr);
8073 if (value && ctoon_is_str(val)) {
8074 *value = unsafe_ctoon_get_str(val);
8075 return true;
8076 } else {
8077 return false;
8078 }
8079}
8080
8081
8082
8083/*==============================================================================
8084 * MARK: - Deprecated
8085 *============================================================================*/
8086
8088ctoon_deprecated("renamed to ctoon_doc_ptr_get")
8089ctoon_api_inline ctoon_val *ctoon_doc_get_pointer(ctoon_doc *doc,
8090 const char *ptr) {
8091 return ctoon_doc_ptr_get(doc, ptr);
8092}
8093
8095ctoon_deprecated("renamed to ctoon_doc_ptr_getn")
8096ctoon_api_inline ctoon_val *ctoon_doc_get_pointern(ctoon_doc *doc,
8097 const char *ptr,
8098 size_t len) {
8099 return ctoon_doc_ptr_getn(doc, ptr, len);
8100}
8101
8103ctoon_deprecated("renamed to ctoon_mut_doc_ptr_get")
8104ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_pointer(
8105 ctoon_mut_doc *doc, const char *ptr) {
8106 return ctoon_mut_doc_ptr_get(doc, ptr);
8107}
8108
8110ctoon_deprecated("renamed to ctoon_mut_doc_ptr_getn")
8111ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_pointern(
8112 ctoon_mut_doc *doc, const char *ptr, size_t len) {
8113 return ctoon_mut_doc_ptr_getn(doc, ptr, len);
8114}
8115
8117ctoon_deprecated("renamed to ctoon_ptr_get")
8118ctoon_api_inline ctoon_val *ctoon_get_pointer(ctoon_val *val,
8119 const char *ptr) {
8120 return ctoon_ptr_get(val, ptr);
8121}
8122
8124ctoon_deprecated("renamed to ctoon_ptr_getn")
8125ctoon_api_inline ctoon_val *ctoon_get_pointern(ctoon_val *val,
8126 const char *ptr,
8127 size_t len) {
8128 return ctoon_ptr_getn(val, ptr, len);
8129}
8130
8132ctoon_deprecated("renamed to ctoon_mut_ptr_get")
8133ctoon_api_inline ctoon_mut_val *ctoon_mut_get_pointer(ctoon_mut_val *val,
8134 const char *ptr) {
8135 return ctoon_mut_ptr_get(val, ptr);
8136}
8137
8139ctoon_deprecated("renamed to ctoon_mut_ptr_getn")
8140ctoon_api_inline ctoon_mut_val *ctoon_mut_get_pointern(ctoon_mut_val *val,
8141 const char *ptr,
8142 size_t len) {
8143 return ctoon_mut_ptr_getn(val, ptr, len);
8144}
8145
8147ctoon_deprecated("renamed to unsafe_ctoon_ptr_getn")
8148ctoon_api_inline ctoon_val *unsafe_ctoon_get_pointer(ctoon_val *val,
8149 const char *ptr,
8150 size_t len) {
8151 ctoon_ptr_err err;
8152 return unsafe_ctoon_ptr_getx(val, ptr, len, &err);
8153}
8154
8156ctoon_deprecated("renamed to unsafe_ctoon_mut_ptr_getx")
8157ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_get_pointer(
8158 ctoon_mut_val *val, const char *ptr, size_t len) {
8159 ctoon_ptr_err err;
8160 return unsafe_ctoon_mut_ptr_getx(val, ptr, len, NULL, &err);
8161}
8162
8163#endif /* CTOON_DISABLE_UTILS */
8164
8165
8166
8167/*==============================================================================
8168 * MARK: - Compiler Hint End
8169 *============================================================================*/
8170
8171#ifdef __cplusplus
8172}
8173#endif /* extern "C" end */
8174
8175#endif /* CTOON_H */
ctoon_spec_tag_hex
uint32_t ctoon_spec_tag_hex(void)
ctoon_mut_obj_getn
static ctoon_mut_val * ctoon_mut_obj_getn(ctoon_mut_val *obj, const char *key, size_t key_len)
Definition ctoon.h:6714
ctoon_mut_set_bool
static unsigned char ctoon_mut_set_bool(ctoon_mut_val *val, unsigned char num)
Definition ctoon.h:5817
CTOON_READ_STOP_WHEN_DONE
static const ctoon_read_flag CTOON_READ_STOP_WHEN_DONE
Definition ctoon.h:788
CTOON_WRITE_INF_AND_NAN_AS_NULL
static const ctoon_write_flag CTOON_WRITE_INF_AND_NAN_AS_NULL
Definition ctoon.h:1264
ctoon_read_file
ctoon_doc * ctoon_read_file(const char *path, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_arr_with_str
static ctoon_mut_val * ctoon_mut_arr_with_str(ctoon_mut_doc *doc, const char **vals, size_t count)
Definition ctoon.h:6275
ctoon_arr_iter_init
static unsigned char ctoon_arr_iter_init(ctoon_val *arr, ctoon_arr_iter *iter)
Definition ctoon.h:5395
ctoon_mut_set_int
static unsigned char ctoon_mut_set_int(ctoon_mut_val *val, int num)
Definition ctoon.h:5835
ctoon_doc_ptr_getx
static ctoon_val * ctoon_doc_ptr_getx(ctoon_doc *doc, const char *ptr, size_t len, ctoon_ptr_err *err)
Definition ctoon.h:7377
ctoon_arr_iter_has_next
static unsigned char ctoon_arr_iter_has_next(ctoon_arr_iter *iter)
Definition ctoon.h:5413
ctoon_set_uint
static unsigned char ctoon_set_uint(ctoon_val *val, uint64_t num)
Definition ctoon.h:5270
ctoon_mut_arr_add_strn
static unsigned char ctoon_mut_arr_add_strn(ctoon_mut_doc *doc, ctoon_mut_val *arr, const char *str, size_t len)
Definition ctoon.h:6651
ctoon_set_int
static unsigned char ctoon_set_int(ctoon_val *val, int num)
Definition ctoon.h:5282
ctoon_set_fp_to_float
static unsigned char ctoon_set_fp_to_float(ctoon_val *val, unsigned char flt)
Definition ctoon.h:5312
CTOON_PTR_ERR_SYNTAX
static const ctoon_ptr_code CTOON_PTR_ERR_SYNTAX
Definition ctoon.h:4032
ctoon_read_json_file
ctoon_doc * ctoon_read_json_file(const char *path, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_read_opts
ctoon_doc * ctoon_read_opts(char *dat, size_t len, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_arr_iter_has_next
static unsigned char ctoon_mut_arr_iter_has_next(ctoon_mut_arr_iter *iter)
Definition ctoon.h:6110
ctoon_delimiter
ctoon_delimiter
Definition ctoon.h:1291
CTOON_DELIMITER_COMMA
@ CTOON_DELIMITER_COMMA
Definition ctoon.h:1292
CTOON_DELIMITER_PIPE
@ CTOON_DELIMITER_PIPE
Definition ctoon.h:1294
CTOON_DELIMITER_TAB
@ CTOON_DELIMITER_TAB
Definition ctoon.h:1293
ctoon_ptr_code
uint32_t ctoon_ptr_code
Definition ctoon.h:4023
ctoon_mut_arr_add_real
static unsigned char ctoon_mut_arr_add_real(ctoon_mut_doc *doc, ctoon_mut_val *arr, double num)
Definition ctoon.h:6631
ctoon_mut_arr_with_uint16
static ctoon_mut_val * ctoon_mut_arr_with_uint16(ctoon_mut_doc *doc, const uint16_t *vals, size_t count)
Definition ctoon.h:6240
ctoon_doc_get_root
static ctoon_val * ctoon_doc_get_root(ctoon_doc *doc)
Definition ctoon.h:5073
CTOON_READ_ERROR_MEMORY_ALLOCATION
static const ctoon_read_code CTOON_READ_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:896
ctoon_ptr_ctx_remove
static unsigned char ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx)
Definition ctoon.h:7946
CTOON_WRITE_ALLOW_INVALID_UNICODE
static const ctoon_write_flag CTOON_WRITE_ALLOW_INVALID_UNICODE
Definition ctoon.h:1267
ctoon_mut_arr_with_strn
static ctoon_mut_val * ctoon_mut_arr_with_strn(ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count)
Definition ctoon.h:6283
ctoon_subtype
uint8_t ctoon_subtype
Definition ctoon.h:580
ctoon_mut_doc_ptr_removex
static ctoon_mut_val * ctoon_mut_doc_ptr_removex(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7797
ctoon_json_to_toon_file
unsigned char ctoon_json_to_toon_file(const char *json_path, const char *toon_path)
ctoon_mut_arr_add_val
static unsigned char ctoon_mut_arr_add_val(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6539
ctoon_set_str_noesc
static unsigned char ctoon_set_str_noesc(ctoon_val *val, unsigned char noesc)
Definition ctoon.h:5333
ctoon_mut_arr_with_double
static ctoon_mut_val * ctoon_mut_arr_with_double(ctoon_mut_doc *doc, const double *vals, size_t count)
Definition ctoon.h:6268
ctoon_set_sint
static unsigned char ctoon_set_sint(ctoon_val *val, int64_t num)
Definition ctoon.h:5276
ctoon_mut_doc_to_json
char * ctoon_mut_doc_to_json(const ctoon_mut_doc *doc, int indent, ctoon_write_flag flags, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_ptr_getn
static ctoon_val * ctoon_ptr_getn(ctoon_val *val, const char *ptr, size_t len)
Definition ctoon.h:7405
ctoon_mut_arr_add_arr
static ctoon_mut_val * ctoon_mut_arr_add_arr(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6681
ctoon_doc_to_json
char * ctoon_doc_to_json(const ctoon_doc *doc, int indent, ctoon_write_flag flags, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_doc_ptr_get
static ctoon_val * ctoon_doc_ptr_get(ctoon_doc *doc, const char *ptr)
Definition ctoon.h:7366
ctoon_mut_is_obj
static unsigned char ctoon_mut_is_obj(ctoon_mut_val *val)
Definition ctoon.h:5719
ctoon_mut_arr_with_sint64
static ctoon_mut_val * ctoon_mut_arr_with_sint64(ctoon_mut_doc *doc, const int64_t *vals, size_t count)
Definition ctoon.h:6226
ctoon_mut_arr_iter_next
static ctoon_mut_val * ctoon_mut_arr_iter_next(ctoon_mut_arr_iter *iter)
Definition ctoon.h:6114
ctoon_ptr_ctx_replace
static unsigned char ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx, ctoon_mut_val *val)
Definition ctoon.h:7914
ctoon_mut_ptr_getx
static ctoon_mut_val * ctoon_mut_ptr_getx(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7478
ctoon_mut_get_str
static const char * ctoon_mut_get_str(ctoon_mut_val *val)
Definition ctoon.h:5777
ctoon_constant_p
#define ctoon_constant_p(value)
Definition ctoon.h:315
ctoon_mut_arr_add_sint
static unsigned char ctoon_mut_arr_add_sint(ctoon_mut_doc *doc, ctoon_mut_val *arr, int64_t num)
Definition ctoon.h:6591
ctoon_mut_arr
static ctoon_mut_val * ctoon_mut_arr(ctoon_mut_doc *doc)
Definition ctoon.h:6149
ctoon_mut_set_arr
static unsigned char ctoon_mut_set_arr(ctoon_mut_val *val)
Definition ctoon.h:5894
ctoon_mut_obj_remove_strn
static ctoon_mut_val * ctoon_mut_obj_remove_strn(ctoon_mut_val *obj, const char *key, size_t len)
Definition ctoon.h:7267
ctoon_ptr_ctx_append
static unsigned char ctoon_ptr_ctx_append(ctoon_ptr_ctx *ctx, ctoon_mut_val *key, ctoon_mut_val *val)
Definition ctoon.h:7860
ctoon_mut_obj_iter_get_val
static ctoon_mut_val * ctoon_mut_obj_iter_get_val(ctoon_mut_val *key)
Definition ctoon.h:6771
ctoon_mut_obj_add_val
static unsigned char ctoon_mut_obj_add_val(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, ctoon_mut_val *val)
Definition ctoon.h:7252
ctoon_get_type
static ctoon_type ctoon_get_type(ctoon_val *val)
Definition ctoon.h:5162
CTOON_READ_INSITU
static const ctoon_read_flag CTOON_READ_INSITU
Definition ctoon.h:783
CTOON_PTR_ERR_NULL_ROOT
static const ctoon_ptr_code CTOON_PTR_ERR_NULL_ROOT
Definition ctoon.h:4038
ctoon_read_code
uint32_t ctoon_read_code
Definition ctoon.h:887
ctoon_is_arr
static unsigned char ctoon_is_arr(ctoon_val *val)
Definition ctoon.h:5144
ctoon_mut_is_str
static unsigned char ctoon_mut_is_str(ctoon_mut_val *val)
Definition ctoon.h:5711
ctoon_doc_mut_copy
ctoon_mut_doc * ctoon_doc_mut_copy(ctoon_doc *doc, const ctoon_alc *alc)
ctoon_mut_strcpy
static ctoon_mut_val * ctoon_mut_strcpy(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:6021
CTOON_READ_NON_STRICT
static const ctoon_read_flag CTOON_READ_NON_STRICT
Definition ctoon.h:867
ctoon_spec_date_string
const char * ctoon_spec_date_string(void)
ctoon_val_write_opts
char * ctoon_val_write_opts(const ctoon_val *val, const ctoon_write_options *opts, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_mut_arr_add_double
static unsigned char ctoon_mut_arr_add_double(ctoon_mut_doc *doc, ctoon_mut_val *arr, double num)
Definition ctoon.h:6621
ctoon_mut_equals_str
static unsigned char ctoon_mut_equals_str(ctoon_mut_val *val, const char *str)
Definition ctoon.h:5785
ctoon_mut_set_strn
static unsigned char ctoon_mut_set_strn(ctoon_mut_val *val, const char *str, size_t len)
Definition ctoon.h:5880
ctoon_mut_obj_add_null
static unsigned char ctoon_mut_obj_add_null(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7117
ctoon_mut_doc_ptr_removen
static ctoon_mut_val * ctoon_mut_doc_ptr_removen(ctoon_mut_doc *doc, const char *ptr, size_t len)
Definition ctoon.h:7792
ctoon_mut_ptr_addx
static unsigned char ctoon_mut_ptr_addx(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_mut_doc *doc, unsigned char create_parent, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7576
ctoon_arr_iter_with
static ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr)
Definition ctoon.h:5407
ctoon_mut_obj_iter_get
static ctoon_mut_val * ctoon_mut_obj_iter_get(ctoon_mut_obj_iter *iter, const char *key)
Definition ctoon.h:6793
ctoon_mut_val_mut_copy
ctoon_mut_val * ctoon_mut_val_mut_copy(ctoon_mut_doc *doc, ctoon_mut_val *val)
ctoon_mut_arr_iter_remove
static ctoon_mut_val * ctoon_mut_arr_iter_remove(ctoon_mut_arr_iter *iter)
Definition ctoon.h:6126
CTOON_WRITE_NEWLINE_AT_END
static const ctoon_write_flag CTOON_WRITE_NEWLINE_AT_END
Definition ctoon.h:1273
ctoon_mut_set_obj
static unsigned char ctoon_mut_set_obj(ctoon_mut_val *val)
Definition ctoon.h:5900
ctoon_mut_arr_with_bool
static ctoon_mut_val * ctoon_mut_arr_with_bool(ctoon_mut_doc *doc, const unsigned char *vals, size_t count)
Definition ctoon.h:6181
ctoon_mut_is_arr
static unsigned char ctoon_mut_is_arr(ctoon_mut_val *val)
Definition ctoon.h:5715
ctoon_mut_val_imut_copy
ctoon_doc * ctoon_mut_val_imut_copy(ctoon_mut_val *val, const ctoon_alc *alc)
ctoon_obj_iter_getn
static ctoon_val * ctoon_obj_iter_getn(ctoon_obj_iter *iter, const char *key, size_t key_len)
Definition ctoon.h:5505
ctoon_incr_state
struct ctoon_incr_state ctoon_incr_state
Definition ctoon.h:1090
ctoon_mut_doc_set_val_pool_size
unsigned char ctoon_mut_doc_set_val_pool_size(ctoon_mut_doc *doc, size_t count)
ctoon_mut_is_num
static unsigned char ctoon_mut_is_num(ctoon_mut_val *val)
Definition ctoon.h:5707
ctoon_mut_arr_add_float
static unsigned char ctoon_mut_arr_add_float(ctoon_mut_doc *doc, ctoon_mut_val *arr, float num)
Definition ctoon.h:6611
ctoon_spec_version_string
const char * ctoon_spec_version_string(void)
ctoon_mut_set_sint
static unsigned char ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num)
Definition ctoon.h:5829
ctoon_mut_get_sint
static int64_t ctoon_mut_get_sint(ctoon_mut_val *val)
Definition ctoon.h:5761
CTOON_READ_ERROR_UNEXPECTED_CONTENT
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CONTENT
Definition ctoon.h:902
ctoon_mut_set_uint
static unsigned char ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num)
Definition ctoon.h:5823
ctoon_get_type_desc
static const char * ctoon_get_type_desc(ctoon_val *val)
Definition ctoon.h:5174
CTOON_PTR_ERR_PARAMETER
static const ctoon_ptr_code CTOON_PTR_ERR_PARAMETER
Definition ctoon.h:4029
ctoon_patch
ctoon_mut_val * ctoon_patch(ctoon_mut_doc *doc, ctoon_val *orig, ctoon_val *patch, ctoon_patch_err *err)
ctoon_mut_merge_patch
ctoon_mut_val * ctoon_mut_merge_patch(ctoon_mut_doc *doc, ctoon_mut_val *orig, ctoon_mut_val *patch)
ctoon_mut_arr_with_sint
static ctoon_mut_val * ctoon_mut_arr_with_sint(ctoon_mut_doc *doc, const int64_t *vals, size_t count)
Definition ctoon.h:6188
ctoon_mut_set_double
static unsigned char ctoon_mut_set_double(ctoon_mut_val *val, double num)
Definition ctoon.h:5847
ctoon_mut_obj_iter_remove
static ctoon_mut_val * ctoon_mut_obj_iter_remove(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6776
ctoon_mut_obj_remove_key
static ctoon_mut_val * ctoon_mut_obj_remove_key(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7047
CTOON_READ_BIGNUM_AS_RAW
static const ctoon_read_flag CTOON_READ_BIGNUM_AS_RAW
Definition ctoon.h:824
ctoon_write_json_mut
char * ctoon_write_json_mut(const ctoon_mut_doc *doc, int indent, ctoon_write_flag flg, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_mut_arr_with_sint32
static ctoon_mut_val * ctoon_mut_arr_with_sint32(ctoon_mut_doc *doc, const int32_t *vals, size_t count)
Definition ctoon.h:6219
ctoon_mut_doc_set_str_pool_size
unsigned char ctoon_mut_doc_set_str_pool_size(ctoon_mut_doc *doc, size_t len)
ctoon_mut_doc_ptr_addx
static unsigned char ctoon_mut_doc_ptr_addx(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val, unsigned char create_parent, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7514
ctoon_mut_arr_add_int
static unsigned char ctoon_mut_arr_add_int(ctoon_mut_doc *doc, ctoon_mut_val *arr, int64_t num)
Definition ctoon.h:6601
ctoon_mut_obj_add
static unsigned char ctoon_mut_obj_add(ctoon_mut_val *obj, ctoon_mut_val *key, ctoon_mut_val *val)
Definition ctoon.h:6979
ctoon_mut_get_int
static int ctoon_mut_get_int(ctoon_mut_val *val)
Definition ctoon.h:5765
CTOON_READ_ERROR_LITERAL
static const ctoon_read_code CTOON_READ_ERROR_LITERAL
Definition ctoon.h:923
ctoon_toon_to_json_file
unsigned char ctoon_toon_to_json_file(const char *toon_path, const char *json_path)
ctoon_mut_is_ctn
static unsigned char ctoon_mut_is_ctn(ctoon_mut_val *val)
Definition ctoon.h:5723
ctoon_mut_obj_insert
static unsigned char ctoon_mut_obj_insert(ctoon_mut_val *obj, ctoon_mut_val *key, ctoon_mut_val *val, size_t idx)
Definition ctoon.h:7016
ctoon_mut_doc_ptr_add
static unsigned char ctoon_mut_doc_ptr_add(ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val)
Definition ctoon.h:7500
ctoon_is_raw
static unsigned char ctoon_is_raw(ctoon_val *val)
Definition ctoon.h:5100
ctoon_mut_arr_with_strncpy
static ctoon_mut_val * ctoon_mut_arr_with_strncpy(ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count)
Definition ctoon.h:6306
ctoon_mut_obj_iter_next
static ctoon_mut_val * ctoon_mut_obj_iter_next(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6759
ctoon_mut_doc_free
void ctoon_mut_doc_free(ctoon_mut_doc *doc)
ctoon_mut_is_uint
static unsigned char ctoon_mut_is_uint(ctoon_mut_val *val)
Definition ctoon.h:5691
ctoon_toon_to_json_file_opts
unsigned char ctoon_toon_to_json_file_opts(const char *toon_path, const char *json_path, ctoon_read_flag rflg, int indent, ctoon_write_flag wflg, const ctoon_alc *alc, ctoon_read_err *rerr, ctoon_write_err *werr)
ctoon_get_bool
static unsigned char ctoon_get_bool(ctoon_val *val)
Definition ctoon.h:5195
ctoon_mut_is_sint
static unsigned char ctoon_mut_is_sint(ctoon_mut_val *val)
Definition ctoon.h:5695
ctoon_mut_doc_ptr_getn
static ctoon_mut_val * ctoon_mut_doc_ptr_getn(ctoon_mut_doc *doc, const char *ptr, size_t len)
Definition ctoon.h:7434
ctoon_mut_arr_add_uint
static unsigned char ctoon_mut_arr_add_uint(ctoon_mut_doc *doc, ctoon_mut_val *arr, uint64_t num)
Definition ctoon.h:6581
ctoon_obj_iter_get_val
static ctoon_val * ctoon_obj_iter_get_val(ctoon_val *key)
Definition ctoon.h:5496
ctoon_type
uint8_t ctoon_type
Definition ctoon.h:561
ctoon_mut_int
static ctoon_mut_val * ctoon_mut_int(ctoon_mut_doc *doc, int64_t num)
Definition ctoon.h:5990
ctoon_mut_obj_iter_has_next
static unsigned char ctoon_mut_obj_iter_has_next(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6755
ctoon_doc_ptr_getn
static ctoon_val * ctoon_doc_ptr_getn(ctoon_doc *doc, const char *ptr, size_t len)
Definition ctoon.h:7372
ctoon_mut_arr_remove
static ctoon_mut_val * ctoon_mut_arr_remove(ctoon_mut_val *arr, size_t idx)
Definition ctoon.h:6426
CTOON_READ_ALLOW_BOM
static const ctoon_read_flag CTOON_READ_ALLOW_BOM
Definition ctoon.h:827
ctoon_get_num
static double ctoon_get_num(ctoon_val *val)
Definition ctoon.h:5215
ctoon_is_uint
static unsigned char ctoon_is_uint(ctoon_val *val)
Definition ctoon.h:5120
ctoon_locate_pos
unsigned char ctoon_locate_pos(const char *str, size_t len, size_t pos, size_t *line, size_t *col, size_t *chr)
ctoon_mut_ptr_setx
static unsigned char ctoon_mut_ptr_setx(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_mut_doc *doc, unsigned char create_parent, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7680
ctoon_get_sint
static int64_t ctoon_get_sint(ctoon_val *val)
Definition ctoon.h:5203
ctoon_mut_write_opts
char * ctoon_mut_write_opts(const ctoon_mut_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_obj_iter_init
static unsigned char ctoon_obj_iter_init(ctoon_val *obj, ctoon_obj_iter *iter)
Definition ctoon.h:5463
CTOON_PATCH_ERROR_POINTER
static const ctoon_patch_code CTOON_PATCH_ERROR_POINTER
Definition ctoon.h:4632
ctoon_arr_get
static ctoon_val * ctoon_arr_get(ctoon_val *arr, size_t idx)
Definition ctoon.h:5349
ctoon_mut_obj_rename_key
static unsigned char ctoon_mut_obj_rename_key(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, const char *new_key)
Definition ctoon.h:7285
ctoon_mut_get_type
static ctoon_type ctoon_mut_get_type(ctoon_mut_val *val)
Definition ctoon.h:5733
ctoon_is_false
static unsigned char ctoon_is_false(ctoon_val *val)
Definition ctoon.h:5112
ctoon_mut_obj_add_real
static unsigned char ctoon_mut_obj_add_real(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, double val)
Definition ctoon.h:7177
ctoon_mut_val_write
static char * ctoon_mut_val_write(const ctoon_mut_val *val, size_t *len)
Definition ctoon.h:1399
ctoon_write_file
unsigned char ctoon_write_file(const char *path, const ctoon_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, ctoon_write_err *err)
ctoon_is_null
static unsigned char ctoon_is_null(ctoon_val *val)
Definition ctoon.h:5104
ctoon_mut_set_null
static unsigned char ctoon_mut_set_null(ctoon_mut_val *val)
Definition ctoon.h:5811
ctoon_write_fp
unsigned char ctoon_write_fp(FILE *fp, const ctoon_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, ctoon_write_err *err)
ctoon_mut_ptr_remove
static ctoon_mut_val * ctoon_mut_ptr_remove(ctoon_mut_val *val, const char *ptr)
Definition ctoon.h:7825
ctoon_mut_arr_add_str
static unsigned char ctoon_mut_arr_add_str(ctoon_mut_doc *doc, ctoon_mut_val *arr, const char *str)
Definition ctoon.h:6641
ctoon_mut_ptr_removen
static ctoon_mut_val * ctoon_mut_ptr_removen(ctoon_mut_val *val, const char *ptr, size_t len)
Definition ctoon.h:7831
ctoon_mut_ptr_replacen
static ctoon_mut_val * ctoon_mut_ptr_replacen(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val)
Definition ctoon.h:7759
CTOON_WRITE_ESCAPE_SLASHES
static const ctoon_write_flag CTOON_WRITE_ESCAPE_SLASHES
Definition ctoon.h:1258
ctoon_mut_real
static ctoon_mut_val * ctoon_mut_real(ctoon_mut_doc *doc, double num)
Definition ctoon.h:6005
ctoon_mut_doc_ptr_replace
static ctoon_mut_val * ctoon_mut_doc_ptr_replace(ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val)
Definition ctoon.h:7709
ctoon_mut_obj_clear
static unsigned char ctoon_mut_obj_clear(ctoon_mut_val *obj)
Definition ctoon.h:7064
ctoon_mut_doc_imut_copy
ctoon_doc * ctoon_mut_doc_imut_copy(ctoon_mut_doc *doc, const ctoon_alc *alc)
CTOON_PATCH_SUCCESS
static const ctoon_patch_code CTOON_PATCH_SUCCESS
Definition ctoon.h:4611
ctoon_set_bool
static unsigned char ctoon_set_bool(ctoon_val *val, unsigned char num)
Definition ctoon.h:5264
ctoon_mut_obj_add_double
static unsigned char ctoon_mut_obj_add_double(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, double val)
Definition ctoon.h:7170
ctoon_get_int
static int ctoon_get_int(ctoon_val *val)
Definition ctoon.h:5207
ctoon_mut_write
static char * ctoon_mut_write(const ctoon_mut_doc *doc, size_t *len)
Definition ctoon.h:1377
ctoon_set_double
static unsigned char ctoon_set_double(ctoon_val *val, double num)
Definition ctoon.h:5294
CTOON_WRITE_ALLOW_INF_AND_NAN
static const ctoon_write_flag CTOON_WRITE_ALLOW_INF_AND_NAN
Definition ctoon.h:1261
ctoon_mut_read_number
static const char * ctoon_mut_read_number(const char *dat, ctoon_mut_val *val, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
Definition ctoon.h:1232
CTOON_READ_ALLOW_SINGLE_QUOTED_STR
static const ctoon_read_flag CTOON_READ_ALLOW_SINGLE_QUOTED_STR
Definition ctoon.h:853
ctoon_mut_arr_with_sint16
static ctoon_mut_val * ctoon_mut_arr_with_sint16(ctoon_mut_doc *doc, const int16_t *vals, size_t count)
Definition ctoon.h:6212
ctoon_mut_arr_replace
static ctoon_mut_val * ctoon_mut_arr_replace(ctoon_mut_val *arr, size_t idx, ctoon_mut_val *val)
Definition ctoon.h:6398
ctoon_mut_obj_add_bool
static unsigned char ctoon_mut_obj_add_bool(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, unsigned char val)
Definition ctoon.h:7135
ctoon_mut_arr_clear
static unsigned char ctoon_mut_arr_clear(ctoon_mut_val *arr)
Definition ctoon.h:6513
ctoon_mut_arr_with_strcpy
static ctoon_mut_val * ctoon_mut_arr_with_strcpy(ctoon_mut_doc *doc, const char **vals, size_t count)
Definition ctoon.h:6292
CTOON_WRITE_LENGTH_MARKER
static const ctoon_write_flag CTOON_WRITE_LENGTH_MARKER
Definition ctoon.h:1270
ctoon_read
static ctoon_doc * ctoon_read(const char *dat, size_t len, ctoon_read_flag flg)
Definition ctoon.h:1077
CTOON_READ_ERROR_UNEXPECTED_END
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_END
Definition ctoon.h:905
ctoon_mut_obj_with_str
static ctoon_mut_val * ctoon_mut_obj_with_str(ctoon_mut_doc *doc, const char **keys, const char **vals, size_t count)
Definition ctoon.h:6836
ctoon_val_mut_copy
ctoon_mut_val * ctoon_val_mut_copy(ctoon_mut_doc *doc, ctoon_val *val)
CTOON_PATCH_ERROR_INVALID_MEMBER
static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_MEMBER
Definition ctoon.h:4626
CTOON_WRITE_ERROR_FILE_WRITE
static const ctoon_write_code CTOON_WRITE_ERROR_FILE_WRITE
Definition ctoon.h:1305
ctoon_mut_raw
static ctoon_mut_val * ctoon_mut_raw(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:5932
CTOON_WRITE_SUCCESS
static const ctoon_write_code CTOON_WRITE_SUCCESS
Definition ctoon.h:1299
ctoon_get_raw
static const char * ctoon_get_raw(ctoon_val *val)
Definition ctoon.h:5191
ctoon_json_to_toon
char * ctoon_json_to_toon(const char *json, size_t len, size_t *out_len)
ctoon_mut_arr_with_uint64
static ctoon_mut_val * ctoon_mut_arr_with_uint64(ctoon_mut_doc *doc, const uint64_t *vals, size_t count)
Definition ctoon.h:6254
ctoon_mut_double
static ctoon_mut_val * ctoon_mut_double(ctoon_mut_doc *doc, double num)
Definition ctoon.h:6000
ctoon_mut_doc_ptr_set
static unsigned char ctoon_mut_doc_ptr_set(ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val)
Definition ctoon.h:7602
ctoon_json_to_toon_opts
char * ctoon_json_to_toon_opts(const char *json, size_t len, ctoon_read_flag rflg, const ctoon_write_options *wopts, const ctoon_alc *alc, size_t *out_len, ctoon_read_err *rerr, ctoon_write_err *werr)
CTOON_READ_ALLOW_UNQUOTED_KEY
static const ctoon_read_flag CTOON_READ_ALLOW_UNQUOTED_KEY
Definition ctoon.h:858
ctoon_mut_get_num
static double ctoon_mut_get_num(ctoon_mut_val *val)
Definition ctoon.h:5773
ctoon_mut_arr_add_false
static unsigned char ctoon_mut_arr_add_false(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6562
CTOON_READ_ALLOW_EXT_WHITESPACE
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_WHITESPACE
Definition ctoon.h:850
ctoon_mut_get_type_desc
static const char * ctoon_mut_get_type_desc(ctoon_mut_val *val)
Definition ctoon.h:5745
ctoon_mut_doc_mut_copy
ctoon_mut_doc * ctoon_mut_doc_mut_copy(ctoon_mut_doc *doc, const ctoon_alc *alc)
ctoon_mut_arr_size
static size_t ctoon_mut_arr_size(ctoon_mut_val *arr)
Definition ctoon.h:6053
CTOON_READ_ERROR_DEPTH
static const ctoon_read_code CTOON_READ_ERROR_DEPTH
Definition ctoon.h:935
ctoon_mut_arr_append
static unsigned char ctoon_mut_arr_append(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6360
ctoon_obj_iter_next
static ctoon_val * ctoon_obj_iter_next(ctoon_obj_iter *iter)
Definition ctoon.h:5486
ctoon_get_len
static size_t ctoon_get_len(ctoon_val *val)
Definition ctoon.h:5223
ctoon_mut_obj_iter_with
static ctoon_mut_obj_iter ctoon_mut_obj_iter_with(ctoon_mut_val *obj)
Definition ctoon.h:6748
ctoon_mut_get_uint
static uint64_t ctoon_mut_get_uint(ctoon_mut_val *val)
Definition ctoon.h:5757
CTOON_WRITE_ERROR_INVALID_PARAMETER
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_PARAMETER
Definition ctoon.h:1300
CTOON_READ_ALLOW_EXT_NUMBER
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_NUMBER
Definition ctoon.h:833
ctoon_mut_set_str
static unsigned char ctoon_mut_set_str(ctoon_mut_val *val, const char *str)
Definition ctoon.h:5873
ctoon_toon_to_json
char * ctoon_toon_to_json(const char *toon, size_t len, size_t *out_len)
ctoon_mut_obj_add_strn
static unsigned char ctoon_mut_obj_add_strn(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, const char *val, size_t len)
Definition ctoon.h:7198
ctoon_mut_is_true
static unsigned char ctoon_mut_is_true(ctoon_mut_val *val)
Definition ctoon.h:5679
ctoon_mut_ptr_addn
static unsigned char ctoon_mut_ptr_addn(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_mut_doc *doc)
Definition ctoon.h:7569
ctoon_arr_size
static size_t ctoon_arr_size(ctoon_val *arr)
Definition ctoon.h:5345
CTOON_READ_ERROR_EMPTY_CONTENT
static const ctoon_read_code CTOON_READ_ERROR_EMPTY_CONTENT
Definition ctoon.h:899
ctoon_mut_ptr_setn
static unsigned char ctoon_mut_ptr_setn(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_mut_doc *doc)
Definition ctoon.h:7673
ctoon_mut_set_str_noesc
static unsigned char ctoon_mut_set_str_noesc(ctoon_mut_val *val, unsigned char noesc)
Definition ctoon.h:5887
ctoon_mut_obj_iter_getn
static ctoon_mut_val * ctoon_mut_obj_iter_getn(ctoon_mut_obj_iter *iter, const char *key, size_t key_len)
Definition ctoon.h:6798
ctoon_mut_obj_with_kv
static ctoon_mut_val * ctoon_mut_obj_with_kv(ctoon_mut_doc *doc, const char **kv_pairs, size_t pair_count)
Definition ctoon.h:6867
ctoon_mut_obj_add_true
static unsigned char ctoon_mut_obj_add_true(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7123
ctoon_mut_is_bool
static unsigned char ctoon_mut_is_bool(ctoon_mut_val *val)
Definition ctoon.h:5687
ctoon_write
static char * ctoon_write(const ctoon_doc *doc, size_t *len)
Definition ctoon.h:1341
ctoon_mut_is_raw
static unsigned char ctoon_mut_is_raw(ctoon_mut_val *val)
Definition ctoon.h:5671
ctoon_mut_arr_remove_first
static ctoon_mut_val * ctoon_mut_arr_remove_first(ctoon_mut_val *arr)
Definition ctoon.h:6450
ctoon_equals_strn
static unsigned char ctoon_equals_strn(ctoon_val *val, const char *str, size_t len)
Definition ctoon.h:5235
ctoon_mut_arr_with_uint8
static ctoon_mut_val * ctoon_mut_arr_with_uint8(ctoon_mut_doc *doc, const uint8_t *vals, size_t count)
Definition ctoon.h:6233
ctoon_mut_obj_add_str
static unsigned char ctoon_mut_obj_add_str(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, const char *val)
Definition ctoon.h:7184
ctoon_mut_get_real
static double ctoon_mut_get_real(ctoon_mut_val *val)
Definition ctoon.h:5769
ctoon_obj_iter_get
static ctoon_val * ctoon_obj_iter_get(ctoon_obj_iter *iter, const char *key)
Definition ctoon.h:5500
CTOON_PTR_ERR_MEMORY_ALLOCATION
static const ctoon_ptr_code CTOON_PTR_ERR_MEMORY_ALLOCATION
Definition ctoon.h:4044
ctoon_set_null
static unsigned char ctoon_set_null(ctoon_val *val)
Definition ctoon.h:5258
ctoon_mut_obj_add_float
static unsigned char ctoon_mut_obj_add_float(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, float val)
Definition ctoon.h:7163
ctoon_mut_write_file
unsigned char ctoon_mut_write_file(const char *path, const ctoon_mut_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, ctoon_write_err *err)
ctoon_mut_equals
static unsigned char ctoon_mut_equals(ctoon_mut_val *lhs, ctoon_mut_val *rhs)
Definition ctoon.h:5798
ctoon_merge_patch
ctoon_mut_val * ctoon_merge_patch(ctoon_mut_doc *doc, ctoon_val *orig, ctoon_val *patch)
CTOON_READ_ERROR_FILE_READ
static const ctoon_read_code CTOON_READ_ERROR_FILE_READ
Definition ctoon.h:929
ctoon_obj_iter_has_next
static unsigned char ctoon_obj_iter_has_next(ctoon_obj_iter *iter)
Definition ctoon.h:5482
ctoon_mut_arr_remove_last
static ctoon_mut_val * ctoon_mut_arr_remove_last(ctoon_mut_val *arr)
Definition ctoon.h:6469
ctoon_mut_is_null
static unsigned char ctoon_mut_is_null(ctoon_mut_val *val)
Definition ctoon.h:5675
CTOON_READ_NUMBER_AS_RAW
static const ctoon_read_flag CTOON_READ_NUMBER_AS_RAW
Definition ctoon.h:808
ctoon_mut_obj_add_strncpy
static unsigned char ctoon_mut_obj_add_strncpy(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, const char *val, size_t len)
Definition ctoon.h:7223
ctoon_mut_set_raw
static unsigned char ctoon_mut_set_raw(ctoon_mut_val *val, const char *raw, size_t len)
Definition ctoon.h:5804
ctoon_mut_obj_add_int
static unsigned char ctoon_mut_obj_add_int(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, int64_t val)
Definition ctoon.h:7156
ctoon_mut_rawncpy
static ctoon_mut_val * ctoon_mut_rawncpy(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5953
ctoon_is_str
static unsigned char ctoon_is_str(ctoon_val *val)
Definition ctoon.h:5140
CTOON_PTR_ERR_RESOLVE
static const ctoon_ptr_code CTOON_PTR_ERR_RESOLVE
Definition ctoon.h:4035
ctoon_mut_arr_rotate
static unsigned char ctoon_mut_arr_rotate(ctoon_mut_val *arr, size_t idx)
Definition ctoon.h:6521
ctoon_mut_arr_remove_range
static unsigned char ctoon_mut_arr_remove_range(ctoon_mut_val *arr, size_t idx, size_t len)
Definition ctoon.h:6491
ctoon_ptr_get
static ctoon_val * ctoon_ptr_get(ctoon_val *val, const char *ptr)
Definition ctoon.h:7399
ctoon_mut_ptr_replace
static ctoon_mut_val * ctoon_mut_ptr_replace(ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val)
Definition ctoon.h:7753
ctoon_write_json
char * ctoon_write_json(const ctoon_doc *doc, int indent, ctoon_write_flag flg, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_toon_to_json_opts
char * ctoon_toon_to_json_opts(const char *toon, size_t len, ctoon_read_flag rflg, int indent, ctoon_write_flag wflg, const ctoon_alc *alc, size_t *out_len, ctoon_read_err *rerr, ctoon_write_err *werr)
ctoon_mut_ptr_set
static unsigned char ctoon_mut_ptr_set(ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val, ctoon_mut_doc *doc)
Definition ctoon.h:7665
CTOON_PATCH_ERROR_EQUAL
static const ctoon_patch_code CTOON_PATCH_ERROR_EQUAL
Definition ctoon.h:4629
ctoon_api_inline
#define ctoon_api_inline
Definition ctoon.h:352
ctoon_mut_arr_get_first
static ctoon_mut_val * ctoon_mut_arr_get_first(ctoon_mut_val *arr)
Definition ctoon.h:6067
ctoon_mut_is_false
static unsigned char ctoon_mut_is_false(ctoon_mut_val *val)
Definition ctoon.h:5683
CTOON_WRITE_ERROR_INVALID_VALUE_TYPE
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_VALUE_TYPE
Definition ctoon.h:1302
ctoon_is_int
static unsigned char ctoon_is_int(ctoon_val *val)
Definition ctoon.h:5128
CTOON_READ_ERROR_FILE_OPEN
static const ctoon_read_code CTOON_READ_ERROR_FILE_OPEN
Definition ctoon.h:926
ctoon_mut_obj_replace
static unsigned char ctoon_mut_obj_replace(ctoon_mut_val *obj, ctoon_mut_val *key, ctoon_mut_val *val)
Definition ctoon.h:7072
ctoon_incr_free
void ctoon_incr_free(ctoon_incr_state *state)
CTOON_WRITE_ESCAPE_UNICODE
static const ctoon_write_flag CTOON_WRITE_ESCAPE_UNICODE
Definition ctoon.h:1255
ctoon_mut_arr_with_uint32
static ctoon_mut_val * ctoon_mut_arr_with_uint32(ctoon_mut_doc *doc, const uint32_t *vals, size_t count)
Definition ctoon.h:6247
ctoon_get_real
static double ctoon_get_real(ctoon_val *val)
Definition ctoon.h:5211
ctoon_mut_obj_add_obj
static ctoon_mut_val * ctoon_mut_obj_add_obj(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7244
CTOON_READ_ALLOW_TRAILING_COMMAS
static const ctoon_read_flag CTOON_READ_ALLOW_TRAILING_COMMAS
Definition ctoon.h:792
ctoon_mut_arr_with_uint
static ctoon_mut_val * ctoon_mut_arr_with_uint(ctoon_mut_doc *doc, const uint64_t *vals, size_t count)
Definition ctoon.h:6193
ctoon_get_tag
static uint8_t ctoon_get_tag(ctoon_val *val)
Definition ctoon.h:5170
ctoon_mut_obj_add_sint
static unsigned char ctoon_mut_obj_add_sint(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, int64_t val)
Definition ctoon.h:7149
ctoon_mut_doc_ptr_replacen
static ctoon_mut_val * ctoon_mut_doc_ptr_replacen(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val)
Definition ctoon.h:7715
ctoon_write_opts
char * ctoon_write_opts(const ctoon_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_mut_patch
ctoon_mut_val * ctoon_mut_patch(ctoon_mut_doc *doc, ctoon_mut_val *orig, ctoon_mut_val *patch, ctoon_patch_err *err)
ctoon_mut_arr_get
static ctoon_mut_val * ctoon_mut_arr_get(ctoon_mut_val *arr, size_t idx)
Definition ctoon.h:6057
ctoon_mut_arr_insert
static unsigned char ctoon_mut_arr_insert(ctoon_mut_val *arr, ctoon_mut_val *val, size_t idx)
Definition ctoon.h:6329
CTOON_READ_ERROR_INVALID_NUMBER
static const ctoon_read_code CTOON_READ_ERROR_INVALID_NUMBER
Definition ctoon.h:917
ctoon_mut_sint
static ctoon_mut_val * ctoon_mut_sint(ctoon_mut_doc *doc, int64_t num)
Definition ctoon.h:5985
ctoon_mut_true
static ctoon_mut_val * ctoon_mut_true(ctoon_mut_doc *doc)
Definition ctoon.h:5967
ctoon_mut_ptr_replacex
static ctoon_mut_val * ctoon_mut_ptr_replacex(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7764
ctoon_get_uint
static uint64_t ctoon_get_uint(ctoon_val *val)
Definition ctoon.h:5199
ctoon_alc_dyn_new
ctoon_alc * ctoon_alc_dyn_new(void)
ctoon_read_max_memory_usage
static size_t ctoon_read_max_memory_usage(size_t len, ctoon_read_flag flg)
Definition ctoon.h:1184
ctoon_mut_obj_iter_init
static unsigned char ctoon_mut_obj_iter_init(ctoon_mut_val *obj, ctoon_mut_obj_iter *iter)
Definition ctoon.h:6734
ctoon_mut_false
static ctoon_mut_val * ctoon_mut_false(ctoon_mut_doc *doc)
Definition ctoon.h:5971
ctoon_mut_val_write_opts
char * ctoon_mut_val_write_opts(const ctoon_mut_val *val, const ctoon_write_options *opts, const ctoon_alc *alc, size_t *len, ctoon_write_err *err)
ctoon_mut_doc_ptr_get
static ctoon_mut_val * ctoon_mut_doc_ptr_get(ctoon_mut_doc *doc, const char *ptr)
Definition ctoon.h:7428
ctoon_incr_new
ctoon_incr_state * ctoon_incr_new(char *buf, size_t buf_len, ctoon_read_flag flg, const ctoon_alc *alc)
ctoon_doc_get_val_count
static size_t ctoon_doc_get_val_count(ctoon_doc *doc)
Definition ctoon.h:5081
ctoon_write_number
char * ctoon_write_number(const ctoon_val *val, char *buf)
CTOON_READ_ALLOW_INVALID_UNICODE
static const ctoon_read_flag CTOON_READ_ALLOW_INVALID_UNICODE
Definition ctoon.h:818
ctoon_read_json_fp
ctoon_doc * ctoon_read_json_fp(FILE *fp, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_is_int
static unsigned char ctoon_mut_is_int(ctoon_mut_val *val)
Definition ctoon.h:5699
ctoon_mut_doc_set_root
static void ctoon_mut_doc_set_root(ctoon_mut_doc *doc, ctoon_mut_val *root)
Definition ctoon.h:5660
ctoon_mut_uint
static ctoon_mut_val * ctoon_mut_uint(ctoon_mut_doc *doc, uint64_t num)
Definition ctoon.h:5980
ctoon_mut_obj_size
static size_t ctoon_mut_obj_size(ctoon_mut_val *obj)
Definition ctoon.h:6705
ctoon_mut_doc_ptr_addn
static unsigned char ctoon_mut_doc_ptr_addn(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val)
Definition ctoon.h:7507
ctoon_patch_code
uint32_t ctoon_patch_code
Definition ctoon.h:4608
ctoon_arr_iter_next
static ctoon_val * ctoon_arr_iter_next(ctoon_arr_iter *iter)
Definition ctoon.h:5417
CTOON_READ_ALLOW_INF_AND_NAN
static const ctoon_read_flag CTOON_READ_ALLOW_INF_AND_NAN
Definition ctoon.h:804
CTOON_PTR_ERR_SET_ROOT
static const ctoon_ptr_code CTOON_PTR_ERR_SET_ROOT
Definition ctoon.h:4041
ctoon_mut_arr_prepend
static unsigned char ctoon_mut_arr_prepend(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6379
ctoon_alc_dyn_free
void ctoon_alc_dyn_free(ctoon_alc *alc)
ctoon_obj_iter_with
static ctoon_obj_iter ctoon_obj_iter_with(ctoon_val *obj)
Definition ctoon.h:5476
ctoon_read_fp
ctoon_doc * ctoon_read_fp(FILE *fp, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_ptr_getn
static ctoon_mut_val * ctoon_mut_ptr_getn(ctoon_mut_val *val, const char *ptr, size_t len)
Definition ctoon.h:7472
ctoon_mut_ptr_add
static unsigned char ctoon_mut_ptr_add(ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val, ctoon_mut_doc *doc)
Definition ctoon.h:7561
ctoon_mut_is_real
static unsigned char ctoon_mut_is_real(ctoon_mut_val *val)
Definition ctoon.h:5703
ctoon_mut_null
static ctoon_mut_val * ctoon_mut_null(ctoon_mut_doc *doc)
Definition ctoon.h:5963
CTOON_PATCH_ERROR_INVALID_PARAMETER
static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_PARAMETER
Definition ctoon.h:4614
ctoon_mut_obj_get
static ctoon_mut_val * ctoon_mut_obj_get(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:6709
ctoon_mut_arr_add_null
static unsigned char ctoon_mut_arr_add_null(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6544
ctoon_mut_get_tag
static uint8_t ctoon_mut_get_tag(ctoon_mut_val *val)
Definition ctoon.h:5741
CTOON_READ_ERROR_INVALID_COMMENT
static const ctoon_read_code CTOON_READ_ERROR_INVALID_COMMENT
Definition ctoon.h:914
ctoon_mut_obj_add_uint
static unsigned char ctoon_mut_obj_add_uint(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, uint64_t val)
Definition ctoon.h:7142
ctoon_is_sint
static unsigned char ctoon_is_sint(ctoon_val *val)
Definition ctoon.h:5124
ctoon_mut_obj_add_strcpy
static unsigned char ctoon_mut_obj_add_strcpy(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, const char *val)
Definition ctoon.h:7210
ctoon_alc_pool_init
unsigned char ctoon_alc_pool_init(ctoon_alc *alc, void *buf, size_t size)
ctoon_is_bool
static unsigned char ctoon_is_bool(ctoon_val *val)
Definition ctoon.h:5116
CTOON_READ_NOFLAG
static const ctoon_read_flag CTOON_READ_NOFLAG
Definition ctoon.h:775
ctoon_mut_doc_ptr_setx
static unsigned char ctoon_mut_doc_ptr_setx(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val, unsigned char create_parent, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7615
CTOON_READ_ALLOW_EXT_ESCAPE
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_ESCAPE
Definition ctoon.h:842
CTOON_READ_SUCCESS
static const ctoon_read_code CTOON_READ_SUCCESS
Definition ctoon.h:890
ctoon_obj_size
static size_t ctoon_obj_size(ctoon_val *obj)
Definition ctoon.h:5434
CTOON_WRITE_ERROR_INVALID_STRING
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_STRING
Definition ctoon.h:1306
ctoon_mut_obj_add_arr
static ctoon_mut_val * ctoon_mut_obj_add_arr(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7236
ctoon_set_float
static unsigned char ctoon_set_float(ctoon_val *val, float num)
Definition ctoon.h:5288
ctoon_set_fp_to_fixed
static unsigned char ctoon_set_fp_to_fixed(ctoon_val *val, int prec)
Definition ctoon.h:5306
ctoon_mut_obj_rotate
static unsigned char ctoon_mut_obj_rotate(ctoon_mut_val *obj, size_t idx)
Definition ctoon.h:7082
CTOON_READ_ERROR_UNEXPECTED_CHARACTER
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CHARACTER
Definition ctoon.h:908
ctoon_mut_doc_new
ctoon_mut_doc * ctoon_mut_doc_new(const ctoon_alc *alc)
CTOON_PTR_ERR_NONE
static const ctoon_ptr_code CTOON_PTR_ERR_NONE
Definition ctoon.h:4026
ctoon_obj_getn
static ctoon_val * ctoon_obj_getn(ctoon_val *obj, const char *key, size_t key_len)
Definition ctoon.h:5443
ctoon_val_write
static char * ctoon_val_write(const ctoon_val *val, size_t *len)
Definition ctoon.h:1366
ctoon_mut_obj_remove_keyn
static ctoon_mut_val * ctoon_mut_obj_remove_keyn(ctoon_mut_val *obj, const char *key, size_t key_len)
Definition ctoon.h:7056
ctoon_mut_write_fp
unsigned char ctoon_mut_write_fp(FILE *fp, const ctoon_mut_doc *doc, const ctoon_write_options *opts, const ctoon_alc *alc, ctoon_write_err *err)
CTOON_READ_ALLOW_COMMENTS
static const ctoon_read_flag CTOON_READ_ALLOW_COMMENTS
Definition ctoon.h:795
ctoon_set_str
static unsigned char ctoon_set_str(ctoon_val *val, const char *str)
Definition ctoon.h:5318
ctoon_mut_ptr_get
static ctoon_mut_val * ctoon_mut_ptr_get(ctoon_mut_val *val, const char *ptr)
Definition ctoon.h:7466
ctoon_mut_arr_get_last
static ctoon_mut_val * ctoon_mut_arr_get_last(ctoon_mut_val *arr)
Definition ctoon.h:6075
ctoon_read_flag
uint32_t ctoon_read_flag
Definition ctoon.h:765
ctoon_mut_doc_ptr_setn
static unsigned char ctoon_mut_doc_ptr_setn(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val)
Definition ctoon.h:7609
ctoon_set_real
static unsigned char ctoon_set_real(ctoon_val *val, double num)
Definition ctoon.h:5300
ctoon_ptr_getx
static ctoon_val * ctoon_ptr_getx(ctoon_val *val, const char *ptr, size_t len, ctoon_ptr_err *err)
Definition ctoon.h:7410
ctoon_mut_arr_iter_with
static ctoon_mut_arr_iter ctoon_mut_arr_iter_with(ctoon_mut_val *arr)
Definition ctoon.h:6103
ctoon_is_num
static unsigned char ctoon_is_num(ctoon_val *val)
Definition ctoon.h:5136
ctoon_write_code
uint32_t ctoon_write_code
Definition ctoon.h:1298
ctoon_mut_arr_with_float
static ctoon_mut_val * ctoon_mut_arr_with_float(ctoon_mut_doc *doc, const float *vals, size_t count)
Definition ctoon.h:6261
ctoon_mut_arr_add_strncpy
static unsigned char ctoon_mut_arr_add_strncpy(ctoon_mut_doc *doc, ctoon_mut_val *arr, const char *str, size_t len)
Definition ctoon.h:6671
ctoon_equals_str
static unsigned char ctoon_equals_str(ctoon_val *val, const char *str)
Definition ctoon.h:5227
CTOON_WRITE_NOFLAG
static const ctoon_write_flag CTOON_WRITE_NOFLAG
Definition ctoon.h:1252
ctoon_mut_arr_add_obj
static ctoon_mut_val * ctoon_mut_arr_add_obj(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6690
ctoon_api
#define ctoon_api
Definition ctoon.h:346
CTOON_PATCH_ERROR_INVALID_OPERATION
static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_OPERATION
Definition ctoon.h:4620
ctoon_mut_ptr_removex
static ctoon_mut_val * ctoon_mut_ptr_removex(ctoon_mut_val *val, const char *ptr, size_t len, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7837
ctoon_read_json
ctoon_doc * ctoon_read_json(char *dat, size_t len, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_arr_with_real
static ctoon_mut_val * ctoon_mut_arr_with_real(ctoon_mut_doc *doc, const double *vals, size_t count)
Definition ctoon.h:6198
ctoon_mut_equals_strn
static unsigned char ctoon_mut_equals_strn(ctoon_mut_val *val, const char *str, size_t len)
Definition ctoon.h:5790
ctoon_mut_get_subtype
static ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val)
Definition ctoon.h:5737
ctoon_mut_arr_add_true
static unsigned char ctoon_mut_arr_add_true(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6553
CTOON_WRITE_ERROR_MEMORY_ALLOCATION
static const ctoon_write_code CTOON_WRITE_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:1301
ctoon_mut_str
static ctoon_mut_val * ctoon_mut_str(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:6010
ctoon_mut_get_len
static size_t ctoon_mut_get_len(ctoon_mut_val *val)
Definition ctoon.h:5781
CTOON_READ_ERROR_TOON_STRUCTURE
static const ctoon_read_code CTOON_READ_ERROR_TOON_STRUCTURE
Definition ctoon.h:911
ctoon_mut_set_fp_to_float
static unsigned char ctoon_mut_set_fp_to_float(ctoon_mut_val *val, unsigned char flt)
Definition ctoon.h:5866
ctoon_write_flag
uint32_t ctoon_write_flag
Definition ctoon.h:1249
ctoon_mut_arr_iter_init
static unsigned char ctoon_mut_arr_iter_init(ctoon_mut_val *arr, ctoon_mut_arr_iter *iter)
Definition ctoon.h:6089
ctoon_mut_arr_add_bool
static unsigned char ctoon_mut_arr_add_bool(ctoon_mut_doc *doc, ctoon_mut_val *arr, unsigned char val)
Definition ctoon.h:6571
ctoon_version
uint32_t ctoon_version(void)
CTOON_WRITE_ERROR_FILE_OPEN
static const ctoon_write_code CTOON_WRITE_ERROR_FILE_OPEN
Definition ctoon.h:1304
ctoon_mut_doc_ptr_remove
static ctoon_mut_val * ctoon_mut_doc_ptr_remove(ctoon_mut_doc *doc, const char *ptr)
Definition ctoon.h:7786
ctoon_mut_doc_ptr_replacex
static ctoon_mut_val * ctoon_mut_doc_ptr_replacex(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7720
ctoon_mut_strn
static ctoon_mut_val * ctoon_mut_strn(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:6015
CTOON_PATCH_ERROR_MISSING_KEY
static const ctoon_patch_code CTOON_PATCH_ERROR_MISSING_KEY
Definition ctoon.h:4623
ctoon_mut_doc_get_root
static ctoon_mut_val * ctoon_mut_doc_get_root(ctoon_mut_doc *doc)
Definition ctoon.h:5656
ctoon_mut_get_bool
static unsigned char ctoon_mut_get_bool(ctoon_mut_val *val)
Definition ctoon.h:5753
ctoon_read_number
const char * ctoon_read_number(const char *dat, ctoon_val *val, ctoon_read_flag flg, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_mut_arr_add_strcpy
static unsigned char ctoon_mut_arr_add_strcpy(ctoon_mut_doc *doc, ctoon_mut_val *arr, const char *str)
Definition ctoon.h:6661
CTOON_READ_ERROR_MORE
static const ctoon_read_code CTOON_READ_ERROR_MORE
Definition ctoon.h:932
ctoon_obj_get
static ctoon_val * ctoon_obj_get(ctoon_val *obj, const char *key)
Definition ctoon.h:5438
ctoon_read_opts_indent
ctoon_doc * ctoon_read_opts_indent(char *dat, size_t len, ctoon_read_flag flg, int indent_size, const ctoon_alc *alc, ctoon_read_err *err)
ctoon_json_to_toon_file_opts
unsigned char ctoon_json_to_toon_file_opts(const char *json_path, const char *toon_path, ctoon_read_flag rflg, const ctoon_write_options *wopts, const ctoon_alc *alc, ctoon_read_err *rerr, ctoon_write_err *werr)
ctoon_is_obj
static unsigned char ctoon_is_obj(ctoon_val *val)
Definition ctoon.h:5148
ctoon_mut_strncpy
static ctoon_mut_val * ctoon_mut_strncpy(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:6034
ctoon_read_json_const
static ctoon_doc * ctoon_read_json_const(const char *dat, size_t len, ctoon_read_flag flg)
Definition ctoon.h:1506
CTOON_READ_ERROR_INVALID_STRING
static const ctoon_read_code CTOON_READ_ERROR_INVALID_STRING
Definition ctoon.h:920
ctoon_set_raw
static unsigned char ctoon_set_raw(ctoon_val *val, const char *raw, size_t len)
Definition ctoon.h:5251
ctoon_doc_free
static void ctoon_doc_free(ctoon_doc *doc)
Definition ctoon.h:5085
ctoon_mut_obj_remove_str
static ctoon_mut_val * ctoon_mut_obj_remove_str(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7262
ctoon_mut_obj_put
static unsigned char ctoon_mut_obj_put(ctoon_mut_val *obj, ctoon_mut_val *key, ctoon_mut_val *val)
Definition ctoon.h:6990
ctoon_equals
static unsigned char ctoon_equals(ctoon_val *lhs, ctoon_val *rhs)
Definition ctoon.h:5246
ctoon_mut_arr_with_sint8
static ctoon_mut_val * ctoon_mut_arr_with_sint8(ctoon_mut_doc *doc, const int8_t *vals, size_t count)
Definition ctoon.h:6205
CTOON_PATCH_ERROR_MEMORY_ALLOCATION
static const ctoon_patch_code CTOON_PATCH_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:4617
ctoon_is_real
static unsigned char ctoon_is_real(ctoon_val *val)
Definition ctoon.h:5132
ctoon_mut_set_float
static unsigned char ctoon_mut_set_float(ctoon_mut_val *val, float num)
Definition ctoon.h:5841
ctoon_mut_rawn
static ctoon_mut_val * ctoon_mut_rawn(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5937
ctoon_mut_bool
static ctoon_mut_val * ctoon_mut_bool(ctoon_mut_doc *doc, unsigned char val)
Definition ctoon.h:5975
ctoon_mut_obj_remove
static ctoon_mut_val * ctoon_mut_obj_remove(ctoon_mut_val *obj, ctoon_mut_val *key)
Definition ctoon.h:7038
ctoon_mut_obj_add_false
static unsigned char ctoon_mut_obj_add_false(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7129
CTOON_READ_ERROR_INVALID_PARAMETER
static const ctoon_read_code CTOON_READ_ERROR_INVALID_PARAMETER
Definition ctoon.h:893
unsafe_ctoon_is_str_noesc
static unsigned char unsafe_ctoon_is_str_noesc(const char *str, size_t len)
Definition ctoon.h:4759
ctoon_incr_read
ctoon_doc * ctoon_incr_read(ctoon_incr_state *state, size_t len, ctoon_read_err *err)
ctoon_mut_obj
static ctoon_mut_val * ctoon_mut_obj(ctoon_mut_doc *doc)
Definition ctoon.h:6825
ctoon_arr_get_last
static ctoon_val * ctoon_arr_get_last(ctoon_val *arr)
Definition ctoon.h:5373
ctoon_mut_rawcpy
static ctoon_mut_val * ctoon_mut_rawcpy(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:5943
ctoon_is_ctn
static unsigned char ctoon_is_ctn(ctoon_val *val)
Definition ctoon.h:5152
ctoon_mut_set_real
static unsigned char ctoon_mut_set_real(ctoon_mut_val *val, double num)
Definition ctoon.h:5853
ctoon_is_true
static unsigned char ctoon_is_true(ctoon_val *val)
Definition ctoon.h:5108
ctoon_mut_float
static ctoon_mut_val * ctoon_mut_float(ctoon_mut_doc *doc, float num)
Definition ctoon.h:5995
ctoon_doc_get_read_size
static size_t ctoon_doc_get_read_size(ctoon_doc *doc)
Definition ctoon.h:5077
CTOON_READ_TOON5
static const ctoon_read_flag CTOON_READ_TOON5
Definition ctoon.h:874
ctoon_get_str
static const char * ctoon_get_str(ctoon_val *val)
Definition ctoon.h:5219
ctoon_set_strn
static unsigned char ctoon_set_strn(ctoon_val *val, const char *str, size_t len)
Definition ctoon.h:5325
ctoon_mut_set_fp_to_fixed
static unsigned char ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val, int prec)
Definition ctoon.h:5859
ctoon_mut_obj_rename_keyn
static unsigned char ctoon_mut_obj_rename_keyn(ctoon_mut_doc *doc, ctoon_mut_val *obj, const char *key, size_t len, const char *new_key, size_t new_len)
Definition ctoon.h:7294
ctoon_mut_get_raw
static const char * ctoon_mut_get_raw(ctoon_mut_val *val)
Definition ctoon.h:5749
ctoon_arr_get_first
static ctoon_val * ctoon_arr_get_first(ctoon_val *arr)
Definition ctoon.h:5364
CTOON_WRITE_ERROR_NAN_OR_INF
static const ctoon_write_code CTOON_WRITE_ERROR_NAN_OR_INF
Definition ctoon.h:1303
ctoon_get_subtype
static ctoon_subtype ctoon_get_subtype(ctoon_val *val)
Definition ctoon.h:5166
ctoon_mut_doc_ptr_getx
static ctoon_mut_val * ctoon_mut_doc_ptr_getx(ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_ptr_ctx *ctx, ctoon_ptr_err *err)
Definition ctoon.h:7440
ctoon_alc
Definition ctoon.h:628
ctoon_alc::free
void(* free)(void *ctx, void *ptr)
Definition ctoon.h:634
ctoon_alc::ctx
void * ctx
Definition ctoon.h:636
ctoon_arr_iter
Definition ctoon.h:1945
ctoon_arr_iter::max
size_t max
Definition ctoon.h:1947
ctoon_arr_iter::cur
ctoon_val * cur
Definition ctoon.h:1948
ctoon_arr_iter::idx
size_t idx
Definition ctoon.h:1946
ctoon_doc
Definition ctoon.h:4725
ctoon_doc::alc
ctoon_alc alc
Definition ctoon.h:4729
ctoon_doc::root
ctoon_val * root
Definition ctoon.h:4727
ctoon_doc::str_pool
char * str_pool
Definition ctoon.h:4735
ctoon_doc::val_read
size_t val_read
Definition ctoon.h:4733
ctoon_doc::dat_read
size_t dat_read
Definition ctoon.h:4731
ctoon_mut_arr_iter
Definition ctoon.h:2666
ctoon_mut_arr_iter::pre
ctoon_mut_val * pre
Definition ctoon.h:2670
ctoon_mut_arr_iter::arr
ctoon_mut_val * arr
Definition ctoon.h:2671
ctoon_mut_arr_iter::idx
size_t idx
Definition ctoon.h:2667
ctoon_mut_arr_iter::max
size_t max
Definition ctoon.h:2668
ctoon_mut_arr_iter::cur
ctoon_mut_val * cur
Definition ctoon.h:2669
ctoon_mut_doc
Definition ctoon.h:5593
ctoon_mut_obj_iter
Definition ctoon.h:3492
ctoon_mut_obj_iter::max
size_t max
Definition ctoon.h:3494
ctoon_mut_obj_iter::cur
ctoon_mut_val * cur
Definition ctoon.h:3495
ctoon_mut_obj_iter::obj
ctoon_mut_val * obj
Definition ctoon.h:3497
ctoon_mut_obj_iter::pre
ctoon_mut_val * pre
Definition ctoon.h:3496
ctoon_mut_obj_iter::idx
size_t idx
Definition ctoon.h:3493
ctoon_mut_val
Definition ctoon.h:5545
ctoon_obj_iter
Definition ctoon.h:2069
ctoon_obj_iter::idx
size_t idx
Definition ctoon.h:2070
ctoon_obj_iter::obj
ctoon_val * obj
Definition ctoon.h:2073
ctoon_obj_iter::max
size_t max
Definition ctoon.h:2071
ctoon_obj_iter::cur
ctoon_val * cur
Definition ctoon.h:2072
ctoon_patch_err
Definition ctoon.h:4635
ctoon_patch_err::ptr
ctoon_ptr_err ptr
Definition ctoon.h:4643
ctoon_patch_err::msg
const char * msg
Definition ctoon.h:4641
ctoon_patch_err::idx
size_t idx
Definition ctoon.h:4639
ctoon_patch_err::code
ctoon_patch_code code
Definition ctoon.h:4637
ctoon_ptr_ctx
Definition ctoon.h:4075
ctoon_ptr_ctx::ctn
ctoon_mut_val * ctn
Definition ctoon.h:4083
ctoon_ptr_ctx::pre
ctoon_mut_val * pre
Definition ctoon.h:4092
ctoon_ptr_ctx::old
ctoon_mut_val * old
Definition ctoon.h:4097
ctoon_ptr_err
Definition ctoon.h:4047
ctoon_ptr_err::pos
size_t pos
Definition ctoon.h:4053
ctoon_ptr_err::msg
const char * msg
Definition ctoon.h:4051
ctoon_ptr_err::code
ctoon_ptr_code code
Definition ctoon.h:4049
ctoon_read_err
Definition ctoon.h:938
ctoon_read_err::msg
const char * msg
Definition ctoon.h:942
ctoon_read_err::pos
size_t pos
Definition ctoon.h:944
ctoon_read_err::code
ctoon_read_code code
Definition ctoon.h:940
ctoon_val
Definition ctoon.h:4720
ctoon_val::tag
uint64_t tag
Definition ctoon.h:4721
ctoon_val::uni
ctoon_val_uni uni
Definition ctoon.h:4722
ctoon_write_err
Definition ctoon.h:1309
ctoon_write_err::code
ctoon_write_code code
Definition ctoon.h:1310
ctoon_write_err::msg
const char * msg
Definition ctoon.h:1311
ctoon_write_options
Definition ctoon.h:1315
ctoon_write_options::indent
int indent
Definition ctoon.h:1318
ctoon_write_options::flag
ctoon_write_flag flag
Definition ctoon.h:1316
ctoon_write_options::delimiter
ctoon_delimiter delimiter
Definition ctoon.h:1317
ctoon_val_uni
Definition ctoon.h:4708
ctoon_val_uni::str
const char * str
Definition ctoon.h:4712
ctoon_val_uni::ptr
void * ptr
Definition ctoon.h:4713
ctoon_val_uni::f64
double f64
Definition ctoon.h:4711
ctoon_val_uni::ofs
size_t ofs
Definition ctoon.h:4714
ctoon_val_uni::i64
int64_t i64
Definition ctoon.h:4710
ctoon_val_uni::u64
uint64_t u64
Definition ctoon.h:4709

CToon C v0.9.0 - A C99 TOON/JSON serialization library

© 2024-present Mohammad Raziei - GitHub Repository | MIT License