CToon C 0.6.1
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 Define as 1 to enable the JSON reader and writer.
83 This enables ctoon_read_json*, ctoon_write_json* functions.
84 */
85#ifndef CTOON_ENABLE_JSON
86#endif
87
88/*
89 Define as 1 to disable the fast floating-point number conversion in ctoon.
90 Libc's `strtod/snprintf` will be used instead.
91
92 This reduces binary size by about 30%, but significantly slows down the
93 floating-point read/write speed.
94 */
95#ifndef CTOON_DISABLE_FAST_FP_CONV
96#endif
97
98/*
99 Define as 1 to disable non-standard TOON features support at compile-time,
100 such as CTOON_READ_ALLOW_XXX and CTOON_WRITE_ALLOW_XXX.
101
102 This reduces binary size by about 10%, and slightly improves performance.
103 */
104#ifndef CTOON_DISABLE_NON_STANDARD
105#endif
106
107/*
108 Define as 1 to disable UTF-8 validation at compile-time.
109
110 Use this if all input strings are guaranteed to be valid UTF-8
111 (e.g. language-level String types are already validated).
112
113 Disabling UTF-8 validation improves performance for non-ASCII strings by about
114 3% to 7%.
115
116 Note: If this flag is enabled while passing illegal UTF-8 strings,
117 the following errors may occur:
118 - Escaped characters may be ignored when parsing TOON strings.
119 - Ending quotes may be ignored when parsing TOON strings, causing the
120 string to merge with the next value.
121 - When serializing with `ctoon_mut_val`, the string's end may be accessed
122 out of bounds, potentially causing a segmentation fault.
123 */
124#ifndef CTOON_DISABLE_UTF8_VALIDATION
125#endif
126
127/*
128 Define as 1 to improve performance on architectures that do not support
129 unaligned memory access.
130
131 Normally, this does not need to be set manually. See the C file for details.
132 */
133#ifndef CTOON_DISABLE_UNALIGNED_MEMORY_ACCESS
134#endif
135
136/* Define as 1 to export symbols when building this library as a Windows DLL. */
137#ifndef CTOON_EXPORTS
138#endif
139
140/* Define as 1 to import symbols when using this library as a Windows DLL. */
141#ifndef CTOON_IMPORTS
142#endif
143
144/* Define as 1 to include <stdint.h> for compilers without C99 support. */
145#ifndef CTOON_HAS_STDINT_H
146#endif
147
148/* Define as 1 to include <stdbool.h> for compilers without C99 support. */
149#ifndef CTOON_HAS_STDBOOL_H
150#endif
151
152/* Define to an integer to set a depth limit for containers (arrays, objects). */
153#ifndef CTOON_READER_DEPTH_LIMIT
154#endif
155
156
157/*==============================================================================
158 * MARK: - Compiler Macros
159 *============================================================================*/
160
162#ifdef _MSC_VER
163# define CTOON_MSC_VER _MSC_VER
164#else
165# define CTOON_MSC_VER 0
166#endif
167
169#ifdef __GNUC__
170# define CTOON_GCC_VER __GNUC__
171# if defined(__GNUC_PATCHLEVEL__)
172# define ctoon_gcc_available(major, minor, patch) \
173 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) \
174 >= (major * 10000 + minor * 100 + patch))
175# else
176# define ctoon_gcc_available(major, minor, patch) \
177 ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) \
178 >= (major * 10000 + minor * 100 + patch))
179# endif
180#else
181# define CTOON_GCC_VER 0
182# define ctoon_gcc_available(major, minor, patch) 0
183#endif
184
186#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
187 !defined(__clang__) && !defined(__llvm__) && \
188 !defined(__INTEL_COMPILER) && !defined(__ICC) && \
189 !defined(__NVCC__) && !defined(__PGI) && !defined(__TINYC__)
190# define CTOON_IS_REAL_GCC 1
191#else
192# define CTOON_IS_REAL_GCC 0
193#endif
194
196#if defined(__STDC__) && (__STDC__ >= 1) && defined(__STDC_VERSION__)
197# define CTOON_STDC_VER __STDC_VERSION__
198#else
199# define CTOON_STDC_VER 0
200#endif
201
203#if defined(__cplusplus)
204# define CTOON_CPP_VER __cplusplus
205#else
206# define CTOON_CPP_VER 0
207#endif
208
210#ifndef ctoon_has_builtin
211# ifdef __has_builtin
212# define ctoon_has_builtin(x) __has_builtin(x)
213# else
214# define ctoon_has_builtin(x) 0
215# endif
216#endif
217
219#ifndef ctoon_has_attribute
220# ifdef __has_attribute
221# define ctoon_has_attribute(x) __has_attribute(x)
222# else
223# define ctoon_has_attribute(x) 0
224# endif
225#endif
226
228#ifndef ctoon_has_feature
229# ifdef __has_feature
230# define ctoon_has_feature(x) __has_feature(x)
231# else
232# define ctoon_has_feature(x) 0
233# endif
234#endif
235
237#ifndef ctoon_has_include
238# ifdef __has_include
239# define ctoon_has_include(x) __has_include(x)
240# else
241# define ctoon_has_include(x) 0
242# endif
243#endif
244
246#ifndef ctoon_inline
247# if CTOON_MSC_VER >= 1200
248# define ctoon_inline __forceinline
249# elif defined(_MSC_VER)
250# define ctoon_inline __inline
251# elif ctoon_has_attribute(always_inline) || CTOON_GCC_VER >= 4
252# define ctoon_inline __inline__ __attribute__((always_inline))
253# elif defined(__clang__) || defined(__GNUC__)
254# define ctoon_inline __inline__
255# elif defined(__cplusplus) || CTOON_STDC_VER >= 199901L
256# define ctoon_inline inline
257# else
258# define ctoon_inline
259# endif
260#endif
261
263#ifndef ctoon_noinline
264# if CTOON_MSC_VER >= 1400
265# define ctoon_noinline __declspec(noinline)
266# elif ctoon_has_attribute(noinline) || CTOON_GCC_VER >= 4
267# define ctoon_noinline __attribute__((noinline))
268# else
269# define ctoon_noinline
270# endif
271#endif
272
274#ifndef ctoon_align
275# if CTOON_MSC_VER >= 1300
276# define ctoon_align(x) __declspec(align(x))
277# elif ctoon_has_attribute(aligned) || defined(__GNUC__)
278# define ctoon_align(x) __attribute__((aligned(x)))
279# elif CTOON_CPP_VER >= 201103L
280# define ctoon_align(x) alignas(x)
281# else
282# define ctoon_align(x)
283# endif
284#endif
285
287#ifndef ctoon_likely
288# if ctoon_has_builtin(__builtin_expect) || \
289 (CTOON_GCC_VER >= 4 && CTOON_GCC_VER != 5)
290# define ctoon_likely(expr) __builtin_expect(!!(expr), 1)
291# else
292# define ctoon_likely(expr) (expr)
293# endif
294#endif
295
297#ifndef ctoon_unlikely
298# if ctoon_has_builtin(__builtin_expect) || \
299 (CTOON_GCC_VER >= 4 && CTOON_GCC_VER != 5)
300# define ctoon_unlikely(expr) __builtin_expect(!!(expr), 0)
301# else
302# define ctoon_unlikely(expr) (expr)
303# endif
304#endif
305
307#ifndef ctoon_constant_p
308# if ctoon_has_builtin(__builtin_constant_p) || (CTOON_GCC_VER >= 3)
309# define CTOON_HAS_CONSTANT_P 1
310# define ctoon_constant_p(value) __builtin_constant_p(value)
311# else
312# define CTOON_HAS_CONSTANT_P 0
313# define ctoon_constant_p(value) 0
314# endif
315#endif
316
318#ifndef ctoon_deprecated
319# if CTOON_MSC_VER >= 1400
320# define ctoon_deprecated(msg) __declspec(deprecated(msg))
321# elif ctoon_has_feature(attribute_deprecated_with_message) || \
322 (CTOON_GCC_VER > 4 || (CTOON_GCC_VER == 4 && __GNUC_MINOR__ >= 5))
323# define ctoon_deprecated(msg) __attribute__((deprecated(msg)))
324# elif CTOON_GCC_VER >= 3
325# define ctoon_deprecated(msg) __attribute__((deprecated))
326# else
327# define ctoon_deprecated(msg)
328# endif
329#endif
330
332#ifndef ctoon_api
333# if defined(_WIN32)
334# if defined(CTOON_EXPORTS) && CTOON_EXPORTS
335# define ctoon_api __declspec(dllexport)
336# elif defined(CTOON_IMPORTS) && CTOON_IMPORTS
337# define ctoon_api __declspec(dllimport)
338# else
339# define ctoon_api
340# endif
341# elif ctoon_has_attribute(visibility) || CTOON_GCC_VER >= 4
342# define ctoon_api __attribute__((visibility("default")))
343# else
344# define ctoon_api
345# endif
346#endif
347
349#ifndef ctoon_api_inline
350# define ctoon_api_inline static ctoon_inline
351#endif
352
354#if (defined(CTOON_HAS_STDINT_H) && CTOON_HAS_STDINT_H) || \
355 CTOON_MSC_VER >= 1600 || CTOON_STDC_VER >= 199901L || \
356 defined(_STDINT_H) || defined(_STDINT_H_) || \
357 defined(__CLANG_STDINT_H) || defined(_STDINT_H_INCLUDED) || \
358 ctoon_has_include(<stdint.h>)
359# include <stdint.h>
360#elif defined(_MSC_VER)
361# if _MSC_VER < 1300
362 typedef signed char int8_t;
363 typedef signed short int16_t;
364 typedef signed int int32_t;
365 typedef unsigned char uint8_t;
366 typedef unsigned short uint16_t;
367 typedef unsigned int uint32_t;
368 typedef signed __int64 int64_t;
369 typedef unsigned __int64 uint64_t;
370# else
371 typedef signed __int8 int8_t;
372 typedef signed __int16 int16_t;
373 typedef signed __int32 int32_t;
374 typedef unsigned __int8 uint8_t;
375 typedef unsigned __int16 uint16_t;
376 typedef unsigned __int32 uint32_t;
377 typedef signed __int64 int64_t;
378 typedef unsigned __int64 uint64_t;
379# endif
380#else
381# if UCHAR_MAX == 0xFFU
382 typedef signed char int8_t;
383 typedef unsigned char uint8_t;
384# else
385# error cannot find 8-bit integer type
386# endif
387# if USHRT_MAX == 0xFFFFU
388 typedef unsigned short uint16_t;
389 typedef signed short int16_t;
390# elif UINT_MAX == 0xFFFFU
391 typedef unsigned int uint16_t;
392 typedef signed int int16_t;
393# else
394# error cannot find 16-bit integer type
395# endif
396# if UINT_MAX == 0xFFFFFFFFUL
397 typedef unsigned int uint32_t;
398 typedef signed int int32_t;
399# elif ULONG_MAX == 0xFFFFFFFFUL
400 typedef unsigned long uint32_t;
401 typedef signed long int32_t;
402# elif USHRT_MAX == 0xFFFFFFFFUL
403 typedef unsigned short uint32_t;
404 typedef signed short int32_t;
405# else
406# error cannot find 32-bit integer type
407# endif
408# if defined(__INT64_TYPE__) && defined(__UINT64_TYPE__)
409 typedef __INT64_TYPE__ int64_t;
410 typedef __UINT64_TYPE__ uint64_t;
411# elif defined(__GNUC__) || defined(__clang__)
412# if !defined(_SYS_TYPES_H) && !defined(__int8_t_defined)
413 __extension__ typedef long long int64_t;
414# endif
415 __extension__ typedef unsigned long long uint64_t;
416# elif defined(_LONG_LONG) || defined(__MWERKS__) || defined(_CRAYC) || \
417 defined(__SUNPRO_C) || defined(__SUNPRO_CC)
418 typedef long long int64_t;
419 typedef unsigned long long uint64_t;
420# elif (defined(__BORLANDC__) && __BORLANDC__ > 0x460) || \
421 defined(__WATCOM_INT64__) || defined (__alpha) || defined (__DECC)
422 typedef __int64 int64_t;
423 typedef unsigned __int64 uint64_t;
424# else
425# error cannot find 64-bit integer type
426# endif
427#endif
428
430#if (defined(CTOON_HAS_STDBOOL_H) && CTOON_HAS_STDBOOL_H) || \
431 CTOON_MSC_VER >= 1800 || CTOON_STDC_VER >= 199901L || \
432 (ctoon_has_include(<stdbool.h>) && !defined(__STRICT_ANSI__))
433# include <stdbool.h>
434#elif !defined(__bool_true_false_are_defined)
435# define __bool_true_false_are_defined 1
436# if defined(__cplusplus)
437# if defined(__GNUC__) && !defined(__STRICT_ANSI__)
438# define _Bool bool
439# if __cplusplus < 201103L
440# define bool bool
441# define false false
442# define true true
443# endif
444# endif
445# else
446# define bool unsigned char
447# define true 1
448# define false 0
449# endif
450#endif
451
453#if defined(CHAR_BIT)
454# if CHAR_BIT != 8
455# error non 8-bit char is not supported
456# endif
457#endif
458
463#ifndef CTOON_U64_TO_F64_NO_IMPL
464# if (0 < CTOON_MSC_VER) && (CTOON_MSC_VER <= 1200)
465# define CTOON_U64_TO_F64_NO_IMPL 1
466# else
467# define CTOON_U64_TO_F64_NO_IMPL 0
468# endif
469#endif
470
471
472
473/*==============================================================================
474 * MARK: - Compile Hint Begin
475 *============================================================================*/
476
477/* extern "C" begin */
478#ifdef __cplusplus
479extern "C" {
480#endif
481
482/*==============================================================================
483 * MARK: - Version
484 *============================================================================*/
485
487#define CTOON_VERSION_MAJOR 0
488
490#define CTOON_VERSION_MINOR 6
491
493#define CTOON_VERSION_PATCH 1
494
495#define CTOON_VERSION_ENCODE(maj,min,pat) (((maj)*10000)+((min)*100)+(pat))
496#define CTOON_VERSION \
497 CTOON_VERSION_ENCODE(CTOON_VERSION_MAJOR,CTOON_VERSION_MINOR,CTOON_VERSION_PATCH)
498
500#define CTOON_VERSION_HEX \
501 ((CTOON_VERSION_MAJOR << 16) | (CTOON_VERSION_MINOR << 8) | CTOON_VERSION_PATCH)
502
503/* Internal helpers for CTOON_VERSION_STRING */
504#define _CTOON_VERSION_XSTR(a,b,c) #a"."#b"."#c
505#define _CTOON_VERSION_STR(a,b,c) _CTOON_VERSION_XSTR(a,b,c)
506
508#define CTOON_VERSION_STRING \
509 _CTOON_VERSION_STR(CTOON_VERSION_MAJOR,CTOON_VERSION_MINOR,CTOON_VERSION_PATCH)
510
512ctoon_api uint32_t ctoon_version(void);
513
514
515
516/*==============================================================================
517 * MARK: - TOON Types
518 *============================================================================*/
519
521typedef uint8_t ctoon_type;
523#define CTOON_TYPE_NONE ((uint8_t)0) /* _____000 */
525#define CTOON_TYPE_RAW ((uint8_t)1) /* _____001 */
527#define CTOON_TYPE_NULL ((uint8_t)2) /* _____010 */
529#define CTOON_TYPE_BOOL ((uint8_t)3) /* _____011 */
531#define CTOON_TYPE_NUM ((uint8_t)4) /* _____100 */
533#define CTOON_TYPE_STR ((uint8_t)5) /* _____101 */
535#define CTOON_TYPE_ARR ((uint8_t)6) /* _____110 */
537#define CTOON_TYPE_OBJ ((uint8_t)7) /* _____111 */
538
540typedef uint8_t ctoon_subtype;
542#define CTOON_SUBTYPE_NONE ((uint8_t)(0 << 3)) /* ___00___ */
544#define CTOON_SUBTYPE_FALSE ((uint8_t)(0 << 3)) /* ___00___ */
546#define CTOON_SUBTYPE_TRUE ((uint8_t)(1 << 3)) /* ___01___ */
548#define CTOON_SUBTYPE_UINT ((uint8_t)(0 << 3)) /* ___00___ */
550#define CTOON_SUBTYPE_SINT ((uint8_t)(1 << 3)) /* ___01___ */
552#define CTOON_SUBTYPE_REAL ((uint8_t)(2 << 3)) /* ___10___ */
554#define CTOON_SUBTYPE_NOESC ((uint8_t)(1 << 3)) /* ___01___ */
555
557#define CTOON_TYPE_MASK ((uint8_t)0x07) /* _____111 */
559#define CTOON_TYPE_BIT ((uint8_t)3)
561#define CTOON_SUBTYPE_MASK ((uint8_t)0x18) /* ___11___ */
563#define CTOON_SUBTYPE_BIT ((uint8_t)2)
565#define CTOON_RESERVED_MASK ((uint8_t)0xE0) /* 111_____ */
567#define CTOON_RESERVED_BIT ((uint8_t)3)
569#define CTOON_TAG_MASK ((uint8_t)0xFF) /* 11111111 */
571#define CTOON_TAG_BIT ((uint8_t)8)
572
574#define CTOON_PADDING_SIZE 4
575
576
577
578/*==============================================================================
579 * MARK: - Allocator
580 *============================================================================*/
581
588typedef struct ctoon_alc {
590 void *(*malloc)(void *ctx, size_t size);
592 void *(*realloc)(void *ctx, void *ptr, size_t old_size, size_t size);
594 void (*free)(void *ctx, void *ptr);
596 void *ctx;
597} ctoon_alc;
598
638ctoon_api bool ctoon_alc_pool_init(ctoon_alc *alc, void *buf, size_t size);
639
652ctoon_api ctoon_alc *ctoon_alc_dyn_new(void);
653
658ctoon_api void ctoon_alc_dyn_free(ctoon_alc *alc);
659
660
661
662/*==============================================================================
663 * MARK: - Text Locating
664 *============================================================================*/
665
681ctoon_api bool ctoon_locate_pos(const char *str, size_t len, size_t pos,
682 size_t *line, size_t *col, size_t *chr);
683
684
685
686/*==============================================================================
687 * MARK: - TOON Structure
688 *============================================================================*/
689
695typedef struct ctoon_doc ctoon_doc;
696
702typedef struct ctoon_val ctoon_val;
703
709typedef struct ctoon_mut_doc ctoon_mut_doc;
710
716typedef struct ctoon_mut_val ctoon_mut_val;
717
718
719
720/*==============================================================================
721 * MARK: - TOON Reader API
722 *============================================================================*/
723
725typedef uint32_t ctoon_read_flag;
726
735static const ctoon_read_flag CTOON_READ_NOFLAG = 0;
736
743static const ctoon_read_flag CTOON_READ_INSITU = 1 << 0;
744
748static const ctoon_read_flag CTOON_READ_STOP_WHEN_DONE = 1 << 1;
749
752static const ctoon_read_flag CTOON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
753
755static const ctoon_read_flag CTOON_READ_ALLOW_COMMENTS = 1 << 3;
756
759static const ctoon_read_flag CTOON_READ_ALLOW_INF_AND_NAN = 1 << 4;
760
763static const ctoon_read_flag CTOON_READ_NUMBER_AS_RAW = 1 << 5;
764
773static const ctoon_read_flag CTOON_READ_ALLOW_INVALID_UNICODE = 1 << 6;
774
779static const ctoon_read_flag CTOON_READ_BIGNUM_AS_RAW = 1 << 7;
780
782static const ctoon_read_flag CTOON_READ_ALLOW_BOM = 1 << 8;
783
788static const ctoon_read_flag CTOON_READ_ALLOW_EXT_NUMBER = 1 << 9;
789
797static const ctoon_read_flag CTOON_READ_ALLOW_EXT_ESCAPE = 1 << 10;
798
805static const ctoon_read_flag CTOON_READ_ALLOW_EXT_WHITESPACE = 1 << 11;
806
808static const ctoon_read_flag CTOON_READ_ALLOW_SINGLE_QUOTED_STR = 1 << 12;
809
813static const ctoon_read_flag CTOON_READ_ALLOW_UNQUOTED_KEY = 1 << 13;
814
820static const ctoon_read_flag CTOON_READ_TOON5 =
821 (1 << 2) | /* CTOON_READ_ALLOW_TRAILING_COMMAS */
822 (1 << 3) | /* CTOON_READ_ALLOW_COMMENTS */
823 (1 << 4) | /* CTOON_READ_ALLOW_INF_AND_NAN */
824 (1 << 9) | /* CTOON_READ_ALLOW_EXT_NUMBER */
825 (1 << 10) | /* CTOON_READ_ALLOW_EXT_ESCAPE */
826 (1 << 11) | /* CTOON_READ_ALLOW_EXT_WHITESPACE */
827 (1 << 12) | /* CTOON_READ_ALLOW_SINGLE_QUOTED_STR */
828 (1 << 13); /* CTOON_READ_ALLOW_UNQUOTED_KEY */
829
830
831
833typedef uint32_t ctoon_read_code;
834
836static const ctoon_read_code CTOON_READ_SUCCESS = 0;
837
839static const ctoon_read_code CTOON_READ_ERROR_INVALID_PARAMETER = 1;
840
842static const ctoon_read_code CTOON_READ_ERROR_MEMORY_ALLOCATION = 2;
843
845static const ctoon_read_code CTOON_READ_ERROR_EMPTY_CONTENT = 3;
846
848static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CONTENT = 4;
849
851static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_END = 5;
852
854static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CHARACTER = 6;
855
857static const ctoon_read_code CTOON_READ_ERROR_TOON_STRUCTURE = 7;
858
860static const ctoon_read_code CTOON_READ_ERROR_INVALID_COMMENT = 8;
861
863static const ctoon_read_code CTOON_READ_ERROR_INVALID_NUMBER = 9;
864
866static const ctoon_read_code CTOON_READ_ERROR_INVALID_STRING = 10;
867
869static const ctoon_read_code CTOON_READ_ERROR_LITERAL = 11;
870
872static const ctoon_read_code CTOON_READ_ERROR_FILE_OPEN = 12;
873
875static const ctoon_read_code CTOON_READ_ERROR_FILE_READ = 13;
876
878static const ctoon_read_code CTOON_READ_ERROR_MORE = 14;
879
881static const ctoon_read_code CTOON_READ_ERROR_DEPTH = 15;
882
892
893
894
895#if !defined(CTOON_DISABLE_READER) || !CTOON_DISABLE_READER
896
920ctoon_api ctoon_doc *ctoon_read_opts(char *dat,
921 size_t len,
922 ctoon_read_flag flg,
923 const ctoon_alc *alc,
924 ctoon_read_err *err);
925
954ctoon_api ctoon_doc *ctoon_read_opts_indent(char *dat,
955 size_t len,
956 ctoon_read_flag flg,
957 int indent_size,
958 const ctoon_alc *alc,
959 ctoon_read_err *err);
960
982ctoon_api ctoon_doc *ctoon_read_file(const char *path,
983 ctoon_read_flag flg,
984 const ctoon_alc *alc,
985 ctoon_read_err *err);
986
1004ctoon_api ctoon_doc *ctoon_read_fp(FILE *fp,
1005 ctoon_read_flag flg,
1006 const ctoon_alc *alc,
1007 ctoon_read_err *err);
1008
1023ctoon_api_inline ctoon_doc *ctoon_read(const char *dat,
1024 size_t len,
1025 ctoon_read_flag flg) {
1026 flg &= ~CTOON_READ_INSITU; /* const string cannot be modified */
1027 return ctoon_read_opts((char *)(void *)(size_t)(const void *)dat,
1028 len, flg, NULL, NULL);
1029}
1030
1031
1032
1033#if !defined(CTOON_DISABLE_INCR_READER) || !CTOON_DISABLE_INCR_READER
1034
1036typedef struct ctoon_incr_state ctoon_incr_state;
1037
1061ctoon_api ctoon_incr_state *ctoon_incr_new(char *buf, size_t buf_len,
1062 ctoon_read_flag flg,
1063 const ctoon_alc *alc);
1064
1085ctoon_api ctoon_doc *ctoon_incr_read(ctoon_incr_state *state, size_t len,
1086 ctoon_read_err *err);
1087
1089ctoon_api void ctoon_incr_free(ctoon_incr_state *state);
1090
1091#endif /* CTOON_DISABLE_INCR_READER */
1092
1130ctoon_api_inline size_t ctoon_read_max_memory_usage(size_t len,
1131 ctoon_read_flag flg) {
1132 /*
1133 1. The max value count is (json_size / 2 + 1),
1134 for example: "[1,2,3,4]" size is 9, value count is 5.
1135 2. Some broken TOON may cost more memory during reading, but fail at end,
1136 for example: "[[[[[[[[".
1137 3. ctoon use 16 bytes per value, see struct ctoon_val.
1138 4. ctoon use dynamic memory with a growth factor of 1.5.
1139
1140 The max memory size is (json_size / 2 * 16 * 1.5 + padding).
1141 */
1142 size_t mul = (size_t)12 + !(flg & CTOON_READ_INSITU);
1143 size_t pad = 256;
1144 size_t max = (size_t)(~(size_t)0);
1145 if (flg & CTOON_READ_STOP_WHEN_DONE) len = len < 256 ? 256 : len;
1146 if (len >= (max - pad - mul) / mul) return 0;
1147 return len * mul + pad;
1148}
1149
1171ctoon_api const char *ctoon_read_number(const char *dat,
1172 ctoon_val *val,
1173 ctoon_read_flag flg,
1174 const ctoon_alc *alc,
1175 ctoon_read_err *err);
1176
1178ctoon_api_inline const char *ctoon_mut_read_number(const char *dat,
1179 ctoon_mut_val *val,
1180 ctoon_read_flag flg,
1181 const ctoon_alc *alc,
1182 ctoon_read_err *err) {
1183 return ctoon_read_number(dat, (ctoon_val *)val, flg, alc, err);
1184}
1185
1186#endif /* CTOON_DISABLE_READER */
1187
1188
1189
1190/*==============================================================================
1191 * MARK: - TOON Writer API
1192 *============================================================================*/
1193
1195typedef uint32_t ctoon_write_flag;
1196
1198static const ctoon_write_flag CTOON_WRITE_NOFLAG = 0;
1199
1201static const ctoon_write_flag CTOON_WRITE_ESCAPE_UNICODE = 1 << 1;
1202
1204static const ctoon_write_flag CTOON_WRITE_ESCAPE_SLASHES = 1 << 2;
1205
1207static const ctoon_write_flag CTOON_WRITE_ALLOW_INF_AND_NAN = 1 << 3;
1208
1210static const ctoon_write_flag CTOON_WRITE_INF_AND_NAN_AS_NULL = 1 << 4;
1211
1213static const ctoon_write_flag CTOON_WRITE_ALLOW_INVALID_UNICODE = 1 << 5;
1214
1216static const ctoon_write_flag CTOON_WRITE_LENGTH_MARKER = 1 << 6;
1217
1219static const ctoon_write_flag CTOON_WRITE_NEWLINE_AT_END = 1 << 7;
1220
1225#define CTOON_WRITE_FP_FLAG_BITS 8
1226#define CTOON_WRITE_FP_PREC_BITS 4
1227
1229#define CTOON_WRITE_FP_TO_FIXED(prec) ((ctoon_write_flag)( \
1230 (uint32_t)((uint32_t)(prec)) << (32 - 4) ))
1231
1233#define CTOON_WRITE_FP_TO_FLOAT ((ctoon_write_flag)(1 << (32 - 5)))
1234
1235
1242
1244typedef uint32_t ctoon_write_code;
1245static const ctoon_write_code CTOON_WRITE_SUCCESS = 0;
1246static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_PARAMETER = 1;
1247static const ctoon_write_code CTOON_WRITE_ERROR_MEMORY_ALLOCATION = 2;
1248static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_VALUE_TYPE = 3;
1249static const ctoon_write_code CTOON_WRITE_ERROR_NAN_OR_INF = 4;
1250static const ctoon_write_code CTOON_WRITE_ERROR_FILE_OPEN = 5;
1251static const ctoon_write_code CTOON_WRITE_ERROR_FILE_WRITE = 6;
1252static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_STRING = 7;
1253
1259
1266
1267
1268#if !defined(CTOON_DISABLE_WRITER) || !CTOON_DISABLE_WRITER
1269
1280ctoon_api char *ctoon_write_opts(const ctoon_doc *doc,
1281 const ctoon_write_options *opts,
1282 const ctoon_alc *alc,
1283 size_t *len,
1284 ctoon_write_err *err);
1285
1287ctoon_api_inline char *ctoon_write(const ctoon_doc *doc, size_t *len) {
1288 return ctoon_write_opts(doc, NULL, NULL, len, NULL);
1289}
1290
1292ctoon_api bool ctoon_write_file(const char *path,
1293 const ctoon_doc *doc,
1294 const ctoon_write_options *opts,
1295 const ctoon_alc *alc,
1296 ctoon_write_err *err);
1297
1299ctoon_api bool ctoon_write_fp(FILE *fp,
1300 const ctoon_doc *doc,
1301 const ctoon_write_options *opts,
1302 const ctoon_alc *alc,
1303 ctoon_write_err *err);
1304
1306ctoon_api char *ctoon_val_write_opts(const ctoon_val *val,
1307 const ctoon_write_options *opts,
1308 const ctoon_alc *alc,
1309 size_t *len,
1310 ctoon_write_err *err);
1311
1312ctoon_api_inline char *ctoon_val_write(const ctoon_val *val, size_t *len) {
1313 return ctoon_val_write_opts(val, NULL, NULL, len, NULL);
1314}
1315
1317ctoon_api char *ctoon_mut_write_opts(const ctoon_mut_doc *doc,
1318 const ctoon_write_options *opts,
1319 const ctoon_alc *alc,
1320 size_t *len,
1321 ctoon_write_err *err);
1322
1323ctoon_api_inline char *ctoon_mut_write(const ctoon_mut_doc *doc, size_t *len) {
1324 return ctoon_mut_write_opts(doc, NULL, NULL, len, NULL);
1325}
1326
1327ctoon_api bool ctoon_mut_write_file(const char *path,
1328 const ctoon_mut_doc *doc,
1329 const ctoon_write_options *opts,
1330 const ctoon_alc *alc,
1331 ctoon_write_err *err);
1332
1333ctoon_api bool ctoon_mut_write_fp(FILE *fp,
1334 const ctoon_mut_doc *doc,
1335 const ctoon_write_options *opts,
1336 const ctoon_alc *alc,
1337 ctoon_write_err *err);
1338
1339ctoon_api char *ctoon_mut_val_write_opts(const ctoon_mut_val *val,
1340 const ctoon_write_options *opts,
1341 const ctoon_alc *alc,
1342 size_t *len,
1343 ctoon_write_err *err);
1344
1345ctoon_api_inline char *ctoon_mut_val_write(const ctoon_mut_val *val,
1346 size_t *len) {
1347 return ctoon_mut_val_write_opts(val, NULL, NULL, len, NULL);
1348}
1349
1351ctoon_api char *ctoon_write_number(const ctoon_val *val, char *buf);
1352
1372ctoon_api char *ctoon_doc_to_json(const ctoon_doc *doc,
1373 int indent,
1374 ctoon_write_flag flags,
1375 const ctoon_alc *alc,
1376 size_t *len,
1377 ctoon_write_err *err);
1378
1397ctoon_api char *ctoon_mut_doc_to_json(const ctoon_mut_doc *doc,
1398 int indent,
1399 ctoon_write_flag flags,
1400 const ctoon_alc *alc,
1401 size_t *len,
1402 ctoon_write_err *err);
1403
1404#endif /* CTOON_DISABLE_WRITER */
1405
1406
1407
1408/*==============================================================================
1409 * MARK: - JSON API
1410 *============================================================================*/
1411
1412#if defined(CTOON_ENABLE_JSON) && CTOON_ENABLE_JSON
1413
1430ctoon_api ctoon_doc *ctoon_read_json(char *dat, size_t len,
1431 ctoon_read_flag flg,
1432 const ctoon_alc *alc,
1433 ctoon_read_err *err);
1434
1436ctoon_api ctoon_doc *ctoon_read_json_file(const char *path,
1437 ctoon_read_flag flg,
1438 const ctoon_alc *alc,
1439 ctoon_read_err *err);
1440
1442ctoon_api ctoon_doc *ctoon_read_json_fp(FILE *fp,
1443 ctoon_read_flag flg,
1444 const ctoon_alc *alc,
1445 ctoon_read_err *err);
1446
1460ctoon_api char *ctoon_write_json(const ctoon_doc *doc,
1461 int indent,
1462 ctoon_write_flag flg,
1463 const ctoon_alc *alc,
1464 size_t *len,
1465 ctoon_write_err *err);
1466
1468ctoon_api char *ctoon_write_json_mut(const ctoon_mut_doc *doc,
1469 int indent,
1470 ctoon_write_flag flg,
1471 const ctoon_alc *alc,
1472 size_t *len,
1473 ctoon_write_err *err);
1474
1475#endif /* CTOON_ENABLE_JSON */
1476
1477
1478
1479/*==============================================================================
1480 * MARK: - TOON Document API
1481 *============================================================================*/
1482
1485ctoon_api_inline ctoon_val *ctoon_doc_get_root(ctoon_doc *doc);
1486
1490ctoon_api_inline size_t ctoon_doc_get_read_size(ctoon_doc *doc);
1491
1495ctoon_api_inline size_t ctoon_doc_get_val_count(ctoon_doc *doc);
1496
1500ctoon_api_inline void ctoon_doc_free(ctoon_doc *doc);
1501
1502
1503
1504/*==============================================================================
1505 * MARK: - TOON Value Type API
1506 *============================================================================*/
1507
1510ctoon_api_inline bool ctoon_is_raw(ctoon_val *val);
1511
1514ctoon_api_inline bool ctoon_is_null(ctoon_val *val);
1515
1518ctoon_api_inline bool ctoon_is_true(ctoon_val *val);
1519
1522ctoon_api_inline bool ctoon_is_false(ctoon_val *val);
1523
1526ctoon_api_inline bool ctoon_is_bool(ctoon_val *val);
1527
1530ctoon_api_inline bool ctoon_is_uint(ctoon_val *val);
1531
1534ctoon_api_inline bool ctoon_is_sint(ctoon_val *val);
1535
1538ctoon_api_inline bool ctoon_is_int(ctoon_val *val);
1539
1542ctoon_api_inline bool ctoon_is_real(ctoon_val *val);
1543
1546ctoon_api_inline bool ctoon_is_num(ctoon_val *val);
1547
1550ctoon_api_inline bool ctoon_is_str(ctoon_val *val);
1551
1554ctoon_api_inline bool ctoon_is_arr(ctoon_val *val);
1555
1558ctoon_api_inline bool ctoon_is_obj(ctoon_val *val);
1559
1562ctoon_api_inline bool ctoon_is_ctn(ctoon_val *val);
1563
1564
1565
1566/*==============================================================================
1567 * MARK: - TOON Value Content API
1568 *============================================================================*/
1569
1572ctoon_api_inline ctoon_type ctoon_get_type(ctoon_val *val);
1573
1576ctoon_api_inline ctoon_subtype ctoon_get_subtype(ctoon_val *val);
1577
1580ctoon_api_inline uint8_t ctoon_get_tag(ctoon_val *val);
1581
1585ctoon_api_inline const char *ctoon_get_type_desc(ctoon_val *val);
1586
1589ctoon_api_inline const char *ctoon_get_raw(ctoon_val *val);
1590
1593ctoon_api_inline bool ctoon_get_bool(ctoon_val *val);
1594
1597ctoon_api_inline uint64_t ctoon_get_uint(ctoon_val *val);
1598
1601ctoon_api_inline int64_t ctoon_get_sint(ctoon_val *val);
1602
1605ctoon_api_inline int ctoon_get_int(ctoon_val *val);
1606
1609ctoon_api_inline double ctoon_get_real(ctoon_val *val);
1610
1613ctoon_api_inline double ctoon_get_num(ctoon_val *val);
1614
1617ctoon_api_inline const char *ctoon_get_str(ctoon_val *val);
1618
1621ctoon_api_inline size_t ctoon_get_len(ctoon_val *val);
1622
1625ctoon_api_inline bool ctoon_equals_str(ctoon_val *val, const char *str);
1626
1630ctoon_api_inline bool ctoon_equals_strn(ctoon_val *val, const char *str,
1631 size_t len);
1632
1638ctoon_api_inline bool ctoon_equals(ctoon_val *lhs, ctoon_val *rhs);
1639
1643ctoon_api_inline bool ctoon_set_raw(ctoon_val *val,
1644 const char *raw, size_t len);
1645
1649ctoon_api_inline bool ctoon_set_null(ctoon_val *val);
1650
1654ctoon_api_inline bool ctoon_set_bool(ctoon_val *val, bool num);
1655
1659ctoon_api_inline bool ctoon_set_uint(ctoon_val *val, uint64_t num);
1660
1664ctoon_api_inline bool ctoon_set_sint(ctoon_val *val, int64_t num);
1665
1669ctoon_api_inline bool ctoon_set_int(ctoon_val *val, int num);
1670
1674ctoon_api_inline bool ctoon_set_float(ctoon_val *val, float num);
1675
1679ctoon_api_inline bool ctoon_set_double(ctoon_val *val, double num);
1680
1684ctoon_api_inline bool ctoon_set_real(ctoon_val *val, double num);
1685
1690ctoon_api_inline bool ctoon_set_fp_to_fixed(ctoon_val *val, int prec);
1691
1696ctoon_api_inline bool ctoon_set_fp_to_float(ctoon_val *val, bool flt);
1697
1701ctoon_api_inline bool ctoon_set_str(ctoon_val *val, const char *str);
1702
1706ctoon_api_inline bool ctoon_set_strn(ctoon_val *val,
1707 const char *str, size_t len);
1708
1715ctoon_api_inline bool ctoon_set_str_noesc(ctoon_val *val, bool noesc);
1716
1717
1718
1719/*==============================================================================
1720 * MARK: - TOON Array API
1721 *============================================================================*/
1722
1725ctoon_api_inline size_t ctoon_arr_size(ctoon_val *arr);
1726
1731ctoon_api_inline ctoon_val *ctoon_arr_get(ctoon_val *arr, size_t idx);
1732
1735ctoon_api_inline ctoon_val *ctoon_arr_get_first(ctoon_val *arr);
1736
1741ctoon_api_inline ctoon_val *ctoon_arr_get_last(ctoon_val *arr);
1742
1743
1744
1745/*==============================================================================
1746 * MARK: - TOON Array Iterator API
1747 *============================================================================*/
1748
1766
1778ctoon_api_inline bool ctoon_arr_iter_init(ctoon_val *arr,
1779 ctoon_arr_iter *iter);
1780
1790ctoon_api_inline ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr);
1791
1796ctoon_api_inline bool ctoon_arr_iter_has_next(ctoon_arr_iter *iter);
1797
1802ctoon_api_inline ctoon_val *ctoon_arr_iter_next(ctoon_arr_iter *iter);
1803
1817#define ctoon_arr_foreach(arr, idx, max, val) \
1818 for ((idx) = 0, \
1819 (max) = ctoon_arr_size(arr), \
1820 (val) = ctoon_arr_get_first(arr); \
1821 (idx) < (max); \
1822 (idx)++, \
1823 (val) = unsafe_ctoon_get_next(val))
1824
1825
1826
1827/*==============================================================================
1828 * MARK: - TOON Object API
1829 *============================================================================*/
1830
1833ctoon_api_inline size_t ctoon_obj_size(ctoon_val *obj);
1834
1842ctoon_api_inline ctoon_val *ctoon_obj_get(ctoon_val *obj, const char *key);
1843
1852ctoon_api_inline ctoon_val *ctoon_obj_getn(ctoon_val *obj, const char *key,
1853 size_t key_len);
1854
1855
1856
1857/*==============================================================================
1858 * MARK: - TOON Object Iterator API
1859 *============================================================================*/
1860
1891
1903ctoon_api_inline bool ctoon_obj_iter_init(ctoon_val *obj,
1904 ctoon_obj_iter *iter);
1905
1915ctoon_api_inline ctoon_obj_iter ctoon_obj_iter_with(ctoon_val *obj);
1916
1921ctoon_api_inline bool ctoon_obj_iter_has_next(ctoon_obj_iter *iter);
1922
1927ctoon_api_inline ctoon_val *ctoon_obj_iter_next(ctoon_obj_iter *iter);
1928
1933ctoon_api_inline ctoon_val *ctoon_obj_iter_get_val(ctoon_val *key);
1934
1951ctoon_api_inline ctoon_val *ctoon_obj_iter_get(ctoon_obj_iter *iter,
1952 const char *key);
1953
1971ctoon_api_inline ctoon_val *ctoon_obj_iter_getn(ctoon_obj_iter *iter,
1972 const char *key,
1973 size_t key_len);
1974
1988#define ctoon_obj_foreach(obj, idx, max, key, val) \
1989 for ((idx) = 0, \
1990 (max) = ctoon_obj_size(obj), \
1991 (key) = (obj) ? unsafe_ctoon_get_first(obj) : NULL, \
1992 (val) = (key) + 1; \
1993 (idx) < (max); \
1994 (idx)++, \
1995 (key) = unsafe_ctoon_get_next(val), \
1996 (val) = (key) + 1)
1997
1998
1999
2000/*==============================================================================
2001 * MARK: - Mutable TOON Document API
2002 *============================================================================*/
2003
2006ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_root(ctoon_mut_doc *doc);
2007
2010ctoon_api_inline void ctoon_mut_doc_set_root(ctoon_mut_doc *doc,
2011 ctoon_mut_val *root);
2012
2026ctoon_api bool ctoon_mut_doc_set_str_pool_size(ctoon_mut_doc *doc,
2027 size_t len);
2028
2042ctoon_api bool ctoon_mut_doc_set_val_pool_size(ctoon_mut_doc *doc,
2043 size_t count);
2044
2048ctoon_api void ctoon_mut_doc_free(ctoon_mut_doc *doc);
2049
2052ctoon_api ctoon_mut_doc *ctoon_mut_doc_new(const ctoon_alc *alc);
2053
2058ctoon_api ctoon_mut_doc *ctoon_doc_mut_copy(ctoon_doc *doc,
2059 const ctoon_alc *alc);
2060
2065ctoon_api ctoon_mut_doc *ctoon_mut_doc_mut_copy(ctoon_mut_doc *doc,
2066 const ctoon_alc *alc);
2067
2072ctoon_api ctoon_mut_val *ctoon_val_mut_copy(ctoon_mut_doc *doc,
2073 ctoon_val *val);
2074
2081ctoon_api ctoon_mut_val *ctoon_mut_val_mut_copy(ctoon_mut_doc *doc,
2082 ctoon_mut_val *val);
2083
2090ctoon_api ctoon_doc *ctoon_mut_doc_imut_copy(ctoon_mut_doc *doc,
2091 const ctoon_alc *alc);
2092
2099ctoon_api ctoon_doc *ctoon_mut_val_imut_copy(ctoon_mut_val *val,
2100 const ctoon_alc *alc);
2101
2102
2103
2104/*==============================================================================
2105 * MARK: - Mutable TOON Value Type API
2106 *============================================================================*/
2107
2110ctoon_api_inline bool ctoon_mut_is_raw(ctoon_mut_val *val);
2111
2114ctoon_api_inline bool ctoon_mut_is_null(ctoon_mut_val *val);
2115
2118ctoon_api_inline bool ctoon_mut_is_true(ctoon_mut_val *val);
2119
2122ctoon_api_inline bool ctoon_mut_is_false(ctoon_mut_val *val);
2123
2126ctoon_api_inline bool ctoon_mut_is_bool(ctoon_mut_val *val);
2127
2130ctoon_api_inline bool ctoon_mut_is_uint(ctoon_mut_val *val);
2131
2134ctoon_api_inline bool ctoon_mut_is_sint(ctoon_mut_val *val);
2135
2138ctoon_api_inline bool ctoon_mut_is_int(ctoon_mut_val *val);
2139
2142ctoon_api_inline bool ctoon_mut_is_real(ctoon_mut_val *val);
2143
2146ctoon_api_inline bool ctoon_mut_is_num(ctoon_mut_val *val);
2147
2150ctoon_api_inline bool ctoon_mut_is_str(ctoon_mut_val *val);
2151
2154ctoon_api_inline bool ctoon_mut_is_arr(ctoon_mut_val *val);
2155
2158ctoon_api_inline bool ctoon_mut_is_obj(ctoon_mut_val *val);
2159
2162ctoon_api_inline bool ctoon_mut_is_ctn(ctoon_mut_val *val);
2163
2164
2165
2166/*==============================================================================
2167 * MARK: - Mutable TOON Value Content API
2168 *============================================================================*/
2169
2172ctoon_api_inline ctoon_type ctoon_mut_get_type(ctoon_mut_val *val);
2173
2176ctoon_api_inline ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val);
2177
2180ctoon_api_inline uint8_t ctoon_mut_get_tag(ctoon_mut_val *val);
2181
2185ctoon_api_inline const char *ctoon_mut_get_type_desc(ctoon_mut_val *val);
2186
2189ctoon_api_inline const char *ctoon_mut_get_raw(ctoon_mut_val *val);
2190
2193ctoon_api_inline bool ctoon_mut_get_bool(ctoon_mut_val *val);
2194
2197ctoon_api_inline uint64_t ctoon_mut_get_uint(ctoon_mut_val *val);
2198
2201ctoon_api_inline int64_t ctoon_mut_get_sint(ctoon_mut_val *val);
2202
2205ctoon_api_inline int ctoon_mut_get_int(ctoon_mut_val *val);
2206
2209ctoon_api_inline double ctoon_mut_get_real(ctoon_mut_val *val);
2210
2213ctoon_api_inline double ctoon_mut_get_num(ctoon_mut_val *val);
2214
2217ctoon_api_inline const char *ctoon_mut_get_str(ctoon_mut_val *val);
2218
2221ctoon_api_inline size_t ctoon_mut_get_len(ctoon_mut_val *val);
2222
2226ctoon_api_inline bool ctoon_mut_equals_str(ctoon_mut_val *val,
2227 const char *str);
2228
2232ctoon_api_inline bool ctoon_mut_equals_strn(ctoon_mut_val *val,
2233 const char *str, size_t len);
2234
2240ctoon_api_inline bool ctoon_mut_equals(ctoon_mut_val *lhs,
2241 ctoon_mut_val *rhs);
2242
2246ctoon_api_inline bool ctoon_mut_set_raw(ctoon_mut_val *val,
2247 const char *raw, size_t len);
2248
2252ctoon_api_inline bool ctoon_mut_set_null(ctoon_mut_val *val);
2253
2257ctoon_api_inline bool ctoon_mut_set_bool(ctoon_mut_val *val, bool num);
2258
2262ctoon_api_inline bool ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num);
2263
2267ctoon_api_inline bool ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num);
2268
2272ctoon_api_inline bool ctoon_mut_set_int(ctoon_mut_val *val, int num);
2273
2277ctoon_api_inline bool ctoon_mut_set_float(ctoon_mut_val *val, float num);
2278
2282ctoon_api_inline bool ctoon_mut_set_double(ctoon_mut_val *val, double num);
2283
2287ctoon_api_inline bool ctoon_mut_set_real(ctoon_mut_val *val, double num);
2288
2293ctoon_api_inline bool ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val,
2294 int prec);
2295
2300ctoon_api_inline bool ctoon_mut_set_fp_to_float(ctoon_mut_val *val,
2301 bool flt);
2302
2306ctoon_api_inline bool ctoon_mut_set_str(ctoon_mut_val *val, const char *str);
2307
2311ctoon_api_inline bool ctoon_mut_set_strn(ctoon_mut_val *val,
2312 const char *str, size_t len);
2313
2320ctoon_api_inline bool ctoon_mut_set_str_noesc(ctoon_mut_val *val,
2321 bool noesc);
2322
2326ctoon_api_inline bool ctoon_mut_set_arr(ctoon_mut_val *val);
2327
2331ctoon_api_inline bool ctoon_mut_set_obj(ctoon_mut_val *val);
2332
2333
2334
2335/*==============================================================================
2336 * MARK: - Mutable TOON Value Creation API
2337 *============================================================================*/
2338
2344ctoon_api_inline ctoon_mut_val *ctoon_mut_raw(ctoon_mut_doc *doc,
2345 const char *str);
2346
2352ctoon_api_inline ctoon_mut_val *ctoon_mut_rawn(ctoon_mut_doc *doc,
2353 const char *str,
2354 size_t len);
2355
2359ctoon_api_inline ctoon_mut_val *ctoon_mut_rawcpy(ctoon_mut_doc *doc,
2360 const char *str);
2361
2365ctoon_api_inline ctoon_mut_val *ctoon_mut_rawncpy(ctoon_mut_doc *doc,
2366 const char *str,
2367 size_t len);
2368
2370ctoon_api_inline ctoon_mut_val *ctoon_mut_null(ctoon_mut_doc *doc);
2371
2373ctoon_api_inline ctoon_mut_val *ctoon_mut_true(ctoon_mut_doc *doc);
2374
2376ctoon_api_inline ctoon_mut_val *ctoon_mut_false(ctoon_mut_doc *doc);
2377
2379ctoon_api_inline ctoon_mut_val *ctoon_mut_bool(ctoon_mut_doc *doc,
2380 bool val);
2381
2383ctoon_api_inline ctoon_mut_val *ctoon_mut_uint(ctoon_mut_doc *doc,
2384 uint64_t num);
2385
2387ctoon_api_inline ctoon_mut_val *ctoon_mut_sint(ctoon_mut_doc *doc,
2388 int64_t num);
2389
2391ctoon_api_inline ctoon_mut_val *ctoon_mut_int(ctoon_mut_doc *doc,
2392 int64_t num);
2393
2395ctoon_api_inline ctoon_mut_val *ctoon_mut_float(ctoon_mut_doc *doc,
2396 float num);
2397
2399ctoon_api_inline ctoon_mut_val *ctoon_mut_double(ctoon_mut_doc *doc,
2400 double num);
2401
2403ctoon_api_inline ctoon_mut_val *ctoon_mut_real(ctoon_mut_doc *doc,
2404 double num);
2405
2410ctoon_api_inline ctoon_mut_val *ctoon_mut_str(ctoon_mut_doc *doc,
2411 const char *str);
2412
2417ctoon_api_inline ctoon_mut_val *ctoon_mut_strn(ctoon_mut_doc *doc,
2418 const char *str,
2419 size_t len);
2420
2424ctoon_api_inline ctoon_mut_val *ctoon_mut_strcpy(ctoon_mut_doc *doc,
2425 const char *str);
2426
2430ctoon_api_inline ctoon_mut_val *ctoon_mut_strncpy(ctoon_mut_doc *doc,
2431 const char *str,
2432 size_t len);
2433
2434
2435
2436/*==============================================================================
2437 * MARK: - Mutable TOON Array API
2438 *============================================================================*/
2439
2442ctoon_api_inline size_t ctoon_mut_arr_size(ctoon_mut_val *arr);
2443
2447ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get(ctoon_mut_val *arr,
2448 size_t idx);
2449
2452ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_first(ctoon_mut_val *arr);
2453
2456ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_last(ctoon_mut_val *arr);
2457
2458
2459
2460/*==============================================================================
2461 * MARK: - Mutable TOON Array Iterator API
2462 *============================================================================*/
2463
2489
2501ctoon_api_inline bool ctoon_mut_arr_iter_init(ctoon_mut_val *arr,
2502 ctoon_mut_arr_iter *iter);
2503
2513ctoon_api_inline ctoon_mut_arr_iter ctoon_mut_arr_iter_with(
2514 ctoon_mut_val *arr);
2515
2520ctoon_api_inline bool ctoon_mut_arr_iter_has_next(
2521 ctoon_mut_arr_iter *iter);
2522
2527ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_next(
2528 ctoon_mut_arr_iter *iter);
2529
2534ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_remove(
2535 ctoon_mut_arr_iter *iter);
2536
2552#define ctoon_mut_arr_foreach(arr, idx, max, val) \
2553 for ((idx) = 0, \
2554 (max) = ctoon_mut_arr_size(arr), \
2555 (val) = ctoon_mut_arr_get_first(arr); \
2556 (idx) < (max); \
2557 (idx)++, \
2558 (val) = (val)->next)
2559
2560
2561
2562/*==============================================================================
2563 * MARK: - Mutable TOON Array Creation API
2564 *============================================================================*/
2565
2571ctoon_api_inline ctoon_mut_val *ctoon_mut_arr(ctoon_mut_doc *doc);
2572
2588ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_bool(
2589 ctoon_mut_doc *doc, const bool *vals, size_t count);
2590
2606ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint(
2607 ctoon_mut_doc *doc, const int64_t *vals, size_t count);
2608
2624ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint(
2625 ctoon_mut_doc *doc, const uint64_t *vals, size_t count);
2626
2642ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_real(
2643 ctoon_mut_doc *doc, const double *vals, size_t count);
2644
2660ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint8(
2661 ctoon_mut_doc *doc, const int8_t *vals, size_t count);
2662
2678ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint16(
2679 ctoon_mut_doc *doc, const int16_t *vals, size_t count);
2680
2696ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint32(
2697 ctoon_mut_doc *doc, const int32_t *vals, size_t count);
2698
2714ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint64(
2715 ctoon_mut_doc *doc, const int64_t *vals, size_t count);
2716
2732ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint8(
2733 ctoon_mut_doc *doc, const uint8_t *vals, size_t count);
2734
2750ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint16(
2751 ctoon_mut_doc *doc, const uint16_t *vals, size_t count);
2752
2768ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint32(
2769 ctoon_mut_doc *doc, const uint32_t *vals, size_t count);
2770
2786ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint64(
2787 ctoon_mut_doc *doc, const uint64_t *vals, size_t count);
2788
2804ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_float(
2805 ctoon_mut_doc *doc, const float *vals, size_t count);
2806
2822ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_double(
2823 ctoon_mut_doc *doc, const double *vals, size_t count);
2824
2847ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_str(
2848 ctoon_mut_doc *doc, const char **vals, size_t count);
2849
2874ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strn(
2875 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
2876
2895ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strcpy(
2896 ctoon_mut_doc *doc, const char **vals, size_t count);
2897
2918ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strncpy(
2919 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count);
2920
2921
2922
2923/*==============================================================================
2924 * MARK: - Mutable TOON Array Modification API
2925 *============================================================================*/
2926
2937ctoon_api_inline bool ctoon_mut_arr_insert(ctoon_mut_val *arr,
2938 ctoon_mut_val *val, size_t idx);
2939
2947ctoon_api_inline bool ctoon_mut_arr_append(ctoon_mut_val *arr,
2948 ctoon_mut_val *val);
2949
2957ctoon_api_inline bool ctoon_mut_arr_prepend(ctoon_mut_val *arr,
2958 ctoon_mut_val *val);
2959
2970ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_replace(ctoon_mut_val *arr,
2971 size_t idx,
2972 ctoon_mut_val *val);
2973
2983ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove(ctoon_mut_val *arr,
2984 size_t idx);
2985
2992ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_first(
2993 ctoon_mut_val *arr);
2994
3001ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_last(
3002 ctoon_mut_val *arr);
3003
3013ctoon_api_inline bool ctoon_mut_arr_remove_range(ctoon_mut_val *arr,
3014 size_t idx, size_t len);
3015
3022ctoon_api_inline bool ctoon_mut_arr_clear(ctoon_mut_val *arr);
3023
3031ctoon_api_inline bool ctoon_mut_arr_rotate(ctoon_mut_val *arr,
3032 size_t idx);
3033
3034
3035
3036/*==============================================================================
3037 * MARK: - Mutable TOON Array Modification Convenience API
3038 *============================================================================*/
3039
3047ctoon_api_inline bool ctoon_mut_arr_add_val(ctoon_mut_val *arr,
3048 ctoon_mut_val *val);
3049
3057ctoon_api_inline bool ctoon_mut_arr_add_null(ctoon_mut_doc *doc,
3058 ctoon_mut_val *arr);
3059
3067ctoon_api_inline bool ctoon_mut_arr_add_true(ctoon_mut_doc *doc,
3068 ctoon_mut_val *arr);
3069
3077ctoon_api_inline bool ctoon_mut_arr_add_false(ctoon_mut_doc *doc,
3078 ctoon_mut_val *arr);
3079
3088ctoon_api_inline bool ctoon_mut_arr_add_bool(ctoon_mut_doc *doc,
3089 ctoon_mut_val *arr,
3090 bool val);
3091
3100ctoon_api_inline bool ctoon_mut_arr_add_uint(ctoon_mut_doc *doc,
3101 ctoon_mut_val *arr,
3102 uint64_t num);
3103
3112ctoon_api_inline bool ctoon_mut_arr_add_sint(ctoon_mut_doc *doc,
3113 ctoon_mut_val *arr,
3114 int64_t num);
3115
3124ctoon_api_inline bool ctoon_mut_arr_add_int(ctoon_mut_doc *doc,
3125 ctoon_mut_val *arr,
3126 int64_t num);
3127
3136ctoon_api_inline bool ctoon_mut_arr_add_float(ctoon_mut_doc *doc,
3137 ctoon_mut_val *arr,
3138 float num);
3139
3148ctoon_api_inline bool ctoon_mut_arr_add_double(ctoon_mut_doc *doc,
3149 ctoon_mut_val *arr,
3150 double num);
3151
3160ctoon_api_inline bool ctoon_mut_arr_add_real(ctoon_mut_doc *doc,
3161 ctoon_mut_val *arr,
3162 double num);
3163
3174ctoon_api_inline bool ctoon_mut_arr_add_str(ctoon_mut_doc *doc,
3175 ctoon_mut_val *arr,
3176 const char *str);
3177
3189ctoon_api_inline bool ctoon_mut_arr_add_strn(ctoon_mut_doc *doc,
3190 ctoon_mut_val *arr,
3191 const char *str,
3192 size_t len);
3193
3202ctoon_api_inline bool ctoon_mut_arr_add_strcpy(ctoon_mut_doc *doc,
3203 ctoon_mut_val *arr,
3204 const char *str);
3205
3215ctoon_api_inline bool ctoon_mut_arr_add_strncpy(ctoon_mut_doc *doc,
3216 ctoon_mut_val *arr,
3217 const char *str,
3218 size_t len);
3219
3227ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_arr(ctoon_mut_doc *doc,
3228 ctoon_mut_val *arr);
3229
3237ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_obj(ctoon_mut_doc *doc,
3238 ctoon_mut_val *arr);
3239
3240
3241
3242/*==============================================================================
3243 * MARK: - Mutable TOON Object API
3244 *============================================================================*/
3245
3248ctoon_api_inline size_t ctoon_mut_obj_size(ctoon_mut_val *obj);
3249
3257ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_get(ctoon_mut_val *obj,
3258 const char *key);
3259
3268ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_getn(ctoon_mut_val *obj,
3269 const char *key,
3270 size_t key_len);
3271
3272
3273
3274/*==============================================================================
3275 * MARK: - Mutable TOON Object Iterator API
3276 *============================================================================*/
3277
3315
3327ctoon_api_inline bool ctoon_mut_obj_iter_init(ctoon_mut_val *obj,
3328 ctoon_mut_obj_iter *iter);
3329
3339ctoon_api_inline ctoon_mut_obj_iter ctoon_mut_obj_iter_with(
3340 ctoon_mut_val *obj);
3341
3346ctoon_api_inline bool ctoon_mut_obj_iter_has_next(
3347 ctoon_mut_obj_iter *iter);
3348
3353ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_next(
3354 ctoon_mut_obj_iter *iter);
3355
3360ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get_val(
3361 ctoon_mut_val *key);
3362
3367ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_remove(
3368 ctoon_mut_obj_iter *iter);
3369
3386ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get(
3387 ctoon_mut_obj_iter *iter, const char *key);
3388
3406ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_getn(
3407 ctoon_mut_obj_iter *iter, const char *key, size_t key_len);
3408
3424#define ctoon_mut_obj_foreach(obj, idx, max, key, val) \
3425 for ((idx) = 0, \
3426 (max) = ctoon_mut_obj_size(obj), \
3427 (key) = (max) ? ((ctoon_mut_val *)(obj)->uni.ptr)->next->next : NULL, \
3428 (val) = (key) ? (key)->next : NULL; \
3429 (idx) < (max); \
3430 (idx)++, \
3431 (key) = (val)->next, \
3432 (val) = (key)->next)
3433
3434
3435
3436/*==============================================================================
3437 * MARK: - Mutable TOON Object Creation API
3438 *============================================================================*/
3439
3441ctoon_api_inline ctoon_mut_val *ctoon_mut_obj(ctoon_mut_doc *doc);
3442
3458ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_str(ctoon_mut_doc *doc,
3459 const char **keys,
3460 const char **vals,
3461 size_t count);
3462
3477ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_kv(ctoon_mut_doc *doc,
3478 const char **kv_pairs,
3479 size_t pair_count);
3480
3481
3482
3483/*==============================================================================
3484 * MARK: - Mutable TOON Object Modification API
3485 *============================================================================*/
3486
3496ctoon_api_inline bool ctoon_mut_obj_add(ctoon_mut_val *obj,
3497 ctoon_mut_val *key,
3498 ctoon_mut_val *val);
3509ctoon_api_inline bool ctoon_mut_obj_put(ctoon_mut_val *obj,
3510 ctoon_mut_val *key,
3511 ctoon_mut_val *val);
3512
3523ctoon_api_inline bool ctoon_mut_obj_insert(ctoon_mut_val *obj,
3524 ctoon_mut_val *key,
3525 ctoon_mut_val *val,
3526 size_t idx);
3527
3535ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove(ctoon_mut_val *obj,
3536 ctoon_mut_val *key);
3537
3545ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_key(
3546 ctoon_mut_val *obj, const char *key);
3547
3556ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_keyn(
3557 ctoon_mut_val *obj, const char *key, size_t key_len);
3558
3564ctoon_api_inline bool ctoon_mut_obj_clear(ctoon_mut_val *obj);
3565
3575ctoon_api_inline bool ctoon_mut_obj_replace(ctoon_mut_val *obj,
3576 ctoon_mut_val *key,
3577 ctoon_mut_val *val);
3578
3588ctoon_api_inline bool ctoon_mut_obj_rotate(ctoon_mut_val *obj,
3589 size_t idx);
3590
3591
3592
3593/*==============================================================================
3594 * MARK: - Mutable TOON Object Modification Convenience API
3595 *============================================================================*/
3596
3603ctoon_api_inline bool ctoon_mut_obj_add_null(ctoon_mut_doc *doc,
3604 ctoon_mut_val *obj,
3605 const char *key);
3606
3613ctoon_api_inline bool ctoon_mut_obj_add_true(ctoon_mut_doc *doc,
3614 ctoon_mut_val *obj,
3615 const char *key);
3616
3623ctoon_api_inline bool ctoon_mut_obj_add_false(ctoon_mut_doc *doc,
3624 ctoon_mut_val *obj,
3625 const char *key);
3626
3633ctoon_api_inline bool ctoon_mut_obj_add_bool(ctoon_mut_doc *doc,
3634 ctoon_mut_val *obj,
3635 const char *key, bool val);
3636
3643ctoon_api_inline bool ctoon_mut_obj_add_uint(ctoon_mut_doc *doc,
3644 ctoon_mut_val *obj,
3645 const char *key, uint64_t val);
3646
3653ctoon_api_inline bool ctoon_mut_obj_add_sint(ctoon_mut_doc *doc,
3654 ctoon_mut_val *obj,
3655 const char *key, int64_t val);
3656
3663ctoon_api_inline bool ctoon_mut_obj_add_int(ctoon_mut_doc *doc,
3664 ctoon_mut_val *obj,
3665 const char *key, int64_t val);
3666
3673ctoon_api_inline bool ctoon_mut_obj_add_float(ctoon_mut_doc *doc,
3674 ctoon_mut_val *obj,
3675 const char *key, float val);
3676
3683ctoon_api_inline bool ctoon_mut_obj_add_double(ctoon_mut_doc *doc,
3684 ctoon_mut_val *obj,
3685 const char *key, double val);
3686
3693ctoon_api_inline bool ctoon_mut_obj_add_real(ctoon_mut_doc *doc,
3694 ctoon_mut_val *obj,
3695 const char *key, double val);
3696
3703ctoon_api_inline bool ctoon_mut_obj_add_str(ctoon_mut_doc *doc,
3704 ctoon_mut_val *obj,
3705 const char *key, const char *val);
3706
3715ctoon_api_inline bool ctoon_mut_obj_add_strn(ctoon_mut_doc *doc,
3716 ctoon_mut_val *obj,
3717 const char *key,
3718 const char *val, size_t len);
3719
3727ctoon_api_inline bool ctoon_mut_obj_add_strcpy(ctoon_mut_doc *doc,
3728 ctoon_mut_val *obj,
3729 const char *key,
3730 const char *val);
3731
3740ctoon_api_inline bool ctoon_mut_obj_add_strncpy(ctoon_mut_doc *doc,
3741 ctoon_mut_val *obj,
3742 const char *key,
3743 const char *val, size_t len);
3744
3754ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_arr(ctoon_mut_doc *doc,
3755 ctoon_mut_val *obj,
3756 const char *key);
3757
3767ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_obj(ctoon_mut_doc *doc,
3768 ctoon_mut_val *obj,
3769 const char *key);
3770
3777ctoon_api_inline bool ctoon_mut_obj_add_val(ctoon_mut_doc *doc,
3778 ctoon_mut_val *obj,
3779 const char *key,
3780 ctoon_mut_val *val);
3781
3788ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_str(
3789 ctoon_mut_val *obj, const char *key);
3790
3798ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_strn(
3799 ctoon_mut_val *obj, const char *key, size_t len);
3800
3809ctoon_api_inline bool ctoon_mut_obj_rename_key(ctoon_mut_doc *doc,
3810 ctoon_mut_val *obj,
3811 const char *key,
3812 const char *new_key);
3813
3822ctoon_api_inline bool ctoon_mut_obj_rename_keyn(ctoon_mut_doc *doc,
3823 ctoon_mut_val *obj,
3824 const char *key,
3825 size_t len,
3826 const char *new_key,
3827 size_t new_len);
3828
3829
3830
3831#if !defined(CTOON_DISABLE_UTILS) || !CTOON_DISABLE_UTILS
3832
3833/*==============================================================================
3834 * MARK: - TOON Pointer API (RFC 6901)
3835 * https://tools.ietf.org/html/rfc6901
3836 *============================================================================*/
3837
3839typedef uint32_t ctoon_ptr_code;
3840
3842static const ctoon_ptr_code CTOON_PTR_ERR_NONE = 0;
3843
3845static const ctoon_ptr_code CTOON_PTR_ERR_PARAMETER = 1;
3846
3848static const ctoon_ptr_code CTOON_PTR_ERR_SYNTAX = 2;
3849
3851static const ctoon_ptr_code CTOON_PTR_ERR_RESOLVE = 3;
3852
3854static const ctoon_ptr_code CTOON_PTR_ERR_NULL_ROOT = 4;
3855
3857static const ctoon_ptr_code CTOON_PTR_ERR_SET_ROOT = 5;
3858
3860static const ctoon_ptr_code CTOON_PTR_ERR_MEMORY_ALLOCATION = 6;
3861
3871
3915
3923ctoon_api_inline ctoon_val *ctoon_doc_ptr_get(ctoon_doc *doc,
3924 const char *ptr);
3925
3934ctoon_api_inline ctoon_val *ctoon_doc_ptr_getn(ctoon_doc *doc,
3935 const char *ptr, size_t len);
3936
3946ctoon_api_inline ctoon_val *ctoon_doc_ptr_getx(ctoon_doc *doc,
3947 const char *ptr, size_t len,
3948 ctoon_ptr_err *err);
3949
3957ctoon_api_inline ctoon_val *ctoon_ptr_get(ctoon_val *val,
3958 const char *ptr);
3959
3968ctoon_api_inline ctoon_val *ctoon_ptr_getn(ctoon_val *val,
3969 const char *ptr, size_t len);
3970
3980ctoon_api_inline ctoon_val *ctoon_ptr_getx(ctoon_val *val,
3981 const char *ptr, size_t len,
3982 ctoon_ptr_err *err);
3983
3991ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_get(ctoon_mut_doc *doc,
3992 const char *ptr);
3993
4002ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getn(ctoon_mut_doc *doc,
4003 const char *ptr,
4004 size_t len);
4005
4016ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getx(ctoon_mut_doc *doc,
4017 const char *ptr,
4018 size_t len,
4019 ctoon_ptr_ctx *ctx,
4020 ctoon_ptr_err *err);
4021
4029ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_get(ctoon_mut_val *val,
4030 const char *ptr);
4031
4040ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getn(ctoon_mut_val *val,
4041 const char *ptr,
4042 size_t len);
4043
4054ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getx(ctoon_mut_val *val,
4055 const char *ptr,
4056 size_t len,
4057 ctoon_ptr_ctx *ctx,
4058 ctoon_ptr_err *err);
4059
4068ctoon_api_inline bool ctoon_mut_doc_ptr_add(ctoon_mut_doc *doc,
4069 const char *ptr,
4070 ctoon_mut_val *new_val);
4071
4081ctoon_api_inline bool ctoon_mut_doc_ptr_addn(ctoon_mut_doc *doc,
4082 const char *ptr, size_t len,
4083 ctoon_mut_val *new_val);
4084
4096ctoon_api_inline bool ctoon_mut_doc_ptr_addx(ctoon_mut_doc *doc,
4097 const char *ptr, size_t len,
4098 ctoon_mut_val *new_val,
4099 bool create_parent,
4100 ctoon_ptr_ctx *ctx,
4101 ctoon_ptr_err *err);
4102
4112ctoon_api_inline bool ctoon_mut_ptr_add(ctoon_mut_val *val,
4113 const char *ptr,
4114 ctoon_mut_val *new_val,
4115 ctoon_mut_doc *doc);
4116
4127ctoon_api_inline bool ctoon_mut_ptr_addn(ctoon_mut_val *val,
4128 const char *ptr, size_t len,
4129 ctoon_mut_val *new_val,
4130 ctoon_mut_doc *doc);
4131
4144ctoon_api_inline bool ctoon_mut_ptr_addx(ctoon_mut_val *val,
4145 const char *ptr, size_t len,
4146 ctoon_mut_val *new_val,
4147 ctoon_mut_doc *doc,
4148 bool create_parent,
4149 ctoon_ptr_ctx *ctx,
4150 ctoon_ptr_err *err);
4151
4161ctoon_api_inline bool ctoon_mut_doc_ptr_set(ctoon_mut_doc *doc,
4162 const char *ptr,
4163 ctoon_mut_val *new_val);
4164
4175ctoon_api_inline bool ctoon_mut_doc_ptr_setn(ctoon_mut_doc *doc,
4176 const char *ptr, size_t len,
4177 ctoon_mut_val *new_val);
4178
4191ctoon_api_inline bool ctoon_mut_doc_ptr_setx(ctoon_mut_doc *doc,
4192 const char *ptr, size_t len,
4193 ctoon_mut_val *new_val,
4194 bool create_parent,
4195 ctoon_ptr_ctx *ctx,
4196 ctoon_ptr_err *err);
4197
4208ctoon_api_inline bool ctoon_mut_ptr_set(ctoon_mut_val *val,
4209 const char *ptr,
4210 ctoon_mut_val *new_val,
4211 ctoon_mut_doc *doc);
4212
4224ctoon_api_inline bool ctoon_mut_ptr_setn(ctoon_mut_val *val,
4225 const char *ptr, size_t len,
4226 ctoon_mut_val *new_val,
4227 ctoon_mut_doc *doc);
4228
4242ctoon_api_inline bool ctoon_mut_ptr_setx(ctoon_mut_val *val,
4243 const char *ptr, size_t len,
4244 ctoon_mut_val *new_val,
4245 ctoon_mut_doc *doc,
4246 bool create_parent,
4247 ctoon_ptr_ctx *ctx,
4248 ctoon_ptr_err *err);
4249
4257ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replace(
4258 ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val);
4259
4268ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacen(
4269 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val);
4270
4281ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacex(
4282 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val,
4283 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4284
4292ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replace(
4293 ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val);
4294
4303ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacen(
4304 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val);
4305
4316ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacex(
4317 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
4318 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4319
4326ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_remove(
4327 ctoon_mut_doc *doc, const char *ptr);
4328
4336ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removen(
4337 ctoon_mut_doc *doc, const char *ptr, size_t len);
4338
4348ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removex(
4349 ctoon_mut_doc *doc, const char *ptr, size_t len,
4350 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
4351
4358ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_remove(ctoon_mut_val *val,
4359 const char *ptr);
4360
4368ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removen(ctoon_mut_val *val,
4369 const char *ptr,
4370 size_t len);
4371
4381ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removex(ctoon_mut_val *val,
4382 const char *ptr,
4383 size_t len,
4384 ctoon_ptr_ctx *ctx,
4385 ctoon_ptr_err *err);
4386
4394ctoon_api_inline bool ctoon_ptr_ctx_append(ctoon_ptr_ctx *ctx,
4395 ctoon_mut_val *key,
4396 ctoon_mut_val *val);
4397
4405ctoon_api_inline bool ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx,
4406 ctoon_mut_val *val);
4407
4414ctoon_api_inline bool ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx);
4415
4416
4417
4418/*==============================================================================
4419 * MARK: - TOON Patch API (RFC 6902)
4420 * https://tools.ietf.org/html/rfc6902
4421 *============================================================================*/
4422
4424typedef uint32_t ctoon_patch_code;
4425
4427static const ctoon_patch_code CTOON_PATCH_SUCCESS = 0;
4428
4430static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_PARAMETER = 1;
4431
4433static const ctoon_patch_code CTOON_PATCH_ERROR_MEMORY_ALLOCATION = 2;
4434
4436static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_OPERATION = 3;
4437
4439static const ctoon_patch_code CTOON_PATCH_ERROR_MISSING_KEY = 4;
4440
4442static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_MEMBER = 5;
4443
4445static const ctoon_patch_code CTOON_PATCH_ERROR_EQUAL = 6;
4446
4448static const ctoon_patch_code CTOON_PATCH_ERROR_POINTER = 7;
4449
4461
4468ctoon_api ctoon_mut_val *ctoon_patch(ctoon_mut_doc *doc,
4469 ctoon_val *orig,
4470 ctoon_val *patch,
4471 ctoon_patch_err *err);
4472
4479ctoon_api ctoon_mut_val *ctoon_mut_patch(ctoon_mut_doc *doc,
4480 ctoon_mut_val *orig,
4481 ctoon_mut_val *patch,
4482 ctoon_patch_err *err);
4483
4484
4485
4486/*==============================================================================
4487 * MARK: - TOON Merge-Patch API (RFC 7386)
4488 * https://tools.ietf.org/html/rfc7386
4489 *============================================================================*/
4490
4499ctoon_api ctoon_mut_val *ctoon_merge_patch(ctoon_mut_doc *doc,
4500 ctoon_val *orig,
4501 ctoon_val *patch);
4502
4511ctoon_api ctoon_mut_val *ctoon_mut_merge_patch(ctoon_mut_doc *doc,
4512 ctoon_mut_val *orig,
4513 ctoon_mut_val *patch);
4514
4515#endif /* CTOON_DISABLE_UTILS */
4516
4517
4518
4519/*==============================================================================
4520 * MARK: - TOON Structure (Implementation)
4521 *============================================================================*/
4522
4524typedef union ctoon_val_uni {
4525 uint64_t u64;
4526 int64_t i64;
4527 double f64;
4528 const char *str;
4529 void *ptr;
4530 size_t ofs;
4531} ctoon_val_uni;
4532
4536struct ctoon_val {
4537 uint64_t tag;
4538 ctoon_val_uni uni;
4539};
4540
4553
4554
4555
4556/*==============================================================================
4557 * MARK: - Unsafe TOON Value API (Implementation)
4558 *============================================================================*/
4559
4560/*
4561 Whether the string does not need to be escaped for serialization.
4562 This function is used to optimize the writing speed of small constant strings.
4563 This function works only if the compiler can evaluate it at compile time.
4564
4565 Clang supports it since v8.0,
4566 earlier versions do not support constant_p(strlen) and return false.
4567 GCC supports it since at least v4.4,
4568 earlier versions may compile it as run-time instructions.
4569 ICC supports it since at least v16,
4570 earlier versions are uncertain.
4571
4572 @param str The C string.
4573 @param len The returnd value from strlen(str).
4574 */
4575ctoon_api_inline bool unsafe_ctoon_is_str_noesc(const char *str, size_t len) {
4576#if CTOON_HAS_CONSTANT_P && \
4577 (!CTOON_IS_REAL_GCC || ctoon_gcc_available(4, 4, 0))
4578 if (ctoon_constant_p(len) && len <= 32) {
4579 /*
4580 Same as the following loop:
4581
4582 for (size_t i = 0; i < len; i++) {
4583 char c = str[i];
4584 if (c < ' ' || c > '~' || c == '"' || c == '\\') return false;
4585 }
4586
4587 GCC evaluates it at compile time only if the string length is within 17
4588 and -O3 (which turns on the -fpeel-loops flag) is used.
4589 So the loop is unrolled for GCC.
4590 */
4591# define ctoon_repeat32_incr(x) \
4592 x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) \
4593 x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) \
4594 x(16) x(17) x(18) x(19) x(20) x(21) x(22) x(23) \
4595 x(24) x(25) x(26) x(27) x(28) x(29) x(30) x(31)
4596# define ctoon_check_char_noesc(i) \
4597 if (i < len) { \
4598 char c = str[i]; \
4599 if (c < ' ' || c > '~' || c == '"' || c == '\\') return false; }
4600 ctoon_repeat32_incr(ctoon_check_char_noesc)
4601# undef ctoon_repeat32_incr
4602# undef ctoon_check_char_noesc
4603 return true;
4604 }
4605#else
4606 (void)str;
4607 (void)len;
4608#endif
4609 return false;
4610}
4611
4612ctoon_api_inline double unsafe_ctoon_u64_to_f64(uint64_t num) {
4613#if CTOON_U64_TO_F64_NO_IMPL
4614 uint64_t msb = ((uint64_t)1) << 63;
4615 if ((num & msb) == 0) {
4616 return (double)(int64_t)num;
4617 } else {
4618 return ((double)(int64_t)((num >> 1) | (num & 1))) * (double)2.0;
4619 }
4620#else
4621 return (double)num;
4622#endif
4623}
4624
4625ctoon_api_inline ctoon_type unsafe_ctoon_get_type(void *val) {
4626 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4627 return (ctoon_type)(tag & CTOON_TYPE_MASK);
4628}
4629
4630ctoon_api_inline ctoon_subtype unsafe_ctoon_get_subtype(void *val) {
4631 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4632 return (ctoon_subtype)(tag & CTOON_SUBTYPE_MASK);
4633}
4634
4635ctoon_api_inline uint8_t unsafe_ctoon_get_tag(void *val) {
4636 uint8_t tag = (uint8_t)((ctoon_val *)val)->tag;
4637 return (uint8_t)(tag & CTOON_TAG_MASK);
4638}
4639
4640ctoon_api_inline bool unsafe_ctoon_is_raw(void *val) {
4641 return unsafe_ctoon_get_type(val) == CTOON_TYPE_RAW;
4642}
4643
4644ctoon_api_inline bool unsafe_ctoon_is_null(void *val) {
4645 return unsafe_ctoon_get_type(val) == CTOON_TYPE_NULL;
4646}
4647
4648ctoon_api_inline bool unsafe_ctoon_is_bool(void *val) {
4649 return unsafe_ctoon_get_type(val) == CTOON_TYPE_BOOL;
4650}
4651
4652ctoon_api_inline bool unsafe_ctoon_is_num(void *val) {
4653 return unsafe_ctoon_get_type(val) == CTOON_TYPE_NUM;
4654}
4655
4656ctoon_api_inline bool unsafe_ctoon_is_str(void *val) {
4657 return unsafe_ctoon_get_type(val) == CTOON_TYPE_STR;
4658}
4659
4660ctoon_api_inline bool unsafe_ctoon_is_arr(void *val) {
4661 return unsafe_ctoon_get_type(val) == CTOON_TYPE_ARR;
4662}
4663
4664ctoon_api_inline bool unsafe_ctoon_is_obj(void *val) {
4665 return unsafe_ctoon_get_type(val) == CTOON_TYPE_OBJ;
4666}
4667
4668ctoon_api_inline bool unsafe_ctoon_is_ctn(void *val) {
4669 uint8_t mask = CTOON_TYPE_ARR & CTOON_TYPE_OBJ;
4670 return (unsafe_ctoon_get_tag(val) & mask) == mask;
4671}
4672
4673ctoon_api_inline bool unsafe_ctoon_is_uint(void *val) {
4674 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT;
4675 return unsafe_ctoon_get_tag(val) == patt;
4676}
4677
4678ctoon_api_inline bool unsafe_ctoon_is_sint(void *val) {
4679 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT;
4680 return unsafe_ctoon_get_tag(val) == patt;
4681}
4682
4683ctoon_api_inline bool unsafe_ctoon_is_int(void *val) {
4684 const uint8_t mask = CTOON_TAG_MASK & (~CTOON_SUBTYPE_SINT);
4685 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT;
4686 return (unsafe_ctoon_get_tag(val) & mask) == patt;
4687}
4688
4689ctoon_api_inline bool unsafe_ctoon_is_real(void *val) {
4690 const uint8_t patt = CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL;
4691 return unsafe_ctoon_get_tag(val) == patt;
4692}
4693
4694ctoon_api_inline bool unsafe_ctoon_is_true(void *val) {
4695 const uint8_t patt = CTOON_TYPE_BOOL | CTOON_SUBTYPE_TRUE;
4696 return unsafe_ctoon_get_tag(val) == patt;
4697}
4698
4699ctoon_api_inline bool unsafe_ctoon_is_false(void *val) {
4700 const uint8_t patt = CTOON_TYPE_BOOL | CTOON_SUBTYPE_FALSE;
4701 return unsafe_ctoon_get_tag(val) == patt;
4702}
4703
4704ctoon_api_inline bool unsafe_ctoon_arr_is_flat(ctoon_val *val) {
4705 size_t ofs = val->uni.ofs;
4706 size_t len = (size_t)(val->tag >> CTOON_TAG_BIT);
4707 return len * sizeof(ctoon_val) + sizeof(ctoon_val) == ofs;
4708}
4709
4710ctoon_api_inline const char *unsafe_ctoon_get_raw(void *val) {
4711 return ((ctoon_val *)val)->uni.str;
4712}
4713
4714ctoon_api_inline bool unsafe_ctoon_get_bool(void *val) {
4715 uint8_t tag = unsafe_ctoon_get_tag(val);
4716 return (bool)((tag & CTOON_SUBTYPE_MASK) >> CTOON_TYPE_BIT);
4717}
4718
4719ctoon_api_inline uint64_t unsafe_ctoon_get_uint(void *val) {
4720 return ((ctoon_val *)val)->uni.u64;
4721}
4722
4723ctoon_api_inline int64_t unsafe_ctoon_get_sint(void *val) {
4724 return ((ctoon_val *)val)->uni.i64;
4725}
4726
4727ctoon_api_inline int unsafe_ctoon_get_int(void *val) {
4728 return (int)((ctoon_val *)val)->uni.i64;
4729}
4730
4731ctoon_api_inline double unsafe_ctoon_get_real(void *val) {
4732 return ((ctoon_val *)val)->uni.f64;
4733}
4734
4735ctoon_api_inline double unsafe_ctoon_get_num(void *val) {
4736 uint8_t tag = unsafe_ctoon_get_tag(val);
4737 if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL)) {
4738 return ((ctoon_val *)val)->uni.f64;
4739 } else if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT)) {
4740 return (double)((ctoon_val *)val)->uni.i64;
4741 } else if (tag == (CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT)) {
4742 return unsafe_ctoon_u64_to_f64(((ctoon_val *)val)->uni.u64);
4743 }
4744 return 0.0;
4745}
4746
4747ctoon_api_inline const char *unsafe_ctoon_get_str(void *val) {
4748 return ((ctoon_val *)val)->uni.str;
4749}
4750
4751ctoon_api_inline size_t unsafe_ctoon_get_len(void *val) {
4752 return (size_t)(((ctoon_val *)val)->tag >> CTOON_TAG_BIT);
4753}
4754
4755ctoon_api_inline ctoon_val *unsafe_ctoon_get_first(ctoon_val *ctn) {
4756 return ctn + 1;
4757}
4758
4759ctoon_api_inline ctoon_val *unsafe_ctoon_get_next(ctoon_val *val) {
4760 bool is_ctn = unsafe_ctoon_is_ctn(val);
4761 size_t ctn_ofs = val->uni.ofs;
4762 size_t ofs = (is_ctn ? ctn_ofs : sizeof(ctoon_val));
4763 return (ctoon_val *)(void *)((uint8_t *)val + ofs);
4764}
4765
4766ctoon_api_inline bool unsafe_ctoon_equals_strn(void *val, const char *str,
4767 size_t len) {
4768 return unsafe_ctoon_get_len(val) == len &&
4769 memcmp(((ctoon_val *)val)->uni.str, str, len) == 0;
4770}
4771
4772ctoon_api_inline bool unsafe_ctoon_equals_str(void *val, const char *str) {
4773 return unsafe_ctoon_equals_strn(val, str, strlen(str));
4774}
4775
4776ctoon_api_inline void unsafe_ctoon_set_type(void *val, ctoon_type type,
4777 ctoon_subtype subtype) {
4778 uint8_t tag = (type | subtype);
4779 uint64_t new_tag = ((ctoon_val *)val)->tag;
4780 new_tag = (new_tag & (~(uint64_t)CTOON_TAG_MASK)) | (uint64_t)tag;
4781 ((ctoon_val *)val)->tag = new_tag;
4782}
4783
4784ctoon_api_inline void unsafe_ctoon_set_len(void *val, size_t len) {
4785 uint64_t tag = ((ctoon_val *)val)->tag & CTOON_TAG_MASK;
4786 tag |= (uint64_t)len << CTOON_TAG_BIT;
4787 ((ctoon_val *)val)->tag = tag;
4788}
4789
4790ctoon_api_inline void unsafe_ctoon_set_tag(void *val, ctoon_type type,
4791 ctoon_subtype subtype,
4792 size_t len) {
4793 uint64_t tag = (uint64_t)len << CTOON_TAG_BIT;
4794 tag |= (type | subtype);
4795 ((ctoon_val *)val)->tag = tag;
4796}
4797
4798ctoon_api_inline void unsafe_ctoon_inc_len(void *val) {
4799 uint64_t tag = ((ctoon_val *)val)->tag;
4800 tag += (uint64_t)(1 << CTOON_TAG_BIT);
4801 ((ctoon_val *)val)->tag = tag;
4802}
4803
4804ctoon_api_inline void unsafe_ctoon_set_raw(void *val, const char *raw,
4805 size_t len) {
4806 unsafe_ctoon_set_tag(val, CTOON_TYPE_RAW, CTOON_SUBTYPE_NONE, len);
4807 ((ctoon_val *)val)->uni.str = raw;
4808}
4809
4810ctoon_api_inline void unsafe_ctoon_set_null(void *val) {
4811 unsafe_ctoon_set_tag(val, CTOON_TYPE_NULL, CTOON_SUBTYPE_NONE, 0);
4812}
4813
4814ctoon_api_inline void unsafe_ctoon_set_bool(void *val, bool num) {
4815 ctoon_subtype subtype = num ? CTOON_SUBTYPE_TRUE : CTOON_SUBTYPE_FALSE;
4816 unsafe_ctoon_set_tag(val, CTOON_TYPE_BOOL, subtype, 0);
4817}
4818
4819ctoon_api_inline void unsafe_ctoon_set_uint(void *val, uint64_t num) {
4820 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_UINT, 0);
4821 ((ctoon_val *)val)->uni.u64 = num;
4822}
4823
4824ctoon_api_inline void unsafe_ctoon_set_sint(void *val, int64_t num) {
4825 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_SINT, 0);
4826 ((ctoon_val *)val)->uni.i64 = num;
4827}
4828
4829ctoon_api_inline void unsafe_ctoon_set_fp_to_fixed(void *val, int prec) {
4830 ((ctoon_val *)val)->tag &= ~((uint64_t)CTOON_WRITE_FP_TO_FIXED(15) << 32);
4831 ((ctoon_val *)val)->tag |= (uint64_t)CTOON_WRITE_FP_TO_FIXED(prec) << 32;
4832}
4833
4834ctoon_api_inline void unsafe_ctoon_set_fp_to_float(void *val, bool flt) {
4835 uint64_t flag = (uint64_t)CTOON_WRITE_FP_TO_FLOAT << 32;
4836 if (flt) ((ctoon_val *)val)->tag |= flag;
4837 else ((ctoon_val *)val)->tag &= ~flag;
4838}
4839
4840ctoon_api_inline void unsafe_ctoon_set_float(void *val, float num) {
4841 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
4842 ((ctoon_val *)val)->tag |= (uint64_t)CTOON_WRITE_FP_TO_FLOAT << 32;
4843 ((ctoon_val *)val)->uni.f64 = (double)num;
4844}
4845
4846ctoon_api_inline void unsafe_ctoon_set_double(void *val, double num) {
4847 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
4848 ((ctoon_val *)val)->uni.f64 = num;
4849}
4850
4851ctoon_api_inline void unsafe_ctoon_set_real(void *val, double num) {
4852 unsafe_ctoon_set_tag(val, CTOON_TYPE_NUM, CTOON_SUBTYPE_REAL, 0);
4853 ((ctoon_val *)val)->uni.f64 = num;
4854}
4855
4856ctoon_api_inline void unsafe_ctoon_set_str_noesc(void *val, bool noesc) {
4857 ((ctoon_val *)val)->tag &= ~(uint64_t)CTOON_SUBTYPE_MASK;
4858 if (noesc) ((ctoon_val *)val)->tag |= (uint64_t)CTOON_SUBTYPE_NOESC;
4859}
4860
4861ctoon_api_inline void unsafe_ctoon_set_strn(void *val, const char *str,
4862 size_t len) {
4863 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, CTOON_SUBTYPE_NONE, len);
4864 ((ctoon_val *)val)->uni.str = str;
4865}
4866
4867ctoon_api_inline void unsafe_ctoon_set_str(void *val, const char *str) {
4868 size_t len = strlen(str);
4869 bool noesc = unsafe_ctoon_is_str_noesc(str, len);
4870 ctoon_subtype subtype = noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
4871 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, subtype, len);
4872 ((ctoon_val *)val)->uni.str = str;
4873}
4874
4875ctoon_api_inline void unsafe_ctoon_set_arr(void *val, size_t size) {
4876 unsafe_ctoon_set_tag(val, CTOON_TYPE_ARR, CTOON_SUBTYPE_NONE, size);
4877}
4878
4879ctoon_api_inline void unsafe_ctoon_set_obj(void *val, size_t size) {
4880 unsafe_ctoon_set_tag(val, CTOON_TYPE_OBJ, CTOON_SUBTYPE_NONE, size);
4881}
4882
4883
4884
4885/*==============================================================================
4886 * MARK: - TOON Document API (Implementation)
4887 *============================================================================*/
4888
4889ctoon_api_inline ctoon_val *ctoon_doc_get_root(ctoon_doc *doc) {
4890 return doc ? doc->root : NULL;
4891}
4892
4893ctoon_api_inline size_t ctoon_doc_get_read_size(ctoon_doc *doc) {
4894 return doc ? doc->dat_read : 0;
4895}
4896
4897ctoon_api_inline size_t ctoon_doc_get_val_count(ctoon_doc *doc) {
4898 return doc ? doc->val_read : 0;
4899}
4900
4901ctoon_api_inline void ctoon_doc_free(ctoon_doc *doc) {
4902 if (doc) {
4903 ctoon_alc alc = doc->alc;
4904 memset(&doc->alc, 0, sizeof(alc));
4905 if (doc->str_pool) alc.free(alc.ctx, doc->str_pool);
4906 alc.free(alc.ctx, doc);
4907 }
4908}
4909
4910
4911
4912/*==============================================================================
4913 * MARK: - TOON Value Type API (Implementation)
4914 *============================================================================*/
4915
4916ctoon_api_inline bool ctoon_is_raw(ctoon_val *val) {
4917 return val ? unsafe_ctoon_is_raw(val) : false;
4918}
4919
4920ctoon_api_inline bool ctoon_is_null(ctoon_val *val) {
4921 return val ? unsafe_ctoon_is_null(val) : false;
4922}
4923
4924ctoon_api_inline bool ctoon_is_true(ctoon_val *val) {
4925 return val ? unsafe_ctoon_is_true(val) : false;
4926}
4927
4928ctoon_api_inline bool ctoon_is_false(ctoon_val *val) {
4929 return val ? unsafe_ctoon_is_false(val) : false;
4930}
4931
4932ctoon_api_inline bool ctoon_is_bool(ctoon_val *val) {
4933 return val ? unsafe_ctoon_is_bool(val) : false;
4934}
4935
4936ctoon_api_inline bool ctoon_is_uint(ctoon_val *val) {
4937 return val ? unsafe_ctoon_is_uint(val) : false;
4938}
4939
4940ctoon_api_inline bool ctoon_is_sint(ctoon_val *val) {
4941 return val ? unsafe_ctoon_is_sint(val) : false;
4942}
4943
4944ctoon_api_inline bool ctoon_is_int(ctoon_val *val) {
4945 return val ? unsafe_ctoon_is_int(val) : false;
4946}
4947
4948ctoon_api_inline bool ctoon_is_real(ctoon_val *val) {
4949 return val ? unsafe_ctoon_is_real(val) : false;
4950}
4951
4952ctoon_api_inline bool ctoon_is_num(ctoon_val *val) {
4953 return val ? unsafe_ctoon_is_num(val) : false;
4954}
4955
4956ctoon_api_inline bool ctoon_is_str(ctoon_val *val) {
4957 return val ? unsafe_ctoon_is_str(val) : false;
4958}
4959
4960ctoon_api_inline bool ctoon_is_arr(ctoon_val *val) {
4961 return val ? unsafe_ctoon_is_arr(val) : false;
4962}
4963
4964ctoon_api_inline bool ctoon_is_obj(ctoon_val *val) {
4965 return val ? unsafe_ctoon_is_obj(val) : false;
4966}
4967
4968ctoon_api_inline bool ctoon_is_ctn(ctoon_val *val) {
4969 return val ? unsafe_ctoon_is_ctn(val) : false;
4970}
4971
4972
4973
4974/*==============================================================================
4975 * MARK: - TOON Value Content API (Implementation)
4976 *============================================================================*/
4977
4978ctoon_api_inline ctoon_type ctoon_get_type(ctoon_val *val) {
4979 return val ? unsafe_ctoon_get_type(val) : CTOON_TYPE_NONE;
4980}
4981
4982ctoon_api_inline ctoon_subtype ctoon_get_subtype(ctoon_val *val) {
4983 return val ? unsafe_ctoon_get_subtype(val) : CTOON_SUBTYPE_NONE;
4984}
4985
4986ctoon_api_inline uint8_t ctoon_get_tag(ctoon_val *val) {
4987 return val ? unsafe_ctoon_get_tag(val) : 0;
4988}
4989
4990ctoon_api_inline const char *ctoon_get_type_desc(ctoon_val *val) {
4991 switch (ctoon_get_tag(val)) {
4992 case CTOON_TYPE_RAW | CTOON_SUBTYPE_NONE: return "raw";
4993 case CTOON_TYPE_NULL | CTOON_SUBTYPE_NONE: return "null";
4994 case CTOON_TYPE_STR | CTOON_SUBTYPE_NONE: return "string";
4995 case CTOON_TYPE_STR | CTOON_SUBTYPE_NOESC: return "string";
4996 case CTOON_TYPE_ARR | CTOON_SUBTYPE_NONE: return "array";
4997 case CTOON_TYPE_OBJ | CTOON_SUBTYPE_NONE: return "object";
4998 case CTOON_TYPE_BOOL | CTOON_SUBTYPE_TRUE: return "true";
4999 case CTOON_TYPE_BOOL | CTOON_SUBTYPE_FALSE: return "false";
5000 case CTOON_TYPE_NUM | CTOON_SUBTYPE_UINT: return "uint";
5001 case CTOON_TYPE_NUM | CTOON_SUBTYPE_SINT: return "sint";
5002 case CTOON_TYPE_NUM | CTOON_SUBTYPE_REAL: return "real";
5003 default: return "unknown";
5004 }
5005}
5006
5007ctoon_api_inline const char *ctoon_get_raw(ctoon_val *val) {
5008 return ctoon_is_raw(val) ? unsafe_ctoon_get_raw(val) : NULL;
5009}
5010
5011ctoon_api_inline bool ctoon_get_bool(ctoon_val *val) {
5012 return ctoon_is_bool(val) ? unsafe_ctoon_get_bool(val) : false;
5013}
5014
5015ctoon_api_inline uint64_t ctoon_get_uint(ctoon_val *val) {
5016 return ctoon_is_int(val) ? unsafe_ctoon_get_uint(val) : 0;
5017}
5018
5019ctoon_api_inline int64_t ctoon_get_sint(ctoon_val *val) {
5020 return ctoon_is_int(val) ? unsafe_ctoon_get_sint(val) : 0;
5021}
5022
5023ctoon_api_inline int ctoon_get_int(ctoon_val *val) {
5024 return ctoon_is_int(val) ? unsafe_ctoon_get_int(val) : 0;
5025}
5026
5027ctoon_api_inline double ctoon_get_real(ctoon_val *val) {
5028 return ctoon_is_real(val) ? unsafe_ctoon_get_real(val) : 0.0;
5029}
5030
5031ctoon_api_inline double ctoon_get_num(ctoon_val *val) {
5032 return val ? unsafe_ctoon_get_num(val) : 0.0;
5033}
5034
5035ctoon_api_inline const char *ctoon_get_str(ctoon_val *val) {
5036 return ctoon_is_str(val) ? unsafe_ctoon_get_str(val) : NULL;
5037}
5038
5039ctoon_api_inline size_t ctoon_get_len(ctoon_val *val) {
5040 return val ? unsafe_ctoon_get_len(val) : 0;
5041}
5042
5043ctoon_api_inline bool ctoon_equals_str(ctoon_val *val, const char *str) {
5044 if (ctoon_likely(val && str)) {
5045 return unsafe_ctoon_is_str(val) &&
5046 unsafe_ctoon_equals_str(val, str);
5047 }
5048 return false;
5049}
5050
5051ctoon_api_inline bool ctoon_equals_strn(ctoon_val *val, const char *str,
5052 size_t len) {
5053 if (ctoon_likely(val && str)) {
5054 return unsafe_ctoon_is_str(val) &&
5055 unsafe_ctoon_equals_strn(val, str, len);
5056 }
5057 return false;
5058}
5059
5060ctoon_api bool unsafe_ctoon_equals(ctoon_val *lhs, ctoon_val *rhs);
5061
5062ctoon_api_inline bool ctoon_equals(ctoon_val *lhs, ctoon_val *rhs) {
5063 if (ctoon_unlikely(!lhs || !rhs)) return false;
5064 return unsafe_ctoon_equals(lhs, rhs);
5065}
5066
5067ctoon_api_inline bool ctoon_set_raw(ctoon_val *val,
5068 const char *raw, size_t len) {
5069 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5070 unsafe_ctoon_set_raw(val, raw, len);
5071 return true;
5072}
5073
5074ctoon_api_inline bool ctoon_set_null(ctoon_val *val) {
5075 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5076 unsafe_ctoon_set_null(val);
5077 return true;
5078}
5079
5080ctoon_api_inline bool ctoon_set_bool(ctoon_val *val, bool num) {
5081 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5082 unsafe_ctoon_set_bool(val, num);
5083 return true;
5084}
5085
5086ctoon_api_inline bool ctoon_set_uint(ctoon_val *val, uint64_t num) {
5087 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5088 unsafe_ctoon_set_uint(val, num);
5089 return true;
5090}
5091
5092ctoon_api_inline bool ctoon_set_sint(ctoon_val *val, int64_t num) {
5093 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5094 unsafe_ctoon_set_sint(val, num);
5095 return true;
5096}
5097
5098ctoon_api_inline bool ctoon_set_int(ctoon_val *val, int num) {
5099 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5100 unsafe_ctoon_set_sint(val, (int64_t)num);
5101 return true;
5102}
5103
5104ctoon_api_inline bool ctoon_set_float(ctoon_val *val, float num) {
5105 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5106 unsafe_ctoon_set_float(val, num);
5107 return true;
5108}
5109
5110ctoon_api_inline bool ctoon_set_double(ctoon_val *val, double num) {
5111 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5112 unsafe_ctoon_set_double(val, num);
5113 return true;
5114}
5115
5116ctoon_api_inline bool ctoon_set_real(ctoon_val *val, double num) {
5117 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5118 unsafe_ctoon_set_real(val, num);
5119 return true;
5120}
5121
5122ctoon_api_inline bool ctoon_set_fp_to_fixed(ctoon_val *val, int prec) {
5123 if (ctoon_unlikely(!ctoon_is_real(val))) return false;
5124 unsafe_ctoon_set_fp_to_fixed(val, prec);
5125 return true;
5126}
5127
5128ctoon_api_inline bool ctoon_set_fp_to_float(ctoon_val *val, bool flt) {
5129 if (ctoon_unlikely(!ctoon_is_real(val))) return false;
5130 unsafe_ctoon_set_fp_to_float(val, flt);
5131 return true;
5132}
5133
5134ctoon_api_inline bool ctoon_set_str(ctoon_val *val, const char *str) {
5135 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5136 if (ctoon_unlikely(!str)) return false;
5137 unsafe_ctoon_set_str(val, str);
5138 return true;
5139}
5140
5141ctoon_api_inline bool ctoon_set_strn(ctoon_val *val,
5142 const char *str, size_t len) {
5143 if (ctoon_unlikely(!val || unsafe_ctoon_is_ctn(val))) return false;
5144 if (ctoon_unlikely(!str)) return false;
5145 unsafe_ctoon_set_strn(val, str, len);
5146 return true;
5147}
5148
5149ctoon_api_inline bool ctoon_set_str_noesc(ctoon_val *val, bool noesc) {
5150 if (ctoon_unlikely(!ctoon_is_str(val))) return false;
5151 unsafe_ctoon_set_str_noesc(val, noesc);
5152 return true;
5153}
5154
5155
5156
5157/*==============================================================================
5158 * MARK: - TOON Array API (Implementation)
5159 *============================================================================*/
5160
5161ctoon_api_inline size_t ctoon_arr_size(ctoon_val *arr) {
5162 return ctoon_is_arr(arr) ? unsafe_ctoon_get_len(arr) : 0;
5163}
5164
5165ctoon_api_inline ctoon_val *ctoon_arr_get(ctoon_val *arr, size_t idx) {
5166 if (ctoon_likely(ctoon_is_arr(arr))) {
5167 if (ctoon_likely(unsafe_ctoon_get_len(arr) > idx)) {
5168 ctoon_val *val = unsafe_ctoon_get_first(arr);
5169 if (unsafe_ctoon_arr_is_flat(arr)) {
5170 return val + idx;
5171 } else {
5172 while (idx-- > 0) val = unsafe_ctoon_get_next(val);
5173 return val;
5174 }
5175 }
5176 }
5177 return NULL;
5178}
5179
5180ctoon_api_inline ctoon_val *ctoon_arr_get_first(ctoon_val *arr) {
5181 if (ctoon_likely(ctoon_is_arr(arr))) {
5182 if (ctoon_likely(unsafe_ctoon_get_len(arr) > 0)) {
5183 return unsafe_ctoon_get_first(arr);
5184 }
5185 }
5186 return NULL;
5187}
5188
5189ctoon_api_inline ctoon_val *ctoon_arr_get_last(ctoon_val *arr) {
5190 if (ctoon_likely(ctoon_is_arr(arr))) {
5191 size_t len = unsafe_ctoon_get_len(arr);
5192 if (ctoon_likely(len > 0)) {
5193 ctoon_val *val = unsafe_ctoon_get_first(arr);
5194 if (unsafe_ctoon_arr_is_flat(arr)) {
5195 return val + (len - 1);
5196 } else {
5197 while (len-- > 1) val = unsafe_ctoon_get_next(val);
5198 return val;
5199 }
5200 }
5201 }
5202 return NULL;
5203}
5204
5205
5206
5207/*==============================================================================
5208 * MARK: - TOON Array Iterator API (Implementation)
5209 *============================================================================*/
5210
5211ctoon_api_inline bool ctoon_arr_iter_init(ctoon_val *arr,
5212 ctoon_arr_iter *iter) {
5213 if (ctoon_likely(ctoon_is_arr(arr) && iter)) {
5214 iter->idx = 0;
5215 iter->max = unsafe_ctoon_get_len(arr);
5216 iter->cur = unsafe_ctoon_get_first(arr);
5217 return true;
5218 }
5219 if (iter) memset(iter, 0, sizeof(ctoon_arr_iter));
5220 return false;
5221}
5222
5223ctoon_api_inline ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr) {
5224 ctoon_arr_iter iter;
5225 ctoon_arr_iter_init(arr, &iter);
5226 return iter;
5227}
5228
5229ctoon_api_inline bool ctoon_arr_iter_has_next(ctoon_arr_iter *iter) {
5230 return iter ? iter->idx < iter->max : false;
5231}
5232
5233ctoon_api_inline ctoon_val *ctoon_arr_iter_next(ctoon_arr_iter *iter) {
5234 ctoon_val *val;
5235 if (iter && iter->idx < iter->max) {
5236 val = iter->cur;
5237 iter->cur = unsafe_ctoon_get_next(val);
5238 iter->idx++;
5239 return val;
5240 }
5241 return NULL;
5242}
5243
5244
5245
5246/*==============================================================================
5247 * MARK: - TOON Object API (Implementation)
5248 *============================================================================*/
5249
5250ctoon_api_inline size_t ctoon_obj_size(ctoon_val *obj) {
5251 return ctoon_is_obj(obj) ? unsafe_ctoon_get_len(obj) : 0;
5252}
5253
5254ctoon_api_inline ctoon_val *ctoon_obj_get(ctoon_val *obj,
5255 const char *key) {
5256 return ctoon_obj_getn(obj, key, key ? strlen(key) : 0);
5257}
5258
5259ctoon_api_inline ctoon_val *ctoon_obj_getn(ctoon_val *obj,
5260 const char *_key,
5261 size_t key_len) {
5262 if (ctoon_likely(ctoon_is_obj(obj) && _key)) {
5263 size_t len = unsafe_ctoon_get_len(obj);
5264 ctoon_val *key = unsafe_ctoon_get_first(obj);
5265 while (len-- > 0) {
5266 if (unsafe_ctoon_equals_strn(key, _key, key_len)) return key + 1;
5267 key = unsafe_ctoon_get_next(key + 1);
5268 }
5269 }
5270 return NULL;
5271}
5272
5273
5274
5275/*==============================================================================
5276 * MARK: - TOON Object Iterator API (Implementation)
5277 *============================================================================*/
5278
5279ctoon_api_inline bool ctoon_obj_iter_init(ctoon_val *obj,
5280 ctoon_obj_iter *iter) {
5281 if (ctoon_likely(ctoon_is_obj(obj) && iter)) {
5282 iter->idx = 0;
5283 iter->max = unsafe_ctoon_get_len(obj);
5284 iter->cur = unsafe_ctoon_get_first(obj);
5285 iter->obj = obj;
5286 return true;
5287 }
5288 if (iter) memset(iter, 0, sizeof(ctoon_obj_iter));
5289 return false;
5290}
5291
5292ctoon_api_inline ctoon_obj_iter ctoon_obj_iter_with(ctoon_val *obj) {
5293 ctoon_obj_iter iter;
5294 ctoon_obj_iter_init(obj, &iter);
5295 return iter;
5296}
5297
5298ctoon_api_inline bool ctoon_obj_iter_has_next(ctoon_obj_iter *iter) {
5299 return iter ? iter->idx < iter->max : false;
5300}
5301
5302ctoon_api_inline ctoon_val *ctoon_obj_iter_next(ctoon_obj_iter *iter) {
5303 if (iter && iter->idx < iter->max) {
5304 ctoon_val *key = iter->cur;
5305 iter->idx++;
5306 iter->cur = unsafe_ctoon_get_next(key + 1);
5307 return key;
5308 }
5309 return NULL;
5310}
5311
5312ctoon_api_inline ctoon_val *ctoon_obj_iter_get_val(ctoon_val *key) {
5313 return key ? key + 1 : NULL;
5314}
5315
5316ctoon_api_inline ctoon_val *ctoon_obj_iter_get(ctoon_obj_iter *iter,
5317 const char *key) {
5318 return ctoon_obj_iter_getn(iter, key, key ? strlen(key) : 0);
5319}
5320
5321ctoon_api_inline ctoon_val *ctoon_obj_iter_getn(ctoon_obj_iter *iter,
5322 const char *key,
5323 size_t key_len) {
5324 if (iter && key) {
5325 size_t idx = iter->idx;
5326 size_t max = iter->max;
5327 ctoon_val *cur = iter->cur;
5328 if (ctoon_unlikely(idx == max)) {
5329 idx = 0;
5330 cur = unsafe_ctoon_get_first(iter->obj);
5331 }
5332 while (idx++ < max) {
5333 ctoon_val *next = unsafe_ctoon_get_next(cur + 1);
5334 if (unsafe_ctoon_equals_strn(cur, key, key_len)) {
5335 iter->idx = idx;
5336 iter->cur = next;
5337 return cur + 1;
5338 }
5339 cur = next;
5340 if (idx == iter->max && iter->idx < iter->max) {
5341 idx = 0;
5342 max = iter->idx;
5343 cur = unsafe_ctoon_get_first(iter->obj);
5344 }
5345 }
5346 }
5347 return NULL;
5348}
5349
5350
5351
5352/*==============================================================================
5353 * MARK: - Mutable TOON Structure (Implementation)
5354 *============================================================================*/
5355
5361struct ctoon_mut_val {
5362 uint64_t tag; /**< type, subtype and length */
5363 ctoon_val_uni uni; /**< payload */
5364 ctoon_mut_val *next; /**< the next value in circular linked list */
5365};
5366
5370typedef struct ctoon_str_chunk {
5371 struct ctoon_str_chunk *next; /* next chunk linked list */
5372 size_t chunk_size; /* chunk size in bytes */
5373 /* char str[]; flexible array member */
5374} ctoon_str_chunk;
5375
5379typedef struct ctoon_str_pool {
5380 char *cur; /* cursor inside current chunk */
5381 char *end; /* the end of current chunk */
5382 size_t chunk_size; /* chunk size in bytes while creating new chunk */
5383 size_t chunk_size_max; /* maximum chunk size in bytes */
5384 ctoon_str_chunk *chunks; /* a linked list of chunks, nullable */
5385} ctoon_str_pool;
5386
5391typedef struct ctoon_val_chunk {
5392 struct ctoon_val_chunk *next; /* next chunk linked list */
5393 size_t chunk_size; /* chunk size in bytes */
5394 /* char pad[sizeof(ctoon_mut_val) - sizeof(ctoon_val_chunk)]; padding */
5395 /* ctoon_mut_val vals[]; flexible array member */
5396} ctoon_val_chunk;
5397
5401typedef struct ctoon_val_pool {
5402 ctoon_mut_val *cur; /* cursor inside current chunk */
5403 ctoon_mut_val *end; /* the end of current chunk */
5404 size_t chunk_size; /* chunk size in bytes while creating new chunk */
5405 size_t chunk_size_max; /* maximum chunk size in bytes */
5406 ctoon_val_chunk *chunks; /* a linked list of chunks, nullable */
5407} ctoon_val_pool;
5408
5409struct ctoon_mut_doc {
5410 ctoon_mut_val *root; /**< root value of the TOON document, nullable */
5411 ctoon_alc alc; /**< a valid allocator, nonnull */
5412 ctoon_str_pool str_pool; /**< string memory pool */
5413 ctoon_val_pool val_pool; /**< value memory pool */
5414};
5415
5416/* Ensures the capacity to at least equal to the specified byte length. */
5417ctoon_api bool unsafe_ctoon_str_pool_grow(ctoon_str_pool *pool,
5418 const ctoon_alc *alc,
5419 size_t len);
5420
5421/* Ensures the capacity to at least equal to the specified value count. */
5422ctoon_api bool unsafe_ctoon_val_pool_grow(ctoon_val_pool *pool,
5423 const ctoon_alc *alc,
5424 size_t count);
5425
5426/* Allocate memory for string. */
5427ctoon_api_inline char *unsafe_ctoon_mut_str_alc(ctoon_mut_doc *doc,
5428 size_t len) {
5429 char *mem;
5430 const ctoon_alc *alc = &doc->alc;
5431 ctoon_str_pool *pool = &doc->str_pool;
5432 if (ctoon_unlikely((size_t)(pool->end - pool->cur) <= len)) {
5433 if (ctoon_unlikely(!unsafe_ctoon_str_pool_grow(pool, alc, len + 1))) {
5434 return NULL;
5435 }
5436 }
5437 mem = pool->cur;
5438 pool->cur = mem + len + 1;
5439 return mem;
5440}
5441
5442ctoon_api_inline char *unsafe_ctoon_mut_strncpy(ctoon_mut_doc *doc,
5443 const char *str, size_t len) {
5444 char *mem = unsafe_ctoon_mut_str_alc(doc, len);
5445 if (ctoon_unlikely(!mem)) return NULL;
5446 memcpy((void *)mem, (const void *)str, len);
5447 mem[len] = '\0';
5448 return mem;
5449}
5450
5451ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_val(ctoon_mut_doc *doc,
5452 size_t count) {
5453 ctoon_mut_val *val;
5454 ctoon_alc *alc = &doc->alc;
5455 ctoon_val_pool *pool = &doc->val_pool;
5456 if (ctoon_unlikely((size_t)(pool->end - pool->cur) < count)) {
5457 if (ctoon_unlikely(!unsafe_ctoon_val_pool_grow(pool, alc, count))) {
5458 return NULL;
5459 }
5460 }
5461 val = pool->cur;
5462 pool->cur += count;
5463 return val;
5464}
5465
5466
5467
5468/*==============================================================================
5469 * MARK: - Mutable TOON Document API (Implementation)
5470 *============================================================================*/
5471
5472ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_root(ctoon_mut_doc *doc) {
5473 return doc ? doc->root : NULL;
5474}
5475
5476ctoon_api_inline void ctoon_mut_doc_set_root(ctoon_mut_doc *doc,
5477 ctoon_mut_val *root) {
5478 if (doc) doc->root = root;
5479}
5480
5481
5482
5483/*==============================================================================
5484 * MARK: - Mutable TOON Value Type API (Implementation)
5485 *============================================================================*/
5486
5487ctoon_api_inline bool ctoon_mut_is_raw(ctoon_mut_val *val) {
5488 return val ? unsafe_ctoon_is_raw(val) : false;
5489}
5490
5491ctoon_api_inline bool ctoon_mut_is_null(ctoon_mut_val *val) {
5492 return val ? unsafe_ctoon_is_null(val) : false;
5493}
5494
5495ctoon_api_inline bool ctoon_mut_is_true(ctoon_mut_val *val) {
5496 return val ? unsafe_ctoon_is_true(val) : false;
5497}
5498
5499ctoon_api_inline bool ctoon_mut_is_false(ctoon_mut_val *val) {
5500 return val ? unsafe_ctoon_is_false(val) : false;
5501}
5502
5503ctoon_api_inline bool ctoon_mut_is_bool(ctoon_mut_val *val) {
5504 return val ? unsafe_ctoon_is_bool(val) : false;
5505}
5506
5507ctoon_api_inline bool ctoon_mut_is_uint(ctoon_mut_val *val) {
5508 return val ? unsafe_ctoon_is_uint(val) : false;
5509}
5510
5511ctoon_api_inline bool ctoon_mut_is_sint(ctoon_mut_val *val) {
5512 return val ? unsafe_ctoon_is_sint(val) : false;
5513}
5514
5515ctoon_api_inline bool ctoon_mut_is_int(ctoon_mut_val *val) {
5516 return val ? unsafe_ctoon_is_int(val) : false;
5517}
5518
5519ctoon_api_inline bool ctoon_mut_is_real(ctoon_mut_val *val) {
5520 return val ? unsafe_ctoon_is_real(val) : false;
5521}
5522
5523ctoon_api_inline bool ctoon_mut_is_num(ctoon_mut_val *val) {
5524 return val ? unsafe_ctoon_is_num(val) : false;
5525}
5526
5527ctoon_api_inline bool ctoon_mut_is_str(ctoon_mut_val *val) {
5528 return val ? unsafe_ctoon_is_str(val) : false;
5529}
5530
5531ctoon_api_inline bool ctoon_mut_is_arr(ctoon_mut_val *val) {
5532 return val ? unsafe_ctoon_is_arr(val) : false;
5533}
5534
5535ctoon_api_inline bool ctoon_mut_is_obj(ctoon_mut_val *val) {
5536 return val ? unsafe_ctoon_is_obj(val) : false;
5537}
5538
5539ctoon_api_inline bool ctoon_mut_is_ctn(ctoon_mut_val *val) {
5540 return val ? unsafe_ctoon_is_ctn(val) : false;
5541}
5542
5543
5544
5545/*==============================================================================
5546 * MARK: - Mutable TOON Value Content API (Implementation)
5547 *============================================================================*/
5548
5549ctoon_api_inline ctoon_type ctoon_mut_get_type(ctoon_mut_val *val) {
5550 return ctoon_get_type((ctoon_val *)val);
5551}
5552
5553ctoon_api_inline ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val) {
5554 return ctoon_get_subtype((ctoon_val *)val);
5555}
5556
5557ctoon_api_inline uint8_t ctoon_mut_get_tag(ctoon_mut_val *val) {
5558 return ctoon_get_tag((ctoon_val *)val);
5559}
5560
5561ctoon_api_inline const char *ctoon_mut_get_type_desc(ctoon_mut_val *val) {
5562 return ctoon_get_type_desc((ctoon_val *)val);
5563}
5564
5565ctoon_api_inline const char *ctoon_mut_get_raw(ctoon_mut_val *val) {
5566 return ctoon_get_raw((ctoon_val *)val);
5567}
5568
5569ctoon_api_inline bool ctoon_mut_get_bool(ctoon_mut_val *val) {
5570 return ctoon_get_bool((ctoon_val *)val);
5571}
5572
5573ctoon_api_inline uint64_t ctoon_mut_get_uint(ctoon_mut_val *val) {
5574 return ctoon_get_uint((ctoon_val *)val);
5575}
5576
5577ctoon_api_inline int64_t ctoon_mut_get_sint(ctoon_mut_val *val) {
5578 return ctoon_get_sint((ctoon_val *)val);
5579}
5580
5581ctoon_api_inline int ctoon_mut_get_int(ctoon_mut_val *val) {
5582 return ctoon_get_int((ctoon_val *)val);
5583}
5584
5585ctoon_api_inline double ctoon_mut_get_real(ctoon_mut_val *val) {
5586 return ctoon_get_real((ctoon_val *)val);
5587}
5588
5589ctoon_api_inline double ctoon_mut_get_num(ctoon_mut_val *val) {
5590 return ctoon_get_num((ctoon_val *)val);
5591}
5592
5593ctoon_api_inline const char *ctoon_mut_get_str(ctoon_mut_val *val) {
5594 return ctoon_get_str((ctoon_val *)val);
5595}
5596
5597ctoon_api_inline size_t ctoon_mut_get_len(ctoon_mut_val *val) {
5598 return ctoon_get_len((ctoon_val *)val);
5599}
5600
5601ctoon_api_inline bool ctoon_mut_equals_str(ctoon_mut_val *val,
5602 const char *str) {
5603 return ctoon_equals_str((ctoon_val *)val, str);
5604}
5605
5606ctoon_api_inline bool ctoon_mut_equals_strn(ctoon_mut_val *val,
5607 const char *str, size_t len) {
5608 return ctoon_equals_strn((ctoon_val *)val, str, len);
5609}
5610
5611ctoon_api bool unsafe_ctoon_mut_equals(ctoon_mut_val *lhs,
5612 ctoon_mut_val *rhs);
5613
5614ctoon_api_inline bool ctoon_mut_equals(ctoon_mut_val *lhs,
5615 ctoon_mut_val *rhs) {
5616 if (ctoon_unlikely(!lhs || !rhs)) return false;
5617 return unsafe_ctoon_mut_equals(lhs, rhs);
5618}
5619
5620ctoon_api_inline bool ctoon_mut_set_raw(ctoon_mut_val *val,
5621 const char *raw, size_t len) {
5622 if (ctoon_unlikely(!val || !raw)) return false;
5623 unsafe_ctoon_set_raw(val, raw, len);
5624 return true;
5625}
5626
5627ctoon_api_inline bool ctoon_mut_set_null(ctoon_mut_val *val) {
5628 if (ctoon_unlikely(!val)) return false;
5629 unsafe_ctoon_set_null(val);
5630 return true;
5631}
5632
5633ctoon_api_inline bool ctoon_mut_set_bool(ctoon_mut_val *val, bool num) {
5634 if (ctoon_unlikely(!val)) return false;
5635 unsafe_ctoon_set_bool(val, num);
5636 return true;
5637}
5638
5639ctoon_api_inline bool ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num) {
5640 if (ctoon_unlikely(!val)) return false;
5641 unsafe_ctoon_set_uint(val, num);
5642 return true;
5643}
5644
5645ctoon_api_inline bool ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num) {
5646 if (ctoon_unlikely(!val)) return false;
5647 unsafe_ctoon_set_sint(val, num);
5648 return true;
5649}
5650
5651ctoon_api_inline bool ctoon_mut_set_int(ctoon_mut_val *val, int num) {
5652 if (ctoon_unlikely(!val)) return false;
5653 unsafe_ctoon_set_sint(val, (int64_t)num);
5654 return true;
5655}
5656
5657ctoon_api_inline bool ctoon_mut_set_float(ctoon_mut_val *val, float num) {
5658 if (ctoon_unlikely(!val)) return false;
5659 unsafe_ctoon_set_float(val, num);
5660 return true;
5661}
5662
5663ctoon_api_inline bool ctoon_mut_set_double(ctoon_mut_val *val, double num) {
5664 if (ctoon_unlikely(!val)) return false;
5665 unsafe_ctoon_set_double(val, num);
5666 return true;
5667}
5668
5669ctoon_api_inline bool ctoon_mut_set_real(ctoon_mut_val *val, double num) {
5670 if (ctoon_unlikely(!val)) return false;
5671 unsafe_ctoon_set_real(val, num);
5672 return true;
5673}
5674
5675ctoon_api_inline bool ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val,
5676 int prec) {
5677 if (ctoon_unlikely(!ctoon_mut_is_real(val))) return false;
5678 unsafe_ctoon_set_fp_to_fixed(val, prec);
5679 return true;
5680}
5681
5682ctoon_api_inline bool ctoon_mut_set_fp_to_float(ctoon_mut_val *val,
5683 bool flt) {
5684 if (ctoon_unlikely(!ctoon_mut_is_real(val))) return false;
5685 unsafe_ctoon_set_fp_to_float(val, flt);
5686 return true;
5687}
5688
5689ctoon_api_inline bool ctoon_mut_set_str(ctoon_mut_val *val,
5690 const char *str) {
5691 if (ctoon_unlikely(!val || !str)) return false;
5692 unsafe_ctoon_set_str(val, str);
5693 return true;
5694}
5695
5696ctoon_api_inline bool ctoon_mut_set_strn(ctoon_mut_val *val,
5697 const char *str, size_t len) {
5698 if (ctoon_unlikely(!val || !str)) return false;
5699 unsafe_ctoon_set_strn(val, str, len);
5700 return true;
5701}
5702
5703ctoon_api_inline bool ctoon_mut_set_str_noesc(ctoon_mut_val *val,
5704 bool noesc) {
5705 if (ctoon_unlikely(!ctoon_mut_is_str(val))) return false;
5706 unsafe_ctoon_set_str_noesc(val, noesc);
5707 return true;
5708}
5709
5710ctoon_api_inline bool ctoon_mut_set_arr(ctoon_mut_val *val) {
5711 if (ctoon_unlikely(!val)) return false;
5712 unsafe_ctoon_set_arr(val, 0);
5713 return true;
5714}
5715
5716ctoon_api_inline bool ctoon_mut_set_obj(ctoon_mut_val *val) {
5717 if (ctoon_unlikely(!val)) return false;
5718 unsafe_ctoon_set_obj(val, 0);
5719 return true;
5720}
5721
5722
5723
5724/*==============================================================================
5725 * MARK: - Mutable TOON Value Creation API (Implementation)
5726 *============================================================================*/
5727
5728#define ctoon_mut_val_one(func) \
5729 if (ctoon_likely(doc)) { \
5730 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1); \
5731 if (ctoon_likely(val)) { \
5732 func \
5733 return val; \
5734 } \
5735 } \
5736 return NULL
5737
5738#define ctoon_mut_val_one_str(func) \
5739 if (ctoon_likely(doc && str)) { \
5740 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1); \
5741 if (ctoon_likely(val)) { \
5742 func \
5743 return val; \
5744 } \
5745 } \
5746 return NULL
5747
5748ctoon_api_inline ctoon_mut_val *ctoon_mut_raw(ctoon_mut_doc *doc,
5749 const char *str) {
5750 ctoon_mut_val_one_str({ unsafe_ctoon_set_raw(val, str, strlen(str)); });
5751}
5752
5753ctoon_api_inline ctoon_mut_val *ctoon_mut_rawn(ctoon_mut_doc *doc,
5754 const char *str,
5755 size_t len) {
5756 ctoon_mut_val_one_str({ unsafe_ctoon_set_raw(val, str, len); });
5757}
5758
5759ctoon_api_inline ctoon_mut_val *ctoon_mut_rawcpy(ctoon_mut_doc *doc,
5760 const char *str) {
5761 ctoon_mut_val_one_str({
5762 size_t len = strlen(str);
5763 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5764 if (ctoon_unlikely(!new_str)) return NULL;
5765 unsafe_ctoon_set_raw(val, new_str, len);
5766 });
5767}
5768
5769ctoon_api_inline ctoon_mut_val *ctoon_mut_rawncpy(ctoon_mut_doc *doc,
5770 const char *str,
5771 size_t len) {
5772 ctoon_mut_val_one_str({
5773 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5774 if (ctoon_unlikely(!new_str)) return NULL;
5775 unsafe_ctoon_set_raw(val, new_str, len);
5776 });
5777}
5778
5779ctoon_api_inline ctoon_mut_val *ctoon_mut_null(ctoon_mut_doc *doc) {
5780 ctoon_mut_val_one({ unsafe_ctoon_set_null(val); });
5781}
5782
5783ctoon_api_inline ctoon_mut_val *ctoon_mut_true(ctoon_mut_doc *doc) {
5784 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, true); });
5785}
5786
5787ctoon_api_inline ctoon_mut_val *ctoon_mut_false(ctoon_mut_doc *doc) {
5788 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, false); });
5789}
5790
5791ctoon_api_inline ctoon_mut_val *ctoon_mut_bool(ctoon_mut_doc *doc,
5792 bool _val) {
5793 ctoon_mut_val_one({ unsafe_ctoon_set_bool(val, _val); });
5794}
5795
5796ctoon_api_inline ctoon_mut_val *ctoon_mut_uint(ctoon_mut_doc *doc,
5797 uint64_t num) {
5798 ctoon_mut_val_one({ unsafe_ctoon_set_uint(val, num); });
5799}
5800
5801ctoon_api_inline ctoon_mut_val *ctoon_mut_sint(ctoon_mut_doc *doc,
5802 int64_t num) {
5803 ctoon_mut_val_one({ unsafe_ctoon_set_sint(val, num); });
5804}
5805
5806ctoon_api_inline ctoon_mut_val *ctoon_mut_int(ctoon_mut_doc *doc,
5807 int64_t num) {
5808 ctoon_mut_val_one({ unsafe_ctoon_set_sint(val, num); });
5809}
5810
5811ctoon_api_inline ctoon_mut_val *ctoon_mut_float(ctoon_mut_doc *doc,
5812 float num) {
5813 ctoon_mut_val_one({ unsafe_ctoon_set_float(val, num); });
5814}
5815
5816ctoon_api_inline ctoon_mut_val *ctoon_mut_double(ctoon_mut_doc *doc,
5817 double num) {
5818 ctoon_mut_val_one({ unsafe_ctoon_set_double(val, num); });
5819}
5820
5821ctoon_api_inline ctoon_mut_val *ctoon_mut_real(ctoon_mut_doc *doc,
5822 double num) {
5823 ctoon_mut_val_one({ unsafe_ctoon_set_real(val, num); });
5824}
5825
5826ctoon_api_inline ctoon_mut_val *ctoon_mut_str(ctoon_mut_doc *doc,
5827 const char *str) {
5828 ctoon_mut_val_one_str({ unsafe_ctoon_set_str(val, str); });
5829}
5830
5831ctoon_api_inline ctoon_mut_val *ctoon_mut_strn(ctoon_mut_doc *doc,
5832 const char *str,
5833 size_t len) {
5834 ctoon_mut_val_one_str({ unsafe_ctoon_set_strn(val, str, len); });
5835}
5836
5837ctoon_api_inline ctoon_mut_val *ctoon_mut_strcpy(ctoon_mut_doc *doc,
5838 const char *str) {
5839 ctoon_mut_val_one_str({
5840 size_t len = strlen(str);
5841 bool noesc = unsafe_ctoon_is_str_noesc(str, len);
5842 ctoon_subtype sub = noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
5843 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5844 if (ctoon_unlikely(!new_str)) return NULL;
5845 unsafe_ctoon_set_tag(val, CTOON_TYPE_STR, sub, len);
5846 val->uni.str = new_str;
5847 });
5848}
5849
5850ctoon_api_inline ctoon_mut_val *ctoon_mut_strncpy(ctoon_mut_doc *doc,
5851 const char *str,
5852 size_t len) {
5853 ctoon_mut_val_one_str({
5854 char *new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
5855 if (ctoon_unlikely(!new_str)) return NULL;
5856 unsafe_ctoon_set_strn(val, new_str, len);
5857 });
5858}
5859
5860#undef ctoon_mut_val_one
5861#undef ctoon_mut_val_one_str
5862
5863
5864
5865/*==============================================================================
5866 * MARK: - Mutable TOON Array API (Implementation)
5867 *============================================================================*/
5868
5869ctoon_api_inline size_t ctoon_mut_arr_size(ctoon_mut_val *arr) {
5870 return ctoon_mut_is_arr(arr) ? unsafe_ctoon_get_len(arr) : 0;
5871}
5872
5873ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get(ctoon_mut_val *arr,
5874 size_t idx) {
5875 if (ctoon_likely(idx < ctoon_mut_arr_size(arr))) {
5876 ctoon_mut_val *val = (ctoon_mut_val *)arr->uni.ptr;
5877 while (idx-- > 0) val = val->next;
5878 return val->next;
5879 }
5880 return NULL;
5881}
5882
5883ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_first(
5884 ctoon_mut_val *arr) {
5885 if (ctoon_likely(ctoon_mut_arr_size(arr) > 0)) {
5886 return ((ctoon_mut_val *)arr->uni.ptr)->next;
5887 }
5888 return NULL;
5889}
5890
5891ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_get_last(
5892 ctoon_mut_val *arr) {
5893 if (ctoon_likely(ctoon_mut_arr_size(arr) > 0)) {
5894 return ((ctoon_mut_val *)arr->uni.ptr);
5895 }
5896 return NULL;
5897}
5898
5899
5900
5901/*==============================================================================
5902 * MARK: - Mutable TOON Array Iterator API (Implementation)
5903 *============================================================================*/
5904
5905ctoon_api_inline bool ctoon_mut_arr_iter_init(ctoon_mut_val *arr,
5906 ctoon_mut_arr_iter *iter) {
5907 if (ctoon_likely(ctoon_mut_is_arr(arr) && iter)) {
5908 iter->idx = 0;
5909 iter->max = unsafe_ctoon_get_len(arr);
5910 iter->cur = iter->max ? (ctoon_mut_val *)arr->uni.ptr : NULL;
5911 iter->pre = NULL;
5912 iter->arr = arr;
5913 return true;
5914 }
5915 if (iter) memset(iter, 0, sizeof(ctoon_mut_arr_iter));
5916 return false;
5917}
5918
5919ctoon_api_inline ctoon_mut_arr_iter ctoon_mut_arr_iter_with(
5920 ctoon_mut_val *arr) {
5921 ctoon_mut_arr_iter iter;
5922 ctoon_mut_arr_iter_init(arr, &iter);
5923 return iter;
5924}
5925
5926ctoon_api_inline bool ctoon_mut_arr_iter_has_next(ctoon_mut_arr_iter *iter) {
5927 return iter ? iter->idx < iter->max : false;
5928}
5929
5930ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_next(
5931 ctoon_mut_arr_iter *iter) {
5932 if (iter && iter->idx < iter->max) {
5933 ctoon_mut_val *val = iter->cur;
5934 iter->pre = val;
5935 iter->cur = val->next;
5936 iter->idx++;
5937 return iter->cur;
5938 }
5939 return NULL;
5940}
5941
5942ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_iter_remove(
5943 ctoon_mut_arr_iter *iter) {
5944 if (ctoon_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
5945 ctoon_mut_val *prev = iter->pre;
5946 ctoon_mut_val *cur = iter->cur;
5947 ctoon_mut_val *next = cur->next;
5948 if (ctoon_unlikely(iter->idx == iter->max)) iter->arr->uni.ptr = prev;
5949 iter->idx--;
5950 iter->max--;
5951 unsafe_ctoon_set_len(iter->arr, iter->max);
5952 prev->next = next;
5953 iter->cur = prev;
5954 return cur;
5955 }
5956 return NULL;
5957}
5958
5959
5960
5961/*==============================================================================
5962 * MARK: - Mutable TOON Array Creation API (Implementation)
5963 *============================================================================*/
5964
5965ctoon_api_inline ctoon_mut_val *ctoon_mut_arr(ctoon_mut_doc *doc) {
5966 if (ctoon_likely(doc)) {
5967 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1);
5968 if (ctoon_likely(val)) {
5969 val->tag = CTOON_TYPE_ARR | CTOON_SUBTYPE_NONE;
5970 return val;
5971 }
5972 }
5973 return NULL;
5974}
5975
5976#define ctoon_mut_arr_with_func(func) \
5977 if (ctoon_likely(doc && ((0 < count && count < \
5978 (~(size_t)0) / sizeof(ctoon_mut_val) && vals) || count == 0))) { \
5979 ctoon_mut_val *arr = unsafe_ctoon_mut_val(doc, 1 + count); \
5980 if (ctoon_likely(arr)) { \
5981 arr->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_ARR; \
5982 if (count > 0) { \
5983 size_t i; \
5984 for (i = 0; i < count; i++) { \
5985 ctoon_mut_val *val = arr + i + 1; \
5986 func \
5987 val->next = val + 1; \
5988 } \
5989 arr[count].next = arr + 1; \
5990 arr->uni.ptr = arr + count; \
5991 } \
5992 return arr; \
5993 } \
5994 } \
5995 return NULL
5996
5997ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_bool(
5998 ctoon_mut_doc *doc, const bool *vals, size_t count) {
5999 ctoon_mut_arr_with_func({
6000 unsafe_ctoon_set_bool(val, vals[i]);
6001 });
6002}
6003
6004ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint(
6005 ctoon_mut_doc *doc, const int64_t *vals, size_t count) {
6006 return ctoon_mut_arr_with_sint64(doc, vals, count);
6007}
6008
6009ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint(
6010 ctoon_mut_doc *doc, const uint64_t *vals, size_t count) {
6011 return ctoon_mut_arr_with_uint64(doc, vals, count);
6012}
6013
6014ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_real(
6015 ctoon_mut_doc *doc, const double *vals, size_t count) {
6016 ctoon_mut_arr_with_func({
6017 unsafe_ctoon_set_real(val, vals[i]);
6018 });
6019}
6020
6021ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint8(
6022 ctoon_mut_doc *doc, const int8_t *vals, size_t count) {
6023 ctoon_mut_arr_with_func({
6024 unsafe_ctoon_set_sint(val, vals[i]);
6025 });
6026}
6027
6028ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint16(
6029 ctoon_mut_doc *doc, const int16_t *vals, size_t count) {
6030 ctoon_mut_arr_with_func({
6031 unsafe_ctoon_set_sint(val, vals[i]);
6032 });
6033}
6034
6035ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint32(
6036 ctoon_mut_doc *doc, const int32_t *vals, size_t count) {
6037 ctoon_mut_arr_with_func({
6038 unsafe_ctoon_set_sint(val, vals[i]);
6039 });
6040}
6041
6042ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_sint64(
6043 ctoon_mut_doc *doc, const int64_t *vals, size_t count) {
6044 ctoon_mut_arr_with_func({
6045 unsafe_ctoon_set_sint(val, vals[i]);
6046 });
6047}
6048
6049ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint8(
6050 ctoon_mut_doc *doc, const uint8_t *vals, size_t count) {
6051 ctoon_mut_arr_with_func({
6052 unsafe_ctoon_set_uint(val, vals[i]);
6053 });
6054}
6055
6056ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint16(
6057 ctoon_mut_doc *doc, const uint16_t *vals, size_t count) {
6058 ctoon_mut_arr_with_func({
6059 unsafe_ctoon_set_uint(val, vals[i]);
6060 });
6061}
6062
6063ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint32(
6064 ctoon_mut_doc *doc, const uint32_t *vals, size_t count) {
6065 ctoon_mut_arr_with_func({
6066 unsafe_ctoon_set_uint(val, vals[i]);
6067 });
6068}
6069
6070ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_uint64(
6071 ctoon_mut_doc *doc, const uint64_t *vals, size_t count) {
6072 ctoon_mut_arr_with_func({
6073 unsafe_ctoon_set_uint(val, vals[i]);
6074 });
6075}
6076
6077ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_float(
6078 ctoon_mut_doc *doc, const float *vals, size_t count) {
6079 ctoon_mut_arr_with_func({
6080 unsafe_ctoon_set_float(val, vals[i]);
6081 });
6082}
6083
6084ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_double(
6085 ctoon_mut_doc *doc, const double *vals, size_t count) {
6086 ctoon_mut_arr_with_func({
6087 unsafe_ctoon_set_double(val, vals[i]);
6088 });
6089}
6090
6091ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_str(
6092 ctoon_mut_doc *doc, const char **vals, size_t count) {
6093 ctoon_mut_arr_with_func({
6094 if (ctoon_unlikely(!vals[i])) return NULL;
6095 unsafe_ctoon_set_str(val, vals[i]);
6096 });
6097}
6098
6099ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strn(
6100 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
6101 if (ctoon_unlikely(count > 0 && !lens)) return NULL;
6102 ctoon_mut_arr_with_func({
6103 if (ctoon_unlikely(!vals[i])) return NULL;
6104 unsafe_ctoon_set_strn(val, vals[i], lens[i]);
6105 });
6106}
6107
6108ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strcpy(
6109 ctoon_mut_doc *doc, const char **vals, size_t count) {
6110 size_t len;
6111 const char *str, *new_str;
6112 ctoon_mut_arr_with_func({
6113 str = vals[i];
6114 if (ctoon_unlikely(!str)) return NULL;
6115 len = strlen(str);
6116 new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6117 if (ctoon_unlikely(!new_str)) return NULL;
6118 unsafe_ctoon_set_strn(val, new_str, len);
6119 });
6120}
6121
6122ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_with_strncpy(
6123 ctoon_mut_doc *doc, const char **vals, const size_t *lens, size_t count) {
6124 size_t len;
6125 const char *str, *new_str;
6126 if (ctoon_unlikely(count > 0 && !lens)) return NULL;
6127 ctoon_mut_arr_with_func({
6128 str = vals[i];
6129 if (ctoon_unlikely(!str)) return NULL;
6130 len = lens[i];
6131 new_str = unsafe_ctoon_mut_strncpy(doc, str, len);
6132 if (ctoon_unlikely(!new_str)) return NULL;
6133 unsafe_ctoon_set_strn(val, new_str, len);
6134 });
6135}
6136
6137#undef ctoon_mut_arr_with_func
6138
6139
6140
6141/*==============================================================================
6142 * MARK: - Mutable TOON Array Modification API (Implementation)
6143 *============================================================================*/
6144
6145ctoon_api_inline bool ctoon_mut_arr_insert(ctoon_mut_val *arr,
6146 ctoon_mut_val *val, size_t idx) {
6147 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6148 size_t len = unsafe_ctoon_get_len(arr);
6149 if (ctoon_likely(idx <= len)) {
6150 unsafe_ctoon_set_len(arr, len + 1);
6151 if (len == 0) {
6152 val->next = val;
6153 arr->uni.ptr = val;
6154 } else {
6155 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6156 ctoon_mut_val *next = prev->next;
6157 if (idx == len) {
6158 prev->next = val;
6159 val->next = next;
6160 arr->uni.ptr = val;
6161 } else {
6162 while (idx-- > 0) {
6163 prev = next;
6164 next = next->next;
6165 }
6166 prev->next = val;
6167 val->next = next;
6168 }
6169 }
6170 return true;
6171 }
6172 }
6173 return false;
6174}
6175
6176ctoon_api_inline bool ctoon_mut_arr_append(ctoon_mut_val *arr,
6177 ctoon_mut_val *val) {
6178 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6179 size_t len = unsafe_ctoon_get_len(arr);
6180 unsafe_ctoon_set_len(arr, len + 1);
6181 if (len == 0) {
6182 val->next = val;
6183 } else {
6184 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6185 ctoon_mut_val *next = prev->next;
6186 prev->next = val;
6187 val->next = next;
6188 }
6189 arr->uni.ptr = val;
6190 return true;
6191 }
6192 return false;
6193}
6194
6195ctoon_api_inline bool ctoon_mut_arr_prepend(ctoon_mut_val *arr,
6196 ctoon_mut_val *val) {
6197 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6198 size_t len = unsafe_ctoon_get_len(arr);
6199 unsafe_ctoon_set_len(arr, len + 1);
6200 if (len == 0) {
6201 val->next = val;
6202 arr->uni.ptr = val;
6203 } else {
6204 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6205 ctoon_mut_val *next = prev->next;
6206 prev->next = val;
6207 val->next = next;
6208 }
6209 return true;
6210 }
6211 return false;
6212}
6213
6214ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_replace(ctoon_mut_val *arr,
6215 size_t idx,
6216 ctoon_mut_val *val) {
6217 if (ctoon_likely(ctoon_mut_is_arr(arr) && val)) {
6218 size_t len = unsafe_ctoon_get_len(arr);
6219 if (ctoon_likely(idx < len)) {
6220 if (ctoon_likely(len > 1)) {
6221 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6222 ctoon_mut_val *next = prev->next;
6223 while (idx-- > 0) {
6224 prev = next;
6225 next = next->next;
6226 }
6227 prev->next = val;
6228 val->next = next->next;
6229 if ((void *)next == arr->uni.ptr) arr->uni.ptr = val;
6230 return next;
6231 } else {
6232 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6233 val->next = val;
6234 arr->uni.ptr = val;
6235 return prev;
6236 }
6237 }
6238 }
6239 return NULL;
6240}
6241
6242ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove(ctoon_mut_val *arr,
6243 size_t idx) {
6244 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6245 size_t len = unsafe_ctoon_get_len(arr);
6246 if (ctoon_likely(idx < len)) {
6247 unsafe_ctoon_set_len(arr, len - 1);
6248 if (ctoon_likely(len > 1)) {
6249 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6250 ctoon_mut_val *next = prev->next;
6251 while (idx-- > 0) {
6252 prev = next;
6253 next = next->next;
6254 }
6255 prev->next = next->next;
6256 if ((void *)next == arr->uni.ptr) arr->uni.ptr = prev;
6257 return next;
6258 } else {
6259 return ((ctoon_mut_val *)arr->uni.ptr);
6260 }
6261 }
6262 }
6263 return NULL;
6264}
6265
6266ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_first(
6267 ctoon_mut_val *arr) {
6268 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6269 size_t len = unsafe_ctoon_get_len(arr);
6270 if (len > 1) {
6271 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6272 ctoon_mut_val *next = prev->next;
6273 prev->next = next->next;
6274 unsafe_ctoon_set_len(arr, len - 1);
6275 return next;
6276 } else if (len == 1) {
6277 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6278 unsafe_ctoon_set_len(arr, 0);
6279 return prev;
6280 }
6281 }
6282 return NULL;
6283}
6284
6285ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_remove_last(
6286 ctoon_mut_val *arr) {
6287 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6288 size_t len = unsafe_ctoon_get_len(arr);
6289 if (ctoon_likely(len > 1)) {
6290 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6291 ctoon_mut_val *next = prev->next;
6292 unsafe_ctoon_set_len(arr, len - 1);
6293 while (--len > 0) prev = prev->next;
6294 prev->next = next;
6295 next = (ctoon_mut_val *)arr->uni.ptr;
6296 arr->uni.ptr = prev;
6297 return next;
6298 } else if (len == 1) {
6299 ctoon_mut_val *prev = ((ctoon_mut_val *)arr->uni.ptr);
6300 unsafe_ctoon_set_len(arr, 0);
6301 return prev;
6302 }
6303 }
6304 return NULL;
6305}
6306
6307ctoon_api_inline bool ctoon_mut_arr_remove_range(ctoon_mut_val *arr,
6308 size_t _idx, size_t _len) {
6309 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6310 ctoon_mut_val *prev, *next;
6311 bool tail_removed;
6312 size_t len = unsafe_ctoon_get_len(arr);
6313 if (ctoon_unlikely(_idx + _len > len)) return false;
6314 if (ctoon_unlikely(_len == 0)) return true;
6315 unsafe_ctoon_set_len(arr, len - _len);
6316 if (ctoon_unlikely(len == _len)) return true;
6317 tail_removed = (_idx + _len == len);
6318 prev = ((ctoon_mut_val *)arr->uni.ptr);
6319 while (_idx-- > 0) prev = prev->next;
6320 next = prev->next;
6321 while (_len-- > 0) next = next->next;
6322 prev->next = next;
6323 if (ctoon_unlikely(tail_removed)) arr->uni.ptr = prev;
6324 return true;
6325 }
6326 return false;
6327}
6328
6329ctoon_api_inline bool ctoon_mut_arr_clear(ctoon_mut_val *arr) {
6330 if (ctoon_likely(ctoon_mut_is_arr(arr))) {
6331 unsafe_ctoon_set_len(arr, 0);
6332 return true;
6333 }
6334 return false;
6335}
6336
6337ctoon_api_inline bool ctoon_mut_arr_rotate(ctoon_mut_val *arr,
6338 size_t idx) {
6339 if (ctoon_likely(ctoon_mut_is_arr(arr) &&
6340 unsafe_ctoon_get_len(arr) > idx)) {
6341 ctoon_mut_val *val = (ctoon_mut_val *)arr->uni.ptr;
6342 while (idx-- > 0) val = val->next;
6343 arr->uni.ptr = (void *)val;
6344 return true;
6345 }
6346 return false;
6347}
6348
6349
6350
6351/*==============================================================================
6352 * MARK: - Mutable TOON Array Modification Convenience API (Implementation)
6353 *============================================================================*/
6354
6355ctoon_api_inline bool ctoon_mut_arr_add_val(ctoon_mut_val *arr,
6356 ctoon_mut_val *val) {
6357 return ctoon_mut_arr_append(arr, val);
6358}
6359
6360ctoon_api_inline bool ctoon_mut_arr_add_null(ctoon_mut_doc *doc,
6361 ctoon_mut_val *arr) {
6362 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6363 ctoon_mut_val *val = ctoon_mut_null(doc);
6364 return ctoon_mut_arr_append(arr, val);
6365 }
6366 return false;
6367}
6368
6369ctoon_api_inline bool ctoon_mut_arr_add_true(ctoon_mut_doc *doc,
6370 ctoon_mut_val *arr) {
6371 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6372 ctoon_mut_val *val = ctoon_mut_true(doc);
6373 return ctoon_mut_arr_append(arr, val);
6374 }
6375 return false;
6376}
6377
6378ctoon_api_inline bool ctoon_mut_arr_add_false(ctoon_mut_doc *doc,
6379 ctoon_mut_val *arr) {
6380 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6381 ctoon_mut_val *val = ctoon_mut_false(doc);
6382 return ctoon_mut_arr_append(arr, val);
6383 }
6384 return false;
6385}
6386
6387ctoon_api_inline bool ctoon_mut_arr_add_bool(ctoon_mut_doc *doc,
6388 ctoon_mut_val *arr,
6389 bool _val) {
6390 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6391 ctoon_mut_val *val = ctoon_mut_bool(doc, _val);
6392 return ctoon_mut_arr_append(arr, val);
6393 }
6394 return false;
6395}
6396
6397ctoon_api_inline bool ctoon_mut_arr_add_uint(ctoon_mut_doc *doc,
6398 ctoon_mut_val *arr,
6399 uint64_t num) {
6400 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6401 ctoon_mut_val *val = ctoon_mut_uint(doc, num);
6402 return ctoon_mut_arr_append(arr, val);
6403 }
6404 return false;
6405}
6406
6407ctoon_api_inline bool ctoon_mut_arr_add_sint(ctoon_mut_doc *doc,
6408 ctoon_mut_val *arr,
6409 int64_t num) {
6410 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6411 ctoon_mut_val *val = ctoon_mut_sint(doc, num);
6412 return ctoon_mut_arr_append(arr, val);
6413 }
6414 return false;
6415}
6416
6417ctoon_api_inline bool ctoon_mut_arr_add_int(ctoon_mut_doc *doc,
6418 ctoon_mut_val *arr,
6419 int64_t num) {
6420 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6421 ctoon_mut_val *val = ctoon_mut_sint(doc, num);
6422 return ctoon_mut_arr_append(arr, val);
6423 }
6424 return false;
6425}
6426
6427ctoon_api_inline bool ctoon_mut_arr_add_float(ctoon_mut_doc *doc,
6428 ctoon_mut_val *arr,
6429 float num) {
6430 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6431 ctoon_mut_val *val = ctoon_mut_float(doc, num);
6432 return ctoon_mut_arr_append(arr, val);
6433 }
6434 return false;
6435}
6436
6437ctoon_api_inline bool ctoon_mut_arr_add_double(ctoon_mut_doc *doc,
6438 ctoon_mut_val *arr,
6439 double num) {
6440 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6441 ctoon_mut_val *val = ctoon_mut_double(doc, num);
6442 return ctoon_mut_arr_append(arr, val);
6443 }
6444 return false;
6445}
6446
6447ctoon_api_inline bool ctoon_mut_arr_add_real(ctoon_mut_doc *doc,
6448 ctoon_mut_val *arr,
6449 double num) {
6450 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6451 ctoon_mut_val *val = ctoon_mut_real(doc, num);
6452 return ctoon_mut_arr_append(arr, val);
6453 }
6454 return false;
6455}
6456
6457ctoon_api_inline bool ctoon_mut_arr_add_str(ctoon_mut_doc *doc,
6458 ctoon_mut_val *arr,
6459 const char *str) {
6460 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6461 ctoon_mut_val *val = ctoon_mut_str(doc, str);
6462 return ctoon_mut_arr_append(arr, val);
6463 }
6464 return false;
6465}
6466
6467ctoon_api_inline bool ctoon_mut_arr_add_strn(ctoon_mut_doc *doc,
6468 ctoon_mut_val *arr,
6469 const char *str, size_t len) {
6470 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6471 ctoon_mut_val *val = ctoon_mut_strn(doc, str, len);
6472 return ctoon_mut_arr_append(arr, val);
6473 }
6474 return false;
6475}
6476
6477ctoon_api_inline bool ctoon_mut_arr_add_strcpy(ctoon_mut_doc *doc,
6478 ctoon_mut_val *arr,
6479 const char *str) {
6480 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6481 ctoon_mut_val *val = ctoon_mut_strcpy(doc, str);
6482 return ctoon_mut_arr_append(arr, val);
6483 }
6484 return false;
6485}
6486
6487ctoon_api_inline bool ctoon_mut_arr_add_strncpy(ctoon_mut_doc *doc,
6488 ctoon_mut_val *arr,
6489 const char *str, size_t len) {
6490 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6491 ctoon_mut_val *val = ctoon_mut_strncpy(doc, str, len);
6492 return ctoon_mut_arr_append(arr, val);
6493 }
6494 return false;
6495}
6496
6497ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_arr(ctoon_mut_doc *doc,
6498 ctoon_mut_val *arr) {
6499 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6500 ctoon_mut_val *val = ctoon_mut_arr(doc);
6501 return ctoon_mut_arr_append(arr, val) ? val : NULL;
6502 }
6503 return NULL;
6504}
6505
6506ctoon_api_inline ctoon_mut_val *ctoon_mut_arr_add_obj(ctoon_mut_doc *doc,
6507 ctoon_mut_val *arr) {
6508 if (ctoon_likely(doc && ctoon_mut_is_arr(arr))) {
6509 ctoon_mut_val *val = ctoon_mut_obj(doc);
6510 return ctoon_mut_arr_append(arr, val) ? val : NULL;
6511 }
6512 return NULL;
6513}
6514
6515
6516
6517/*==============================================================================
6518 * MARK: - Mutable TOON Object API (Implementation)
6519 *============================================================================*/
6520
6521ctoon_api_inline size_t ctoon_mut_obj_size(ctoon_mut_val *obj) {
6522 return ctoon_mut_is_obj(obj) ? unsafe_ctoon_get_len(obj) : 0;
6523}
6524
6525ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_get(ctoon_mut_val *obj,
6526 const char *key) {
6527 return ctoon_mut_obj_getn(obj, key, key ? strlen(key) : 0);
6528}
6529
6530ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_getn(ctoon_mut_val *obj,
6531 const char *_key,
6532 size_t key_len) {
6533 size_t len = ctoon_mut_obj_size(obj);
6534 if (ctoon_likely(len && _key)) {
6535 ctoon_mut_val *key = ((ctoon_mut_val *)obj->uni.ptr)->next->next;
6536 while (len-- > 0) {
6537 if (unsafe_ctoon_equals_strn(key, _key, key_len)) return key->next;
6538 key = key->next->next;
6539 }
6540 }
6541 return NULL;
6542}
6543
6544
6545
6546/*==============================================================================
6547 * MARK: - Mutable TOON Object Iterator API (Implementation)
6548 *============================================================================*/
6549
6550ctoon_api_inline bool ctoon_mut_obj_iter_init(ctoon_mut_val *obj,
6551 ctoon_mut_obj_iter *iter) {
6552 if (ctoon_likely(ctoon_mut_is_obj(obj) && iter)) {
6553 iter->idx = 0;
6554 iter->max = unsafe_ctoon_get_len(obj);
6555 iter->cur = iter->max ? (ctoon_mut_val *)obj->uni.ptr : NULL;
6556 iter->pre = NULL;
6557 iter->obj = obj;
6558 return true;
6559 }
6560 if (iter) memset(iter, 0, sizeof(ctoon_mut_obj_iter));
6561 return false;
6562}
6563
6564ctoon_api_inline ctoon_mut_obj_iter ctoon_mut_obj_iter_with(
6565 ctoon_mut_val *obj) {
6566 ctoon_mut_obj_iter iter;
6567 ctoon_mut_obj_iter_init(obj, &iter);
6568 return iter;
6569}
6570
6571ctoon_api_inline bool ctoon_mut_obj_iter_has_next(ctoon_mut_obj_iter *iter) {
6572 return iter ? iter->idx < iter->max : false;
6573}
6574
6575ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_next(
6576 ctoon_mut_obj_iter *iter) {
6577 if (iter && iter->idx < iter->max) {
6578 ctoon_mut_val *key = iter->cur;
6579 iter->pre = key;
6580 iter->cur = key->next->next;
6581 iter->idx++;
6582 return iter->cur;
6583 }
6584 return NULL;
6585}
6586
6587ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get_val(
6588 ctoon_mut_val *key) {
6589 return key ? key->next : NULL;
6590}
6591
6592ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_remove(
6593 ctoon_mut_obj_iter *iter) {
6594 if (ctoon_likely(iter && 0 < iter->idx && iter->idx <= iter->max)) {
6595 ctoon_mut_val *prev = iter->pre;
6596 ctoon_mut_val *cur = iter->cur;
6597 ctoon_mut_val *next = cur->next->next;
6598 if (ctoon_unlikely(iter->idx == iter->max)) iter->obj->uni.ptr = prev;
6599 iter->idx--;
6600 iter->max--;
6601 unsafe_ctoon_set_len(iter->obj, iter->max);
6602 prev->next->next = next;
6603 iter->cur = prev;
6604 return cur->next;
6605 }
6606 return NULL;
6607}
6608
6609ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_get(
6610 ctoon_mut_obj_iter *iter, const char *key) {
6611 return ctoon_mut_obj_iter_getn(iter, key, key ? strlen(key) : 0);
6612}
6613
6614ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_iter_getn(
6615 ctoon_mut_obj_iter *iter, const char *key, size_t key_len) {
6616 if (iter && key) {
6617 size_t idx = 0;
6618 size_t max = iter->max;
6619 ctoon_mut_val *pre, *cur = iter->cur;
6620 while (idx++ < max) {
6621 pre = cur;
6622 cur = cur->next->next;
6623 if (unsafe_ctoon_equals_strn(cur, key, key_len)) {
6624 iter->idx += idx;
6625 if (iter->idx > max) iter->idx -= max + 1;
6626 iter->pre = pre;
6627 iter->cur = cur;
6628 return cur->next;
6629 }
6630 }
6631 }
6632 return NULL;
6633}
6634
6635
6636
6637/*==============================================================================
6638 * MARK: - Mutable TOON Object Creation API (Implementation)
6639 *============================================================================*/
6640
6641ctoon_api_inline ctoon_mut_val *ctoon_mut_obj(ctoon_mut_doc *doc) {
6642 if (ctoon_likely(doc)) {
6643 ctoon_mut_val *val = unsafe_ctoon_mut_val(doc, 1);
6644 if (ctoon_likely(val)) {
6645 val->tag = CTOON_TYPE_OBJ | CTOON_SUBTYPE_NONE;
6646 return val;
6647 }
6648 }
6649 return NULL;
6650}
6651
6652ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_str(ctoon_mut_doc *doc,
6653 const char **keys,
6654 const char **vals,
6655 size_t count) {
6656 if (ctoon_likely(doc && ((count > 0 && keys && vals) || (count == 0)))) {
6657 ctoon_mut_val *obj = unsafe_ctoon_mut_val(doc, 1 + count * 2);
6658 if (ctoon_likely(obj)) {
6659 obj->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_OBJ;
6660 if (count > 0) {
6661 size_t i;
6662 for (i = 0; i < count; i++) {
6663 ctoon_mut_val *key = obj + (i * 2 + 1);
6664 ctoon_mut_val *val = obj + (i * 2 + 2);
6665 uint64_t key_len = (uint64_t)strlen(keys[i]);
6666 uint64_t val_len = (uint64_t)strlen(vals[i]);
6667 key->tag = (key_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6668 val->tag = (val_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6669 key->uni.str = keys[i];
6670 val->uni.str = vals[i];
6671 key->next = val;
6672 val->next = val + 1;
6673 }
6674 obj[count * 2].next = obj + 1;
6675 obj->uni.ptr = obj + (count * 2 - 1);
6676 }
6677 return obj;
6678 }
6679 }
6680 return NULL;
6681}
6682
6683ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_with_kv(ctoon_mut_doc *doc,
6684 const char **pairs,
6685 size_t count) {
6686 if (ctoon_likely(doc && ((count > 0 && pairs) || (count == 0)))) {
6687 ctoon_mut_val *obj = unsafe_ctoon_mut_val(doc, 1 + count * 2);
6688 if (ctoon_likely(obj)) {
6689 obj->tag = ((uint64_t)count << CTOON_TAG_BIT) | CTOON_TYPE_OBJ;
6690 if (count > 0) {
6691 size_t i;
6692 for (i = 0; i < count; i++) {
6693 ctoon_mut_val *key = obj + (i * 2 + 1);
6694 ctoon_mut_val *val = obj + (i * 2 + 2);
6695 const char *key_str = pairs[i * 2 + 0];
6696 const char *val_str = pairs[i * 2 + 1];
6697 uint64_t key_len = (uint64_t)strlen(key_str);
6698 uint64_t val_len = (uint64_t)strlen(val_str);
6699 key->tag = (key_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6700 val->tag = (val_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
6701 key->uni.str = key_str;
6702 val->uni.str = val_str;
6703 key->next = val;
6704 val->next = val + 1;
6705 }
6706 obj[count * 2].next = obj + 1;
6707 obj->uni.ptr = obj + (count * 2 - 1);
6708 }
6709 return obj;
6710 }
6711 }
6712 return NULL;
6713}
6714
6715
6716
6717/*==============================================================================
6718 * MARK: - Mutable TOON Object Modification API (Implementation)
6719 *============================================================================*/
6720
6721ctoon_api_inline void unsafe_ctoon_mut_obj_add(ctoon_mut_val *obj,
6722 ctoon_mut_val *key,
6723 ctoon_mut_val *val,
6724 size_t len) {
6725 if (ctoon_likely(len)) {
6726 ctoon_mut_val *prev_val = ((ctoon_mut_val *)obj->uni.ptr)->next;
6727 ctoon_mut_val *next_key = prev_val->next;
6728 prev_val->next = key;
6729 val->next = next_key;
6730 } else {
6731 val->next = key;
6732 }
6733 key->next = val;
6734 obj->uni.ptr = (void *)key;
6735 unsafe_ctoon_set_len(obj, len + 1);
6736}
6737
6738ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_obj_remove(
6739 ctoon_mut_val *obj, const char *key, size_t key_len) {
6740 size_t obj_len = unsafe_ctoon_get_len(obj);
6741 if (obj_len) {
6742 ctoon_mut_val *pre_key = (ctoon_mut_val *)obj->uni.ptr;
6743 ctoon_mut_val *cur_key = pre_key->next->next;
6744 ctoon_mut_val *removed_item = NULL;
6745 size_t i;
6746 for (i = 0; i < obj_len; i++) {
6747 if (unsafe_ctoon_equals_strn(cur_key, key, key_len)) {
6748 if (!removed_item) removed_item = cur_key->next;
6749 cur_key = cur_key->next->next;
6750 pre_key->next->next = cur_key;
6751 if (i + 1 == obj_len) obj->uni.ptr = pre_key;
6752 i--;
6753 obj_len--;
6754 } else {
6755 pre_key = cur_key;
6756 cur_key = cur_key->next->next;
6757 }
6758 }
6759 unsafe_ctoon_set_len(obj, obj_len);
6760 return removed_item;
6761 } else {
6762 return NULL;
6763 }
6764}
6765
6766ctoon_api_inline bool unsafe_ctoon_mut_obj_replace(ctoon_mut_val *obj,
6767 ctoon_mut_val *key,
6768 ctoon_mut_val *val) {
6769 size_t key_len = unsafe_ctoon_get_len(key);
6770 size_t obj_len = unsafe_ctoon_get_len(obj);
6771 if (obj_len) {
6772 ctoon_mut_val *pre_key = (ctoon_mut_val *)obj->uni.ptr;
6773 ctoon_mut_val *cur_key = pre_key->next->next;
6774 size_t i;
6775 for (i = 0; i < obj_len; i++) {
6776 if (unsafe_ctoon_equals_strn(cur_key, key->uni.str, key_len)) {
6777 cur_key->next->tag = val->tag;
6778 cur_key->next->uni.u64 = val->uni.u64;
6779 return true;
6780 } else {
6781 cur_key = cur_key->next->next;
6782 }
6783 }
6784 }
6785 return false;
6786}
6787
6788ctoon_api_inline void unsafe_ctoon_mut_obj_rotate(ctoon_mut_val *obj,
6789 size_t idx) {
6790 ctoon_mut_val *key = (ctoon_mut_val *)obj->uni.ptr;
6791 while (idx-- > 0) key = key->next->next;
6792 obj->uni.ptr = (void *)key;
6793}
6794
6795ctoon_api_inline bool ctoon_mut_obj_add(ctoon_mut_val *obj,
6796 ctoon_mut_val *key,
6797 ctoon_mut_val *val) {
6798 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
6799 ctoon_mut_is_str(key) && val)) {
6800 unsafe_ctoon_mut_obj_add(obj, key, val, unsafe_ctoon_get_len(obj));
6801 return true;
6802 }
6803 return false;
6804}
6805
6806ctoon_api_inline bool ctoon_mut_obj_put(ctoon_mut_val *obj,
6807 ctoon_mut_val *key,
6808 ctoon_mut_val *val) {
6809 bool replaced = false;
6810 size_t key_len;
6811 ctoon_mut_obj_iter iter;
6812 ctoon_mut_val *cur_key;
6813 if (ctoon_unlikely(!ctoon_mut_is_obj(obj) ||
6814 !ctoon_mut_is_str(key))) return false;
6815 key_len = unsafe_ctoon_get_len(key);
6816 ctoon_mut_obj_iter_init(obj, &iter);
6817 while ((cur_key = ctoon_mut_obj_iter_next(&iter)) != 0) {
6818 if (unsafe_ctoon_equals_strn(cur_key, key->uni.str, key_len)) {
6819 if (!replaced && val) {
6820 replaced = true;
6821 val->next = cur_key->next->next;
6822 cur_key->next = val;
6823 } else {
6824 ctoon_mut_obj_iter_remove(&iter);
6825 }
6826 }
6827 }
6828 if (!replaced && val) unsafe_ctoon_mut_obj_add(obj, key, val, iter.max);
6829 return true;
6830}
6831
6832ctoon_api_inline bool ctoon_mut_obj_insert(ctoon_mut_val *obj,
6833 ctoon_mut_val *key,
6834 ctoon_mut_val *val,
6835 size_t idx) {
6836 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
6837 ctoon_mut_is_str(key) && val)) {
6838 size_t len = unsafe_ctoon_get_len(obj);
6839 if (ctoon_likely(len >= idx)) {
6840 if (len > idx) {
6841 void *ptr = obj->uni.ptr;
6842 unsafe_ctoon_mut_obj_rotate(obj, idx);
6843 unsafe_ctoon_mut_obj_add(obj, key, val, len);
6844 obj->uni.ptr = ptr;
6845 } else {
6846 unsafe_ctoon_mut_obj_add(obj, key, val, len);
6847 }
6848 return true;
6849 }
6850 }
6851 return false;
6852}
6853
6854ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove(ctoon_mut_val *obj,
6855 ctoon_mut_val *key) {
6856 if (ctoon_likely(ctoon_mut_is_obj(obj) && ctoon_mut_is_str(key))) {
6857 return unsafe_ctoon_mut_obj_remove(obj, key->uni.str,
6858 unsafe_ctoon_get_len(key));
6859 }
6860 return NULL;
6861}
6862
6863ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_key(
6864 ctoon_mut_val *obj, const char *key) {
6865 if (ctoon_likely(ctoon_mut_is_obj(obj) && key)) {
6866 size_t key_len = strlen(key);
6867 return unsafe_ctoon_mut_obj_remove(obj, key, key_len);
6868 }
6869 return NULL;
6870}
6871
6872ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_keyn(
6873 ctoon_mut_val *obj, const char *key, size_t key_len) {
6874 if (ctoon_likely(ctoon_mut_is_obj(obj) && key)) {
6875 return unsafe_ctoon_mut_obj_remove(obj, key, key_len);
6876 }
6877 return NULL;
6878}
6879
6880ctoon_api_inline bool ctoon_mut_obj_clear(ctoon_mut_val *obj) {
6881 if (ctoon_likely(ctoon_mut_is_obj(obj))) {
6882 unsafe_ctoon_set_len(obj, 0);
6883 return true;
6884 }
6885 return false;
6886}
6887
6888ctoon_api_inline bool ctoon_mut_obj_replace(ctoon_mut_val *obj,
6889 ctoon_mut_val *key,
6890 ctoon_mut_val *val) {
6891 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
6892 ctoon_mut_is_str(key) && val)) {
6893 return unsafe_ctoon_mut_obj_replace(obj, key, val);
6894 }
6895 return false;
6896}
6897
6898ctoon_api_inline bool ctoon_mut_obj_rotate(ctoon_mut_val *obj,
6899 size_t idx) {
6900 if (ctoon_likely(ctoon_mut_is_obj(obj) &&
6901 unsafe_ctoon_get_len(obj) > idx)) {
6902 unsafe_ctoon_mut_obj_rotate(obj, idx);
6903 return true;
6904 }
6905 return false;
6906}
6907
6908
6909
6910/*==============================================================================
6911 * MARK: - Mutable TOON Object Modification Convenience API (Implementation)
6912 *============================================================================*/
6913
6914#define ctoon_mut_obj_add_func(func) \
6915 if (ctoon_likely(doc && ctoon_mut_is_obj(obj) && _key)) { \
6916 ctoon_mut_val *key = unsafe_ctoon_mut_val(doc, 2); \
6917 if (ctoon_likely(key)) { \
6918 size_t len = unsafe_ctoon_get_len(obj); \
6919 ctoon_mut_val *val = key + 1; \
6920 size_t key_len = strlen(_key); \
6921 bool noesc = unsafe_ctoon_is_str_noesc(_key, key_len); \
6922 key->tag = CTOON_TYPE_STR; \
6923 key->tag |= noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE; \
6924 key->tag |= (uint64_t)strlen(_key) << CTOON_TAG_BIT; \
6925 key->uni.str = _key; \
6926 func \
6927 unsafe_ctoon_mut_obj_add(obj, key, val, len); \
6928 return true; \
6929 } \
6930 } \
6931 return false
6932
6933ctoon_api_inline bool ctoon_mut_obj_add_null(ctoon_mut_doc *doc,
6934 ctoon_mut_val *obj,
6935 const char *_key) {
6936 ctoon_mut_obj_add_func({ unsafe_ctoon_set_null(val); });
6937}
6938
6939ctoon_api_inline bool ctoon_mut_obj_add_true(ctoon_mut_doc *doc,
6940 ctoon_mut_val *obj,
6941 const char *_key) {
6942 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, true); });
6943}
6944
6945ctoon_api_inline bool ctoon_mut_obj_add_false(ctoon_mut_doc *doc,
6946 ctoon_mut_val *obj,
6947 const char *_key) {
6948 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, false); });
6949}
6950
6951ctoon_api_inline bool ctoon_mut_obj_add_bool(ctoon_mut_doc *doc,
6952 ctoon_mut_val *obj,
6953 const char *_key,
6954 bool _val) {
6955 ctoon_mut_obj_add_func({ unsafe_ctoon_set_bool(val, _val); });
6956}
6957
6958ctoon_api_inline bool ctoon_mut_obj_add_uint(ctoon_mut_doc *doc,
6959 ctoon_mut_val *obj,
6960 const char *_key,
6961 uint64_t _val) {
6962 ctoon_mut_obj_add_func({ unsafe_ctoon_set_uint(val, _val); });
6963}
6964
6965ctoon_api_inline bool ctoon_mut_obj_add_sint(ctoon_mut_doc *doc,
6966 ctoon_mut_val *obj,
6967 const char *_key,
6968 int64_t _val) {
6969 ctoon_mut_obj_add_func({ unsafe_ctoon_set_sint(val, _val); });
6970}
6971
6972ctoon_api_inline bool ctoon_mut_obj_add_int(ctoon_mut_doc *doc,
6973 ctoon_mut_val *obj,
6974 const char *_key,
6975 int64_t _val) {
6976 ctoon_mut_obj_add_func({ unsafe_ctoon_set_sint(val, _val); });
6977}
6978
6979ctoon_api_inline bool ctoon_mut_obj_add_float(ctoon_mut_doc *doc,
6980 ctoon_mut_val *obj,
6981 const char *_key,
6982 float _val) {
6983 ctoon_mut_obj_add_func({ unsafe_ctoon_set_float(val, _val); });
6984}
6985
6986ctoon_api_inline bool ctoon_mut_obj_add_double(ctoon_mut_doc *doc,
6987 ctoon_mut_val *obj,
6988 const char *_key,
6989 double _val) {
6990 ctoon_mut_obj_add_func({ unsafe_ctoon_set_double(val, _val); });
6991}
6992
6993ctoon_api_inline bool ctoon_mut_obj_add_real(ctoon_mut_doc *doc,
6994 ctoon_mut_val *obj,
6995 const char *_key,
6996 double _val) {
6997 ctoon_mut_obj_add_func({ unsafe_ctoon_set_real(val, _val); });
6998}
6999
7000ctoon_api_inline bool ctoon_mut_obj_add_str(ctoon_mut_doc *doc,
7001 ctoon_mut_val *obj,
7002 const char *_key,
7003 const char *_val) {
7004 if (ctoon_unlikely(!_val)) return false;
7005 ctoon_mut_obj_add_func({
7006 size_t val_len = strlen(_val);
7007 bool val_noesc = unsafe_ctoon_is_str_noesc(_val, val_len);
7008 val->tag = ((uint64_t)strlen(_val) << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7009 val->tag |= val_noesc ? CTOON_SUBTYPE_NOESC : CTOON_SUBTYPE_NONE;
7010 val->uni.str = _val;
7011 });
7012}
7013
7014ctoon_api_inline bool ctoon_mut_obj_add_strn(ctoon_mut_doc *doc,
7015 ctoon_mut_val *obj,
7016 const char *_key,
7017 const char *_val,
7018 size_t _len) {
7019 if (ctoon_unlikely(!_val)) return false;
7020 ctoon_mut_obj_add_func({
7021 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7022 val->uni.str = _val;
7023 });
7024}
7025
7026ctoon_api_inline bool ctoon_mut_obj_add_strcpy(ctoon_mut_doc *doc,
7027 ctoon_mut_val *obj,
7028 const char *_key,
7029 const char *_val) {
7030 if (ctoon_unlikely(!_val)) return false;
7031 ctoon_mut_obj_add_func({
7032 size_t _len = strlen(_val);
7033 val->uni.str = unsafe_ctoon_mut_strncpy(doc, _val, _len);
7034 if (ctoon_unlikely(!val->uni.str)) return false;
7035 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7036 });
7037}
7038
7039ctoon_api_inline bool ctoon_mut_obj_add_strncpy(ctoon_mut_doc *doc,
7040 ctoon_mut_val *obj,
7041 const char *_key,
7042 const char *_val,
7043 size_t _len) {
7044 if (ctoon_unlikely(!_val)) return false;
7045 ctoon_mut_obj_add_func({
7046 val->uni.str = unsafe_ctoon_mut_strncpy(doc, _val, _len);
7047 if (ctoon_unlikely(!val->uni.str)) return false;
7048 val->tag = ((uint64_t)_len << CTOON_TAG_BIT) | CTOON_TYPE_STR;
7049 });
7050}
7051
7052ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_arr(ctoon_mut_doc *doc,
7053 ctoon_mut_val *obj,
7054 const char *_key) {
7055 ctoon_mut_val *key = ctoon_mut_str(doc, _key);
7056 ctoon_mut_val *val = ctoon_mut_arr(doc);
7057 return ctoon_mut_obj_add(obj, key, val) ? val : NULL;
7058}
7059
7060ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_add_obj(ctoon_mut_doc *doc,
7061 ctoon_mut_val *obj,
7062 const char *_key) {
7063 ctoon_mut_val *key = ctoon_mut_str(doc, _key);
7064 ctoon_mut_val *val = ctoon_mut_obj(doc);
7065 return ctoon_mut_obj_add(obj, key, val) ? val : NULL;
7066}
7067
7068ctoon_api_inline bool ctoon_mut_obj_add_val(ctoon_mut_doc *doc,
7069 ctoon_mut_val *obj,
7070 const char *_key,
7071 ctoon_mut_val *_val) {
7072 if (ctoon_unlikely(!_val)) return false;
7073 ctoon_mut_obj_add_func({
7074 val = _val;
7075 });
7076}
7077
7078ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_str(ctoon_mut_val *obj,
7079 const char *key) {
7080 return ctoon_mut_obj_remove_strn(obj, key, key ? strlen(key) : 0);
7081}
7082
7083ctoon_api_inline ctoon_mut_val *ctoon_mut_obj_remove_strn(
7084 ctoon_mut_val *obj, const char *_key, size_t _len) {
7085 if (ctoon_likely(ctoon_mut_is_obj(obj) && _key)) {
7086 ctoon_mut_val *key;
7087 ctoon_mut_obj_iter iter;
7088 ctoon_mut_val *val_removed = NULL;
7089 ctoon_mut_obj_iter_init(obj, &iter);
7090 while ((key = ctoon_mut_obj_iter_next(&iter)) != NULL) {
7091 if (unsafe_ctoon_equals_strn(key, _key, _len)) {
7092 if (!val_removed) val_removed = key->next;
7093 ctoon_mut_obj_iter_remove(&iter);
7094 }
7095 }
7096 return val_removed;
7097 }
7098 return NULL;
7099}
7100
7101ctoon_api_inline bool ctoon_mut_obj_rename_key(ctoon_mut_doc *doc,
7102 ctoon_mut_val *obj,
7103 const char *key,
7104 const char *new_key) {
7105 if (!key || !new_key) return false;
7106 return ctoon_mut_obj_rename_keyn(doc, obj, key, strlen(key),
7107 new_key, strlen(new_key));
7108}
7109
7110ctoon_api_inline bool ctoon_mut_obj_rename_keyn(ctoon_mut_doc *doc,
7111 ctoon_mut_val *obj,
7112 const char *key,
7113 size_t len,
7114 const char *new_key,
7115 size_t new_len) {
7116 char *cpy_key = NULL;
7117 ctoon_mut_val *old_key;
7118 ctoon_mut_obj_iter iter;
7119 if (!doc || !obj || !key || !new_key) return false;
7120 ctoon_mut_obj_iter_init(obj, &iter);
7121 while ((old_key = ctoon_mut_obj_iter_next(&iter))) {
7122 if (unsafe_ctoon_equals_strn((void *)old_key, key, len)) {
7123 if (!cpy_key) {
7124 cpy_key = unsafe_ctoon_mut_strncpy(doc, new_key, new_len);
7125 if (!cpy_key) return false;
7126 }
7127 ctoon_mut_set_strn(old_key, cpy_key, new_len);
7128 }
7129 }
7130 return cpy_key != NULL;
7131}
7132
7133
7134
7135#if !defined(CTOON_DISABLE_UTILS) || !CTOON_DISABLE_UTILS
7136
7137/*==============================================================================
7138 * MARK: - TOON Pointer API (Implementation)
7139 *============================================================================*/
7140
7141#define ctoon_ptr_set_err(_code, _msg) do { \
7142 if (err) { \
7143 err->code = CTOON_PTR_ERR_##_code; \
7144 err->msg = _msg; \
7145 err->pos = 0; \
7146 } \
7147} while(false)
7148
7149/* require: val != NULL, *ptr == '/', len > 0 */
7150ctoon_api ctoon_val *unsafe_ctoon_ptr_getx(ctoon_val *val,
7151 const char *ptr, size_t len,
7152 ctoon_ptr_err *err);
7153
7154/* require: val != NULL, *ptr == '/', len > 0 */
7155ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_getx(ctoon_mut_val *val,
7156 const char *ptr,
7157 size_t len,
7158 ctoon_ptr_ctx *ctx,
7159 ctoon_ptr_err *err);
7160
7161/* require: val/new_val/doc != NULL, *ptr == '/', len > 0 */
7162ctoon_api bool unsafe_ctoon_mut_ptr_putx(ctoon_mut_val *val,
7163 const char *ptr, size_t len,
7164 ctoon_mut_val *new_val,
7165 ctoon_mut_doc *doc,
7166 bool create_parent, bool insert_new,
7167 ctoon_ptr_ctx *ctx,
7168 ctoon_ptr_err *err);
7169
7170/* require: val/err != NULL, *ptr == '/', len > 0 */
7171ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_replacex(
7172 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
7173 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err);
7174
7175/* require: val/err != NULL, *ptr == '/', len > 0 */
7176ctoon_api ctoon_mut_val *unsafe_ctoon_mut_ptr_removex(ctoon_mut_val *val,
7177 const char *ptr,
7178 size_t len,
7179 ctoon_ptr_ctx *ctx,
7180 ctoon_ptr_err *err);
7181
7182ctoon_api_inline ctoon_val *ctoon_doc_ptr_get(ctoon_doc *doc,
7183 const char *ptr) {
7184 if (ctoon_unlikely(!ptr)) return NULL;
7185 return ctoon_doc_ptr_getn(doc, ptr, strlen(ptr));
7186}
7187
7188ctoon_api_inline ctoon_val *ctoon_doc_ptr_getn(ctoon_doc *doc,
7189 const char *ptr, size_t len) {
7190 return ctoon_doc_ptr_getx(doc, ptr, len, NULL);
7191}
7192
7193ctoon_api_inline ctoon_val *ctoon_doc_ptr_getx(ctoon_doc *doc,
7194 const char *ptr, size_t len,
7195 ctoon_ptr_err *err) {
7196 ctoon_ptr_set_err(NONE, NULL);
7197 if (ctoon_unlikely(!doc || !ptr)) {
7198 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7199 return NULL;
7200 }
7201 if (ctoon_unlikely(!doc->root)) {
7202 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7203 return NULL;
7204 }
7205 if (ctoon_unlikely(len == 0)) {
7206 return doc->root;
7207 }
7208 if (ctoon_unlikely(*ptr != '/')) {
7209 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7210 return NULL;
7211 }
7212 return unsafe_ctoon_ptr_getx(doc->root, ptr, len, err);
7213}
7214
7215ctoon_api_inline ctoon_val *ctoon_ptr_get(ctoon_val *val,
7216 const char *ptr) {
7217 if (ctoon_unlikely(!ptr)) return NULL;
7218 return ctoon_ptr_getn(val, ptr, strlen(ptr));
7219}
7220
7221ctoon_api_inline ctoon_val *ctoon_ptr_getn(ctoon_val *val,
7222 const char *ptr, size_t len) {
7223 return ctoon_ptr_getx(val, ptr, len, NULL);
7224}
7225
7226ctoon_api_inline ctoon_val *ctoon_ptr_getx(ctoon_val *val,
7227 const char *ptr, size_t len,
7228 ctoon_ptr_err *err) {
7229 ctoon_ptr_set_err(NONE, NULL);
7230 if (ctoon_unlikely(!val || !ptr)) {
7231 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7232 return NULL;
7233 }
7234 if (ctoon_unlikely(len == 0)) {
7235 return val;
7236 }
7237 if (ctoon_unlikely(*ptr != '/')) {
7238 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7239 return NULL;
7240 }
7241 return unsafe_ctoon_ptr_getx(val, ptr, len, err);
7242}
7243
7244ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_get(ctoon_mut_doc *doc,
7245 const char *ptr) {
7246 if (!ptr) return NULL;
7247 return ctoon_mut_doc_ptr_getn(doc, ptr, strlen(ptr));
7248}
7249
7250ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getn(ctoon_mut_doc *doc,
7251 const char *ptr,
7252 size_t len) {
7253 return ctoon_mut_doc_ptr_getx(doc, ptr, len, NULL, NULL);
7254}
7255
7256ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_getx(ctoon_mut_doc *doc,
7257 const char *ptr,
7258 size_t len,
7259 ctoon_ptr_ctx *ctx,
7260 ctoon_ptr_err *err) {
7261 ctoon_ptr_set_err(NONE, NULL);
7262 if (ctx) memset(ctx, 0, sizeof(*ctx));
7263
7264 if (ctoon_unlikely(!doc || !ptr)) {
7265 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7266 return NULL;
7267 }
7268 if (ctoon_unlikely(!doc->root)) {
7269 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7270 return NULL;
7271 }
7272 if (ctoon_unlikely(len == 0)) {
7273 return doc->root;
7274 }
7275 if (ctoon_unlikely(*ptr != '/')) {
7276 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7277 return NULL;
7278 }
7279 return unsafe_ctoon_mut_ptr_getx(doc->root, ptr, len, ctx, err);
7280}
7281
7282ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_get(ctoon_mut_val *val,
7283 const char *ptr) {
7284 if (!ptr) return NULL;
7285 return ctoon_mut_ptr_getn(val, ptr, strlen(ptr));
7286}
7287
7288ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getn(ctoon_mut_val *val,
7289 const char *ptr,
7290 size_t len) {
7291 return ctoon_mut_ptr_getx(val, ptr, len, NULL, NULL);
7292}
7293
7294ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_getx(ctoon_mut_val *val,
7295 const char *ptr,
7296 size_t len,
7297 ctoon_ptr_ctx *ctx,
7298 ctoon_ptr_err *err) {
7299 ctoon_ptr_set_err(NONE, NULL);
7300 if (ctx) memset(ctx, 0, sizeof(*ctx));
7301
7302 if (ctoon_unlikely(!val || !ptr)) {
7303 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7304 return NULL;
7305 }
7306 if (ctoon_unlikely(len == 0)) {
7307 return val;
7308 }
7309 if (ctoon_unlikely(*ptr != '/')) {
7310 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7311 return NULL;
7312 }
7313 return unsafe_ctoon_mut_ptr_getx(val, ptr, len, ctx, err);
7314}
7315
7316ctoon_api_inline bool ctoon_mut_doc_ptr_add(ctoon_mut_doc *doc,
7317 const char *ptr,
7318 ctoon_mut_val *new_val) {
7319 if (ctoon_unlikely(!ptr)) return false;
7320 return ctoon_mut_doc_ptr_addn(doc, ptr, strlen(ptr), new_val);
7321}
7322
7323ctoon_api_inline bool ctoon_mut_doc_ptr_addn(ctoon_mut_doc *doc,
7324 const char *ptr,
7325 size_t len,
7326 ctoon_mut_val *new_val) {
7327 return ctoon_mut_doc_ptr_addx(doc, ptr, len, new_val, true, NULL, NULL);
7328}
7329
7330ctoon_api_inline bool ctoon_mut_doc_ptr_addx(ctoon_mut_doc *doc,
7331 const char *ptr, size_t len,
7332 ctoon_mut_val *new_val,
7333 bool create_parent,
7334 ctoon_ptr_ctx *ctx,
7335 ctoon_ptr_err *err) {
7336 ctoon_ptr_set_err(NONE, NULL);
7337 if (ctx) memset(ctx, 0, sizeof(*ctx));
7338
7339 if (ctoon_unlikely(!doc || !ptr || !new_val)) {
7340 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7341 return false;
7342 }
7343 if (ctoon_unlikely(len == 0)) {
7344 if (doc->root) {
7345 ctoon_ptr_set_err(SET_ROOT, "cannot set document's root");
7346 return false;
7347 } else {
7348 doc->root = new_val;
7349 return true;
7350 }
7351 }
7352 if (ctoon_unlikely(*ptr != '/')) {
7353 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7354 return false;
7355 }
7356 if (ctoon_unlikely(!doc->root && !create_parent)) {
7357 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7358 return false;
7359 }
7360 if (ctoon_unlikely(!doc->root)) {
7361 ctoon_mut_val *root = ctoon_mut_obj(doc);
7362 if (ctoon_unlikely(!root)) {
7363 ctoon_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
7364 return false;
7365 }
7366 if (unsafe_ctoon_mut_ptr_putx(root, ptr, len, new_val, doc,
7367 create_parent, true, ctx, err)) {
7368 doc->root = root;
7369 return true;
7370 }
7371 return false;
7372 }
7373 return unsafe_ctoon_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
7374 create_parent, true, ctx, err);
7375}
7376
7377ctoon_api_inline bool ctoon_mut_ptr_add(ctoon_mut_val *val,
7378 const char *ptr,
7379 ctoon_mut_val *new_val,
7380 ctoon_mut_doc *doc) {
7381 if (ctoon_unlikely(!ptr)) return false;
7382 return ctoon_mut_ptr_addn(val, ptr, strlen(ptr), new_val, doc);
7383}
7384
7385ctoon_api_inline bool ctoon_mut_ptr_addn(ctoon_mut_val *val,
7386 const char *ptr, size_t len,
7387 ctoon_mut_val *new_val,
7388 ctoon_mut_doc *doc) {
7389 return ctoon_mut_ptr_addx(val, ptr, len, new_val, doc, true, NULL, NULL);
7390}
7391
7392ctoon_api_inline bool ctoon_mut_ptr_addx(ctoon_mut_val *val,
7393 const char *ptr, size_t len,
7394 ctoon_mut_val *new_val,
7395 ctoon_mut_doc *doc,
7396 bool create_parent,
7397 ctoon_ptr_ctx *ctx,
7398 ctoon_ptr_err *err) {
7399 ctoon_ptr_set_err(NONE, NULL);
7400 if (ctx) memset(ctx, 0, sizeof(*ctx));
7401
7402 if (ctoon_unlikely(!val || !ptr || !new_val || !doc)) {
7403 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7404 return false;
7405 }
7406 if (ctoon_unlikely(len == 0)) {
7407 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7408 return false;
7409 }
7410 if (ctoon_unlikely(*ptr != '/')) {
7411 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7412 return false;
7413 }
7414 return unsafe_ctoon_mut_ptr_putx(val, ptr, len, new_val,
7415 doc, create_parent, true, ctx, err);
7416}
7417
7418ctoon_api_inline bool ctoon_mut_doc_ptr_set(ctoon_mut_doc *doc,
7419 const char *ptr,
7420 ctoon_mut_val *new_val) {
7421 if (ctoon_unlikely(!ptr)) return false;
7422 return ctoon_mut_doc_ptr_setn(doc, ptr, strlen(ptr), new_val);
7423}
7424
7425ctoon_api_inline bool ctoon_mut_doc_ptr_setn(ctoon_mut_doc *doc,
7426 const char *ptr, size_t len,
7427 ctoon_mut_val *new_val) {
7428 return ctoon_mut_doc_ptr_setx(doc, ptr, len, new_val, true, NULL, NULL);
7429}
7430
7431ctoon_api_inline bool ctoon_mut_doc_ptr_setx(ctoon_mut_doc *doc,
7432 const char *ptr, size_t len,
7433 ctoon_mut_val *new_val,
7434 bool create_parent,
7435 ctoon_ptr_ctx *ctx,
7436 ctoon_ptr_err *err) {
7437 ctoon_ptr_set_err(NONE, NULL);
7438 if (ctx) memset(ctx, 0, sizeof(*ctx));
7439
7440 if (ctoon_unlikely(!doc || !ptr)) {
7441 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7442 return false;
7443 }
7444 if (ctoon_unlikely(len == 0)) {
7445 if (ctx) ctx->old = doc->root;
7446 doc->root = new_val;
7447 return true;
7448 }
7449 if (ctoon_unlikely(*ptr != '/')) {
7450 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7451 return false;
7452 }
7453 if (!new_val) {
7454 if (!doc->root) {
7455 ctoon_ptr_set_err(RESOLVE, "TOON pointer cannot be resolved");
7456 return false;
7457 }
7458 return !!unsafe_ctoon_mut_ptr_removex(doc->root, ptr, len, ctx, err);
7459 }
7460 if (ctoon_unlikely(!doc->root && !create_parent)) {
7461 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7462 return false;
7463 }
7464 if (ctoon_unlikely(!doc->root)) {
7465 ctoon_mut_val *root = ctoon_mut_obj(doc);
7466 if (ctoon_unlikely(!root)) {
7467 ctoon_ptr_set_err(MEMORY_ALLOCATION, "failed to create value");
7468 return false;
7469 }
7470 if (unsafe_ctoon_mut_ptr_putx(root, ptr, len, new_val, doc,
7471 create_parent, false, ctx, err)) {
7472 doc->root = root;
7473 return true;
7474 }
7475 return false;
7476 }
7477 return unsafe_ctoon_mut_ptr_putx(doc->root, ptr, len, new_val, doc,
7478 create_parent, false, ctx, err);
7479}
7480
7481ctoon_api_inline bool ctoon_mut_ptr_set(ctoon_mut_val *val,
7482 const char *ptr,
7483 ctoon_mut_val *new_val,
7484 ctoon_mut_doc *doc) {
7485 if (ctoon_unlikely(!ptr)) return false;
7486 return ctoon_mut_ptr_setn(val, ptr, strlen(ptr), new_val, doc);
7487}
7488
7489ctoon_api_inline bool ctoon_mut_ptr_setn(ctoon_mut_val *val,
7490 const char *ptr, size_t len,
7491 ctoon_mut_val *new_val,
7492 ctoon_mut_doc *doc) {
7493 return ctoon_mut_ptr_setx(val, ptr, len, new_val, doc, true, NULL, NULL);
7494}
7495
7496ctoon_api_inline bool ctoon_mut_ptr_setx(ctoon_mut_val *val,
7497 const char *ptr, size_t len,
7498 ctoon_mut_val *new_val,
7499 ctoon_mut_doc *doc,
7500 bool create_parent,
7501 ctoon_ptr_ctx *ctx,
7502 ctoon_ptr_err *err) {
7503 ctoon_ptr_set_err(NONE, NULL);
7504 if (ctx) memset(ctx, 0, sizeof(*ctx));
7505
7506 if (ctoon_unlikely(!val || !ptr || !doc)) {
7507 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7508 return false;
7509 }
7510 if (ctoon_unlikely(len == 0)) {
7511 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7512 return false;
7513 }
7514 if (ctoon_unlikely(*ptr != '/')) {
7515 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7516 return false;
7517 }
7518 if (!new_val) {
7519 return !!unsafe_ctoon_mut_ptr_removex(val, ptr, len, ctx, err);
7520 }
7521 return unsafe_ctoon_mut_ptr_putx(val, ptr, len, new_val, doc,
7522 create_parent, false, ctx, err);
7523}
7524
7525ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replace(
7526 ctoon_mut_doc *doc, const char *ptr, ctoon_mut_val *new_val) {
7527 if (!ptr) return NULL;
7528 return ctoon_mut_doc_ptr_replacen(doc, ptr, strlen(ptr), new_val);
7529}
7530
7531ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacen(
7532 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val) {
7533 return ctoon_mut_doc_ptr_replacex(doc, ptr, len, new_val, NULL, NULL);
7534}
7535
7536ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_replacex(
7537 ctoon_mut_doc *doc, const char *ptr, size_t len, ctoon_mut_val *new_val,
7538 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7539
7540 ctoon_ptr_set_err(NONE, NULL);
7541 if (ctx) memset(ctx, 0, sizeof(*ctx));
7542
7543 if (ctoon_unlikely(!doc || !ptr || !new_val)) {
7544 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7545 return NULL;
7546 }
7547 if (ctoon_unlikely(len == 0)) {
7548 ctoon_mut_val *root = doc->root;
7549 if (ctoon_unlikely(!root)) {
7550 ctoon_ptr_set_err(RESOLVE, "TOON pointer cannot be resolved");
7551 return NULL;
7552 }
7553 if (ctx) ctx->old = root;
7554 doc->root = new_val;
7555 return root;
7556 }
7557 if (ctoon_unlikely(!doc->root)) {
7558 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7559 return NULL;
7560 }
7561 if (ctoon_unlikely(*ptr != '/')) {
7562 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7563 return NULL;
7564 }
7565 return unsafe_ctoon_mut_ptr_replacex(doc->root, ptr, len, new_val,
7566 ctx, err);
7567}
7568
7569ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replace(
7570 ctoon_mut_val *val, const char *ptr, ctoon_mut_val *new_val) {
7571 if (!ptr) return NULL;
7572 return ctoon_mut_ptr_replacen(val, ptr, strlen(ptr), new_val);
7573}
7574
7575ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacen(
7576 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val) {
7577 return ctoon_mut_ptr_replacex(val, ptr, len, new_val, NULL, NULL);
7578}
7579
7580ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_replacex(
7581 ctoon_mut_val *val, const char *ptr, size_t len, ctoon_mut_val *new_val,
7582 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7583
7584 ctoon_ptr_set_err(NONE, NULL);
7585 if (ctx) memset(ctx, 0, sizeof(*ctx));
7586
7587 if (ctoon_unlikely(!val || !ptr || !new_val)) {
7588 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7589 return NULL;
7590 }
7591 if (ctoon_unlikely(len == 0)) {
7592 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7593 return NULL;
7594 }
7595 if (ctoon_unlikely(*ptr != '/')) {
7596 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7597 return NULL;
7598 }
7599 return unsafe_ctoon_mut_ptr_replacex(val, ptr, len, new_val, ctx, err);
7600}
7601
7602ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_remove(
7603 ctoon_mut_doc *doc, const char *ptr) {
7604 if (!ptr) return NULL;
7605 return ctoon_mut_doc_ptr_removen(doc, ptr, strlen(ptr));
7606}
7607
7608ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removen(
7609 ctoon_mut_doc *doc, const char *ptr, size_t len) {
7610 return ctoon_mut_doc_ptr_removex(doc, ptr, len, NULL, NULL);
7611}
7612
7613ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_ptr_removex(
7614 ctoon_mut_doc *doc, const char *ptr, size_t len,
7615 ctoon_ptr_ctx *ctx, ctoon_ptr_err *err) {
7616
7617 ctoon_ptr_set_err(NONE, NULL);
7618 if (ctx) memset(ctx, 0, sizeof(*ctx));
7619
7620 if (ctoon_unlikely(!doc || !ptr)) {
7621 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7622 return NULL;
7623 }
7624 if (ctoon_unlikely(!doc->root)) {
7625 ctoon_ptr_set_err(NULL_ROOT, "document's root is NULL");
7626 return NULL;
7627 }
7628 if (ctoon_unlikely(len == 0)) {
7629 ctoon_mut_val *root = doc->root;
7630 if (ctx) ctx->old = root;
7631 doc->root = NULL;
7632 return root;
7633 }
7634 if (ctoon_unlikely(*ptr != '/')) {
7635 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7636 return NULL;
7637 }
7638 return unsafe_ctoon_mut_ptr_removex(doc->root, ptr, len, ctx, err);
7639}
7640
7641ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_remove(ctoon_mut_val *val,
7642 const char *ptr) {
7643 if (!ptr) return NULL;
7644 return ctoon_mut_ptr_removen(val, ptr, strlen(ptr));
7645}
7646
7647ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removen(ctoon_mut_val *val,
7648 const char *ptr,
7649 size_t len) {
7650 return ctoon_mut_ptr_removex(val, ptr, len, NULL, NULL);
7651}
7652
7653ctoon_api_inline ctoon_mut_val *ctoon_mut_ptr_removex(ctoon_mut_val *val,
7654 const char *ptr,
7655 size_t len,
7656 ctoon_ptr_ctx *ctx,
7657 ctoon_ptr_err *err) {
7658 ctoon_ptr_set_err(NONE, NULL);
7659 if (ctx) memset(ctx, 0, sizeof(*ctx));
7660
7661 if (ctoon_unlikely(!val || !ptr)) {
7662 ctoon_ptr_set_err(PARAMETER, "input parameter is NULL");
7663 return NULL;
7664 }
7665 if (ctoon_unlikely(len == 0)) {
7666 ctoon_ptr_set_err(SET_ROOT, "cannot set root");
7667 return NULL;
7668 }
7669 if (ctoon_unlikely(*ptr != '/')) {
7670 ctoon_ptr_set_err(SYNTAX, "no prefix '/'");
7671 return NULL;
7672 }
7673 return unsafe_ctoon_mut_ptr_removex(val, ptr, len, ctx, err);
7674}
7675
7676ctoon_api_inline bool ctoon_ptr_ctx_append(ctoon_ptr_ctx *ctx,
7677 ctoon_mut_val *key,
7678 ctoon_mut_val *val) {
7679 ctoon_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
7680 if (!ctx || !ctx->ctn || !val) return false;
7681 ctn = ctx->ctn;
7682
7683 if (ctoon_mut_is_obj(ctn)) {
7684 if (!key) return false;
7685 key->next = val;
7686 pre_key = ctx->pre;
7687 if (unsafe_ctoon_get_len(ctn) == 0) {
7688 val->next = key;
7689 ctn->uni.ptr = key;
7690 ctx->pre = key;
7691 } else if (!pre_key) {
7692 pre_key = (ctoon_mut_val *)ctn->uni.ptr;
7693 pre_val = pre_key->next;
7694 val->next = pre_val->next;
7695 pre_val->next = key;
7696 ctn->uni.ptr = key;
7697 ctx->pre = pre_key;
7698 } else {
7699 cur_key = pre_key->next->next;
7700 cur_val = cur_key->next;
7701 val->next = cur_val->next;
7702 cur_val->next = key;
7703 if (ctn->uni.ptr == cur_key) ctn->uni.ptr = key;
7704 ctx->pre = cur_key;
7705 }
7706 } else {
7707 pre_val = ctx->pre;
7708 if (unsafe_ctoon_get_len(ctn) == 0) {
7709 val->next = val;
7710 ctn->uni.ptr = val;
7711 ctx->pre = val;
7712 } else if (!pre_val) {
7713 pre_val = (ctoon_mut_val *)ctn->uni.ptr;
7714 val->next = pre_val->next;
7715 pre_val->next = val;
7716 ctn->uni.ptr = val;
7717 ctx->pre = pre_val;
7718 } else {
7719 cur_val = pre_val->next;
7720 val->next = cur_val->next;
7721 cur_val->next = val;
7722 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
7723 ctx->pre = cur_val;
7724 }
7725 }
7726 unsafe_ctoon_inc_len(ctn);
7727 return true;
7728}
7729
7730ctoon_api_inline bool ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx,
7731 ctoon_mut_val *val) {
7732 ctoon_mut_val *ctn, *pre_key, *cur_key, *pre_val, *cur_val;
7733 if (!ctx || !ctx->ctn || !ctx->pre || !val) return false;
7734 ctn = ctx->ctn;
7735 if (ctoon_mut_is_obj(ctn)) {
7736 pre_key = ctx->pre;
7737 pre_val = pre_key->next;
7738 cur_key = pre_val->next;
7739 cur_val = cur_key->next;
7740 /* replace current value */
7741 cur_key->next = val;
7742 val->next = cur_val->next;
7743 ctx->old = cur_val;
7744 } else {
7745 pre_val = ctx->pre;
7746 cur_val = pre_val->next;
7747 /* replace current value */
7748 if (pre_val != cur_val) {
7749 val->next = cur_val->next;
7750 pre_val->next = val;
7751 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = val;
7752 } else {
7753 val->next = val;
7754 ctn->uni.ptr = val;
7755 ctx->pre = val;
7756 }
7757 ctx->old = cur_val;
7758 }
7759 return true;
7760}
7761
7762ctoon_api_inline bool ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx) {
7763 ctoon_mut_val *ctn, *pre_key, *pre_val, *cur_key, *cur_val;
7764 size_t len;
7765 if (!ctx || !ctx->ctn || !ctx->pre) return false;
7766 ctn = ctx->ctn;
7767 if (ctoon_mut_is_obj(ctn)) {
7768 pre_key = ctx->pre;
7769 pre_val = pre_key->next;
7770 cur_key = pre_val->next;
7771 cur_val = cur_key->next;
7772 /* remove current key-value */
7773 pre_val->next = cur_val->next;
7774 if (ctn->uni.ptr == cur_key) ctn->uni.ptr = pre_key;
7775 ctx->pre = NULL;
7776 ctx->old = cur_val;
7777 } else {
7778 pre_val = ctx->pre;
7779 cur_val = pre_val->next;
7780 /* remove current key-value */
7781 pre_val->next = cur_val->next;
7782 if (ctn->uni.ptr == cur_val) ctn->uni.ptr = pre_val;
7783 ctx->pre = NULL;
7784 ctx->old = cur_val;
7785 }
7786 len = unsafe_ctoon_get_len(ctn) - 1;
7787 if (len == 0) ctn->uni.ptr = NULL;
7788 unsafe_ctoon_set_len(ctn, len);
7789 return true;
7790}
7791
7792#undef ctoon_ptr_set_err
7793
7794
7795
7796/*==============================================================================
7797 * MARK: - TOON Value at Pointer API (Implementation)
7798 *============================================================================*/
7799
7804ctoon_api_inline bool ctoon_ptr_get_bool(
7805 ctoon_val *root, const char *ptr, bool *value) {
7806 ctoon_val *val = ctoon_ptr_get(root, ptr);
7807 if (value && ctoon_is_bool(val)) {
7808 *value = unsafe_ctoon_get_bool(val);
7809 return true;
7810 } else {
7811 return false;
7812 }
7813}
7814
7819ctoon_api_inline bool ctoon_ptr_get_uint(
7820 ctoon_val *root, const char *ptr, uint64_t *value) {
7821 ctoon_val *val = ctoon_ptr_get(root, ptr);
7822 if (value && val) {
7823 uint64_t ret = val->uni.u64;
7824 if (unsafe_ctoon_is_uint(val) ||
7825 (unsafe_ctoon_is_sint(val) && !(ret >> 63))) {
7826 *value = ret;
7827 return true;
7828 }
7829 }
7830 return false;
7831}
7832
7837ctoon_api_inline bool ctoon_ptr_get_sint(
7838 ctoon_val *root, const char *ptr, int64_t *value) {
7839 ctoon_val *val = ctoon_ptr_get(root, ptr);
7840 if (value && val) {
7841 int64_t ret = val->uni.i64;
7842 if (unsafe_ctoon_is_sint(val) ||
7843 (unsafe_ctoon_is_uint(val) && ret >= 0)) {
7844 *value = ret;
7845 return true;
7846 }
7847 }
7848 return false;
7849}
7850
7855ctoon_api_inline bool ctoon_ptr_get_real(
7856 ctoon_val *root, const char *ptr, double *value) {
7857 ctoon_val *val = ctoon_ptr_get(root, ptr);
7858 if (value && ctoon_is_real(val)) {
7859 *value = unsafe_ctoon_get_real(val);
7860 return true;
7861 } else {
7862 return false;
7863 }
7864}
7865
7871ctoon_api_inline bool ctoon_ptr_get_num(
7872 ctoon_val *root, const char *ptr, double *value) {
7873 ctoon_val *val = ctoon_ptr_get(root, ptr);
7874 if (value && ctoon_is_num(val)) {
7875 *value = unsafe_ctoon_get_num(val);
7876 return true;
7877 } else {
7878 return false;
7879 }
7880}
7881
7886ctoon_api_inline bool ctoon_ptr_get_str(
7887 ctoon_val *root, const char *ptr, const char **value) {
7888 ctoon_val *val = ctoon_ptr_get(root, ptr);
7889 if (value && ctoon_is_str(val)) {
7890 *value = unsafe_ctoon_get_str(val);
7891 return true;
7892 } else {
7893 return false;
7894 }
7895}
7896
7897
7898
7899/*==============================================================================
7900 * MARK: - Deprecated
7901 *============================================================================*/
7902
7904ctoon_deprecated("renamed to ctoon_doc_ptr_get")
7905ctoon_api_inline ctoon_val *ctoon_doc_get_pointer(ctoon_doc *doc,
7906 const char *ptr) {
7907 return ctoon_doc_ptr_get(doc, ptr);
7908}
7909
7911ctoon_deprecated("renamed to ctoon_doc_ptr_getn")
7912ctoon_api_inline ctoon_val *ctoon_doc_get_pointern(ctoon_doc *doc,
7913 const char *ptr,
7914 size_t len) {
7915 return ctoon_doc_ptr_getn(doc, ptr, len);
7916}
7917
7919ctoon_deprecated("renamed to ctoon_mut_doc_ptr_get")
7920ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_pointer(
7921 ctoon_mut_doc *doc, const char *ptr) {
7922 return ctoon_mut_doc_ptr_get(doc, ptr);
7923}
7924
7926ctoon_deprecated("renamed to ctoon_mut_doc_ptr_getn")
7927ctoon_api_inline ctoon_mut_val *ctoon_mut_doc_get_pointern(
7928 ctoon_mut_doc *doc, const char *ptr, size_t len) {
7929 return ctoon_mut_doc_ptr_getn(doc, ptr, len);
7930}
7931
7933ctoon_deprecated("renamed to ctoon_ptr_get")
7934ctoon_api_inline ctoon_val *ctoon_get_pointer(ctoon_val *val,
7935 const char *ptr) {
7936 return ctoon_ptr_get(val, ptr);
7937}
7938
7940ctoon_deprecated("renamed to ctoon_ptr_getn")
7941ctoon_api_inline ctoon_val *ctoon_get_pointern(ctoon_val *val,
7942 const char *ptr,
7943 size_t len) {
7944 return ctoon_ptr_getn(val, ptr, len);
7945}
7946
7948ctoon_deprecated("renamed to ctoon_mut_ptr_get")
7949ctoon_api_inline ctoon_mut_val *ctoon_mut_get_pointer(ctoon_mut_val *val,
7950 const char *ptr) {
7951 return ctoon_mut_ptr_get(val, ptr);
7952}
7953
7955ctoon_deprecated("renamed to ctoon_mut_ptr_getn")
7956ctoon_api_inline ctoon_mut_val *ctoon_mut_get_pointern(ctoon_mut_val *val,
7957 const char *ptr,
7958 size_t len) {
7959 return ctoon_mut_ptr_getn(val, ptr, len);
7960}
7961
7963ctoon_deprecated("renamed to unsafe_ctoon_ptr_getn")
7964ctoon_api_inline ctoon_val *unsafe_ctoon_get_pointer(ctoon_val *val,
7965 const char *ptr,
7966 size_t len) {
7967 ctoon_ptr_err err;
7968 return unsafe_ctoon_ptr_getx(val, ptr, len, &err);
7969}
7970
7972ctoon_deprecated("renamed to unsafe_ctoon_mut_ptr_getx")
7973ctoon_api_inline ctoon_mut_val *unsafe_ctoon_mut_get_pointer(
7974 ctoon_mut_val *val, const char *ptr, size_t len) {
7975 ctoon_ptr_err err;
7976 return unsafe_ctoon_mut_ptr_getx(val, ptr, len, NULL, &err);
7977}
7978
7979#endif /* CTOON_DISABLE_UTILS */
7980
7981
7982
7983/*==============================================================================
7984 * MARK: - Compiler Hint End
7985 *============================================================================*/
7986
7987#ifdef __cplusplus
7988}
7989#endif /* extern "C" end */
7990
7991#endif /* CTOON_H */
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:6530
ctoon_mut_set_bool
static unsigned char ctoon_mut_set_bool(ctoon_mut_val *val, unsigned char num)
Definition ctoon.h:5633
CTOON_READ_STOP_WHEN_DONE
static const ctoon_read_flag CTOON_READ_STOP_WHEN_DONE
Definition ctoon.h:748
CTOON_WRITE_INF_AND_NAN_AS_NULL
static const ctoon_write_flag CTOON_WRITE_INF_AND_NAN_AS_NULL
Definition ctoon.h:1210
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:6091
ctoon_arr_iter_init
static unsigned char ctoon_arr_iter_init(ctoon_val *arr, ctoon_arr_iter *iter)
Definition ctoon.h:5211
ctoon_mut_set_int
static unsigned char ctoon_mut_set_int(ctoon_mut_val *val, int num)
Definition ctoon.h:5651
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:7193
ctoon_arr_iter_has_next
static unsigned char ctoon_arr_iter_has_next(ctoon_arr_iter *iter)
Definition ctoon.h:5229
ctoon_set_uint
static unsigned char ctoon_set_uint(ctoon_val *val, uint64_t num)
Definition ctoon.h:5086
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:6467
ctoon_set_int
static unsigned char ctoon_set_int(ctoon_val *val, int num)
Definition ctoon.h:5098
ctoon_set_fp_to_float
static unsigned char ctoon_set_fp_to_float(ctoon_val *val, unsigned char flt)
Definition ctoon.h:5128
CTOON_PTR_ERR_SYNTAX
static const ctoon_ptr_code CTOON_PTR_ERR_SYNTAX
Definition ctoon.h:3848
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:5926
ctoon_delimiter
ctoon_delimiter
Definition ctoon.h:1237
CTOON_DELIMITER_COMMA
@ CTOON_DELIMITER_COMMA
Definition ctoon.h:1238
CTOON_DELIMITER_PIPE
@ CTOON_DELIMITER_PIPE
Definition ctoon.h:1240
CTOON_DELIMITER_TAB
@ CTOON_DELIMITER_TAB
Definition ctoon.h:1239
ctoon_ptr_code
uint32_t ctoon_ptr_code
Definition ctoon.h:3839
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:6447
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:6056
ctoon_doc_get_root
static ctoon_val * ctoon_doc_get_root(ctoon_doc *doc)
Definition ctoon.h:4889
CTOON_READ_ERROR_MEMORY_ALLOCATION
static const ctoon_read_code CTOON_READ_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:842
ctoon_ptr_ctx_remove
static unsigned char ctoon_ptr_ctx_remove(ctoon_ptr_ctx *ctx)
Definition ctoon.h:7762
CTOON_WRITE_ALLOW_INVALID_UNICODE
static const ctoon_write_flag CTOON_WRITE_ALLOW_INVALID_UNICODE
Definition ctoon.h:1213
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:6099
ctoon_subtype
uint8_t ctoon_subtype
Definition ctoon.h:540
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:7613
ctoon_mut_arr_add_val
static unsigned char ctoon_mut_arr_add_val(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6355
ctoon_set_str_noesc
static unsigned char ctoon_set_str_noesc(ctoon_val *val, unsigned char noesc)
Definition ctoon.h:5149
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:6084
ctoon_set_sint
static unsigned char ctoon_set_sint(ctoon_val *val, int64_t num)
Definition ctoon.h:5092
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:7221
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:6497
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:7182
ctoon_mut_is_obj
static unsigned char ctoon_mut_is_obj(ctoon_mut_val *val)
Definition ctoon.h:5535
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:6042
ctoon_mut_arr_iter_next
static ctoon_mut_val * ctoon_mut_arr_iter_next(ctoon_mut_arr_iter *iter)
Definition ctoon.h:5930
ctoon_ptr_ctx_replace
static unsigned char ctoon_ptr_ctx_replace(ctoon_ptr_ctx *ctx, ctoon_mut_val *val)
Definition ctoon.h:7730
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:7294
ctoon_mut_get_str
static const char * ctoon_mut_get_str(ctoon_mut_val *val)
Definition ctoon.h:5593
ctoon_constant_p
#define ctoon_constant_p(value)
Definition ctoon.h:313
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:6407
ctoon_mut_arr
static ctoon_mut_val * ctoon_mut_arr(ctoon_mut_doc *doc)
Definition ctoon.h:5965
ctoon_mut_set_arr
static unsigned char ctoon_mut_set_arr(ctoon_mut_val *val)
Definition ctoon.h:5710
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:7083
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:7676
ctoon_mut_obj_iter_get_val
static ctoon_mut_val * ctoon_mut_obj_iter_get_val(ctoon_mut_val *key)
Definition ctoon.h:6587
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:7068
ctoon_get_type
static ctoon_type ctoon_get_type(ctoon_val *val)
Definition ctoon.h:4978
CTOON_READ_INSITU
static const ctoon_read_flag CTOON_READ_INSITU
Definition ctoon.h:743
CTOON_PTR_ERR_NULL_ROOT
static const ctoon_ptr_code CTOON_PTR_ERR_NULL_ROOT
Definition ctoon.h:3854
ctoon_read_code
uint32_t ctoon_read_code
Definition ctoon.h:833
ctoon_is_arr
static unsigned char ctoon_is_arr(ctoon_val *val)
Definition ctoon.h:4960
ctoon_mut_is_str
static unsigned char ctoon_mut_is_str(ctoon_mut_val *val)
Definition ctoon.h:5527
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:5837
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:6437
ctoon_mut_equals_str
static unsigned char ctoon_mut_equals_str(ctoon_mut_val *val, const char *str)
Definition ctoon.h:5601
ctoon_mut_set_strn
static unsigned char ctoon_mut_set_strn(ctoon_mut_val *val, const char *str, size_t len)
Definition ctoon.h:5696
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:6933
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:7608
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:7392
ctoon_arr_iter_with
static ctoon_arr_iter ctoon_arr_iter_with(ctoon_val *arr)
Definition ctoon.h:5223
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:6609
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:5942
CTOON_WRITE_NEWLINE_AT_END
static const ctoon_write_flag CTOON_WRITE_NEWLINE_AT_END
Definition ctoon.h:1219
ctoon_mut_set_obj
static unsigned char ctoon_mut_set_obj(ctoon_mut_val *val)
Definition ctoon.h:5716
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:5997
ctoon_mut_is_arr
static unsigned char ctoon_mut_is_arr(ctoon_mut_val *val)
Definition ctoon.h:5531
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:5321
ctoon_incr_state
struct ctoon_incr_state ctoon_incr_state
Definition ctoon.h:1036
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:5523
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:6427
ctoon_mut_set_sint
static unsigned char ctoon_mut_set_sint(ctoon_mut_val *val, int64_t num)
Definition ctoon.h:5645
ctoon_mut_get_sint
static int64_t ctoon_mut_get_sint(ctoon_mut_val *val)
Definition ctoon.h:5577
CTOON_READ_ERROR_UNEXPECTED_CONTENT
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CONTENT
Definition ctoon.h:848
ctoon_mut_set_uint
static unsigned char ctoon_mut_set_uint(ctoon_mut_val *val, uint64_t num)
Definition ctoon.h:5639
ctoon_get_type_desc
static const char * ctoon_get_type_desc(ctoon_val *val)
Definition ctoon.h:4990
CTOON_PTR_ERR_PARAMETER
static const ctoon_ptr_code CTOON_PTR_ERR_PARAMETER
Definition ctoon.h:3845
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:6004
ctoon_mut_set_double
static unsigned char ctoon_mut_set_double(ctoon_mut_val *val, double num)
Definition ctoon.h:5663
ctoon_mut_obj_iter_remove
static ctoon_mut_val * ctoon_mut_obj_iter_remove(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6592
ctoon_mut_obj_remove_key
static ctoon_mut_val * ctoon_mut_obj_remove_key(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:6863
CTOON_READ_BIGNUM_AS_RAW
static const ctoon_read_flag CTOON_READ_BIGNUM_AS_RAW
Definition ctoon.h:779
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:6035
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:7330
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:6417
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:6795
ctoon_mut_get_int
static int ctoon_mut_get_int(ctoon_mut_val *val)
Definition ctoon.h:5581
CTOON_READ_ERROR_LITERAL
static const ctoon_read_code CTOON_READ_ERROR_LITERAL
Definition ctoon.h:869
ctoon_mut_is_ctn
static unsigned char ctoon_mut_is_ctn(ctoon_mut_val *val)
Definition ctoon.h:5539
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:6832
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:7316
ctoon_is_raw
static unsigned char ctoon_is_raw(ctoon_val *val)
Definition ctoon.h:4916
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:6122
ctoon_mut_obj_iter_next
static ctoon_mut_val * ctoon_mut_obj_iter_next(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6575
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:5507
ctoon_get_bool
static unsigned char ctoon_get_bool(ctoon_val *val)
Definition ctoon.h:5011
ctoon_mut_is_sint
static unsigned char ctoon_mut_is_sint(ctoon_mut_val *val)
Definition ctoon.h:5511
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:7250
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:6397
ctoon_obj_iter_get_val
static ctoon_val * ctoon_obj_iter_get_val(ctoon_val *key)
Definition ctoon.h:5312
ctoon_type
uint8_t ctoon_type
Definition ctoon.h:521
ctoon_mut_int
static ctoon_mut_val * ctoon_mut_int(ctoon_mut_doc *doc, int64_t num)
Definition ctoon.h:5806
ctoon_mut_obj_iter_has_next
static unsigned char ctoon_mut_obj_iter_has_next(ctoon_mut_obj_iter *iter)
Definition ctoon.h:6571
ctoon_doc_ptr_getn
static ctoon_val * ctoon_doc_ptr_getn(ctoon_doc *doc, const char *ptr, size_t len)
Definition ctoon.h:7188
ctoon_mut_arr_remove
static ctoon_mut_val * ctoon_mut_arr_remove(ctoon_mut_val *arr, size_t idx)
Definition ctoon.h:6242
CTOON_READ_ALLOW_BOM
static const ctoon_read_flag CTOON_READ_ALLOW_BOM
Definition ctoon.h:782
ctoon_get_num
static double ctoon_get_num(ctoon_val *val)
Definition ctoon.h:5031
ctoon_is_uint
static unsigned char ctoon_is_uint(ctoon_val *val)
Definition ctoon.h:4936
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:7496
ctoon_get_sint
static int64_t ctoon_get_sint(ctoon_val *val)
Definition ctoon.h:5019
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:5279
CTOON_PATCH_ERROR_POINTER
static const ctoon_patch_code CTOON_PATCH_ERROR_POINTER
Definition ctoon.h:4448
ctoon_arr_get
static ctoon_val * ctoon_arr_get(ctoon_val *arr, size_t idx)
Definition ctoon.h:5165
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:7101
ctoon_mut_get_type
static ctoon_type ctoon_mut_get_type(ctoon_mut_val *val)
Definition ctoon.h:5549
ctoon_is_false
static unsigned char ctoon_is_false(ctoon_val *val)
Definition ctoon.h:4928
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:6993
ctoon_mut_val_write
static char * ctoon_mut_val_write(const ctoon_mut_val *val, size_t *len)
Definition ctoon.h:1345
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:4920
ctoon_mut_set_null
static unsigned char ctoon_mut_set_null(ctoon_mut_val *val)
Definition ctoon.h:5627
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:7641
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:6457
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:7647
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:7575
CTOON_WRITE_ESCAPE_SLASHES
static const ctoon_write_flag CTOON_WRITE_ESCAPE_SLASHES
Definition ctoon.h:1204
ctoon_mut_real
static ctoon_mut_val * ctoon_mut_real(ctoon_mut_doc *doc, double num)
Definition ctoon.h:5821
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:7525
ctoon_mut_obj_clear
static unsigned char ctoon_mut_obj_clear(ctoon_mut_val *obj)
Definition ctoon.h:6880
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:4427
ctoon_set_bool
static unsigned char ctoon_set_bool(ctoon_val *val, unsigned char num)
Definition ctoon.h:5080
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:6986
ctoon_get_int
static int ctoon_get_int(ctoon_val *val)
Definition ctoon.h:5023
ctoon_mut_write
static char * ctoon_mut_write(const ctoon_mut_doc *doc, size_t *len)
Definition ctoon.h:1323
ctoon_set_double
static unsigned char ctoon_set_double(ctoon_val *val, double num)
Definition ctoon.h:5110
CTOON_WRITE_ALLOW_INF_AND_NAN
static const ctoon_write_flag CTOON_WRITE_ALLOW_INF_AND_NAN
Definition ctoon.h:1207
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:1178
CTOON_READ_ALLOW_SINGLE_QUOTED_STR
static const ctoon_read_flag CTOON_READ_ALLOW_SINGLE_QUOTED_STR
Definition ctoon.h:808
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:6028
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:6214
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:6951
ctoon_mut_arr_clear
static unsigned char ctoon_mut_arr_clear(ctoon_mut_val *arr)
Definition ctoon.h:6329
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:6108
CTOON_WRITE_LENGTH_MARKER
static const ctoon_write_flag CTOON_WRITE_LENGTH_MARKER
Definition ctoon.h:1216
ctoon_read
static ctoon_doc * ctoon_read(const char *dat, size_t len, ctoon_read_flag flg)
Definition ctoon.h:1023
CTOON_READ_ERROR_UNEXPECTED_END
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_END
Definition ctoon.h:851
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:6652
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:4442
CTOON_WRITE_ERROR_FILE_WRITE
static const ctoon_write_code CTOON_WRITE_ERROR_FILE_WRITE
Definition ctoon.h:1251
ctoon_mut_raw
static ctoon_mut_val * ctoon_mut_raw(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:5748
CTOON_WRITE_SUCCESS
static const ctoon_write_code CTOON_WRITE_SUCCESS
Definition ctoon.h:1245
ctoon_get_raw
static const char * ctoon_get_raw(ctoon_val *val)
Definition ctoon.h:5007
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:6070
ctoon_mut_double
static ctoon_mut_val * ctoon_mut_double(ctoon_mut_doc *doc, double num)
Definition ctoon.h:5816
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:7418
CTOON_READ_ALLOW_UNQUOTED_KEY
static const ctoon_read_flag CTOON_READ_ALLOW_UNQUOTED_KEY
Definition ctoon.h:813
ctoon_mut_get_num
static double ctoon_mut_get_num(ctoon_mut_val *val)
Definition ctoon.h:5589
ctoon_mut_arr_add_false
static unsigned char ctoon_mut_arr_add_false(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6378
CTOON_READ_ALLOW_EXT_WHITESPACE
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_WHITESPACE
Definition ctoon.h:805
ctoon_mut_get_type_desc
static const char * ctoon_mut_get_type_desc(ctoon_mut_val *val)
Definition ctoon.h:5561
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:5869
CTOON_READ_ERROR_DEPTH
static const ctoon_read_code CTOON_READ_ERROR_DEPTH
Definition ctoon.h:881
ctoon_mut_arr_append
static unsigned char ctoon_mut_arr_append(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6176
ctoon_obj_iter_next
static ctoon_val * ctoon_obj_iter_next(ctoon_obj_iter *iter)
Definition ctoon.h:5302
ctoon_get_len
static size_t ctoon_get_len(ctoon_val *val)
Definition ctoon.h:5039
ctoon_mut_obj_iter_with
static ctoon_mut_obj_iter ctoon_mut_obj_iter_with(ctoon_mut_val *obj)
Definition ctoon.h:6564
ctoon_mut_get_uint
static uint64_t ctoon_mut_get_uint(ctoon_mut_val *val)
Definition ctoon.h:5573
CTOON_WRITE_ERROR_INVALID_PARAMETER
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_PARAMETER
Definition ctoon.h:1246
CTOON_READ_ALLOW_EXT_NUMBER
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_NUMBER
Definition ctoon.h:788
ctoon_mut_set_str
static unsigned char ctoon_mut_set_str(ctoon_mut_val *val, const char *str)
Definition ctoon.h:5689
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:7014
ctoon_mut_is_true
static unsigned char ctoon_mut_is_true(ctoon_mut_val *val)
Definition ctoon.h:5495
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:7385
ctoon_arr_size
static size_t ctoon_arr_size(ctoon_val *arr)
Definition ctoon.h:5161
CTOON_READ_ERROR_EMPTY_CONTENT
static const ctoon_read_code CTOON_READ_ERROR_EMPTY_CONTENT
Definition ctoon.h:845
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:7489
ctoon_mut_set_str_noesc
static unsigned char ctoon_mut_set_str_noesc(ctoon_mut_val *val, unsigned char noesc)
Definition ctoon.h:5703
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:6614
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:6683
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:6939
ctoon_mut_is_bool
static unsigned char ctoon_mut_is_bool(ctoon_mut_val *val)
Definition ctoon.h:5503
ctoon_write
static char * ctoon_write(const ctoon_doc *doc, size_t *len)
Definition ctoon.h:1287
ctoon_mut_is_raw
static unsigned char ctoon_mut_is_raw(ctoon_mut_val *val)
Definition ctoon.h:5487
ctoon_mut_arr_remove_first
static ctoon_mut_val * ctoon_mut_arr_remove_first(ctoon_mut_val *arr)
Definition ctoon.h:6266
ctoon_equals_strn
static unsigned char ctoon_equals_strn(ctoon_val *val, const char *str, size_t len)
Definition ctoon.h:5051
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:6049
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:7000
ctoon_mut_get_real
static double ctoon_mut_get_real(ctoon_mut_val *val)
Definition ctoon.h:5585
ctoon_obj_iter_get
static ctoon_val * ctoon_obj_iter_get(ctoon_obj_iter *iter, const char *key)
Definition ctoon.h:5316
CTOON_PTR_ERR_MEMORY_ALLOCATION
static const ctoon_ptr_code CTOON_PTR_ERR_MEMORY_ALLOCATION
Definition ctoon.h:3860
ctoon_set_null
static unsigned char ctoon_set_null(ctoon_val *val)
Definition ctoon.h:5074
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:6979
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:5614
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:875
ctoon_obj_iter_has_next
static unsigned char ctoon_obj_iter_has_next(ctoon_obj_iter *iter)
Definition ctoon.h:5298
ctoon_mut_arr_remove_last
static ctoon_mut_val * ctoon_mut_arr_remove_last(ctoon_mut_val *arr)
Definition ctoon.h:6285
ctoon_mut_is_null
static unsigned char ctoon_mut_is_null(ctoon_mut_val *val)
Definition ctoon.h:5491
CTOON_READ_NUMBER_AS_RAW
static const ctoon_read_flag CTOON_READ_NUMBER_AS_RAW
Definition ctoon.h:763
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:7039
ctoon_mut_set_raw
static unsigned char ctoon_mut_set_raw(ctoon_mut_val *val, const char *raw, size_t len)
Definition ctoon.h:5620
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:6972
ctoon_mut_rawncpy
static ctoon_mut_val * ctoon_mut_rawncpy(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5769
ctoon_is_str
static unsigned char ctoon_is_str(ctoon_val *val)
Definition ctoon.h:4956
CTOON_PTR_ERR_RESOLVE
static const ctoon_ptr_code CTOON_PTR_ERR_RESOLVE
Definition ctoon.h:3851
ctoon_mut_arr_rotate
static unsigned char ctoon_mut_arr_rotate(ctoon_mut_val *arr, size_t idx)
Definition ctoon.h:6337
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:6307
ctoon_ptr_get
static ctoon_val * ctoon_ptr_get(ctoon_val *val, const char *ptr)
Definition ctoon.h:7215
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:7569
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:7481
CTOON_PATCH_ERROR_EQUAL
static const ctoon_patch_code CTOON_PATCH_ERROR_EQUAL
Definition ctoon.h:4445
ctoon_api_inline
#define ctoon_api_inline
Definition ctoon.h:350
ctoon_mut_arr_get_first
static ctoon_mut_val * ctoon_mut_arr_get_first(ctoon_mut_val *arr)
Definition ctoon.h:5883
ctoon_mut_is_false
static unsigned char ctoon_mut_is_false(ctoon_mut_val *val)
Definition ctoon.h:5499
CTOON_WRITE_ERROR_INVALID_VALUE_TYPE
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_VALUE_TYPE
Definition ctoon.h:1248
ctoon_is_int
static unsigned char ctoon_is_int(ctoon_val *val)
Definition ctoon.h:4944
CTOON_READ_ERROR_FILE_OPEN
static const ctoon_read_code CTOON_READ_ERROR_FILE_OPEN
Definition ctoon.h:872
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:6888
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:1201
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:6063
ctoon_get_real
static double ctoon_get_real(ctoon_val *val)
Definition ctoon.h:5027
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:7060
CTOON_READ_ALLOW_TRAILING_COMMAS
static const ctoon_read_flag CTOON_READ_ALLOW_TRAILING_COMMAS
Definition ctoon.h:752
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:6009
ctoon_get_tag
static uint8_t ctoon_get_tag(ctoon_val *val)
Definition ctoon.h:4986
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:6965
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:7531
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:5873
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:6145
CTOON_READ_ERROR_INVALID_NUMBER
static const ctoon_read_code CTOON_READ_ERROR_INVALID_NUMBER
Definition ctoon.h:863
ctoon_mut_sint
static ctoon_mut_val * ctoon_mut_sint(ctoon_mut_doc *doc, int64_t num)
Definition ctoon.h:5801
ctoon_mut_true
static ctoon_mut_val * ctoon_mut_true(ctoon_mut_doc *doc)
Definition ctoon.h:5783
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:7580
ctoon_get_uint
static uint64_t ctoon_get_uint(ctoon_val *val)
Definition ctoon.h:5015
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:1130
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:6550
ctoon_mut_false
static ctoon_mut_val * ctoon_mut_false(ctoon_mut_doc *doc)
Definition ctoon.h:5787
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:7244
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:4897
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:773
ctoon_mut_is_int
static unsigned char ctoon_mut_is_int(ctoon_mut_val *val)
Definition ctoon.h:5515
ctoon_mut_doc_set_root
static void ctoon_mut_doc_set_root(ctoon_mut_doc *doc, ctoon_mut_val *root)
Definition ctoon.h:5476
ctoon_mut_uint
static ctoon_mut_val * ctoon_mut_uint(ctoon_mut_doc *doc, uint64_t num)
Definition ctoon.h:5796
ctoon_mut_obj_size
static size_t ctoon_mut_obj_size(ctoon_mut_val *obj)
Definition ctoon.h:6521
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:7323
ctoon_patch_code
uint32_t ctoon_patch_code
Definition ctoon.h:4424
ctoon_arr_iter_next
static ctoon_val * ctoon_arr_iter_next(ctoon_arr_iter *iter)
Definition ctoon.h:5233
CTOON_READ_ALLOW_INF_AND_NAN
static const ctoon_read_flag CTOON_READ_ALLOW_INF_AND_NAN
Definition ctoon.h:759
CTOON_PTR_ERR_SET_ROOT
static const ctoon_ptr_code CTOON_PTR_ERR_SET_ROOT
Definition ctoon.h:3857
ctoon_mut_arr_prepend
static unsigned char ctoon_mut_arr_prepend(ctoon_mut_val *arr, ctoon_mut_val *val)
Definition ctoon.h:6195
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:5292
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:7288
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:7377
ctoon_mut_is_real
static unsigned char ctoon_mut_is_real(ctoon_mut_val *val)
Definition ctoon.h:5519
ctoon_mut_null
static ctoon_mut_val * ctoon_mut_null(ctoon_mut_doc *doc)
Definition ctoon.h:5779
CTOON_PATCH_ERROR_INVALID_PARAMETER
static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_PARAMETER
Definition ctoon.h:4430
ctoon_mut_obj_get
static ctoon_mut_val * ctoon_mut_obj_get(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:6525
ctoon_mut_arr_add_null
static unsigned char ctoon_mut_arr_add_null(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6360
ctoon_mut_get_tag
static uint8_t ctoon_mut_get_tag(ctoon_mut_val *val)
Definition ctoon.h:5557
CTOON_READ_ERROR_INVALID_COMMENT
static const ctoon_read_code CTOON_READ_ERROR_INVALID_COMMENT
Definition ctoon.h:860
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:6958
ctoon_is_sint
static unsigned char ctoon_is_sint(ctoon_val *val)
Definition ctoon.h:4940
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:7026
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:4932
CTOON_READ_NOFLAG
static const ctoon_read_flag CTOON_READ_NOFLAG
Definition ctoon.h:735
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:7431
CTOON_READ_ALLOW_EXT_ESCAPE
static const ctoon_read_flag CTOON_READ_ALLOW_EXT_ESCAPE
Definition ctoon.h:797
CTOON_READ_SUCCESS
static const ctoon_read_code CTOON_READ_SUCCESS
Definition ctoon.h:836
ctoon_obj_size
static size_t ctoon_obj_size(ctoon_val *obj)
Definition ctoon.h:5250
CTOON_WRITE_ERROR_INVALID_STRING
static const ctoon_write_code CTOON_WRITE_ERROR_INVALID_STRING
Definition ctoon.h:1252
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:7052
ctoon_set_float
static unsigned char ctoon_set_float(ctoon_val *val, float num)
Definition ctoon.h:5104
ctoon_set_fp_to_fixed
static unsigned char ctoon_set_fp_to_fixed(ctoon_val *val, int prec)
Definition ctoon.h:5122
ctoon_mut_obj_rotate
static unsigned char ctoon_mut_obj_rotate(ctoon_mut_val *obj, size_t idx)
Definition ctoon.h:6898
CTOON_READ_ERROR_UNEXPECTED_CHARACTER
static const ctoon_read_code CTOON_READ_ERROR_UNEXPECTED_CHARACTER
Definition ctoon.h:854
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:3842
ctoon_obj_getn
static ctoon_val * ctoon_obj_getn(ctoon_val *obj, const char *key, size_t key_len)
Definition ctoon.h:5259
ctoon_val_write
static char * ctoon_val_write(const ctoon_val *val, size_t *len)
Definition ctoon.h:1312
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:6872
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:755
ctoon_set_str
static unsigned char ctoon_set_str(ctoon_val *val, const char *str)
Definition ctoon.h:5134
ctoon_mut_ptr_get
static ctoon_mut_val * ctoon_mut_ptr_get(ctoon_mut_val *val, const char *ptr)
Definition ctoon.h:7282
ctoon_mut_arr_get_last
static ctoon_mut_val * ctoon_mut_arr_get_last(ctoon_mut_val *arr)
Definition ctoon.h:5891
ctoon_read_flag
uint32_t ctoon_read_flag
Definition ctoon.h:725
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:7425
ctoon_set_real
static unsigned char ctoon_set_real(ctoon_val *val, double num)
Definition ctoon.h:5116
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:7226
ctoon_mut_arr_iter_with
static ctoon_mut_arr_iter ctoon_mut_arr_iter_with(ctoon_mut_val *arr)
Definition ctoon.h:5919
ctoon_is_num
static unsigned char ctoon_is_num(ctoon_val *val)
Definition ctoon.h:4952
ctoon_write_code
uint32_t ctoon_write_code
Definition ctoon.h:1244
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:6077
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:6487
ctoon_equals_str
static unsigned char ctoon_equals_str(ctoon_val *val, const char *str)
Definition ctoon.h:5043
CTOON_WRITE_NOFLAG
static const ctoon_write_flag CTOON_WRITE_NOFLAG
Definition ctoon.h:1198
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:6506
ctoon_api
#define ctoon_api
Definition ctoon.h:344
CTOON_PATCH_ERROR_INVALID_OPERATION
static const ctoon_patch_code CTOON_PATCH_ERROR_INVALID_OPERATION
Definition ctoon.h:4436
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:7653
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:6014
ctoon_mut_equals_strn
static unsigned char ctoon_mut_equals_strn(ctoon_mut_val *val, const char *str, size_t len)
Definition ctoon.h:5606
ctoon_mut_get_subtype
static ctoon_subtype ctoon_mut_get_subtype(ctoon_mut_val *val)
Definition ctoon.h:5553
ctoon_mut_arr_add_true
static unsigned char ctoon_mut_arr_add_true(ctoon_mut_doc *doc, ctoon_mut_val *arr)
Definition ctoon.h:6369
CTOON_WRITE_ERROR_MEMORY_ALLOCATION
static const ctoon_write_code CTOON_WRITE_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:1247
ctoon_mut_str
static ctoon_mut_val * ctoon_mut_str(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:5826
ctoon_mut_get_len
static size_t ctoon_mut_get_len(ctoon_mut_val *val)
Definition ctoon.h:5597
CTOON_READ_ERROR_TOON_STRUCTURE
static const ctoon_read_code CTOON_READ_ERROR_TOON_STRUCTURE
Definition ctoon.h:857
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:5682
ctoon_write_flag
uint32_t ctoon_write_flag
Definition ctoon.h:1195
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:5905
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:6387
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:1250
ctoon_mut_doc_ptr_remove
static ctoon_mut_val * ctoon_mut_doc_ptr_remove(ctoon_mut_doc *doc, const char *ptr)
Definition ctoon.h:7602
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:7536
ctoon_mut_strn
static ctoon_mut_val * ctoon_mut_strn(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5831
CTOON_PATCH_ERROR_MISSING_KEY
static const ctoon_patch_code CTOON_PATCH_ERROR_MISSING_KEY
Definition ctoon.h:4439
ctoon_mut_doc_get_root
static ctoon_mut_val * ctoon_mut_doc_get_root(ctoon_mut_doc *doc)
Definition ctoon.h:5472
ctoon_mut_get_bool
static unsigned char ctoon_mut_get_bool(ctoon_mut_val *val)
Definition ctoon.h:5569
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:6477
CTOON_READ_ERROR_MORE
static const ctoon_read_code CTOON_READ_ERROR_MORE
Definition ctoon.h:878
ctoon_obj_get
static ctoon_val * ctoon_obj_get(ctoon_val *obj, const char *key)
Definition ctoon.h:5254
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_is_obj
static unsigned char ctoon_is_obj(ctoon_val *val)
Definition ctoon.h:4964
ctoon_mut_strncpy
static ctoon_mut_val * ctoon_mut_strncpy(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5850
CTOON_READ_ERROR_INVALID_STRING
static const ctoon_read_code CTOON_READ_ERROR_INVALID_STRING
Definition ctoon.h:866
ctoon_set_raw
static unsigned char ctoon_set_raw(ctoon_val *val, const char *raw, size_t len)
Definition ctoon.h:5067
ctoon_doc_free
static void ctoon_doc_free(ctoon_doc *doc)
Definition ctoon.h:4901
ctoon_mut_obj_remove_str
static ctoon_mut_val * ctoon_mut_obj_remove_str(ctoon_mut_val *obj, const char *key)
Definition ctoon.h:7078
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:6806
ctoon_equals
static unsigned char ctoon_equals(ctoon_val *lhs, ctoon_val *rhs)
Definition ctoon.h:5062
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:6021
CTOON_PATCH_ERROR_MEMORY_ALLOCATION
static const ctoon_patch_code CTOON_PATCH_ERROR_MEMORY_ALLOCATION
Definition ctoon.h:4433
ctoon_is_real
static unsigned char ctoon_is_real(ctoon_val *val)
Definition ctoon.h:4948
ctoon_mut_set_float
static unsigned char ctoon_mut_set_float(ctoon_mut_val *val, float num)
Definition ctoon.h:5657
ctoon_mut_rawn
static ctoon_mut_val * ctoon_mut_rawn(ctoon_mut_doc *doc, const char *str, size_t len)
Definition ctoon.h:5753
ctoon_mut_bool
static ctoon_mut_val * ctoon_mut_bool(ctoon_mut_doc *doc, unsigned char val)
Definition ctoon.h:5791
ctoon_mut_obj_remove
static ctoon_mut_val * ctoon_mut_obj_remove(ctoon_mut_val *obj, ctoon_mut_val *key)
Definition ctoon.h:6854
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:6945
CTOON_READ_ERROR_INVALID_PARAMETER
static const ctoon_read_code CTOON_READ_ERROR_INVALID_PARAMETER
Definition ctoon.h:839
unsafe_ctoon_is_str_noesc
static unsigned char unsafe_ctoon_is_str_noesc(const char *str, size_t len)
Definition ctoon.h:4575
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:6641
ctoon_arr_get_last
static ctoon_val * ctoon_arr_get_last(ctoon_val *arr)
Definition ctoon.h:5189
ctoon_mut_rawcpy
static ctoon_mut_val * ctoon_mut_rawcpy(ctoon_mut_doc *doc, const char *str)
Definition ctoon.h:5759
ctoon_is_ctn
static unsigned char ctoon_is_ctn(ctoon_val *val)
Definition ctoon.h:4968
ctoon_mut_set_real
static unsigned char ctoon_mut_set_real(ctoon_mut_val *val, double num)
Definition ctoon.h:5669
ctoon_is_true
static unsigned char ctoon_is_true(ctoon_val *val)
Definition ctoon.h:4924
ctoon_mut_float
static ctoon_mut_val * ctoon_mut_float(ctoon_mut_doc *doc, float num)
Definition ctoon.h:5811
ctoon_doc_get_read_size
static size_t ctoon_doc_get_read_size(ctoon_doc *doc)
Definition ctoon.h:4893
CTOON_READ_TOON5
static const ctoon_read_flag CTOON_READ_TOON5
Definition ctoon.h:820
ctoon_get_str
static const char * ctoon_get_str(ctoon_val *val)
Definition ctoon.h:5035
ctoon_set_strn
static unsigned char ctoon_set_strn(ctoon_val *val, const char *str, size_t len)
Definition ctoon.h:5141
ctoon_mut_set_fp_to_fixed
static unsigned char ctoon_mut_set_fp_to_fixed(ctoon_mut_val *val, int prec)
Definition ctoon.h:5675
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:7110
ctoon_mut_get_raw
static const char * ctoon_mut_get_raw(ctoon_mut_val *val)
Definition ctoon.h:5565
ctoon_arr_get_first
static ctoon_val * ctoon_arr_get_first(ctoon_val *arr)
Definition ctoon.h:5180
CTOON_WRITE_ERROR_NAN_OR_INF
static const ctoon_write_code CTOON_WRITE_ERROR_NAN_OR_INF
Definition ctoon.h:1249
ctoon_get_subtype
static ctoon_subtype ctoon_get_subtype(ctoon_val *val)
Definition ctoon.h:4982
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:7256
ctoon_alc
Definition ctoon.h:588
ctoon_alc::free
void(* free)(void *ctx, void *ptr)
Definition ctoon.h:594
ctoon_alc::ctx
void * ctx
Definition ctoon.h:596
ctoon_arr_iter
Definition ctoon.h:1761
ctoon_arr_iter::max
size_t max
Definition ctoon.h:1763
ctoon_arr_iter::cur
ctoon_val * cur
Definition ctoon.h:1764
ctoon_arr_iter::idx
size_t idx
Definition ctoon.h:1762
ctoon_doc
Definition ctoon.h:4541
ctoon_doc::alc
ctoon_alc alc
Definition ctoon.h:4545
ctoon_doc::root
ctoon_val * root
Definition ctoon.h:4543
ctoon_doc::str_pool
char * str_pool
Definition ctoon.h:4551
ctoon_doc::val_read
size_t val_read
Definition ctoon.h:4549
ctoon_doc::dat_read
size_t dat_read
Definition ctoon.h:4547
ctoon_mut_arr_iter
Definition ctoon.h:2482
ctoon_mut_arr_iter::pre
ctoon_mut_val * pre
Definition ctoon.h:2486
ctoon_mut_arr_iter::arr
ctoon_mut_val * arr
Definition ctoon.h:2487
ctoon_mut_arr_iter::idx
size_t idx
Definition ctoon.h:2483
ctoon_mut_arr_iter::max
size_t max
Definition ctoon.h:2484
ctoon_mut_arr_iter::cur
ctoon_mut_val * cur
Definition ctoon.h:2485
ctoon_mut_doc
Definition ctoon.h:5409
ctoon_mut_obj_iter
Definition ctoon.h:3308
ctoon_mut_obj_iter::max
size_t max
Definition ctoon.h:3310
ctoon_mut_obj_iter::cur
ctoon_mut_val * cur
Definition ctoon.h:3311
ctoon_mut_obj_iter::obj
ctoon_mut_val * obj
Definition ctoon.h:3313
ctoon_mut_obj_iter::pre
ctoon_mut_val * pre
Definition ctoon.h:3312
ctoon_mut_obj_iter::idx
size_t idx
Definition ctoon.h:3309
ctoon_mut_val
Definition ctoon.h:5361
ctoon_obj_iter
Definition ctoon.h:1885
ctoon_obj_iter::idx
size_t idx
Definition ctoon.h:1886
ctoon_obj_iter::obj
ctoon_val * obj
Definition ctoon.h:1889
ctoon_obj_iter::max
size_t max
Definition ctoon.h:1887
ctoon_obj_iter::cur
ctoon_val * cur
Definition ctoon.h:1888
ctoon_patch_err
Definition ctoon.h:4451
ctoon_patch_err::ptr
ctoon_ptr_err ptr
Definition ctoon.h:4459
ctoon_patch_err::msg
const char * msg
Definition ctoon.h:4457
ctoon_patch_err::idx
size_t idx
Definition ctoon.h:4455
ctoon_patch_err::code
ctoon_patch_code code
Definition ctoon.h:4453
ctoon_ptr_ctx
Definition ctoon.h:3891
ctoon_ptr_ctx::ctn
ctoon_mut_val * ctn
Definition ctoon.h:3899
ctoon_ptr_ctx::pre
ctoon_mut_val * pre
Definition ctoon.h:3908
ctoon_ptr_ctx::old
ctoon_mut_val * old
Definition ctoon.h:3913
ctoon_ptr_err
Definition ctoon.h:3863
ctoon_ptr_err::pos
size_t pos
Definition ctoon.h:3869
ctoon_ptr_err::msg
const char * msg
Definition ctoon.h:3867
ctoon_ptr_err::code
ctoon_ptr_code code
Definition ctoon.h:3865
ctoon_read_err
Definition ctoon.h:884
ctoon_read_err::msg
const char * msg
Definition ctoon.h:888
ctoon_read_err::pos
size_t pos
Definition ctoon.h:890
ctoon_read_err::code
ctoon_read_code code
Definition ctoon.h:886
ctoon_val
Definition ctoon.h:4536
ctoon_val::tag
uint64_t tag
Definition ctoon.h:4537
ctoon_val::uni
ctoon_val_uni uni
Definition ctoon.h:4538
ctoon_write_err
Definition ctoon.h:1255
ctoon_write_err::code
ctoon_write_code code
Definition ctoon.h:1256
ctoon_write_err::msg
const char * msg
Definition ctoon.h:1257
ctoon_write_options
Definition ctoon.h:1261
ctoon_write_options::indent
int indent
Definition ctoon.h:1264
ctoon_write_options::flag
ctoon_write_flag flag
Definition ctoon.h:1262
ctoon_write_options::delimiter
ctoon_delimiter delimiter
Definition ctoon.h:1263
ctoon_val_uni
Definition ctoon.h:4524
ctoon_val_uni::str
const char * str
Definition ctoon.h:4528
ctoon_val_uni::ptr
void * ptr
Definition ctoon.h:4529
ctoon_val_uni::f64
double f64
Definition ctoon.h:4527
ctoon_val_uni::ofs
size_t ofs
Definition ctoon.h:4530
ctoon_val_uni::i64
int64_t i64
Definition ctoon.h:4526
ctoon_val_uni::u64
uint64_t u64
Definition ctoon.h:4525

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

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