7¤0ìÍUED 3ãÃ0Ü:†a†a@X¬xf4k[ŠÔ-r%–t#¡M²]kutaÛ·Æ¢VÄGuÆâýßm?í,íÅŽçiÉc"‰<$ŽË ‹%š• â`(Ã(Š‚(ˆ†aŒQH!+ÑŒÈô×E=Ë)d, x28, \ x29, x30, x31, x32, x33, x34, x35, x36) ine _FM2_34(a, m, x29) #define _FM2_30(a, m,(a, x26) m(a, x27) m(a, x28) #define _FM2_29(a, m,21, x22, x23, x24, x25) \ m23) #define _FM2_24(a, m,(a, x20) m(a, x21) m(a, x22) #define _FM2_23(a, m,, \ x14, x15, x16, x17, x18, x19, x20, x21, x22) (a, x17) m(a, x18) m(a, x19) #define _FM2_20(a, m, x15) \ m(a, x16) m(a, x17) #define _FM2_18(a, m,(a, x13) m(a, x14) m(a, x15) #define _FM2_16(a, m,(a, x11) m(a, x12) m(a, x13) #define _FM2_14(a, m,x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) \ mine _FM2_8(a, m, x1, x2, x3, x4, x5, x6, x7, x8) \ANY(...) FY_CPP_MAP_too_many_arguments() #def64) /* _FM2_: apply m(a, x) to each of n argum x50, x51, x52, x53, x54, x55, x56, x57, x58) \ m) m(x52) m(x53) m(x54) m(x55) #define _FM_56(m, x1) m(x51) m(x52) m(x53) m(x54) #define _FM_55(m, x151) #define _FM_52(m, x15) \ m(x46) m(x47) m(x48) m(x49) m(x50) m(x51) #d m(x46) m(x47) m(x48) m(x49) #define _FM_50(m, x11, x42, x43, \ x44, x45, x46, x47, x48, x49) \ m(x44) m(x45) \ m(x46) m(x47) #define _FM_48(m, x1) m(x42) m(x43) m(x44) m(x45) #define _FM_46(m, x16, x37, x38, x39, x40, x41, x42, x43, \ x44) \ m) m(x39) m(x40) m(x41) m(x42) #define _FM_43(m, x1 x34, x35, x36, x37, x38, x39, x40, x41, x42) \ m) m(x37) m(x38) m(x39) m(x40) #define _FM_41(m, x1 m(x35) m(x36) m(x37) m(x38) #define _FM_39(m, x1 x30, x31, x32, x33, x34, x35, x36, x37, x38) \ m(x33) m(x34) \ m(x35) m(x36) #define _FM_37(m, x17, x28, \ x29, x30, x31, x32, x33, x34, x35) \ m) m(x31) m(x32) m(x33) m(x34) #define _FM_35(m, x15, x26, x27, x28, \ x29, x30, x31, x32, x33) \ m) m(x28) m(x29) m(x30) m(x31) #define _FM_32(m, x13, x24, x25, x26, x27, x28, \ x29, x30, x31) \ mx25) m(x26) m(x27) m(x28) #define _FM_29(m, x1 x20, x21, x22, x23, x24, x25, x26, x27, x28) \ m x18, x19, x20, x21, x22, x23, x24, x25, x26) \ m7, x18, x19, x20, x21, x22, x23, x24) \ m8) m(x19) m(x20) m(x21) m(x22) #define _FM_23(m, x3, \ x14, x15, x16, x17, x18, x19, x20, x21) \ m1, x12, x13, \ x14, x15, x16, x17, x18, x19) \ m m(x13) m(x14) m(x15) m(x16) #define _FM_17(m, x1(x12) \ m(x13) m(x14) m(x15) #define _FM_16(m, x1x7) m(x8) m(x9) m(x10) m(x11) #define _FM_12(m, x13) m(x4) #define _FM_5(m, x1, x2, x3, x4, x5) \ mine _FMC_(_a, _b) _a ## _b /* _FM_: apply m() , 57, 56, 55, \ 54, 53, 52, 51, 50, 49, 48, 47, 448, _49, _50, _51, _52, _53, _54, _55, _56, _57, _3, _4, _5, ...) _5 #define _F5F(...) \ _F5(__VA_OA_ARGS__)) #else #define _E(...) _E16(_E16(__VA_Adefine FY_CPP_SHORT_NAMES /* Legacy forced re-exp{ ... } * * #define do_sum_macro(...) \ * lity**: * * - ``FY_CPP_VA_COUNT(...)`` âAP(macro, ...)`` — expand ``macro(x)`` for each FY_CPP_MAP_too_many_arguments``. The tables are m * to 64 re-expansion passes via an ``FY_CPP_EVALnITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAee of charge, to any person obtaining a copy * ofs * @fydi: The document iterator to associate * */ enum fy_parser_event_generator_flags { FYPEGF_or. If it's in error state, return true * and restion is complete a NULL event will be generated. * followed by all the remaing nodes in the subtreee_start(). The first node returned will be that, iteration run using a starting point * * Startsre created depth first and are in same exact sequecument that was used earlier in the call of * fy_ent_start(struct fy_document_iterator *fydi, strucleanup or a call * to fy_document_iterator_documeerator_stream_end() - Create a stream end event ustream start event on the document iterator and adverator to destroy */ void fy_document_iterator_de given node * * @fyn: The node to iterate on * ough a document * without using recursion. The it_iterator * fy_document_iterator_create(void) FY_ @iterate_root: The root of iteration (NULL when fREAM_DOCUMENT_BODY_EVENTS: Generate stream, documeument, so round-trip fidelity is preserved. */ /arser`` via * ``fy_parser_set_document_iterator()r_node_next(fydi)) != NULL) * process(fyn);ent tree depth-first without using system stack ret bufsz) { return fy_skip_size32(start, bufsz); }ep) { uint32_t sz; const uint8_t *ret; ret = fING_MAX_32 on 32-bit platforms. */ #define FYVL_S uint8_t * fy_skip_size(const uint8_t *start, sizeeak; } *sizep = (size_t)size64; return s; } /*nocheck variant based on ``sizeof(size_t)``. * Thstart, bufsz, &sz); if (!ret) { *sizep = 0; rode_size64() or fy_encode_size32() based on ``SIZEak; } return p + i; } /* is pointless to pretenNG_MAX_64; ) { if ((int8_t)p[i++] >= 0) break goto done; p++; } return NULL; done: if (oto out; } size <<= 8; size |= p[i]; out: *sizIZE_ENCODING_MAX_64-1; i++) { size <<= 7; sizesize; return p; } /** * fy_decode_size64_nochec_64; if (end_max_scan < end) end_scan = end_mats the encoded * 64-bit value. Stops after %FYVL_ p + 8; } if (p + 9 > end) return NULL; p[0] p[5] = (uint8_t)(size >> 7) | 0x80; p[6] = (ui> 35) | 0x80; p[1] = (uint8_t)(size >> 28) | 0x8urn p + 2; } if (size < ((uint64_t)1 << 21)) { or NULL if @bufsz was * too small. */ st of the output buffer. * @bufsz: Available spaceze: The value whose encoded length is queried. * NCODING_MAX_32 bytes are readable. * * @p: Startscan; end = start + bufsz; end_max_scan = stared byte, or NULL if the buffer * was exhize |= (p[i] & 0x7f); if ((int8_t)p[i] >= 0) if (!(*p & 0x80)) goto done; } else { /nt8_t *p, *end, *end_scan, *end_max_scan; uint32_ Reads bytes from [@start, @start+@bufsz) and recorn p + 3; } if (size < ((uint32_t)1 << 28)) { z, uint32_t size) { uint8_t *end = p + bufsz; ito the buffer [@p, @p+@bufsz). * * @p: Startte for @size, * without actually writing anythingfinal unconstrained byte = 7 x 4 + 4 = 32 bits. *bit // // high bit is set, more follow with 0 endi -- -- -- -- // 0k 7 bit leending the run // The final 9th byte always termino a bounded buffer * - ``decode()`` — read 21 16384 .. 2097151 * 4 28 range. * * **64-bit encoding** (up to 9 bytes):_of_place_size_null_type(void *v FY_UNUSED ) { re generic. * @p: Must be NULL; any non-NULL pointece (encode inplace), * out_of_place_size (require * Returns: true if @v has type %FYGT_ALIAS. */ sct_collection(v)) { *typep = FYGT_INVALID; retNULL; } *countp = colp->count * (type == FYGT_MAtion storage block (may be NULL). * @countp: Recec_is_invalid(v) && !fy_generic_is_collection(v); }ence is 0, mapping is 8 (3 lower bits 0) */ } /* y_generic_is_mapping() / fy_generic_is_mapping_typ * A direct mapping has bit 3 set and the low 3 */ FY_GENERIC_IS_TEMPLATE_INLINE(sequence); FY_GENwer 4 bits */ } /** * fy_generic_is_direct_sequec_is_string() / fy_generic_is_string_type() and inst fy_generic v) { // fy_generic_value m = (v.v &PLACE_V || m == FY_FLOAT_OUTPLACE_V; return ((v.ve (%FY_FLOAT_INPLACE_V, 64-bit only) and * out-ofic is an unsigned integer. * * Signed and unsign.v & FY_INPLACE_TYPE_MASK); // return m == FY_INT(), fy_generic_is_indirect_bool_type(), … */ FY_neric_is_null_type(), fy_generic_is_indirect_null__GENERIC_IS_TEMPLATE_NON_INLINE(_gtype) \ \ bool f); \ } \ \ struct fy_useless_struct_for_semicolon onst fy_generic v) \ FY_EXPORT; \ \ bool \ fy_gennctions for the type suffix @_gtype: * - fy_genct_invalid(fy_generic_indirect_get_value(v)); ret if @v (or its wrapped value for indirects) is noteof__(_Generic((_v), \ char *: ((char *)0), \ eneric_typeof() - Yield the canonical C type for ang), &size)) return SIZE_MAX; return size; } /e bytes needed for a mapping of @count pairs. * integer overflow. */ static inline size_t fy_seqquence_handle)NULL) #define fy_map_handle_null ((fapping *fy_generic_mapping_handle; typedef const falue fits in the signed range). Access the * valneric_sized_string; /* FYGDIF_UNSIGNED_RANGE_EXTEappings * uniformly without knowing the concrete fy_generic_mapping - Out-of-place storage for a gequence { size_t count; fy_generic items[]; } fy_ of @count &fy_generic items following the header.direct or direct type accessor as appropriate. * _generic_set_failsafe_str() - Set a failsafe on th fy_generic_set_collection_style() - Set the collescalar style of a generic * * It fails if generic, or remove it if setting @vstyle fy_invalid * nt placement * @vcomm: The generic comment to set/** * fy_generic_set_marker() - Set marker on thed generic value */ fy_generic fy_generic_set_diagPORT; /** * fy_generic_set_tag() - Set tag on thction_style fy_generic_get_collection_style(fy_genneric_get_node_style() - Get the node style of a ggeneric value. * * Returns: * The marker &fy_gehe tag string &fy_generic, or %fy_null if none. *rect generic value. * @placement: The place of thic, or %fy_null if %FYGIF_MARKER is not set. */ flue. * * Returns: * The diagnostics as a &fy_generic_indirect_get_anchor() - Get the anchor from indirect with %FYGIF_VALUE set. * * @v: An indi* * Dereferences the indirect without checking flset. Only use when the flag is known to be set. ect_get(fy_generic v, fy_generic_indirect *gi) FYof the wrapped value. * Only call this when fy_ge value is stored inplace. * * Preferred alias foalue: case fy_map_empty_value: return true; } place (bithack). * * Fast branch-friendly implemCE_V) return true; break; case FYGT_FLOAT: with no * external allocation. Uses a readable sgned int)(v.v >> FY_ESCAPE_SHIFT)) { case FY_ESct_type_bithack(fy_generic v) { if (v.v == fy_invtion that decodes the type from the * low 4 bits _SHIFT); return escape_code < ARRAY_SIZE(escapes)FYGT_INT, [8 | 2] = FYGT_INT, [3] = FYGT_FLic_type of @v, or %FYGT_INVALID for unknown escapeadjusted pointer and the same collection tag. */ rdiff_t d) { v.v = (fy_generic_value)((ptrdiff_t)c inline fy_generic fy_generic_relocate_ptr(fy_genptr) { /* clear the boot 3 bits (all pointers aretor bit) * from @ptr to recover the 16-byte-alignesolve_ptr() - Extract the raw pointer from a non- true if @v equals the %fy_invalid sentinel; false* * Only meaningful for direct (non-indirect) valINDIRECT). * * @v: The generic value to test. *pe and data entirely in the word (inplace * scalaeneric indirect * * Reset the contents of a gene FYGIF_DIAG FY_BIT(FYGIIDX_DIAG) /* @diag field generic right_comment; /* the right comment */ vindirect[FYGIIDX_MAX]; /* an array for ease of ut to * %fy_invalid and @anchor holding the alias FYGIIDX_TOP_COMMENT 7 #define FYGIIDX_RIGHT_COMME) * positional info (if it exists) * > start: inalue }) /* Typed fy_generic sentinel meaning "no vit floats on 64-bit). Larger values * are storedd word encoding any YAML/JSON value without * healar element, at least FY_GENERIC_SCALAR_ALIGN */ #rger of _Alignof(@_v) and @_min as a size_t. */ #gnment (bytes) for heap-allocated sequence and ement) sequence */ #define fy_seq_empty_value ((fSE) #define fy_true_value FY_MAKE_ESCAPE(FY_ESCAvalue)(_v) & FY_ESCAPE_MASK) == FY_ESCAPE_MARK) # length field */ #define FY_INDIRECT_V 7 /* tyat stored out-of-place (pointer) */ /* Bit positiin the escape word */ #define FY_INT_INPLACE_V 1 ts for null (also used by sequence pointer) */ #dex|xxxx|1|111| // // escape codes: // fy_null 0 ppp|p|100| pointer to 8 byte aligned double // 00|0|000| empty sequence // mapping 0 |p0|0000|0|111| null indirect // escape |xxxxx0000|0000|0|010| int zero // float 3 |fffffff---------------+----|-+---+ // sequence 0 |pppppv0 << 24) \ ) #endif #endif // 64 bit memorylace string encoding word (32-bit). * * Packs upFT7(_v0, _v1, _v2, _v3, _v4, _v5, _v6) \ (\ ((fed in, ready to be * OR-ed with the type tag and * @_v1: Second character byte. * @_v2: Third chits to shift when sign-extending an inplace integefine FYGT_GENERIC_BITS FYGT_GENERIC_BITS_32 #defPLACE_SIZE_32 2 /* max bytes of a string stored_SIZE_MASK_64 7 /* mask for the 3-bit inplace ste FYGT_GENERIC_BITS_64 64 /* total bits in a ge = (FYGTM_SEQUENCE | FYGTM_MAPPING), FYGTM_SCALAR for all scalar types (null through string). * @FAS. * @FYGTM_COLLECTION: Combined mask for sequene value. Combine them with bitwise OR to test * ric_type_is_scalar() - Test whether a type is a sc_BOOL, FYGT_INT, FYGT_FLOAT, FYGT_STRING, FYGTerved; internal * bithacks depend on consecutive _generic_to_document()`` * convert between YAML d_alloca()``): build from * pre-constructed ``fy_gtive C types. * Zero heap allocation for scalars ngle machine word (64 or 32 bit) that * encodes opresenting arbitrary YAML * and JSON values in C,de #include ess. * * @dir: Path to the arena directory. * * Roll back the allocator to the checkpoint idenn)( uint64_t slot_gen, uint64_t head_chunk_gen, slot, oldest-to-newest. * * @slot_gen: The slotd or * even rolled back to a previous state. * dex region reserved size * * Return the total reex region base address * * Return the fixed virtal size of a durable arena's content region. * Wass and session, an in-arena * pointer is a stableator_chunk_count() - Get the durable arena chunk cot match (no change), or -1 on * error / if the ahe call enforces the durability * ordering barrier_refs_publish() - Atomically publish a new durablication-defined root pointer/cookie that names thehing but "durable") * this is a no-op that returnf the index region. 0 -> default. * @index_chunk_ @chunk_size: Size of each chunk file. 0 selects _ARENA_SEPARATE_INDEX FY_BIT(4) /* put the dedup illocator_region_base() and * fy_allocator_index_rcross every process and every session. Because theimated max content size (or 0 for don't know) */ EDUP: per tag freeing, dedup obj store * @FYAST_Pplicit_tags; int content_tag; int entries_tag; }edup index allocations. */ struct fy_dedup_allocaor auto) * @estimated_content_size: Estimated consize_t minimum_arena_size; float grow_ratio; floratio: The multiplier for the vm area first allocamremap arena type * */ enum fy_mremap_arena_typear content of the tag, or NULL if othersize. */ c. */ ssize_t fy_allocator_get_tag_linear_size(strAG_NONE for all tags * @usage: Receives the summaocator_usage - Aggregate allocator usage summary. the pointer ptr is contained in the allocator, faONTAINS = FY_BIT(3), FYACF_HAS_EFFICIENT_CONTAI persist at stable addresses across processes and pports releasing entire tags * @FYACF_CAN_DEDUP: of vectors * @align: The alignment restriction o, or NULL if the object does not exist */ const vfy_allocator_lookup() - Lookup for object in an al * @iov: The I/O scatter gather vector * @iovcnt:or no new allocation * will take place and a pointo the location * it was stored. When using a dedbject tracking allocators treat this as a NOP * emory or NULL */ void * fy_allocator_alloc(structontent it carries. * Allocators that cannot perfo tag * * Trim a tag, that is free any excess mem- Get the maximum number of tags a * allocaReleases a tag from an allocator and frees all memgle tag (like the linear * allocator for instanceions will be performed, so it's safe to embed. * nimum amount of memory for an inplace dedup allocae FY_LINEAR_ALLOCATOR_IN_PLACE_MIN_SIZE 256 /** able allocators * with the fy_allocator_get_namesation * argument provided. * The allocator may bsents 'none' */ #define FY_ALLOC_TAG_NONE -2 /** fyaml-thread.h */ /* A tag that represents the deator_release_tag()``. This maps naturally to * dontent-addressed store built on xxhash hashing. *leased at once. * * - ``"malloc"`` — thin wrap1) and * near-zero overhead; individual frees aml allocator API * Copyright (c) 2019-2026 Pantelfy_document_builder *fydb, struct fy_event *fye) ment_with_builder() - Parse a document via built-iparser events * * Load a document by pumping thehe document builders state to in 'document' * * at the document of a document builder. * Ownershidocument() - Take ownership the document of a builmplete. * If it is complete then a call to fy_docnt builder is in 'stream' state, * i.e. after strbuilder. This document * may be incomplete. If yolder * fy_document_builder_create_on_parser(struct document builder * pulling state from tuilder_cfg { struct fy_parse_cfg parse_cfg; voidde is useful when events arrive asynchronously or if (fy_document_builder_is_document_complete(fdestroy(fyd); * } * fy_document_builder_destilder — event-stream to document-tree conversionmic drain. This is intentional and sufficient for subtracts that same value from it in * one logicarpc__) __asm__ volatile ("or 27,27,27"); #else _y-ordering penalties and * allow sibling hardwarest_and_set((_ptr)) /** * fy_cpu_relax() - Emit ak path this * is implemented as a plain store. ** * fy_atomic_fetch_and() - Atomically AND @_v inhe operation. */ #define fy_atomic_fetch_or(_ptr,Returns: The value of @_ptr before the addition. ``*_ptr == *_e``. Prefer in retry loops where a s. * @_e: Pointer to the expected value (updatedThe old value that was at @_ptr before the exchangne fy_atomic_load(_ptr) \ atomic_load((_ptr)) /*or a plain * ``bool`` in the fallback path. */ #ack to these macros (e.g. GCC in C++ mode). */ #de \ *(_ptr) = true; \ } while(0) /* C11 atomicd; \ }) #define atomic_fetch_sub(_ptr, _v) \ ({_typeof__(*(_ptr)) __old = *__ptr; \ bool __res;olatile atomic_flag *__p = (_ptr); bool __ret = *_ine atomic_fetch_and(_ptr, _v) \ ([&]() -> decltympare_exchange_weak(_ptr, _exp, _des) \ atomic_codecltype and immediately-invoked C++ lambdas for tlementations perform plain loads/stores with no meY_HAVE_ATOMICS - Defined when real atomic types arn the compiler supports * ``_Atomic`` as an extenon every supported compiler, so no symbol is ever lang_major__ == 3 && __clang_minor__ >= 6))) || \ fined(__clang__) && (__clang_major__ > 3 || (__clast use because libc++'s decentionally excluded: it falls back to its own * pes and functions are in scope * and all ``fy_atoefine LIBFYAML_ATOMICS_H #include #inflag type * - fy_atomic_load() / fy_atomic_store( memory-ordered (i.e. ```` is in * the standard ``atomic_*`` functions and type=c11``, Clang) and a last-resort non-atomic fallbak_exec_fn fn, fy_work_check_fn check_fn, voidray items */ void fy_thread_arg_array_join(structg argument array * * Execute @fn possibly in parunction to execute in parallel * @check_fn: Pointading * is possible at the time execute in the cuse. */ bool fy_thread_pool_is_any_reserved(structead_submit_work(struct fy_thread *t, struccuting the work in parallel with the * calling th fy_thread_reserve(struct fy_thread_pool *tp) FY_hread again via a call to fy_thread_unreserve. * nction will block until all threads * of the pooly_thread_pool_destroy() - Destroy the given threadthreads: Number of threads, if 0 == online CPUs *escribing the work submitted * to a thread for exworth to * offload to a thread. * * @arg: The a * typedef fy_work_exec_fn - Work exec function hread_wait_work()``. Release the * thread afterw`): the recommended mode for * data-parallel loopilable as a public * API for application use. * pull in common definitions and platform abstractioefault_output() - The default colorizing output mey_emitter_default_output_data - emitter default oug *diag) FY_EXPORT; /** * fy_emitter_set_finaliiagnostic object will be * unref'ed (and freed ife emitter */ const struct fy_emitter_cfg * fy_emiORT; /** * fy_emitter_destroy() - Destroy an emiunion { FILE *output_fp; int output_fd; cons flags * @colors: ANSI color overrides for the deUTPUT_FILENAME: Output to the given filename */ eFYEXCF_PRESERVE_FLOW_LAYOUT: Preserve oneline flow * @FYEXCF_VISIBLE_WS: Make white space visible *_COLOR(x) (((unsigned int)(x) & FYEXCF_COLOR_MASK)nter to the method that will perform output. * @uDIR(0), FYECF_TAG_DIR_OFF = FYECF_TAG_DIR(1), F), FYECF_MODE_FLOW_COMPACT = FYECF_MODE(10), FYDE_JSON = FYECF_MODE(4), FYECF_MODE_JSON_TP = INDENT_3 = FYECF_INDENT(3), FYECF_INDENT_4 = enum fy_emitter_cfg_flags { FYECF_SORT_KEYS = F* @FYECF_MODE_JSON_COMPACT: Emit using JSON compacecting all manual style hints (reformats if needed_WIDTH_80: Output width is 80 * @FYECF_WIDTH_132:ENDED_CFG: Extend configuration, this config struce line mode) * @FYECF_STRIP_EMPTY_KV: Remove all ION_DIR_SHIFT 28 #define FYECF_VERSION_DIR_MASK ine FYECF_INDENT(x) (((x) & FYECF_INDENT_MASK) _indent, }; #define FYEWT_EXTENDED_INDICATORS_FIRSyewt_indicator_colon, fyewt_indicator_dash, fyewt_indicator_chomp: chomp indicator (- or +) * @fyicator_bar: | indicator * @fyewt_indicator_greateomment * @fyewt_indicator_question_mark: ? indicaunk is a folded block scalar * @fyewt_anchor: Outa tag directive * @fyewt_version_directive: Outpu path expression, it may still be member of a * dn explicit document end marker, false if not */ bicit start marker * * Returns: * true if documement, * by replacing references to anchors with tparse_document_destroy(struct fy_parser *fyp, stru method performs parsing on a parser stream and ree pushed back utf8 character was -1, then 0 will bter: The iterator. * @c: The character to push ba utf8 character from an iterator * * Reads a sinterator it shall return that. The character is note * returned in subsequent calls of fy_haracter from an iterator * * Pushes back a singator. * @buf: Pointer to a block of memory to recator position */ void fy_token_iter_advance(strucable * will be filled with 0 for normal end, or -equence, * * @iter: The iterator. * @curr: The elease the resources that it holds. * Call it forerator must be created via a previous call to fy_twly created iterator, or NULL in case of * an errtor for operating on the given token, or * a gene * were not retained by the parser configuration. error, if the node has no such comments, or if * n failure. */ iy_token_set_comment() - Attach a comment to a toke_token *fyt, enum fy_comment_placement which) FY_tached at a token having the given * placement. on top of token * @fycp_right: Comment to the rigso try to use fy_token_get_text() * instead if potoken_get_text0() - Get zero terminated text of a to be valid * after the parser is destroyed. * tent. It is also different than an * empty scalar check for NULLity. * * Note that this is differf the token, or FYSS_PLAIN on each other case */ _ARGS__) #define fy_parser_report_notice(_fyp, _fy...) \ fy_parser_report((_fyp), FYET_DEBUG, (_fyters diagnostics printf style and mark token (va_ar , ## __VA_ARGS__) #define fy_parser_warning(_fyp,parser's diagnostics * * @fyp: The parser * @ty fypm_json; } /** * fy_parser_vlog() - Log usingparser_is_in_yaml_mode(struct fy_parser *fyp) { rer_mode { fypm_invalid = -1, fypm_none, /* scanne very * efficient. * * Returns: * The number of sequence items on suc * fy_parser_count_sequence_items() - Count the se/** * fy_parser_parse_peek() - Parse and peek at he parser * @fd: The file descriptor to use * *ser_set_input_callback(struct fy_parser *fyp, voidt fy_parser *fyp, const char *name, FILE *fp) FY_ @str: The YAML string to parse (allocated). * @lis active the string must not go out of scope. * ing. The file * is located by honoring the searchefault * * Returns: * 0 if everything OK, -1 othe diag argument shall take a reference too. * *onst struct fy_parse_cfg * fy_parser_get_cfg(strucser * * Returns: * A pointer to the parser or N the given document event is an implicit one * *module to convert * * Returns: * The string valror */ const char *fy_error_type_to_string(enum fring_to_error_type() - Return the error type from * fy_library_version() - Return the library vers * the same... */ switch (fye->type) { case should not have to use this in other language bindevent (the main token) * @FYEP_TAG: The tag of th &enum FYET_MAPPING_END */ struct fy_event { enuT_SEQUENCE_START * @sequence_end: Sequence end inis &enum FYET_DOCUMENT_END * @alias: Alias informtype: Type of the event, see &enum fy_event_type struct fy_event_mapping_end_data - mapping end ev if * the sequence was implicitly ended */ sscalar value token (cannot be NULL) * @tag_implic /** * struct fy_event_alias_data - alias event eam_end_data { struct fy_token *stream_end; }alar styles */ enum fy_scalar_style { FYSS_ANY =n_style { FYCS_ANY = -1, FYCS_BLOCK, FYCS_FLOW, Flow style {}[] * @FYCS_MAX: marks end of scalaralar event * @FYET_ALIAS: YAML alias event */ enct fy_parse_cfg { const char *search_path; enum EFAULT_DOC (FYPCF_QUIET | FYPCF_DEFAULT_PARSE) /*PCF_CREATE_MARKERS = FY_BIT(20), FYPCF_KEEP_STYLolving documents * @FYPCF_ENABLE_CACHE: Enable tr * @FYPCF_JSON_FORCE: Force JSON mode always * @FULT_VERSION_1_2: Default version is YAML 1.2 * @Fically resolve them * @FYPCF_DISABLE_MMAP_OPT: Diia filling in the &fy_parse_cfg->flags member. * ) << FYPCF_JSON_SHIFT) /* guaranteed minimum deptFYEM_SCAN, FYEM_PARSE, FYEM_DOC, FYEM_BUILD, F @FYEM_ATOM: Atom module, used by atom chunking *YET_ERROR: Error level - error reporting is using y_mark - marker holding information about a locatiram execution, even if you've never called * any the supported YAML versions of this ibrary. * Thted, false otherwise. */ bool fy_version_is_suppo higher than vb * < 0 if version va is lower thanThe parser fills it according to the \%YAML directut to files, memory buffers, or * user-supplied can be * queried, modified, merged, and serialised * **Three complementary APIs** cover the full liparser_checkpoint; /** * DOC: libfyaml public APsplus } #endif #endif /* LIBFYAML_PATH_EXEC_H */ path_exec_execute(struct fy_path_exec *fypx, struct that the * results reside between this call andout releasing it. * * @fypx: The executor to res * * Returns: * A pointer to the executor or NUruct fy_diag *diag; }; /** * fy_path_exec_createET = FY_BIT(0), FYPXCF_DISABLE_RECYCLING = FY_B * enum fy_path_exec_cfg_flags - Path executor conl use * @level: The nest level; should be set to fy_path_expr_free(struct fy_path_expr *expr) FY__string() - Parse an expression from a given strinse. * @len: The length of the string (or -1 if '\ath parser completely * * Completely reset a path parser. * * Creates a path parser with its conIT(2), }; /** * struct fy_path_parse_cfg - path object, that is, when @diag is NULL. * @FYPPCF_Dcument and may be executed repeatedly. */ structyn; * while ((fyn = fy_path_exec_results_iteraters/0/host`` is first *parsed* into a * compiled EXEC_H #include #ifdemitter * * Replace the emitters's current diagnoly created by fy_emitter_create() * * @emit: Thes xflags; const char *colors[FYEWT_COUNT]; unione set * @output_filename: The output filename, FYUTPUT_FD = FYEXCF_OUTPUT(2), FYEXCF_NULL_OUTPUT PUT_STDERR: Output to stderr, instead of stdout * mode is enabled all the flags are assumed 0. * tput */ #define FYEXCF_OUTPUT_MASK ((1U << 3) - 1)ethod which * is the way to convert a runtime docYECF_WIDTH_INF | FYECF_MODE_ORIGINAL | F_MODE_PRETTY = FYECF_MODE(8), FYECF_MODE_MANUACF_MODE(0), FYECF_MODE_BLOCK = FYECF_MODE(1), F_STRIP_DOC = FY_BIT(4), FYECF_NO_ENDING_NEWLINERK_OFF: Do not generate document end markers * @Fow mode in as much as possible compact form * @FYF_MODE_DEJSON: Emit YAML trying to pretify JSON * is 6 * @FYECF_INDENT_7: Output indent is 7 * @Fput ending new line (useful for single line mode) ng * @FYECF_OUTPUT_COMMENTS: Output comments (expD_MARK_MASK 0x3 #define FYECF_DOC_END_MARK(x) ((IDTH_SHIFT 12 #define FYECF_WIDTH_MASK 0xff #defin_double_quote_end, fyewt_indicator_ambersand, fynebreak, fyewt_alias, fyewt_terminating_zero, fewt_whitespace, fyewt_plain_scalar, fyewt_singleht_brace: } indicator * @fyewt_indicator_comma: ,unk is a tag * @fyewt_linebreak: Outpunk is a literal block scalar * @fyewt_folded_scalutput, or do some other content related * filteri * fy_node_document() - Retreive the document theicit_document_end() - Explicit document end check The document to check for directives existence *ument_resolve() - Resolve anchors and merge keys ns the next * document. This means that for a comhe parser stream * * This method performs parsin/** * fy_token_iter_utf8_peek() - Peeks at singleed back, and any * further calls to ungetc will rr: The iterator. * * Returns: * The next utf8 ctor * * Peeks at the next character to get from of fy_token_iter_getc(). Currently * only a singaracter from an iterator. If the iterator is * five the data. Must be at * least count bytes_iter_ungetc() / * fy_token_iter_utf8_unget() in er_chunk_next(struct fy_token_iter *iter, cons chunk, or NULL in case there's * no other. */ cy_token_iter_start() - Start iterating over the coa matching call to * fy_token_iter_destroy(). * * The iterator produces a stream of chunks which () - Get all comments of a node * * @fyn: The noree'ed if it's not NULL via a call to free() */ cn *fyt, enum fy_comment_placement which, comment is removed. * * @fyt: The token out of whi * Get all the comments that are attached on a toke token * @fycp_bottom: Comment to the bottom of t the NULL token will return a length of zero. */emory to hold * it in the token structure so try e token, while * @lenp will be assigned the charaken is 'simple' enough (i.e. a plain scalar) * orfferent than null of the YAML type system. * It iNote that a NULL * token is a &enum FYSS_PL_VA_ARGS__) #else #define fy_parser_report_debug(uct fy_parser *fyp, enum fy_error_type type, struc The argument list */ void fy_parser_vreport(stru(_fyp), FYET_ERROR, (_fmt) , ## __VA_ARGS__) /** RMAT(printf, 3, 4) FY_EXPORT; #ifndef NDEBUG #dostics printf style (va_arg) * * Output a log onformat being parsed (YAML 1.1, 1.2, 1.3, or JSON).ing for mode, not committed yet */ fypm_yaml_1_1,urned. */ int fy_parser_count_mapping_items(strucmber of items exceeds INT_MAX, INT_MAX will * be equence items. Parser must already * be in a sequte, but as read-only. * * You must not free thist the end of * the stream. The returned event mus ssize_t (*callback)(void *user, void *buf, size_The label of the stream * @fp: The FILE pointer, ership is transferred * to the created input. Wheinated) string. Note that * while the parser is aparser_set_input_file(struct fy_parser *fyp, constarser, including after an error * that caused a preed if its reference gets to 0). * Also note thato the diagnostic object of a parser object. * Nostroy the given parser * * Destroy a parser crea_event to check. * It must be either a docue if the event is an implicit one. */ bool fy_eveue of the error type or the empty string "" on err; /** * fy_error_type_to_string() - Convert an e a version string of the form * .[[ye->document_start; case FYET_DOCUMENT_END: ret * * Some languages *cough*golang*cough* really d_event_part { FYEP_VALUE, FYEP_TAG, FYEP_ANCHORtream_end_data stream_end; struct fy_event_docums &enum FYET_SCALAR * @sequence_start: Sequence stype is &enum FYET_ALIAS * @scalar: Scalar inform* This structure is generated by the parser by eac_token *tag; struct fy_token *mapping_start; }; ata - sequence end event data * * @sequence_end:/** * struct fy_event_scalar_data - scalar event ument_state *document_state; bool implicit; }; /ersion and configured tags) * @implicit: True if FYSS_DOUBLE_QUOTED, FYSS_LITERAL, FYSS_FOLDED,the emitter to choose * @FYSS_PLAIN: Plain scalarE_START, FYET_SEQUENCE_END, FYET_SCALAR, FYET_AYET_NONE: No event * @FYET_STREAM_START: Stream s* * @search_path: Search path when accessing fileG_DIAG_TYPE 0 #define FYPCF_DEBUG_DIAG_MODULE 0 y the code if you actually depended * on the old F_PREFER_RECURSIVE = FY_BIT(15), FYPCF_JSON_AUTOY_BIT(7), FYPCF_DISABLE_BUFFERING = FY_BIT(8), YPCF_ALLOW_DUPLICATE_KEYS: Allow duplicate keys onisable use of access accelerators (saves memory) ble depth limit check, use with enlarged stack * ine FYPCF_GUARANTEED_MINIMUM_DEPTH_LIMIT 64 /** SON_SHIFT 16 /* Mask of the JSON input mode */ #dFYEM_INTERNAL, FYEM_SYSTEM, FYEM_EMIT, FYEM_TYP { FYET_DEBUG, FYET_INFO, FYET_NOTICE, FYET_WA * @column: Column position (0 index based) */ sthe tag (i.e. `"!!"`) * @prefix: The prefix of the * fy_shutdown() - Final cleanup before exit * * @vers: The version to check, NULL means defauln of the library, i.e. the highest * stable versirsion * @vb: The second version, if NULL use defa * * @major: Major version number * @minor: Majlen == FY_NT) \ __len = strlen(__str); \ Y_ALLOCA_COPY_FREE_NO_NULL(_str, _len) \ (fy_allopport GCC statement expressions, so we provide * ndif /* make a copy of an allocated string and ree FY_FORMAT(_t, _x, _y) __attribute__ ((format(_t,_node; struct fy_node_pair; struct fy_anchor; struypedef int ssize_t; #endif #endif /* Windows doesnE, ARISING FROM, * OUT OF OR IN CONNECTION WITH T OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR Pthe rights * to use, copy, modify, merge, publishf no more paths exist */ struct fy_path * fy_compe root path of the composer's path hierarchy. * * A pointer to a ref'ed diagnostic object or NULject has a reference taken so * you should fy_diafye) FY_EXPORT; /** * fy_composer_get_cfg() - Gg decisions. * * @fyc: The composer * @fye: Theomposer_destroy() - Destroy the given composer * ser operation callbacks * @userdata: Opaque user rn (*process_event)(struct fy_composer *fyc, strucTART/END events where the * last component is preReturns the last non collection root component of collection of the path, or NULL if no path */ vod *data) FY_EXPORT; /** * fy_path_get_last_userserdata of the parent collection * * @path: The data */ void fy_path_component_set_mapping_user_dhe path component * @data: The data to set as mapid * fy_path_component_get_mapping_key_user_data(s root * * Note, no error condition if not a path** * fy_path_get_root_user_data() - Return the uss in a mapping value state * * @fypp: The path path is located within a mapping key state */ bopath_in_mapping() - Check if the path is in a mapp a path * * Given a path, return a malloc'ed strr */ int fy_path_depth(struct fy_path *fypp) FY_mpletely built during the composition * of a comppath_component_get_text() - Get the textual represng path component to return it's complex key * *ar or alias token if the mapping contains a scalarce_get_index(struct fy_path_component *fypc) FY_E is a sequence * * @fypc: The path component to back to make intelligent decisions about * creatit *fye, struct fy_path *path, void *userdata); parse_composer_cb - composer callback method * *cessing, event processed * @FYCR_OK_STOP: stop pr - ``FYCR_OK_CONTINUE`` — consume the event an FYCR_OK_START_SKIP; * process(fye); * own path stack:: * * enum fy_composer_return mcommitting to building a full in-memory tree. * 64toh #define le64toh(x) fy_bswap64((uint64_t)(x))x)) #endif #ifndef htole32 #define htole32(x) fy_32toh #define be32toh(x) fy_bswap32((uint32_t)(x)) le16toh(x) ((uint16_t)(x)) #endif #ifndef htobe16(x & (uint64_t)0x000000ff00000000ULL) >> 8) | t32_t)0x000000ffUL) << 24) | ((x & (uint32ne uint16_t fy_bswap16(uint16_t x) { return _bytes/** * bswap_8() - Byte-swap an 8-bit value (no-opefine __BIG_ENDIAN BIG_ENDIAN #endif #if !definedern/OSByteOrder.h> # include #else * // big-endian path * #endif * * __LITTLE_ENDIAN`` — little-endian sentinel valueeader wrapper * * Copyright (c) 2023-2025 Pantelthe BLAKE3 output (sized FY_BLAKE3_OUT_LEN), or NUasher_finalize(struct fy_blake3_hasher *fyh) FY_E state with the given input * * Updates the BLAKher_create(). * * @fyh: The BLAKE3 hasher to desread_pool *tp; int num_threads; }; /** * fy_blar to a context when in key derivation mode. * default * @mmap_min_chunk: Minimum chunk size forLL in \*prevp. * * The default backend is alwaysfine FY_BLAKE3_OUT_LEN 32 /* opaque BLAKE3 hasher * The hasher can be used in streaming fashion (``d, selected via * ``struct fy_blake3_hasher_cfg``de /* pull in common definitions and prtable way */ #ifdef FY_HAS_STATIC_ARRAY_PARAMS #dine FY_VA_ARG_SSIZE_T(ap) ((ssize_t)va_arg(ap, in #if __SIZEOF_FLOAT128__ == 16 #define FY_HAS_FLOAECIMAL_DIG__) #define FY_LDBL_DECIMAL_DIG __LDBL_Dllback: 17. */ #if defined(DBL_DECIMAL_DIG) #defiFY_FLT_DECIMAL_DIG - Decimal digits required for a_) #define FY_DBL_MANT_DIG __DBL_MANT_DIG__ #else FY_FLT_MANT_DIG - Number of base-2 mantissa digitcounts of * ``float``, ``double``, and ``long doustic ignored \"-Wunused-variable\"") /** * FY_DIAIGNORE_UNUSED_VARIABLE - Suppress ``-Wunused-varia#define FY_DIAG_POP _Pragma("GCC diagnoY_DIAG_PUSH * FY_DIAG_IGNORE_ARRAY_BOUNDS * Y_HAVE_LAMBDAS 1 /** * FY_HAVE_NESTED_FUNC_LAMBDAgainst this macro and provide a fallback * for en * %FY_HAVE_BLOCK_LAMBDAS; or * - GCC is in us* * FY_STACK_RESTORE() - Restore the stack pointeuiltin_stack_restore) /** * FY_STACK_SAVE() - Sav multiple macro expansions * in the same file. *nerate a unique identifier using ``__COUNTER__``. (_fmt) __VA_OPT__(,) __VA_ARGS__); \ _size = fy_ char *__fmt = (_fmt); \ int _size; \ char *_b \ va_end(_ap_orig); \ _buf = alloca(_size + 1ine fy_vsprintfa(_fmt, _ap) \ strcpy(alloca(FY_ALvery efficient and wastes memory but it's the bestalloca_sprintf_buf[FY_ALLOCA_SPRINTF_BUFSZ]; statfy_snprintf_fmt(_buf, _sz, _fmt, ...) \ FY_CONCATith ``vsnprintf()``, then allocates a * stack bufse /* no overflow checks for MSVC; tread carefullyoverflow */ #if __has_builtin(__builtin_mul_overflllback requires @_a and @_b to have the same type ((__a ^ __res) & FY_SIGN_BIT(__a)) != 0))); \ *(_r to receive the result (written even on overflow)\ *(_resp) = __res; \ __overflow; \ }) #else /* fine FY_ADD_OVERFLOW(_a, _b, _resp) \ ({ \ __typeto ``__builtin_add_overflow(_a, _b, _resp)``, * wine FY_TYPE_IS_UNSIGNED(_x) \ (((__typeof__(_x))0 FY_SAME_TYPE(_a, _b) __builtin_types_compatible_p * * @_a: First expression. * @_b: Second expresle-time boolean is needed in a macro context. * s are disabled * (``NDEBUG``). */ /* something i reporting is active. * * Defined when both %FY_ned(NDEBUG) && defined(__GNUC__) && __GNUC__ >= 4 * FY_DEBUG_UNUSED - Mark a variable as potential__((destructor))``. Also defines * %FY_HAS_DESTRUothing and %FY_HAS_CONSTRUCTOR is not defined. */used variable/parameter" warnings. * * On GCC/Clumber of elements in a stack-allocated array. * ing struct of type @type. */ #ifndef container_of __strb = ""; \ __strb; \ }) #en_stra, __str, __len); \ __stra[__len] = '\0'; )(_len); \ \ if (__str) { \ if ing to the stack copy. * * When @_str is NULL thca_copy_free_impl((_str), (size_t)(_len)) ? fy_all actual_len = FY_ALLOCA_COPY_FREE_BUFSZ - 1; mendif #ifdef _MSC_VER /* * MSVC doesn't support Gne FY_DEPRECATED __attribute__ ((deprecated)) /** ed symbol. * On other compilers expands to nothinine FY_NT ((size_t)-1) /** * fy_str_empty() - Te #ifndef FY_BIT #define FY_BIT(x) (1U << (x)) #endprovide __has_builtin. * * Always evaluates to 0OMPILE_ERROR_ON_ZERO`` — produce a compile-time ``FY_CHECK_SAME_TYPE`` — assert two expressions y in a single expression * - ``fy_vsprintfa`` / `oolchains * - ``FY_CONSTRUCTOR`` / ``FY_DESTRUCTOrpose utility macros and portability helpers * *nitions */ #ifndef _SSIZE_T_DEFINED #define _SSIZEE OR OTHER DEALINGS IN THE * SOFTWARE. * * SPDXon notice shall be included in all * copies or suithout restriction, including without limitation talloca_align(_sz, _align) \ ({ \ const size_t _valid only for the lifetime of the enclosing functspecific alignment. * * Expands to a statement ey_align_free(p); } /** * fy_ptr_align() - Round Pointer previously returned by fy_cacheline_alloc( * * A NULL @p is silently ignored. * * @p: Poid ``_aligned_malloc()`` on * Windows. Free the re* fy_align_alloc() - Allocate memory with a specifALIGN - Alignment attribute for cache-line-aligned rounded up to the nearest multiple of @_align. *ment) * * @x: Required alignment in bytes (must `` * - MSVC: should be ``__declspec(align(x)``fy_cacheline_free(p)`` — convenience * wrapust be a power of two) * - ``FY_CACHELINE_SIZE_ALr * type; expands to ``__attribute__((aligned(xde #include #ifdef _WIN32 #i objects are equivalent * * Iterates both reflecype_exclude: Regex for type names to drop; NULL = ll * unmarked types. Call this after creating a mf: Meta field * * Returns: * Pointer to the me index * * @mt: Meta type * @idx: Field index /** * fy_meta_type_get_field_count() - Get the nu * * The root meta type corresponds to the entry ream/document boundary events are controlled by * * * @ctx: Type context * @fyp: Parser positntext_parse() - Parse a YAML stream into a C data uilds the meta-type tree for the given entry type,ontext_emit_flags { FYTCEF_SS = (1U << 0), FYTCE annotation; pass NULL to use the annotaection object (must be non-NULL) * @entry_type: Nntext_create() * * @FYTCCF_DUMP_REFLECTION: Dcontext_free_data): * void *data = NULL; * ft fy_meta_field`` — one field within a meta type filled with this value rather than left as zero/` field matches. Works together with the * ``s0``-terminated arrays:: * * int *ids; // y* * ``terminator: `` * Alternative to `d word or * follows a different naming conventiThe * field's value is compared against each arer: len } * size_t len; * }; * *tations** * * ``counter: `` * Namplicit ``selector`` field. * * ``flatten-field-fh parse and emit; * without this flag a NULL fr Accept a YAML mapping node as valid input. * t-if-default`` * Omit the field during emissiony_type_context_cfg``) govern root-level behaviour. // yaml: { key: key, counter: count } * }; * * DOC: YAML metadata annotations * * Metadataeld info if field was found, NULL otherwise */ co field with the enum value on the given type. * nfo_index() - Get the index of a field of a type result as a string instead of * writing to a filcontrolling output format (indentation, comments) lection_generate_c() - Generate C code from reflecnerated output * @FYCGF_COMMENT_RAW: Emit the orces per indentation level * @FYCGF_INDENT_SPACES_int)(x) & ((1 << FYCGF_COMMENT_WIDTH) - 1)) << FYCT; /* flags for generation */ #define FYCGF_INDENve the YAML comment associated with this field fros: * The yaml annotation document, or NULL */ stthe yaml keyword annotations of this type as a stro_get_yaml_annotation() - Get the yaml annotation trying) to remove comment formatting. For example:his is a comment * which requires cooking * foo; * struct { // <- anonymous * int t's dependencies * * Mark the type and recursive* Clear the marker on a type. Note this call will type_info_lookup() - Lookup for a type by a definie()'d when the caller is done with it. */ char * e type by traversing the type definitions * down lified version of a type (removing const, volatilerate(struct fy_reflection *rfl, void **prevp) FY_ This method iterates over all the types of a reflet_userdata() - Get the userdata associated with aiagnostic object to use (or NULL for default) * tion * * @rfl: The reflection * @blob_file: Theror */ void * fy_reflection_to_packed_blob(structpacked blob from the given reflection * * @rfl: s, bool display_diagnostics, bool includection from a single C source file, using a simpleber of arguments to pass to libclang * @argv: Argction * fy_reflection_from_c_files(int filec, consors) * @include_comments: Include comments in the * * @backend_name: The name of the backend * @s: The array of import configs. * @diag: The diag * fy_reflection_from_imports() - Create a refleceflection_destroy(struct fy_reflection *rfl) FY_E/** * fy_field_info_get_unsigned_enum_value() - Gd_info_get_flags(fi) & FYFIF_BITFIELD``. * * @fiield * * Valid only when ``!(fy_field_info_get_ffo_get_parent(const struct fy_field_info *fi) FY_ that contains this field * @fi: The field info to the field info, or NULL if idx is out of range his one depends on * * For pointers, typedefs, etype in bytes, or 0 for incomplete/void types */ info * Returns: Bitfield of ``enum fye_info_get_*()`` accessor functions to inspect it.* type declaration in main file */ FYTIF_SYSTEM_HOUS = FY_BIT(4), /* type is anonymous */ FYTIF_as declared in a system header * @FYTIF_ANONYMOUSinfo`` describes a single struct/union field or enld_info_flags - Flags for a field entry * * @FYFe kind or 0 on error */ size_t fy_type_kind_size(t fy_type_kind_info * fy_type_kind_info_get(enum fnsigned, 0 not relevant for this type */ int fy_telement count is known at compile time and stored FYTK_FUNCTION; } /** * fy_type_kind_has_elementYPEDEF && type_kind <= FYTK_INCOMPLETEARRAY; } /* if the type is directly dependent on another * pe_info *ti) FY_EXPORT; /** * fy_type_kind_is_dme as ``ti->name``. * * @ti: The type info * *ype_info_prefixless_name() - Get the name of a typset without going through a dependent type. * Thind >= FYTK_STRUCT && type_kind <= FYTK_ENUM; } /*rue if it is a type than can be an enum constant dalternate signed/unsigned starting from FYTK_SCHARhe minimum is negative */ if (type_kind == FYTK_Cigned() - Check if an integer kind is signed * *kind_is_integer() - Check if it's a numeric integese */ static inline bool fy_type_kind_is_numeric(e type kind contains other types in a record * lind NULL) * * @type_kind: The type_kind to check _kind <= FYTK_FLOAT128; } /** * fy_type_kind_is__kind type_kind) { return type_kind >= FYTK_VOID st C primary type */ #define FYTK_PRIMARY_FIRST FYONG, FYTK_ULONGLONG, FYTK_INT128, FYTK_UINT128,FYTK_ENUM: An enumeration type * @FYTK_TYPEDEF: Amay not be available on all arches) * @FYTK_FLOATum fy_type_kind - The types of the reflection plum ``fy_reflection_export_packed()``; zero runtime dypes, and qualifiers * - ``struct fy_field_info`` * - ``struct fy_type_info`` — descriptor forospection and YAML schema support * * The reflec6, x57, x58, \ x59, x60, x61, x62, x63, x64) \ m(a, x61) m(a, x62) m(a, x63) #define _FM2_64(a, m,(a, x60) m(a, x61) m(a, x62) #define _FM2_63(a, m,54, x55, x56, x57, x58, \ x59, x60, x61, x62) \ (a, x59) m(a, x60) m(a, x61) #define _FM2_62(a, m,(a, x58) m(a, x59) m(a, x60) #define _FM2_61(a, m,2, x53, x54, x55, x56, x57, x58, \ x59, x60) \ m x57) \ m(a, x58) m(a, x59) #define _FM2_60(a, m, x56) m(a, x57) \ m(a, x58) #define _FM2_59(a, m,(a, x55) m(a, x56) m(a, x57) #define _FM2_58(a, m,(a, x54) m(a, x55) m(a, x56) #define _FM2_57(a, m,(a, x53) m(a, x54) m(a, x55) #define _FM2_56(a, m,3) m(a, x54) #define _FM2_55(a, m,9) m(a, x50) \ m(a, x51) m(a, x52) m(a, x53) m(a,(a, x51) m(a, x52) m(a, x53) #define _FM2_54(a, m, x45, x46, x47, x48, x49, x50, x51, x52, x53) \ m x50) \ m(a, x51) m(a, x52) #define _FM2_53(a, m,50) \ m(a, x51) #define _FM2_52(a, m,m(a, x46) m(a, x47) m(a, x48) m(a, x49) m(a, x50) (a, x48) m(a, x49) m(a, x50) #define _FM2_51(a, m,2, x43, \ x44, x45, x46, x47, x48, x49, x50) \ m(a, x47) m(a, x48) m(a, x49) #define _FM2_50(a, m,(a, x46) m(a, x47) m(a, x48) #define _FM2_49(a, m,(a, x45) m(a, x46) m(a, x47) #define _FM2_48(a, m,(a, x44) m(a, x45) m(a, x46) #define _FM2_47(a, m,8, x39, x40, x41, x42, x43, \ x44, x45, x46) \ m x43) \ m(a, x44) m(a, x45) #define _FM2_46(a, m, x42) m(a, x43) \ m(a, x44) #define _FM2_45(a, m,a, x41) m(a, x42) m(a, x43) #define _FM2_44(a, m, (a, x40) m(a, x41) m(a, x42) #define _FM2_43(a, m,(a, x39) m(a, x40) m(a, x41) #define _FM2_42(a, m,(a, x38) m(a, x39) m(a, x40) #define _FM2_41(a, m, x32, x33, x34, x35, x36, x37, x38, x39, x40) \ ma, x37) m(a, x38) m(a, x39) #define _FM2_40(a, m, x36) \ m(a, x37) m(a, x38) #define _FM2_39(a, m, x35) m(a, x36) \ m(a, x37) #define _FM2_38(a, m,(a, x34) m(a, x35) m(a, x36) #define _FM2_37(a, m,(a, x33) m(a, x34) m(a, x35) #define _FM2_36(a, m,(a, x32) m(a, x33) m(a, x34) #define _FM2_35(a, m, m(a, x1) m(a, x2) m(a, x3) m(a, x4) m(a, x5) m(ax29) \ m(a, x30) m(a, x31) m(a, x32) m(a, x33) #da, x30) m(a, x31) m(a, x32) #define _FM2_33(a, m, x29) \ m(a, x30) m(a, x31) #define _FM2_32(a, m, x28) m(a, x29) \ m(a, x30) #define _FM2_31(a, m,(a, x25) m(a, x26) m(a, x27) m(a, x28) m(a, x29) #a, x25) m(a, x26) m(a, x27) #define _FM2_28(a, m, a, x24) m(a, x25) m(a, x26) #define _FM2_27(a, m, a, x23) m(a, x24) m(a, x25) #define _FM2_26(a, m, x22) \ m(a, x23) m(a, x24) #define _FM2_25(a, m,19) m(a, x20) m(a, x21) m(a, x22) \ m(a, x23) #dea, x19) m(a, x20) m(a, x21) #define _FM2_22(a, m, a, x18) m(a, x19) m(a, x20) #define _FM2_21(a, m, a, x16) m(a, x17) m(a, x18) #define _FM2_19(a, m, (a, x12) m(a, x13) m(a, x14) m(a, x15) \ m(a, x1612) m(a, x13) m(a, x14) #define _FM2_15(a, m, x1, m(a, x10) m(a, x11) m(a, x12) #define _FM2_13(a, mx5) m(a, x6) m(a, x7) m(a, x8) \ m(a, x9) m(a, x1) \ m(a, x1) m(a, x2) m(a, x3) m(a, x4) m(a, x5) threading fixed arg a */ #define _FM2_TOOMANY(...) m(x60) m(x61) m(x62) m(x63) #define _FM_64(m, x15, x56, x57, x58, \ x59, x60, x61, x62, x63) \ m) m(x59) m(x60) m(x61) m(x62) #define _FM_63(m, x1) m(x58) m(x59) m(x60) m(x61) #define _FM_62(m, x153, x54, x55, x56, x57, x58, \ x59, x60, x61) \ m(x57) m(x58) m(x59) m(x60) #define _FM_61(m, x1(x56) \ m(x57) m(x58) m(x59) #define _FM_60(m, x11, x52, x53, x54, x55, x56, x57, x58, \ x59) \ m(x55) m(x56) \ m(x57) m(x58) #define _FM_59(m, x1(x54) m(x55) m(x56) \ m(x57) #define _FM_58(m, x1 x49, x50, x51, x52, x53, x54, x55, x56, x57) \ m) m(x53) m(x54) m(x55) m(x56) #define _FM_57(m, x1x48, x49, x50, x51, x52, x53, x54, x55, x56) \ m( x47, x48, x49, x50, x51, x52, x53, x54, x55) \ m x46, x47, x48, x49, x50, x51, x52, x53, x54) \ m) m(x50) m(x51) m(x52) m(x53) #define _FM_54(m, x1) m(x49) m(x50) m(x51) m(x52) #define _FM_53(m, x1 x44, x45, x46, x47, x48, x49, x50, x51, x52) \ m3, \ x44, x45, x46, x47, x48, x49, x50, x51) \ m) m(x47) m(x48) m(x49) m(x50) #define _FM_51(m, x1, x41, x42, x43, \ x44, x45, x46, x47, x48, x49, x45) \ m(x46) m(x47) m(x48) #define _FM_49(m, x1,, x41, x42, x43, \ x44, x45, x46, x47, x48) \ m(9, x40, x41, x42, x43, \ x44, x45, x46, x47) \ mx43) m(x44) m(x45) \ m(x46) #define _FM_47(m, x1,7, x38, x39, x40, x41, x42, x43, \ x44, x45) \ m m(x41) m(x42) m(x43) m(x44) #define _FM_45(m, x1,) m(x40) m(x41) m(x42) m(x43) #define _FM_44(m, x1 x35, x36, x37, x38, x39, x40, x41, x42, x43) \ m m(x38) m(x39) m(x40) m(x41) #define _FM_42(m, x1,x33, x34, x35, x36, x37, x38, x39, x40, x41) \ m( m(x36) m(x37) m(x38) m(x39) #define _FM_40(m, x1, x31, x32, x33, x34, x35, x36, x37, x38, x39) \ m(x34) \ m(x35) m(x36) m(x37) #define _FM_38(m, x1 x29, x30, x31, x32, x33, x34, x35, x36, x37) \ mx32) m(x33) m(x34) \ m(x35) #define _FM_36(m, x1,, x27, x28, \ x29, x30, x31, x32, x33, x34) \ m( m(x30) m(x31) m(x32) m(x33) #define _FM_34(m, x1,4, x25, x26, x27, x28, \ x29, x30, x31, x32) \ m m(x27) m(x28) m(x29) m(x30) #define _FM_31(m, x1,1, x22, x23, x24, x25, x26, x27, x28, \ x29) \ m m(x24) m(x25) m(x26) m(x27) #define _FM_28(m, x1,x19, x20, x21, x22, x23, x24, x25, x26, x27) \ m( m(x21) m(x22) m(x23) \ m(x24) #define _FM_25(m, 18, x19, x20, x21, x22, x23) \ m(x1) m(x2) m(x3) 5) m(x16) m(x17) m(x18) m(x19) m(x20) m(x21) #defi, x13, \ x14, x15, x16, x17, x18, x19, x20) \ m((x10) m(x11) m(x12) \ m(x13) m(x14) m(x15) m(x16)x7, x8, x9, x10, x11, x12, x13, \ x14, x15) \ m(m(x3) m(x4) m(x5) m(x6) m(x7) m(x8) m(x9) m(x10) m x2, x3, x4, x5, x6, x7, x8, x9) \ m(x1) m(x2) m(x1, x2) \ m(x1) m(x2) #define _FM_3(m, x1, x2, x3OMANY, \ TOOMANY, TOOMANY, TOOMANY, TOOMANY, 64, fine _FVN_(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10 _F4(__VA_OPT__(__VA_ARGS__ ,) 0, 0, 0, 0) #def)) #endif #define _FMT() #define _FP1(m) m _FMT()ARGS__ #define _E2(...) _E1(_E1(__VA_ARGS__)) #def){ 1, 2, 5, 100 })) */ // C preprocessor magic f**Legacy helpers** kept for source compatibility (fourth argument * - ``FY_CPP_FIFTH(...)`` — fication address space on large translation units: _64``), each of which handles one element and chai section implements a portable ``FY_CPP_*`` macro o the following conditions: * * The above copyrilko.com> * * Permission is hereby granted, free BFYAML_DOCITER_H /* * libfyaml-cpp.h - C preproceNERATE_ALL_EVENTS = FYPEGF_GENERATE_STREAM_EVENTS event generator flags * * @FYPEGF_GENERATE_DOCUMrror, or an end of the * event stream. Use fy_docerator_generate_next() - Create events from documeto the next node iterating using as a start the noator_get_error() to check if an error occured. */pth first until the end of the document. * The evument body events until the end * * Creates the ument containing the document state that is used icordingly. The document must not be released until* * @fydi: The document iterator to create the evand advances the internal state * of it accordingr_destroy(struct fy_document_iterator *fydi) FY_Etor, starting at the root of the given document. terator will generate all the events * that creatates a document iterator, that can trawl through a_iterator_create_cfg() method. * * @flags: The dument iterator * * @FYDICF_WANT_BODY_EVENTS: GenANT mode option */ #define FYDICF_WANT(x) (((unsle for feeding into a parser, emitter, or composererator_node_start(fydi, fy_document_root(fyd)); *t fy_document_iterator``, which traverses a * doc #endif // LIBFYAML_VLSIZE_H /* * libfyaml-docite return fy_encode_size32(p, bufsz, size); } static inline unsigned int fy_encode_size_bytes(size_t _skip_size_nocheck() - Skip a native size_t encodi_t): s = fy_decode_size32_nocheck(start, &size64hecking. * * Selects the 64-bit or 32-bit nochecilable bytes. * @sizep: Output: the decoded value space in bytes. * @size: Value to encode. * ode_size32_bytes() based on * ``SIZE_MAX``. * *ip_size64() but assumes the buffer is large enoughax_scan; else end_scan = end; end_max_scan--;hausted before a complete encoding was found. */ i; p = start; size = 0; for (i = 0; i < FYVL_S size <<= 8; size |= *p; goto done; } psize_t bufsz, uint64_t *sizep) { const uint8_t *p@bufsz: Available bytes to read. * @sizep: Outpx80; p[1] = (uint8_t)(size >> 50) | 0x80; p[2] =0; p[4] = (uint8_t)(size >> 14) | 0x80; p[5] = p[2] = (uint8_t)(size >> 21) | 0x80; p[3] = (ui0; p[1] = (uint8_t)(size >> 7) | 0x80; p[2] =< ((uint64_t)1 << 14)) { if (p + 2 > end) retcode_size64() - Encode a 64-bit size into a buffer /** * fy_encode_size64_bytes() - Compute the engh. The caller * must guarantee at least %FYVL_SI; while (p < end_scan) { if (p < end_max_scan) rn p + i + 1; } /** * fy_skip_size32() - Skip pa: Pointer to one past the last consumed byte. */ if (++p >= end) p = end; *sizep = size; retunt8_t * fy_decode_size32(const uint8_t *start, siz * @start: Start of the encoded data. * @bufsz:int8_t)size & 0x7f; return p + 4; } if (p + 5 NULL; p[0] = (uint8_t)(size >> 14) | 0x80; p[turns: Pointer to one past the last written byte, int32_t size) { if (size < ((uint32_t)1 << 7)) NG_MAX_32 - Maximum encoded length of a 32-bit siz4 high bits ignored (at byte 0) // /** * FYVL_SI // 1k 1l 1m 1n 1o 1p 1q 1r t 64 bit length klmnoeck()`` — advance without bounds checking */ native-width ``fy_encode_size()`` / ``fy_decode_si bytes bits value range * 1 7 0 es follow, 0 means * this is the last byte. * return 0; } /** /* * libfyaml-vlsize.h - variab_place_null_type(void *p) { return p == NULL ? fyic_get_null_type_no_check() - Decode a null generiIS_TEMPLATE_INLINE(alias); /* Low-level primitivee, or NULL if @v is not a direct collection. */ sapping, identifies its type, * and returns a poinic * fy_generic_collectionp_get_items(const enum fGet the items array from a collection pointer. * direct_collection(const fy_generic v) { return (vr mapping. * * Both sequences and mappings have * true if @v is a mapping (possibly empty). */ ssequence_type); /** * fy_generic_is_direct_mappiv & FY_COLLECTION_MASK) == 0; /* sequence is 0 lowgeneric_is_direct_string_type() - Alias for fy_gen is a string. * * Checks for both inplace (%FY_SReturns: * true if @v holds a floating-point valuc_is_uint_type(), and indirect variants */ FY_GENEgned integers share the same tag bits; this is an NPLACE_V) and out-of-place (%FY_INT_OUTPLACE_V) *ue. * Returns: true if @v is fy_true or fy_false.eturn v.v == fy_null_value; } /* Generates fy_genis_indirect(v)) \ return false; \ return fy_gen_gtype (v)) \ return true; \ if (!fy_genedirect_ ## _gtype ## _nocheck(const fy_generic v) ic_is_##_gtype(): inline dispatcher handling both ENERIC_IS_TEMPLATE_INLINE() - Generate inline typect and indirect values. For an indirect, the * wic value is not invalid. * * Handles both directv itself. Used internally to normalise argument : true for a mapping, false for a sequence. * @co * The required byte count, or %SIZE_MAX on integ_t size; if (FY_MUL_OVERFLOW(count, sizeof(fy_ge }) /** * fy_sequence_storage_size() - Compute bis if it's a bitfield */ unsigned long long flagsdef fy_generic_decorated_int - An integer paired wtring with an explicit byte count. * * Used when Generic view over a sequence or mapping buffer *ned. * Do not rearrange fields. */ typedef struc_generic_map_pair - A key/value pair within a genet_type(v); } /** * DOC: fy_generic_sequence - Oufe: The generic failsafe to set, fy_invalid to remon. * @v: Any generic value. * @cstyle: The colltyle: The scalar style (FYSS_ANY removes it) * **gb, fy_generic v, enum fy_node_style nstyle) FY_eneric_set_style(struct fy_generic_builder *gb, fy- Set a comment on the given generic * * Sets a of the generic, or removes it if setting @vmarker to remove it * * Returns: * The updated generiid * * @gb: The generic builder to use for allocnum fy_scalar_style fy_generic_get_scalar_style(fyf @v, or %FYSS_ANY if none (or generic is a collec_generic_get_style() - Get the source style from a* fy_generic_get_tag() - Get the tag from any genehor, so %fy_null is returned. * * @v: Any generit_comment() - Get the attached comment from an indct_get_marker() - Get the source-position marker fgeneric, or %fy_null if %FYGIF_ANCHOR is not set. fy_invalid if not available. */ fy_generic fy_gens * a valid indirect and that %FYGIF_VALUE is setr to the value inside an indirect. * * Like fy_ggenericp_indirect_get_valuep_nocheck() - Get a poie fy_generic_get_type_indirect(fy_generic v) FY_Eeturn false; /* for int, float and string, the bue if @v requires no heap/stack allocation; false RING: if ((v.v & FY_INPLACE_TYPE_MASK) == FY_STReturn true; if (fy_generic_is_indirect(v)) retic_is_in_place_bithack() in hot paths. * * @v: T switch (v.v & 15) { case 0: return FYGT_ct_type(). * * @v: A direct (non-indirect) gener low 3 bits * * we have to map: 1, 2 -> int 3, 4D; } /* * The type is encoded at the lower 4 bitESCAPE_FALSE] = FYGT_BOOL, [FY_ESCAPE_TRUE] = FY static const uint8_t table[16] = { [0] = FYGT_generic_get_direct_type_table() - Determine the tyc value. * @d: Byte delta to add to the embedded d. * * @v: An out-of-place non-collection generie collections have the bit 3 cleared too, so it's ~(uintptr_t)FY_INPLACE_TYPE_MASK; return (const values — use fy_generic_resolve_collection_ptr(direct_invalid(const fy_generic v) { return v.v =c_is_direct_valid() - Test whether a direct generise. */ static inline FY_ALWAYS_INLINE bool fy_geneneric_is_direct() - Test whether a generic value #define FYGIF_BOTTOM_COMMENT FY_BIT(FYGIIDX_BOTTOM_BIT(FYGIIDX_FAILSAFE_STR) /* @failsafe_str field _BIT(FYGIIDX_VALUE) /* @value field is present */gnostics */ fy_generic marker; /* the marker (ores the actual * value plus optional metadata co the anchor is an alias */ #define FYGIIDX_ALIAS elta column */ /* fy_generic_indirecfalse ((fy_generic){ .v = fy_false_value }) /* Typ}; } fy_generic; /* Typed fy_generic literal for place float storage alignment */ #define FY_FLOAT__SCALAR_ALIGN) /* GCC/Clang attribute spelling foine FY_MAX_ALIGNOF(_v, _min) ((size_t)(_Alignof(_vine FY_GENERIC_CONTAINER_ALIGNMENT FY_ALIGNED_TO(FQ_V | 0)) /* Raw value for an empty (zero-element)g "no value" / error */ #define fy_invalid_value ESCAPE_NULL 0 /* escape index for the null cons special constants */ #define FY_ESCAPE_SHIFT (FY 32-bit float value within the 64-bit inplace wordvalue)1 << (FY_INPLACE_TYPE_SHIFT + 1)) - 1) #defQ_V 0 /* type-tag bits for an out-of-place sequeer of bits used for the type tag in the low word *|0000|0|100| double zero // string 5 |ssssssssg // int 1 |xxxxxxxxxxxxxxxx|xxxx|x|001| in0000000|0000|0|110| empty string // indirect 7 |6 |pppppppppppppppp|pppp|p|110| 8 byte aligned poi 16 byte aligned mapping // |00000000mory layout for generic types // // |three bytes packed in. */ #if __BYTE_ORDER == __Line FY_STRING_SHIFT7(_v0, _v1, _v2, _v3, _v4, _v5,_generic_value)(uint8_t)_v0 << 8) | \ ((fy_genecter bytes into the upper 56 bits of a * &fy_geneby the variable-length size encoding (architecture #endif #endif #if defined(FYGT_GENERIC_64) #defiored inplace */ #define FYGT_STRING_INPLACE_SIZE_M FYVL_SIZE_ENCODING_MAX_64 /* max vlencoded size eneric word */ #define FYGT_INT_INPLACE_BITS_64 6generic_value - Unsigned word used as the raw taggT(FYGT_INT), FYGTM_FLOAT = FY_BIT(FYGT_FLOAT), %FYGT_INVALID. * @FYGTM_NULL: Bit for %FYGrue if @type is %FYGT_SEQUENCE or %FYGT_MAPPING; fFYGT_NULL && type <= FYGT_STRING; } /** * fy_genvalues. * @FYGT_INDIRECT: Value wrapped with metanum fy_generic_type - Type discriminator for fy_ge */ /* struct fy_generic_builder - opaque generirations * produce new values. Multiple threads mtack-based* (``fy_sequence(…)``, ``fy_mapping(â€L-specific wrappers (anchor, tag, style, …) * to C programs. * * The core type is ``fy_generic_H #define LIBFYAML_GENERIC_H #include decle-threaded contexts. */ #define FY_HAVE_SAFE_ATOM * * ``FY_ATOMIC(_x)`` expands to ``_Atomic(_x)` */ #endif /* * FY_HAVE_C11_ATOMICS - Defined wheern "C"). When the brace closes, the enclosing C-lcompatible * constructs when included inside an e12L) || \ (defined(__GNUC__) && (__GNUC__ > 4 }/__typeof__) extension macros instead, which is 6 (supports and _Atomic as extensionherwise include it). */ #if defined(_MSC_VER) #incic_flag_set() / fy_atomic_flag_test_and_set() * -omic_compare_exchange_weak() * - fy_atomic_fetch_FE_ATOMIC_OPS`` — the underlying operations are * - ``FY_HAVE_STDATOMIC_H`` — ``l fallback for compilers that support ``_Atomic`` t) FY_EXPORT; #ifdef __cplusplus } #endif #endi void *args, size_t argsize, size_t count) FY_pointers * @count: The count of the args array it) - Execute function in parallel using arguments ar to a check function, or NULL for no checks */ v/** * fy_thread_work_join() - Submit works for ex stealing thread pool. * * @t: The thread * * work() - Submit work for execution * * Submit not NULL, NULL if no threads are available. */ se this is only valid for a non-work stealing threacreated threads. * * @tp: The thread pool * * created earlier via fy_thread_pool_create(). * Noool_cfg { enum fy_thread_pool_cfg_flags flags; ue for the thread pool */ enum fy_thread_pool_cfg_ */ typedef bool (*fy_work_check_fn)(const void *opaque types for the user */ struct fy_thread_poolerns: * * - ``fy_thread_args_join()`` — atly reserve a thread with * ``fy_thread_reserve()ern "C" { #endif /** * DOC: Thread pool for para.h - libfyaml thread API * Copyright (c) 2019-202t_output_data structure * * Returns: * 0 on sucault output configuration * * This is the argumeer * * Set a method callback to be called when t fy_emitter_get_diag(struct fy_emitter *emit) FY_it: The emitter to get the diagnostic object * *ter_create(const struct fy_emitter_cfg *cfg) FY_E file descriptor, FYEXCF\_FD\_OUTPUT must be set tput method * @output_fp: The output FILE \*, FYE(4), FYEXCF_VISIBLE_WS = FY_BIT(5), FYEXCF_EXTEeneric values * @FYEXCF_OUTPUT_STDOUT: Output to um fy_emitter_xcfg_flags - Emitter extended config the color settings */ #define FYEXCF_COLOR_SHIFT t, enum fy_emitter_write_type type, const _DIR_ON = FYECF_TAG_DIR(2), FYECF_DEFAULT = FDOC_START_MARK(1), FYECF_DOC_START_MARK_ON = FYEDENT(7), FYECF_INDENT_8 = FYECF_INDENT(8), FYE = FY_BIT(2), FYECF_STRIP_TAGS = FY_BIT(3), FYEON_DIR_OFF: Never generate version directive * @Ferate document end markers if required * @FYECF_D using JSON mode (non type preserving, one line) dth is 132 * @FYECF_WIDTH_INF: Output width is in(not available in streaming mode) * @FYECF_EXTENDFYECF_STRIP_LABELS: Strip labels when emitting * FYECF_TAG_DIR_MASK) << FYECF_TAG_DIR_SHIFT) /** T_MARK_SHIFT 24 #define FYECF_DOC_START_MARK_MASK INDENT_SHIFT 8 #define FYECF_INDENT_MASK 0xf #defilar_key, fyewt_comment, /* extended indicators *icator_explicit_indent: explicit indent indicator tor * @fyewt_indicator_double_quote_end: " indicaterminating zero * @fyewt_plain_scalar_key: Outpuouble quoted scalar * @fyewt_literal_scalar: Outpted output, which makes it * possible to colorizer * when the node has no document attached. */ s bool fy_document_has_explicit_document_end(const has an explicit document start marker, * i.e. --* Checks whether the given document has any directoy() - Destroy a document created by fy_parse_loadr a compound document with multiple * documents, ror. * If the pushed back utf8 character was -1, racter to an iterator stream. It will be * returnaracter in the iterator it shall return that. * e of an error, or end * of stream. */ int fy_toksingle character is allowed to be pushed back, ands * finished, it will return -1. If any calls to e ungetc methods leads to undefined behavior. * en: Number of bytes to advance the iterator positi return value is NULL, the errp variable * will bct fy_iter_chunk * fy_token_iter_peek_chunk(structerator to prepare. */ void fy_token_iter_start(stoken_iter_finish() before the * iterator is start* fy_token_iter_create(struct fy_token *fyt) FY_E cover the whole object. */ struct fy_iter_chunk r * fy_node_get_comments(struct fy_node *fyn) FY_ * @fyn: The node * @which: The placement of t_event_get_comments() - Get all comments of an eve * If another comment is already present it will bements are concatenated and returned as one. * NU comment. * NULL in case of an error or if the to* The size of the text representation of a token, en_get_text_length() - Get length of the text of ar to a variable that will hold the returned lengtht that contains the token. * * That means that tt is *not* * NULL terminated. If you need a NULL scalar_is_null() - Test whether the scalar is null * @fyt: The scalar token to get it's style. Notey_parser_report((_fyp), FYET_NOTICE, (_fyt), (_fmttoken *fyt, const char *fmt, ...) FY_FORMAT(pron the parser and indicate the token's position * ...) \ fy_parser_log((_fyp), FYET_WARNING, (_fmt @...: The extra arguments */ void fy_parser_log(error_type type, const char *fmt, va_list ap) FY_ parser mode * * Retrieve the current mode of thtic inline bool fy_parser_mode_is_yaml(enum fy_par_free() - Free an event * * Free a previously rethat this uses backtracking so it might not be verkip() - Skip the current scalar/collection * * Sn the stream or NULL. */ struct fy_event * fy_pare() returns the next event from * the configured k: The callback method to request data with * * Point the parser to use @fp for processing. * *n the input is free'ed the memory will be automati if '\0' terminated) * * Returns: * zero on sucparser to process the given file * * Point the p_reset() - Reset a parser completely * * Completobject with the one * given as an argument. The p fy_diag_unref() it when you're done with it. * oid fy_parser_destroy(struct fy_parser *fyp) FY_Eits configuration @cfg * The parser may be destro * @fye: A pointer to a &struct fy_event to check. * @str: The string to convert to an error moduler type if greater or equal to zero, FYET_MAX othering_end; default: break; } return NULL; } /id */ static inline void * fy_event_data(structvent_get_type(const struct fy_event *fye) { retur * @FYEP_VALUE: The value of the event (the main tt_type type; /* anonymous union */ union { strQUENCE_END * @mapping_start: Mapping start informCUMENT_START * @document_end: Document end inform by each call * to fy_parser_parse() and release the mapping * was started implicitly */ stuct fy_token *anchor; struct fy_token *tag; stru @anchor: anchor token or NULL * @tag: tag token * * @anchor: The anchor token definining this alNULL if * the document was implicitly start* * @stream_end: The token that ended the stream scalar style * @FYSS_SINGLE_QUOTED: Single quotedtype) FY_EXPORT; /** * enum fy_collection_styleLIAS, }; /** * fy_event_type_get_text() - Returnum fy_event_type - Event types * * @FYET_NONE: Nd which * perform parsing of YAML files. * * @sORCE = FYPCF_JSON(2), FYPCF_YPATH_ALIASES = FY_F_COLLECT_DIAG = FY_BIT(1), FYPCF_RESOLVE_DOCUMEl scalar/collection style information * @FYPCF_RE (experimental) * @FYPCF_SLOPPY_FLOW_INDENTATION:KEEP_COMMENTS: Retain comments from the original s actual limit is larger depending on the platform FYPCF_JSON_MASK ((1U << 2) - 1) /* Build a JSONCTION, FYEM_MAX, }; /* Shift amount of the defauDecode, serialization -> internal form module * @ Non inclusive maximum fy_error_type value * */ uct fy_mark { size_t input_pos; int line; int clls their cleanup functions * so that no memory lersion_supported_iterate() - Iterate over the supp* * Check if the given YAML version is supported.rsion_compare(const struct fy_version *va, const s*``, ``struct fy_node *``, …) so the ABI is stab attributes messages to precise source locations a and * transcoding pipelines. * * *Document treblic API * * This header provides the complete Ytraction macros */ #include sequen(struct fy_event *fye) { if (!fye) return NULL;E when the event is invalid */ static inline enumtype * * Return the type of the event * * @fyeevent_sequence_start_data sequence_start; structm FYET_MAPPING_START * @mapping_end: Mapping end &fy_event->type is &enum FYET_STREAM_END * @docurmation, it is valid when * &fy_evequence_end; }; /** * struct fy_event_mapping_stuence start value token or NULL if the sequence *t: true if the tag was implicit or explicit */ stcument_end_data - doument end event data * * @do@document_start: The token that started the documect fy_event_stream_start_data { struct fy_token *ated by the parser. * Lets the emitter to to get text from * * Returns: * A pointer to a ENT_START: Document start event * @FYET_DOCUMENT_ * * Argument to the fy_parser_create() method w_LEVEL_INFO 0 #define FYPCF_DEBUG_LEVEL_NOTICE 0 ULE_MASK 0 #define FYPCF_DEBUG_LEVEL_SHIFT 0 #deas 0 * so that code can continue to compile. * FY_BIT(6), FYPCF_DISABLE_ACCELERATORS = FY_BIT(7)rse_cfg_flags { FYPCF_QUIET = FY_BIT(0), FYPCFble * @FYPCF_DEFAULT_VERSION_AUTO: Automatically not output any information messages * @FYPCF_COLe configuration flags * * These flags control thfine FYPCF_DEFAULT_VERSION(x) (((unsigned int)(x) YPESET: Prepare types module (C reflection) * @FY generated the diagnostic/error * * @FYEM_UNKNOW* * enum fy_error_type - The supported diagnostictered during parsing. */ struct fy_tag { const cns: * The next node in sequence or NULL at the en * * @prevp: The previous version iterator * *) FY_EXPORT; /** * fy_version_default() - Get tse default version * * Returns: * 0 if versions /** * struct fy_version - The YAML version * e FY_ALLOCA_COPY_FREE(_str, _len) \ ({ return fy_alloca_copy_free_buf; } #define FY_AL static __inline const char *fy_alloca_copy_free_thing */ #else #define FY_EXPORT /* nothing */ #de terminated string length specifier */ #define FY_ct fy_parser; struct fy_emitter; struct fy_documenistd.h> #include #elif defined(_WIN32) #define LIBFYAML_H #ifdef __cplusplus extern "C"tions of the Software. * * THE SOFTWARE IS PROVI * of this software and associated documentation