diff options
Diffstat (limited to 'imxml.h')
| -rw-r--r-- | imxml.h | 1934 |
1 files changed, 1934 insertions, 0 deletions
@@ -0,0 +1,1934 @@ +#ifndef IMXML_H_ +#define IMXML_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* TODO + - a nice way of handling entities inside attribute values. Maybe generalize xml_content + - recursive entity references + - normalization + - end-of-line normalization (CR and CRLF to LF) + - trim whitespace + - attribute-value whitespace normalization + - collapse whitespace + + MAYBE/IDEAS + - signal handling helper + - DTD validation helper functions, maybe? + - XPath + - SYSTEM entities + - ESP port + - XSLT + - schema to code transpiler +*/ + +/* ===== DOCUMENTATION ===== + * === EXPERIMENTAL === + * This library is still in an experimental stage and should not be used in + * environments where stability/safety/security/reliability are important. + * Some minor features like normalization and recursive entity references + * aren't supported yet. + * + * While this library is in an experimental state, semantic versioning + * conventions will not be respected and minor updates may introduce breaking + * API/ABI changes. Semantic versioning will be respected once this library + * hits 1.0. + * + * === COMPATIBILITY === + * Standard C89 (ANSI C) and C++98 are supported. The library has been tested with + * clang, gcc, and tcc. Every standards compliant C compiler should work, + * though if emmintrin.h/immintrin.h isn't supported, only SCALAR will work + * (unless you define your own instruction set). + * + * UTF-8, ISO-Latin-1, ASCII, and in general all char-based encodings are + * supported. UTF-16 is not supported. + * + * === USAGE === + * This API is intended to be used as part of a while (true) loop where you + * break when `xml_tag() == "/your-root"`. For specific examples, see the + * examples/ and benchmarks/imxml/ directories. Here is a basic example for + * counting the number of highway crossing nodes are in a OSM file: + +#define IMXML_LINUX // We're using Linux, of course +#define IMXML_NO_SUPPORT_SINGLE_QUOTES // OSM always uses double-quotes +#define IMXML_NO_SUPPORT_COMMENTS // OSM doesn't include comments +#define IMXML_NO_SUPPORT_CDATA // OSM doesn't include CDATA +#define IMXML_NO_SUPPORT_ENTITIES // We don't need to parse entities +#define IMXML_NO_SUPPORT_NAMESPACES // OSM doesn't include namespaces +#define IMXML_NO_CHECK_BOUNDS // We know our data will end with </osm> +#define THREADLOCAL // We disable thread-local by defining it as nothing +#define IMXML_IMPLEMENTATION +#include "imxml.h" +#include <stdio.h> // for printf + +int main (void) { + size_t file_size; + // We need to use this file_open function because the input data needs to + // be padded to make sure we're not reading out-of-bounds + char* const file = imxml_linux_file_open("dat/yellowstone.osm", &file_size, false); + if (file == 0) return -1; + XmlParser p = {0}; + p.head = file; + + // Verify we're really dealing with osm data. This is mostly unnecessary, + // but it doesn't cost much and might catch some dumb bugs + if (!xml_parse_header(&p, NULL)) goto err; + if (!xml_tag_expect(&p, "osm")) goto err; + if (!xml_has_children(&p)) goto err; + if (!xml_tag_expect(&p, "bounds")) goto err; + if (xml_has_children(&p)) goto err; + + size_t highway_crossing_count = 0; + while (true) { + ImxmlString tag = xml_tag(&p); + if (imxml_streql(tag, imxml_strlit("node"))) { + if (xml_has_children(&p)) { + while (true) { + tag = xml_tag(&p); + if (imxml_streql(tag, imxml_strlit("/node"))) break; + ImxmlString key = xml_value(&p); + if (!imxml_streql(key, imxml_strlit("highway"))) continue; + ImxmlString value = xml_value(&p); + if (imxml_streql(value, imxml_strlit("crossing"))) { + highway_crossing_count += 1; + } + } + } + } else { + // encountered non-node tag, which means we can early-out (because + // OSM always groups all of the nodes up-front). + // Alternatively, we could check if tag == "/osm", but then we'd + // just be skipping over all the <way> and <relation> tags, which + // would be a waste of time + break; + } + } + + printf("%zu\n", highway_crossing_count); + imxml_linux_file_close(file, file_size); + return 0; + + err: + return -1; +} + + * + * === PERFORMANCE FLAGS AND #DEFINES === + * These flags each measurably improve performance in at least some situations, + * at the cost of runtime safety and/or standards compliance. Most of these + * will only give you a few percent better performance, with the exception of + * IMXML_NO_SUPPORT_NAMESPACES and IMXML_NO_SUPPORT_NAMESPACE_LOOKAHEAD, which + * can impact parse-times by about 30%. It's highly recommended to disable + * namespace support entirely, since it's usually not necessary. + * IMXML_NO_CHECK_BOUNDS + * If set, the parser skips checks for NUL terminators. It's + * recommended to enable this only if you can guarantee that the XML will be + * valid. If you can guarantee valid XML, set this flag and break on `xml_tag + * == "/root-node"` to improve performance. Even if you can't guarantee valid + * XML, consider handling SIGSEGV and SIGBUS instead of enabling bounds + * checking to improve performance. + * IMXML_NO_SUPPORT_COMMENTS + * If set, the parser assumes <!--XML comments--> will not occur in the + * input. Only set this flag if you can guarantee that your XML contains no + * comments. If a comment is encountered when this flag is set, the parser + * will break in unpredictable ways. + * IMXML_NO_SUPPORT_CDATA + * If set, the parser assumes <![CDATA[XML CDATA]]> will not occur in the + * input. Only set this flag if you can guarantee that your XML contains no + * CDATA. If CDATA is encountered when this flag is set, the parser will + * break in unpredictable ways. + * IMXML_NO_SUPPORT_SINGLE_QUOTES + * If set, the parser assumes no attribute values (except the XML in the + * header) will be enclosed by 'single quotes'. This flag is relevant even if + * you don't read the attribute values, only disable it if you can guarantee + * there are either no attribute values in the XML, or all attribute values + * are enclosed in "double quotes". This flag is usually mutually exclusive + * with IMXML_NO_SUPPORT_DOUBLE_QUOTES, but technically both can be set if + * you can guarantee that there are no attribute values in the XML, which + * will improve performance and reduce code size + * IMXML_NO_SUPPORT_DOUBLE_QUOTES + * Same as IMXML_NO_SUPPORT_SINGLE_QUOTES, but for "double quotes" + * IMXML_NO_SUPPORT_NAMESPACES + * If set, the parser will not manage namespaces. This is by far the most + * performance-critical flag and it's heavily recommended to set it if at all + * possible. Even when this flag is set, you can check xml_attr for + * "xmlns", check xml_tag for prefixes (you can still use + * xml_tag_remove_namespace for convenience), and manage namespaces yourself, + * which is almost certain to be more efficient than this general solution. + * IMXML_NO_SUPPORT_NAMESPACE_LOOKAHEAD + * If set, imxml_default_namespace_resolve does not resolve namespaces + * defined within the current tag. E.g. The namespace of `foo` in `<foo + * xmlns="foo.com">` would NOT be "foo.com", but instead the default + * namespace of the enclosing tag (which may be empty ""). This lookahead is + * rarely necessary in practice and significantly impacts performance, so, + * even if you're using the library's default namespace handling (which + * itself is rarely optimal), it's strongly recommended to disable this if + * possible. + * IMXML_NO_SUPPORT_ENTITIES + * If set, xml_content ignores &entities;. This is technically safe to + * set, even if you can't guarantee that your XML does not contain entities. + * This means that entities will simply be reported as regular text, which is + * fine if you don't care about resolving the entities. + * IMXML_NO_SUPPORT_CUSTOM_ENTITIES + * If set, the parser ignores !ENTITY definitions in <!DOCTYPE> and will not + * resolve non-standard &entities;. Note that this flag will be ignored if + * IMXML_NO_SUPPORT_ENTITIES is set. + * IMXML_SIMD_DEFAULT and IMXML_SIMD_DENSE + * IMXML_SIMD_DEFAULT determines which instruction set is used for parsing + * when it's probable that a structurally relevant character WILL NOT be + * within a single vector window (e.g. when parsing content). + * IMXML_SIMD_DENSE determines which instruction set is used for parsing when + * it's probable that a structurally relevant character WILL be within a + * single vector window (e.g. when parsing tag arguments and values). + * Possible values are SCALAR, MMX, SSE2, and AVX2. Defaults to SSE2. When + * IMXML_SIMD_DEFAULT is SSE2 or lower, IMXML_SIMD_DENSE will default ot + * IMXML_SIMD_DEFAULT. If it's higher, IMXML_SIMD_DENSE will be set to SSE2. + * If you change these, be sure to benchmark, as it's not uncommon for SSE2 + * to outperform AVX2 in certain configurations for certain workloads. It's + * even possible for SCALAR to outperform everything else depending on the + * exact data, worload, configuration, compiler, and optimization flags. + * + * === OTHER FLAGS AND #DEFINES === + * IMXML_LIT_PAD + * This is just for convenience. You can use it to pad string literals in + * code so the SIMD operations don't read out-of-bounds. Usage example + * `ImxmlCharSequence xml = "<foo bar="baz"/>" IMXML_LIT_PAD;` + * IMXML_CUSTOM_STDBOOL_H + * If set, the library will not include stdint.h, and you must provide + * `uint8_t`, `uint16_t`, `uint32_t`, and `SIZE_MAX`. + * IMXML_CUSTOM_STDINT_H + * If set, the library will not include stdbool.h, and you must provide + * `bool`, `true`, and `false`. + * IMXML_CUSTOM_SIMD_INTRINSICS + * If set, the library will not include emmintrin.h/immintrin.h, and you must + * provide all necessary SIMD intrinsics. This should only be necessary if + * your compiler doesn't support those headers, and/or if you're generating + * custom imxml_seek__next_char_XXX functions with different intrinsics. + * IMXML_SIMD_DEFAULT_INSTRUCTIONS and IMXML_SIMD_DENSE_INSTRUCTIONS + * These are the arguments passed to the imxml_seek_next_char_XXX functions. + * You should only set these if you need to support an instruction set that + * isn't supported by this library (i.e. MMX, SSE2, AVX2). + * IMXMLAPI + * Defaults to `static inline`. If you want to compile this library into an + * object file, you might want to change this. + * IMXML_CUSTOM_CHAR + * If set, you must define a `ImxmlChar` type. You almost certainly don't + * want to do that. `sizeof(ImxmlChar) != 1` is UB. + * IMXML_CUSTOM_CHAR_SEQUENCE + * If set, you must define a `ImxmlCharSequence` type. This is useful if you + * also have a custom string type (see IMXML_CUSTOM_STRING) that uses + * non-const data. + * IMXML_CUSTOM_STRING + * If set, you must define a `ImxmlString` type. You must also define + * IMXML_STRCOUNT and IMXML_STRITEMS as the identifier for your string's + * count/length and items/chars field respectively. Furthermore, you must + * implement/define the following functions/macros: imxml_strsubcstr, + * imxml_strlit, imxml_strsubcstr, imxml_streql. + * IMXML_CUSTOM_ENTITIES_MAX_STATIC_SIZE + * The maximum number of custom entities the default custom entity + * implementation can support. Note that if more entities are encountered, + * they will be silently ignored. Irrelevant if + * IMXML_NO_SUPPORT_CUSTOM_ENTITIES is set. Defaults to 255. + * IMXML_NAMESPACE_STACK_MAX_STATIC_SIZE + * The maximum namespace depth the default implementation can support. Note + * that if namespaces encountered after this maximum has been reached will be + * silently ignored. Irrelevant if IMXML_NO_SUPPORT_NAMESPACES is set. + * Defaults to 255. + * THREADLOCAL + * You can define THREADLOCAL to be nothing (e.g. `#define THREADLOCAL`) if + * you know you won't be using multithreading (this can improve performance + * and simplifies the emitted code), or if you have one parser that calls + * default entity/namespace implementation functions on multiple threads + * (though that's not recommended and you should probably consider just + * creating your own implementations at that point). + * + * === MULTITHREADING === + * This library, by default, has rudimentary thread-safety in the form of + * thread-local global variables. Thread-safety is only guaranteed when a + * single parser runs in a thread. If there are multiple parsers running + * concurrently in the same thread, or one parser runs in multiple threads, + * things will break. Note that, in practice, the only reasonable + * multi-threading approach with this library is parsing multiple different + * documents (with different parsers) on separate threads. Note that this + * library will max out a core, so it's generally best to not run more threads + * than the number of physical cores on the machine. + * + * === A NOTE ON THE DEFAULT CUSTOM ENTITY AND NAMESPACE IMPLEMENTATIONS === + * The imxml_default_XXX functions are included so you don't have to implement + * your own if you're just doing some quick and dirty parsing. But if you + * intend on using this library in a more sophisticated context, these default + * implementations should be replaced by custom code for both performance and + * correctness reasons. The two correctness-related issues with the default + * implementations are that they are limited to a static + * entity-size/namespace-depth, and that they are only thread-safe if each + * parser runs in its own thread. + * + * Creating a custom implementation for custom entities is relatively easy: You + * just need to call xml_parse_header with a custom register_entity callback + * and call xml_entity_resolve with a custom get_entity callback. + * + * Creating a custom implementation for namespace management is substantially + * more involved and not recommended unless you are parsing arbitrary and + * unboundable XML. Firstly, you need to set the namespace_push and + * namespace_pop callbacks in the XmlParser struct. Beside that, you also need + * to provide imxml_default_ns_pop_to_depth_. I'll note again that, in all + * likelihood, this is not what you want to be doing. You're almost certainly + * able to use the regular xml_tag, xml_attr, and xml_value APIs to accurately + * resolve namespaces in a more readable and performant way than would be + * possible with a generalized namespace management solution. + */ + +/* The numbers here aren't super important, we just care that smaller + * instruction sets are smaller so we can compare them. */ +#define SCALAR 100 +#define MMX 6400 /*TODO maybe MMX_NO_EMMS and MMX_FEMS ?*/ +#define SSE2 12800 +#define AVX2 25600 + +#ifndef IMXML_SIMD_DEFAULT +#define IMXML_SIMD_DEFAULT SSE2 +#endif +#ifndef IMXML_SIMD_DENSE +#if IMXML_SIMD_DEFAULT >= SSE2 +#define IMXML_SIMD_DENSE SSE2 +#else +#define IMXML_SIMD_DENSE IMXML_SIMD_DEFAULT +#endif /*IMXML_SIMD_DEFAULT >= SSE2*/ +#endif /*ifndef IMXML_SIMD_DENSE*/ + +#define IMXML_SCALAR (IMXML_SIMD_DEFAULT == SCALAR || IMXML_SIMD_DENSE == SCALAR) +#define IMXML_MMX (IMXML_SIMD_DEFAULT == MMX || IMXML_SIMD_DENSE == MMX) +#define IMXML_SSE2 (IMXML_SIMD_DEFAULT == SSE2 || IMXML_SIMD_DENSE == SSE2) +#define IMXML_AVX2 (IMXML_SIMD_DEFAULT == AVX2 || IMXML_SIMD_DENSE == AVX2) + +#include <stddef.h> +#if !defined(IMXML_CUSTOM_STDBOOL_H) && defined(__STDC_VERSION__) +#include <stdbool.h> +#endif +#ifndef IMXML_CUSTOM_STDINT_H +#include <stdint.h> +#endif +#if !defined(IMXML_CUSTOM_SIMD_INTRINSICS) && !IMXML_SCALAR +#if IMXML_AVX2 +#include <immintrin.h> +#else +#include <emmintrin.h> +#endif /*AVX2*/ +#endif /*IMXML_CUSTOM_SIMD_INTRINSICS*/ + +#ifndef NODISCARD +#if defined(__clang__) || defined(__GNUC__) +#define NODISCARD __attribute__((warn_unused_result)) +#else +#define NODISCARD +#endif +#endif + +#ifndef ASSERT +#ifndef NDEBUG +#define ASSERT(X) if (UNLIKELY(!(X))) __asm__("int3") +#else +#define ASSERT(X) +#endif +#endif + +#ifndef ASSUME +#ifndef NDEBUG +#define ASSUME ASSERT +#else /*NDEBUG*/ +#if defined(__clang__) +#define ASSUME __builtin_assume +#elif defined(__GNUC__) +#define ASSUME(X) if (!(X)) __builtin_unreachable() +#else +#define ASSUME(X) +#endif +#endif /*NDEBUG*/ +#endif /*ASSUME*/ + +#ifndef ALIGN +#if defined(__clang__) || defined(__GNUC__) +#define ALIGN(X) __attribute__((aligned(X))) +#else +#define ALIGN(X) +#endif +#endif + +#ifndef UNLIKELY +#if defined(__clang__) || defined(__GNUC__) +#define UNLIKELY(x) __builtin_expect(!!(x), 0) +#else +#define UNLIKELY(x) (x) +#endif +#endif +#ifndef LIKELY +#if defined(__clang__) || defined(__GNUC__) +#define LIKELY(x) __builtin_expect(!!(x), 1) +#else +#define LIKELY(x) (x) +#endif +#endif + +#ifndef THREADLOCAL +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#define THREADLOCAL _Thread_local +#elif defined(__clang__) || defined(__GNUC__) +#define THREADLOCAL __thread +#else +#error imxml: THREADLOCAL undefined. Use C11 or newer, clang, gcc, or define \ +THREADLOCAL yourself. You may define it as nothing (i.e. `#define \ +THREADLOCAL`), though that may cause issues when using default entity and \ +namespace implementations, and unicode entity decoding in a multithreaded \ +context. +#endif +#endif + +#ifndef __STDC_VERSION__ +/* C89 compatibility */ +#if defined(__clang__) || defined(__GNUC__) +#define inline __inline__ +#define restrict __restrict__ +#else +#define inline /*inline*/ +#define restrict /*restrict*/ +#endif + +#define bool uint8_t +#define true 1 +#define false 0 +#endif /*__STDC_VERSION__*/ + +#ifndef IMXML_NO_CHECK_BOUNDS +#define IMXML_CHECK_BOUNDS +#endif +#ifndef IMXML_NO_SUPPORT_COMMENTS +#define IMXML_SUPPORT_COMMENTS +#endif +#ifndef IMXML_NO_SUPPORT_CDATA +#define IMXML_SUPPORT_CDATA +#endif +#ifndef IMXML_NO_SUPPORT_SINGLE_QUOTES +#define IMXML_SUPPORT_SINGLE_QUOTES +#endif +#ifndef IMXML_NO_SUPPORT_DOUBLE_QUOTES +#define IMXML_SUPPORT_DOUBLE_QUOTES +#endif +#ifndef IMXML_NO_SUPPORT_NAMESPACES +#define IMXML_SUPPORT_NAMESPACES +#endif +#ifndef IMXML_NO_SUPPORT_NAMESPACE_LOOKAHEAD +#define IMXML_SUPPORT_NAMESPACE_LOOKAHEAD +#endif +#ifndef IMXML_NO_SUPPORT_ENTITIES +#define IMXML_SUPPORT_ENTITIES +#ifndef IMXML_NO_SUPPORT_CUSTOM_ENTITIES +#define IMXML_SUPPORT_CUSTOM_ENTITIES +#endif +#endif /*IMXML_NO_SUPPORT_ENTITIES*/ + +#ifdef IMXML_CHECK_BOUNDS +#define IF_BOUNDS(x) x +#else +#define IF_BOUNDS(x) +#endif +#ifdef IMXML_SUPPORT_SINGLE_QUOTES +#define IF_SINGLE_QUOTES(x) x +#else +#define IF_SINGLE_QUOTES(x) +#endif +#ifdef IMXML_SUPPORT_DOUBLE_QUOTES +#define IF_DOUBLE_QUOTES(x) x +#else +#define IF_DOUBLE_QUOTES(x) +#endif +#ifdef IMXML_SUPPORT_COMMENTS +#define IF_COMMENTS(x) x +#else +#define IF_COMMENTS(x) +#endif +#ifdef IMXML_SUPPORT_CDATA +#define IF_CDATA(x) x +#else +#define IF_CDATA(x) +#endif +#if defined(IMXML_SUPPORT_CDATA) || defined(IMXML_SUPPORT_COMMENTS) +#define IF_COMMENTS_OR_CDATA(x) x +#else +#define IF_COMMENTS_OR_CDATA(x) +#endif + +#define scalar_set1(x) ((uint8_t)(x)) +#define scalar_loadu(p) (*(p)) +#define scalar_cmpeq(a, b) ((uint8_t)((a) == (b) ? 0xffu : 0u)) +#define scalar_or(a, b) ((uint8_t)((a) | (b))) +#define scalar_movemask(x) ((unsigned)((x) != 0)) +#define IMXML_SCALAR_INSTRUCTIONS 1, uint8_t, uint8_t, uint8_t, scalar_set1, scalar_loadu, scalar_cmpeq, scalar_or, scalar_movemask, {}, {} + +#define mmx_loadu(PTR) *(__m64 const*)PTR /*TODO this is actually an unaligned load, which may crash on some platforms*/ +#define IMXML_MMX_INSTRUCTIONS 8, uint8_t, __m64, void, _mm_set1_pi8, mmx_loadu, _mm_cmpeq_pi8, _mm_or_si64, _mm_movemask_pi8, {},_mm_empty(); + +#define IMXML_SSE2_INSTRUCTIONS 16, uint16_t, __m128i, __m128i_u, _mm_set1_epi8, _mm_loadu_si128, _mm_cmpeq_epi8, _mm_or_si128, _mm_movemask_epi8, {}, {} + +#define IMXML_AVX2_INSTRUCTIONS 32, uint32_t, __m256i, __m256i_u, _mm256_set1_epi8, _mm256_loadu_si256, _mm256_cmpeq_epi8, _mm256_or_si256, _mm256_movemask_epi8, {}, {} + +#ifndef IMXML_SIMD_DEFAULT_INSTRUCTIONS +#if IMXML_SIMD_DEFAULT == SCALAR +#define IMXML_SIMD_DEFAULT_INSTRUCTIONS IMXML_SCALAR_INSTRUCTIONS +#elif IMXML_SIMD_DEFAULT == MMX +#define IMXML_SIMD_DEFAULT_INSTRUCTIONS IMXML_MMX_INSTRUCTIONS +#elif IMXML_SIMD_DEFAULT == SSE2 +#define IMXML_SIMD_DEFAULT_INSTRUCTIONS IMXML_SSE2_INSTRUCTIONS +#elif IMXML_SIMD_DEFAULT == AVX2 +#define IMXML_SIMD_DEFAULT_INSTRUCTIONS IMXML_AVX2_INSTRUCTIONS +#endif +#endif +#ifndef IMXML_SIMD_DENSE_INSTRUCTIONS +#if IMXML_SIMD_DENSE == SCALAR +#define IMXML_SIMD_DENSE_INSTRUCTIONS IMXML_SCALAR_INSTRUCTIONS +#elif IMXML_SIMD_DENSE == MMX +#define IMXML_SIMD_DENSE_INSTRUCTIONS IMXML_MMX_INSTRUCTIONS +#elif IMXML_SIMD_DENSE == SSE2 +#define IMXML_SIMD_DENSE_INSTRUCTIONS IMXML_SSE2_INSTRUCTIONS +#elif IMXML_SIMD_DENSE == AVX2 +#define IMXML_SIMD_DENSE_INSTRUCTIONS IMXML_AVX2_INSTRUCTIONS +#endif +#endif + +#define IMXML_LIT_PAD "\0""123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" /* NUL + 63 bytes for AVX512 */ + +/* === API === */ + +#ifndef IMXMLAPI +/* NOTE: inline gains about 5% in certain cases, and does't ever seem to hurt, + * so I'm enabling it by default */ +#define IMXMLAPI static inline +#endif + +#ifndef IMXML_CUSTOM_CHAR +/* NOTE sizeof(ImxmlChar) must be 1 */ +typedef char ImxmlChar; +#endif +#ifndef IMXML_CUSTOM_CHAR_SEQUENCE +typedef ImxmlChar const* ImxmlCharSequence; +#endif + +#ifndef IMXML_CUSTOM_STRING +typedef size_t ImxmlStrLen; +typedef struct { + ImxmlStrLen count; + ImxmlChar const* items; +} ALIGN(16) ImxmlString; +#define IMXML_STRCOUNT count +#define IMXML_STRITEMS items +#else /*IMXML_CUSTOM_STRING*/ +#ifndef IMXML_STRCOUNT +#error Must define IMXML_STRCOUNT as the `count`/`size` field of your string struct +#endif /*IMXML_STRCOUNT*/ +#ifndef IMXML_STRITEMS +#error Must define IMXML_STRITEMS as the `items`/`chars` field of your string struct +#endif /*IMXML_STRITEMS*/ +#endif /*IMXML_CUSTOM_STRING*/ + +typedef struct { + ImxmlString prefix; + ImxmlString ns; +} ALIGN(32) ImxmlNamespace; + +typedef struct { + ImxmlString current_tag; + ImxmlCharSequence head; + #ifdef IMXML_SUPPORT_NAMESPACES + size_t depth; + void (*namespace_push)(size_t depth, ImxmlString prefix, ImxmlString ns); + void (*namespace_pop)(void); + #endif + bool in_tag; +} ALIGN(64) XmlParser; + +typedef enum { + XML_CONTENT_NONE = 0, + XML_CONTENT_TEXT, + XML_CONTENT_ENTITY, + XML_CONTENT_TAG, + XML_CONTENT_COMMENT +} XmlContentType; +typedef struct { + ImxmlString data; + XmlContentType type; +} ALIGN(32) XmlContent; +typedef struct { + ImxmlString key; + ImxmlString value; +} ALIGN(32) ImxmlEntityDefinition; + +IMXMLAPI bool imxml_memeql_ (ImxmlCharSequence a, ImxmlCharSequence b, size_t n); +#ifndef IMXML_CUSTOM_STRING +IMXMLAPI ImxmlString imxml_strsubcstr (ImxmlCharSequence cstr, ImxmlStrLen len); +#ifdef __STDC_VERSION__ +#define imxml_strlit(lit) (ImxmlString){.IMXML_STRCOUNT = sizeof(lit) - 1, .IMXML_STRITEMS = "" lit} +#endif /*__STDC_VERSION__*/ +#define imxml_strlit89(res, lit) do { \ + (res).IMXML_STRITEMS = lit; \ + (res).IMXML_STRCOUNT = sizeof(""lit)-1; \ +} while (0) +#endif /*IMXML_CUSTOM_STRING*/ + +IMXMLAPI ImxmlString xml_tag (XmlParser* p); +IMXMLAPI ImxmlString xml_attr (XmlParser* p); +/* NOTE This will just get the next quoted text, which means you should only + * use this if you KNOW there is a following attribute-value. If you're unsure, + * call xml_attribute first. */ +IMXMLAPI ImxmlString xml_value (XmlParser* p); + +IMXMLAPI bool xml_has_children (XmlParser* p); +IMXMLAPI ImxmlString xml_skip_element (XmlParser* p); + +typedef ImxmlString (*ImxmlEntityGetFunc)(ImxmlString key); +typedef void (*ImxmlEntityRegisterFunc)(ImxmlString key, ImxmlString value); +/* Returns the value for an &entity;. If it's a character entity (e.g. E), + * the returned value is a view into a global thread-local buffer that will be + * overwritten when the next character entity is decoded. It's the caller's + * responsibility to either immediately use the value (before another call to + * xml_entity_resolve is made on the same thread) or duplicate it. */ +IMXMLAPI ImxmlString xml_entity_resolve ( + ImxmlString entity_name, + ImxmlEntityGetFunc get_entity +); +/* Returns a string representing the content. See `xml_entity_resolve` + * regarding handling of character entity resolution. */ +IMXMLAPI ImxmlString xml_content_to_string ( + XmlContent content, + ImxmlEntityGetFunc get_entity +); + +IMXMLAPI XmlContent xml_content (XmlParser* p); + +IMXMLAPI bool xml_tag_expect_str (XmlParser* p, ImxmlString expected); +IMXMLAPI bool xml_attr_expect_str (XmlParser* p, ImxmlString expected); +#ifdef __STDC_VERSION__ +#define xml_tag_expect(p, s) xml_tag_expect_str((p), imxml_strlit(s)) +#define xml_attr_expect(p, s) xml_attr_expect_str((p), imxml_strlit(s)) +#endif /*__STDC_VERSION__*/ + +IMXMLAPI bool xml_parse_doctype ( + XmlParser* p, + ImxmlEntityRegisterFunc register_entity +); +IMXMLAPI bool xml_parse_header ( + XmlParser* p, + ImxmlEntityRegisterFunc register_entity +); + +#ifdef IMXML_SUPPORT_CUSTOM_ENTITIES +/* Call before parsing a document */ +IMXMLAPI void imxml_default_entity_reset (void); +IMXMLAPI void imxml_default_entity_register (ImxmlString key, ImxmlString value); +IMXMLAPI ImxmlString imxml_default_entity_get (ImxmlString key); +#endif /*IMXML_SUPPORT_CUSTOM_ENTITIES*/ + +/* NOTE All imxml_default_namespace_* functions are meant to work in tandem. + * I.e., require custom behavior, you'll need to reimplement all the callbacks + * and using any of the default implementations here is UB */ +#ifdef IMXML_SUPPORT_NAMESPACES +/* Call before parsing a document */ +IMXMLAPI void imxml_default_namespace_reset (void); +/* NOTE Only relevant when using the default namespace implementation */ +/* Returns the namespace for `id` where `id` is the full tag with prefix (the + * result of `xml_tag`). By default, this function performs a lookahead to + * check for namespaces that are being opened in the current tag. This incurs a + * significant performance cost and can be disabled via + * IMXML_NO_SUPPORT_NAMESPACE_LOOKAHEAD which, if set, will not consider any + * namespaces that are being opened in the current tag. E.g. `<foo + * xmlns="foo.com">` will NOT be in the "foo.com" namespace. */ +IMXMLAPI ImxmlNamespace imxml_default_namespace_resolve (XmlParser* p, ImxmlString id); +#endif /*IMXML_SUPPORT_NAMESPACES*/ +IMXMLAPI ImxmlString xml_tag_remove_namespace (ImxmlString tag); + +#ifdef IMXML_LINUX +IMXMLAPI char* imxml_linux_file_open ( + char const* const file_name, + size_t* const mapped_size, + bool populate /* load entire file into memory instead of streaming from disk */ +); +IMXMLAPI void imxml_linux_file_close (char* file, size_t file_size); +#endif /*IMXML_LINUX*/ + +/* === END OF API === */ + +#ifdef IMXML_IMPLEMENTATION + +IMXMLAPI bool imxml_memeql_ ( + ImxmlCharSequence const a, + ImxmlCharSequence const b, + size_t const n +) { + size_t i; + for (i = 0; i < n; ++i) { + if (a[i] != b[i]) return false; + } + return true; +} + +#ifndef IMXML_CUSTOM_STRING +IMXMLAPI ImxmlString imxml_strsubcstr (ImxmlCharSequence const cstr, ImxmlStrLen len) { + ImxmlString res; + res.IMXML_STRCOUNT = len; + res.IMXML_STRITEMS = cstr; + return res; +} +IMXMLAPI bool imxml_streql (ImxmlString a, ImxmlString b) { + if (a.IMXML_STRCOUNT != b.IMXML_STRCOUNT) return false; + return imxml_memeql_(a.IMXML_STRITEMS, b.IMXML_STRITEMS, a.IMXML_STRCOUNT); +} +#endif /*IMXML_CUSTOM_STRING*/ + +IMXMLAPI bool is_whitespace (ImxmlChar c) { + return c == ' ' + || c == '\t' + || c == '\r' + || c == '\n' + ; +} + +#ifndef imxml_ctz +#if defined(__builtin_ctz) || (defined(__clang__) || defined(__GNUC__)) +#define imxml_ctz (uint8_t)__builtin_ctz +#else +static inline uint8_t imxml_ctz(uint64_t x) { + uint8_t n = 0; + while (!(x & 1)) { + x >>= 1; + n += 1; + } + return n; +} +#endif +#endif /*imxml_ctz*/ + +#define IMXML_FUNCTION_GENERATOR_xml_skip_single_delim( \ + SUFFIX, \ + STEP, \ + MASK_T, \ + VEC_T, \ + VEC_TU, \ + SET1, \ + LOADU, \ + CMPEQ, \ + VEC_OR, \ + MOVEMASK, \ + PREAMBLE, \ + POSTAMBLE \ +) \ +IMXMLAPI bool xml_skip_single_delim##SUFFIX (XmlParser* const p, ImxmlChar delimiter) { \ + VEC_T const qt = SET1(delimiter); \ + IF_BOUNDS( \ + VEC_T const zero = SET1(0); \ + ) \ + PREAMBLE \ + while (true) { \ + VEC_T block = LOADU((VEC_TU const*)(p->head)); \ + VEC_T match = CMPEQ(block, qt); \ + uint8_t offset; \ + MASK_T mask; \ + IF_BOUNDS( \ + VEC_T cmp_zero = CMPEQ(block, zero); \ + match = VEC_OR(cmp_zero, match); \ + ) \ + mask = (MASK_T)MOVEMASK(match); \ + if (!mask) { \ + p->head += STEP; \ + continue; \ + } \ + offset = imxml_ctz(mask); \ + p->head += offset; \ + IF_BOUNDS( \ + if (*p->head == 0) { \ + POSTAMBLE \ + return false; \ + } \ + ) \ + p->head += 1; \ + POSTAMBLE \ + return true; \ + } \ +} + +#define GEN_FUNC(suffix, x) IMXML_FUNCTION_GENERATOR_xml_skip_single_delim(suffix, x) + +GEN_FUNC(_, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef GEN_FUNC + +#define xml_skip_sstring(p) xml_skip_single_delim_(p, '\'') +#define xml_skip_dstring(p) xml_skip_single_delim_(p, '"') + +#define IMXML_FUNCTION_GENERATOR_xml_skip_double_delim_gt( \ + SUFFIX, \ + STEP, \ + MASK_T, \ + VEC_T, \ + VEC_TU, \ + SET1, \ + LOADU, \ + CMPEQ, \ + VEC_OR, \ + MOVEMASK, \ + PREAMBLE, \ + POSTAMBLE \ +) \ +IMXMLAPI bool xml_skip_double_delim_gt##SUFFIX (XmlParser* const p, ImxmlCharSequence delim) { \ + VEC_T const gt = SET1('>'); \ + IF_BOUNDS( \ + VEC_T const zero = SET1(0); \ + ) \ + PREAMBLE \ + while (true) { \ + VEC_T block = LOADU((VEC_TU const*)(p->head)); \ + VEC_T match = CMPEQ(block, gt); \ + MASK_T mask; \ + uint8_t offset; \ + IF_BOUNDS( \ + VEC_T cmp_zero = CMPEQ(block, zero); \ + match = VEC_OR(cmp_zero, match); \ + ) \ + mask = (MASK_T)MOVEMASK(match); \ + if (mask) { \ + offset = imxml_ctz(mask); \ + p->head += offset; \ + IF_BOUNDS( \ + if (*p->head == 0) { \ + POSTAMBLE \ + return false; \ + } \ + ) \ + p->head += 1; \ + /* NOTE the following can't underflow because this only gets called + * in contexts where we have already parsed >4 bytes ("<!--" or + * "![CDATA[") */ \ + if (*(p->head - 3) == delim[0] && *(p->head - 2) == delim[1]) { \ + POSTAMBLE \ + return true; \ + } else { \ + continue; \ + } \ + } \ + p->head += STEP; \ + } \ +} + +#define GEN_FUNC(suffix, x) IMXML_FUNCTION_GENERATOR_xml_skip_double_delim_gt(suffix, x) + +GEN_FUNC(_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) + +#undef GEN_FUNC + +#define xml_skip_comment(p) xml_skip_double_delim_gt_(p, "--") +#define xml_skip_cdata(p) xml_skip_double_delim_gt_(p, "]]") + +#define IF_SEEK_MULTIPLE(x) +#define IF_SEEK_MULTIPLE2(a, b) +#define IF_NO_SEEK_MULTIPLE(x) x + +#ifndef IMXML_MAX_MULTI_SEEK_COUNT +#define IMXML_MAX_MULTI_SEEK_COUNT 6 +#endif + +#define IMXML_FUNCTION_GENERATOR_imxml_seek_next_char( \ + SUFFIX, \ + STEP, \ + MASK_T, \ + VEC_T, \ + VEC_TU, \ + SET1, \ + LOADU, \ + CMPEQ, \ + VEC_OR, \ + MOVEMASK, \ + PREAMBLE, \ + POSTAMBLE \ +) \ +IMXMLAPI NODISCARD bool imxml_seek_next_char##SUFFIX ( \ + XmlParser* const p, \ + IF_NO_SEEK_MULTIPLE( \ + ImxmlChar const needle_ \ + ) \ + IF_SEEK_MULTIPLE2( \ + ImxmlChar const* const needles_, \ + uint8_t const needles_count \ + ) \ +) { \ + ImxmlCharSequence ptr = p->head; \ + IF_SINGLE_QUOTES( VEC_T const st = SET1('\''); ) \ + IF_DOUBLE_QUOTES( VEC_T const qt = SET1('"'); ) \ + IF_BOUNDS( VEC_T const zero = SET1(0); ) \ + IF_COMMENTS_OR_CDATA( VEC_T const lt = SET1('<'); ) \ + IF_NO_SEEK_MULTIPLE( \ + VEC_T const needle = SET1(needle_); \ + )\ + IF_SEEK_MULTIPLE( \ + uint8_t i; \ + VEC_T needles[IMXML_MAX_MULTI_SEEK_COUNT]; \ + ASSUME(needles_count <= IMXML_MAX_MULTI_SEEK_COUNT); \ + for (i = 0; i < needles_count; ++i) { \ + needles[i] = SET1(needles_[i]); \ + } \ + )\ + PREAMBLE \ + while (true) { \ + VEC_T block = LOADU((VEC_TU const*)(ptr)); \ + MASK_T mask_any; \ + VEC_T any_match; \ + \ + IF_SEEK_MULTIPLE( \ + VEC_T cmp_needle = {0}; \ + for (i = 0; i < needles_count; ++i) { \ + cmp_needle = VEC_OR(cmp_needle, CMPEQ(block, needles[i])); \ + } \ + )\ + IF_NO_SEEK_MULTIPLE( \ + VEC_T cmp_needle = CMPEQ(block, needle); \ + )\ + \ + any_match = cmp_needle; \ + IF_SINGLE_QUOTES({ \ + VEC_T cmp_st = CMPEQ(block, st); \ + any_match = VEC_OR(cmp_st, any_match); \ + }) \ + IF_DOUBLE_QUOTES({ \ + VEC_T cmp_qt = CMPEQ(block, qt); \ + any_match = VEC_OR(cmp_qt, any_match); \ + }) \ + IF_BOUNDS({ \ + VEC_T cmp_zero = CMPEQ(block, zero); \ + any_match = VEC_OR(cmp_zero, any_match); \ + }) \ + IF_COMMENTS_OR_CDATA({ \ + VEC_T cmp_lt = CMPEQ(block, lt); \ + any_match = VEC_OR(cmp_lt, any_match); \ + }) \ + \ + mask_any = (MASK_T)MOVEMASK(any_match); \ + if (!mask_any) { \ + ptr += STEP; \ + continue; \ + } \ + ptr += imxml_ctz(mask_any); \ + if (UNLIKELY(*ptr == '<')) { \ + IF_COMMENTS( \ + if (imxml_memeql_(ptr+1, "!--", 3)) { \ + ptr += 1+3+2; \ + p->head = ptr; \ + (void)xml_skip_comment(p); /* bounds check will happen next iteration */ \ + ptr = p->head; \ + continue; \ + } \ + ) \ + IF_CDATA( \ + if (imxml_memeql_(ptr+1, "![CDATA[", 8)) { \ + ptr += 1+8+2; \ + p->head = ptr; \ + (void)xml_skip_cdata(p); /* bounds check will happen next iteration */ \ + ptr = p->head; \ + continue; \ + } \ + ) \ + IF_SEEK_MULTIPLE ({ \ + bool any_needle_is_gt = false; \ + for (i = 0; i < needles_count; ++i) { \ + any_needle_is_gt |= (bool)(needles_[i] == '<'); \ + } \ + if (!any_needle_is_gt) { \ + ptr += 1; \ + continue; \ + } \ + }) \ + IF_NO_SEEK_MULTIPLE ( \ + if (LIKELY(needle_ != '<')) { \ + ptr += 1; \ + continue; \ + } \ + )\ + } \ + IF_SEEK_MULTIPLE ( \ + for (i = 0; i < needles_count; ++i) { \ + if (*ptr == needles_[i]) { \ + p->head = ptr; \ + POSTAMBLE \ + return true; \ + } \ + } \ + ) \ + IF_NO_SEEK_MULTIPLE ( \ + if (*ptr == needle_) { \ + p->head = ptr; \ + POSTAMBLE \ + return true; \ + } \ + ) \ + IF_SINGLE_QUOTES ( \ + if (*ptr == '\'') { \ + ptr += 1; \ + p->head = ptr; \ + xml_skip_sstring(p); \ + ptr = p->head; \ + continue; \ + } \ + ) \ + IF_DOUBLE_QUOTES ( \ + if (*ptr == '\"') { \ + ptr += 1; \ + p->head = ptr; \ + xml_skip_dstring(p); \ + ptr = p->head; \ + continue; \ + } \ + ) \ + IF_BOUNDS ( \ + ASSUME(*ptr == 0); \ + POSTAMBLE \ + return false; \ + ) \ + } \ +} + +#define GEN_FUNC(suffix, x) IMXML_FUNCTION_GENERATOR_imxml_seek_next_char(suffix, x) + +GEN_FUNC(_default, IMXML_SIMD_DEFAULT_INSTRUCTIONS) +GEN_FUNC(_dense, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef IF_SEEK_MULTIPLE +#define IF_SEEK_MULTIPLE(x) x +#undef IF_SEEK_MULTIPLE2 +#define IF_SEEK_MULTIPLE2(a, b) a,b +#undef IF_NO_SEEK_MULTIPLE +#define IF_NO_SEEK_MULTIPLE(x) +GEN_FUNC(_default_multi_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) +GEN_FUNC(_dense_multi_, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef IF_SEEK_MULTIPLE +#define IF_SEEK_MULTIPLE(x) +#undef IF_SEEK_MULTIPLE2 +#define IF_SEEK_MULTIPLE2(a, b) +#undef IF_NO_SEEK_MULTIPLE +#define IF_NO_SEEK_MULTIPLE(x) x +#undef IF_SINGLE_QUOTES +#define IF_SINGLE_QUOTES(x) +#undef IF_DOUBLE_QUOTES +#define IF_DOUBLE_QUOTES(x) +GEN_FUNC(_default_ignore_quotes_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) + +#undef IF_SEEK_MULTIPLE +#define IF_SEEK_MULTIPLE(x) x +#undef IF_SEEK_MULTIPLE2 +#define IF_SEEK_MULTIPLE2(a, b) a,b +#undef IF_NO_SEEK_MULTIPLE +#define IF_NO_SEEK_MULTIPLE(x) + +#undef IF_CDATA +#define IF_CDATA(x) +#undef IF_COMMENTS_OR_CDATA +#ifdef IMXML_SUPPORT_COMMENTS +#define IF_COMMENTS_OR_CDATA(x) x +#else +#define IF_COMMENTS_OR_CDATA(x) +#endif +GEN_FUNC(_default_raw_text_with_comments_multi_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) +GEN_FUNC(_dense_raw_text_with_comments_multi_, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef IF_COMMENTS +#define IF_COMMENTS(x) +#undef IF_COMMENTS_OR_CDATA +#define IF_COMMENTS_OR_CDATA(x) +GEN_FUNC(_default_raw_text_multi_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) +GEN_FUNC(_dense_raw_text_multi_, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef IF_SEEK_MULTIPLE +#define IF_SEEK_MULTIPLE(x) +#undef IF_SEEK_MULTIPLE2 +#define IF_SEEK_MULTIPLE2(a, b) +#undef IF_NO_SEEK_MULTIPLE +#define IF_NO_SEEK_MULTIPLE(x) x +GEN_FUNC(_default_raw_text_, IMXML_SIMD_DEFAULT_INSTRUCTIONS) +GEN_FUNC(_dense_raw_text_, IMXML_SIMD_DENSE_INSTRUCTIONS) + +#undef GEN_FUNC + +#ifdef IMXML_SUPPORT_CUSTOM_ENTITIES +#ifndef IMXML_CUSTOM_ENTITIES_MAX_STATIC_SIZE +#define IMXML_CUSTOM_ENTITIES_MAX_STATIC_SIZE 255 +#endif +static THREADLOCAL ImxmlEntityDefinition imxml_custom_entities_[IMXML_CUSTOM_ENTITIES_MAX_STATIC_SIZE]; +static THREADLOCAL size_t imxml_custom_entity_count_ = 0; +IMXMLAPI void imxml_default_entity_reset (void) { + imxml_custom_entity_count_ = 0; +} +IMXMLAPI void imxml_default_entity_register (ImxmlString key, ImxmlString value) { + if (imxml_custom_entity_count_ >= IMXML_CUSTOM_ENTITIES_MAX_STATIC_SIZE) { + ASSERT(false); + return; + } + imxml_custom_entities_[imxml_custom_entity_count_].key = key; + imxml_custom_entities_[imxml_custom_entity_count_].value = value; + imxml_custom_entity_count_ += 1; +} +IMXMLAPI ImxmlString imxml_default_entity_get (ImxmlString key) { + size_t i; + ImxmlEntityDefinition e; + ImxmlString res = {0}; + if (imxml_custom_entity_count_ == 0) { + ASSERT(false); + return res; + } + for (i = 0; i < imxml_custom_entity_count_; ++i) { + e = imxml_custom_entities_[i]; + if (imxml_streql(e.key, key)) { + res = e.value; + return res; + } + } + /* NOTE it might seem nice to return "&key;", but that would either require + * an allocation or create a footgun where calling this with a + * `imxml_strlit("foo")` reads OOB, so we just return empty and let the + * user decide how to handle it */ + return res; +} +#endif /*IMXML_SUPPORT_CUSTOM_ENTITIES*/ + +static inline bool imxml_try_parse_xmlns (XmlParser* p); +static inline bool imxml_seek_gt_ (XmlParser* const p) { + #ifdef IMXML_SUPPORT_NAMESPACES + while (true) { + if (!imxml_seek_next_char_dense_multi_(p, "x>", 2)) return false; + if (*p->head != 'x') break; + ASSUME(*p->head == 'x'); + if (imxml_try_parse_xmlns(p)) continue; /* there mighe be multiple namespace definitions */ + p->head += 1; + } + #else + if (!imxml_seek_next_char_dense(p, '>')) return false; + #endif /*IMXML_SUPPORT_NAMESPACES*/ + ASSUME(*p->head == '>'); + p->in_tag = false; + return true; +} + +#ifdef IMXML_SUPPORT_NAMESPACES +#ifndef IMXML_NAMESPACE_STACK_MAX_STATIC_SIZE +#define IMXML_NAMESPACE_STACK_MAX_STATIC_SIZE 255 +#endif +typedef struct { + ImxmlNamespace ns; + size_t depth; +} ALIGN(64) ImxmlNamespaceStackEntry; +static THREADLOCAL ImxmlNamespaceStackEntry imxml_default_namespace_stack_[IMXML_NAMESPACE_STACK_MAX_STATIC_SIZE]; +static THREADLOCAL size_t imxml_default_namespace_stack_count_ = 0; +IMXMLAPI void imxml_default_namespace_reset (void) { + imxml_default_namespace_stack_count_ = 0; +} +static void imxml_default_namespace_push_ (size_t depth, ImxmlString const prefix, ImxmlString const ns_) { + ImxmlNamespace ns; + ns.prefix = prefix; + ns.ns = ns_; + if(imxml_default_namespace_stack_count_ >= IMXML_NAMESPACE_STACK_MAX_STATIC_SIZE) { + ASSERT(false); + return; + } + imxml_default_namespace_stack_[imxml_default_namespace_stack_count_ ].depth = depth; + imxml_default_namespace_stack_[imxml_default_namespace_stack_count_ ].ns = ns; + imxml_default_namespace_stack_count_ += 1; +} +static void imxml_default_namespace_pop_ (void) { + if (imxml_default_namespace_stack_count_ == 0) return; + imxml_default_namespace_stack_count_ -= 1; +} +IMXMLAPI ImxmlNamespace imxml_default_namespace_resolve (XmlParser* const p, ImxmlString const tag) { + ImxmlStrLen i; + ImxmlNamespace res = {0}; + ImxmlString prefix = {0}; + for (i = 0; i < tag.IMXML_STRCOUNT; ++i) { + if (tag.IMXML_STRITEMS[i] == ':') { + prefix.IMXML_STRITEMS = tag.IMXML_STRITEMS; + prefix.IMXML_STRCOUNT = i; + break; + } + } + + if (prefix.IMXML_STRITEMS != 0 && *prefix.IMXML_STRITEMS == '/') { + /*closing tag*/ + prefix.IMXML_STRITEMS += 1; + prefix.IMXML_STRCOUNT -= 1; + } + + { + #ifdef IMXML_SUPPORT_NAMESPACE_LOOKAHEAD + /* NOTE we need to look ahead here, since if this tag might define a + * namespace */ + XmlParser pp = *p; + size_t j; + size_t const old_count = imxml_default_namespace_stack_count_; + imxml_seek_gt_(&pp); /* Finds xmlns definitions */ + j = imxml_default_namespace_stack_count_; + imxml_default_namespace_stack_count_ = old_count; + #else + (void)p; + j = imxml_default_namespace_stack_count_; + #endif + + for (; j; --j) { + res = imxml_default_namespace_stack_[j-1].ns; + if (imxml_streql(res.prefix, prefix)) { + return res; + } + } + } + return res; +} + +void static inline imxml_default_ns_pop_to_depth_ (XmlParser* const p) { + if (UNLIKELY(!p->namespace_pop)) { + p->namespace_pop = imxml_default_namespace_pop_; + } + while (imxml_default_namespace_stack_count_ != 0) { + ImxmlNamespaceStackEntry e = + imxml_default_namespace_stack_[imxml_default_namespace_stack_count_ - 1]; + + if (e.depth <= p->depth) break; + + p->namespace_pop(); + } +} + +static inline bool imxml_try_parse_xmlns (XmlParser* const p) { + ImxmlCharSequence const tmp = p->head; + ImxmlString prefix = {0}; + ImxmlString ns; + if (LIKELY( + *p->head != 'x' + || !is_whitespace(*(p->head - 1)) + || !imxml_memeql_(p->head, "xmlns", 5) + )) return false; + p->head += 5; + if ( *p->head != ':' + && ((!is_whitespace(*p->head) && *p->head != '=') + || (*p->head == '>' || !imxml_seek_next_char_dense_raw_text_multi_(p, "=>", 2)) + ) + ) { + p->head = tmp; + return false; + } + + if (*p->head == ':') { + prefix.IMXML_STRITEMS = p->head + 1; + if (!imxml_seek_next_char_dense_raw_text_(p, '=')) return false; + prefix.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - prefix.IMXML_STRITEMS); + while (is_whitespace(prefix.IMXML_STRITEMS[prefix.IMXML_STRCOUNT-1])) { + prefix.IMXML_STRCOUNT -= 1; + } + } + ASSUME(*p->head == '='); + ns = xml_value(p); + if (UNLIKELY(!p->namespace_push)) { + p->namespace_push = imxml_default_namespace_push_; + } + p->namespace_push(p->depth, prefix, ns); + return true; +} +#endif /*IMXML_SUPPORT_NAMESPACES*/ + +/* Returns the tag without the namespace. + * NOTE This function behaves consistently regardless of whether + * IMXML_NO_SUPPORT_NAMESPACES is set */ +IMXMLAPI ImxmlString xml_tag_remove_namespace (ImxmlString tag) { + ImxmlString tag_without_ns = tag; + + while (true) { + if (tag_without_ns.IMXML_STRITEMS == tag.IMXML_STRITEMS + tag.IMXML_STRCOUNT) { + /*we have to do this for copy-elision, can't just return tag*/ + tag_without_ns.IMXML_STRITEMS = tag.IMXML_STRITEMS; + return tag_without_ns; + } + if (*tag_without_ns.IMXML_STRITEMS == ':') break; + tag_without_ns.IMXML_STRITEMS += 1; + } + tag_without_ns.IMXML_STRITEMS += 1; + + tag_without_ns.IMXML_STRCOUNT -= (ImxmlStrLen)(tag_without_ns.IMXML_STRITEMS - tag.IMXML_STRITEMS); + + return tag_without_ns; +} + +/* NOTE no bounds checking, only use if you know there is a previous + * non-whitespace char */ +static inline ImxmlChar imxml_previous_char_ (XmlParser* const p) { + ImxmlCharSequence h; + for (h = p->head - 1; ; --h) { + if (!is_whitespace(*h)) return *h; + } +} + +static inline void imxml_exit_tag (XmlParser* const p) { + if (!p->in_tag) return; + if (!imxml_seek_gt_(p)) return; + #ifdef IMXML_SUPPORT_NAMESPACES + if (imxml_previous_char_(p) == '/') { + p->depth -= 1; + imxml_default_ns_pop_to_depth_(p); + } + #endif + p->head += 1; + ASSUME(*p->head != '>'); + p->in_tag = *p->head == '<'; +} + +IMXMLAPI ImxmlString xml_tag (XmlParser* const p) { + ImxmlString res = {0}; + ImxmlCharSequence tag_start; + ImxmlChar c; + #ifdef IMXML_SUPPORT_NAMESPACES + imxml_exit_tag(p); /* in case we're still currently inside a tag */ + imxml_default_ns_pop_to_depth_(p); + #endif + /* NOTE we can ignore quotes here because attribute values cannot contain + * '<' and content ignores quotes anyways */ + if (!imxml_seek_next_char_default_ignore_quotes_(p, '<')) return res; + ASSUME(*p->head == '<'); + p->in_tag = true; + p->head += 1; + + tag_start = p->head; + p->head += 1; + while (true) { + c = *p->head; + #ifdef IMXML_CHECK_BOUNDS + if (c == 0) return res; + #endif + if (is_whitespace(c) || c == '>' || c == '/') break; + p->head += 1; + } + res = imxml_strsubcstr(tag_start, (ImxmlStrLen)(p->head - tag_start)); + #ifdef IMXML_SUPPORT_NAMESPACES + if (res.IMXML_STRITEMS[0] == '/') { + imxml_default_ns_pop_to_depth_(p); + p->depth -= 1; + } else { + p->depth += 1; + } + #endif + p->current_tag = res; + return res; +} + +IMXMLAPI ImxmlString xml_attr (XmlParser* const p) { + ImxmlString res = {0}; + /* 1. find whitespace, in case we're in the middle of something */ + while (true) { + ImxmlChar c = *p->head; + if ( + /* UNLIKELY because we probably have >1 attrs */ + #ifdef IMXML_CHECK_BOUNDS + UNLIKELY(c == 0 || c == '>') + #else + UNLIKELY(c == '>') + #endif + ) { + return res; + } + #ifdef IMXML_SUPPORT_SINGLE_QUOTES + if (c == '\'') { + xml_skip_sstring(p); + continue; + } + #endif + #ifdef IMXML_SUPPORT_DOUBLE_QUOTES + if (c == '"') { + xml_skip_dstring(p); + continue; + } + #endif + if (is_whitespace(c)) break; + p->head += 1; + } + /* 2. skip whitespace */ + while (true) { + ImxmlChar c = *p->head; + #ifdef IMXML_CHECK_BOUNDS + if (c == 0) return res; + #endif + if (!is_whitespace(c)) break; + p->head += 1; + } + if (UNLIKELY(*p->head == '>' || imxml_memeql_(p->head, "/>", 2))) { + return res; + } + + { + ImxmlCharSequence const attr_start = p->head; + /* 3. parse */ + if (!imxml_seek_next_char_dense_raw_text_multi_(p, "=>", 2)) return res; + if (*p->head == '>') return res; + res = imxml_strsubcstr(attr_start, (ImxmlStrLen)(p->head - attr_start)); + while (is_whitespace(res.IMXML_STRITEMS[res.IMXML_STRCOUNT-1])) { + res.IMXML_STRCOUNT -= 1; + } + p->head += 1; + } + + #ifdef IMXML_SUPPORT_NAMESPACES + if (UNLIKELY( + imxml_memeql_(res.IMXML_STRITEMS, "xmlns", 5) + && (res.IMXML_STRCOUNT == 5 || *(res.IMXML_STRITEMS + 5) == ':') + )) { + XmlParser pp; + ImxmlString prefix = {0}; + ImxmlString ns; + pp.head = res.IMXML_STRITEMS + 5; + if (*pp.head == ':') { + bool success; + prefix.IMXML_STRITEMS = pp.head + 1; + success = imxml_seek_next_char_dense_raw_text_(&pp, '='); + ASSUME(success); + prefix.IMXML_STRCOUNT = (ImxmlStrLen)(pp.head - prefix.IMXML_STRITEMS); + } + ASSUME(*pp.head == '='); + ns = xml_value(&pp); + + if (UNLIKELY(!p->namespace_push)) { + p->namespace_push = imxml_default_namespace_push_; + } + p->namespace_push(p->depth, prefix, ns); + } + #endif + + return res; +} + +IMXMLAPI ImxmlString xml_value (XmlParser* const p) { + ImxmlChar delim; + ImxmlString res = {0}; + while (true) { + ImxmlChar c = *p->head; + #ifdef IMXML_CHECK_BOUNDS + if (c == 0) return res; + #endif + #ifdef IMXML_SUPPORT_SINGLE_QUOTES + if (c == '\'') { + delim = '\''; + break; + } + #endif + #ifdef IMXML_SUPPORT_DOUBLE_QUOTES + if (c == '"') { + delim = '"'; + break; + } + #endif + p->head += 1; + } + p->head += 1; + { + ImxmlCharSequence const value_start = p->head; + while (true) { + ImxmlChar c = *p->head; + #ifdef IMXML_CHECK_BOUNDS + if (c == 0) return res; + #endif + if (c == delim) break; + p->head += 1; + } + res = imxml_strsubcstr(value_start, (ImxmlStrLen)(p->head - value_start)); + p->head += 1; + } + return res; +} + +IMXMLAPI bool xml_has_children (XmlParser* const p) { + bool has_children; + if (!p->in_tag) return false; + if (!imxml_seek_gt_(p)) return false; + has_children = imxml_previous_char_(p) != '/'; + #ifdef IMXML_SUPPORT_NAMESPACES + if (!has_children) { + p->depth -= 1; + imxml_default_ns_pop_to_depth_(p); + } + #endif + return has_children; +} + +IMXMLAPI ImxmlString xml_skip_element (XmlParser* const p) { + ImxmlString res = {0}; + size_t depth = 0; + /* trying to skip closing tag */ + if (p->current_tag.IMXML_STRCOUNT && p->current_tag.IMXML_STRITEMS[0] == '/') { + res = p->current_tag; + return res; + } + + if (UNLIKELY(!imxml_seek_next_char_default(p, '>'))) return res; + if (imxml_previous_char_(p) == '/') return res; /* no children */ + + while (true) { + ImxmlString next_tag = xml_tag(p); + if (next_tag.IMXML_STRITEMS == NULL) { + res = next_tag; + return res; + } + /* We don't check for matching tags, only if it's a closing tag. + * We expect valid XML. */ + if (next_tag.IMXML_STRITEMS[0] == '/') { + if (depth == 0) { + res = next_tag; + return res; + } + depth -= 1; + continue; + } + if (xml_has_children(p)) { + depth += 1; + } + } +} + +/* NOTE This is some fairly basic utf-8/unicode handling that assumes valid + * XML/UTF-8, doesn't reject surrogate range, doesn't check bounds, etc */ +static inline ImxmlStrLen imxml_utf8_encode_ (uint32_t const cp, ImxmlChar* const out) { + if (cp <= 0x7FU) { + out[0] = (ImxmlChar)cp; + return 1; + } + if (cp <= 0x7FFU) { + out[0] = (ImxmlChar)(0xC0U | (cp >> 6U)); + out[1] = (ImxmlChar)(0x80U | (cp & 0x3FU)); + return 2; + } + if (cp <= 0xFFFFU) { + out[0] = (ImxmlChar)(0xE0U | (cp >> 12U)); + out[1] = (ImxmlChar)(0x80U | ((cp >> 6U) & 0x3FU)); + out[2] = (ImxmlChar)(0x80U | (cp & 0x3FU)); + return 3; + } + if (cp <= 0x10FFFFU) { + out[0] = (ImxmlChar)(0xF0U | (cp >> 18U)); + out[1] = (ImxmlChar)(0x80U | ((cp >> 12U) & 0x3FU)); + out[2] = (ImxmlChar)(0x80U | ((cp >> 6U) & 0x3FU)); + out[3] = (ImxmlChar)(0x80U | (cp & 0x3FU)); + return 4; + } + /* Out of Unicode range: emit U+FFFD replacement character. */ + out[0] = (ImxmlChar)0xEFU; + out[1] = (ImxmlChar)0xBFU; + out[2] = (ImxmlChar)0xBDU; + return 3; +} +static THREADLOCAL ImxmlChar imxml_codepoint_buf_[4]; +static inline ImxmlString imxml_parse_codepoint_base10_ (ImxmlString const s) { + ImxmlString res; + ImxmlStrLen i; + uint32_t cp = 0; + for (i = 0; i < s.IMXML_STRCOUNT; ++i) { + ImxmlChar c = s.IMXML_STRITEMS[i]; + if (c < '0' || c > '9') break; + cp = (cp * 10U) + (uint32_t)(c - '0'); + } + i = imxml_utf8_encode_(cp, imxml_codepoint_buf_); + res.IMXML_STRCOUNT = i; + res.IMXML_STRITEMS = imxml_codepoint_buf_; + return res; +} +static inline ImxmlString imxml_parse_codepoint_base16_ (ImxmlString const s) { + uint32_t cp = 0; + ImxmlStrLen i; + ImxmlString res; + for (i = 0; i < s.IMXML_STRCOUNT; ++i) { + ImxmlChar c = s.IMXML_STRITEMS[i]; + uint32_t digit; + if (c >= '0' && c <= '9') { + digit = (uint32_t)(c - '0'); + } else if (c >= 'a' && c <= 'f') { + digit = (uint32_t)(c - 'a') + 10U; + } else if (c >= 'A' && c <= 'F') { + digit = (uint32_t)(c - 'A') + 10U; + } else { + break; + } + cp = (cp * 16U) + digit; + } + i = imxml_utf8_encode_(cp, imxml_codepoint_buf_); + res.IMXML_STRCOUNT = i; + res.IMXML_STRITEMS = imxml_codepoint_buf_; + return res; +} + +IMXMLAPI ImxmlString xml_entity_resolve (ImxmlString entity_name, ImxmlEntityGetFunc get_entity) { + ImxmlString s; + if (entity_name.IMXML_STRCOUNT > 1 /*needs at least #N*/) { + if (*entity_name.IMXML_STRITEMS == '#') { + if (*(entity_name.IMXML_STRITEMS + 1) == 'x') { + ImxmlString str; + str.IMXML_STRITEMS = entity_name.IMXML_STRITEMS + 2; + str.IMXML_STRCOUNT = entity_name.IMXML_STRCOUNT - 2; + s = imxml_parse_codepoint_base16_(str); + return s; + } else { + ImxmlString str; + str.IMXML_STRITEMS = entity_name.IMXML_STRITEMS + 1; + str.IMXML_STRCOUNT = entity_name.IMXML_STRCOUNT - 1; + s = imxml_parse_codepoint_base10_(str); + return s; + } + } + } + + imxml_strlit89(s, "lt"); + if (imxml_streql(entity_name, s)) { + imxml_strlit89(s, "<"); + return s; + } + imxml_strlit89(s, "gt"); + if (imxml_streql(entity_name, s)) { + imxml_strlit89(s, ">"); + return s; + } + imxml_strlit89(s, "amp"); + if (imxml_streql(entity_name, s)) { + imxml_strlit89(s, "&"); + return s; + } + imxml_strlit89(s, "quot"); + if (imxml_streql(entity_name, s)) { + imxml_strlit89(s, "\""); + return s; + } + imxml_strlit89(s, "apos"); + if (imxml_streql(entity_name, s)) { + imxml_strlit89(s, "'"); + return s; + } + + if (get_entity) { + s = get_entity(entity_name); + } else { + s.IMXML_STRITEMS = 0; + s.IMXML_STRCOUNT = 0; + } + return s; +} + +IMXMLAPI ImxmlString xml_content_to_string (XmlContent content, ImxmlEntityGetFunc get_entity) { + ImxmlString res = {0}; + switch (content.type) { + case XML_CONTENT_TEXT: { + res = content.data; + return res; + } + case XML_CONTENT_ENTITY: { + #ifdef IMXML_SUPPORT_ENTITIES + res = xml_entity_resolve(content.data, get_entity); + return res; + #else + (void)get_entity; + res = content.data; + return res; + #endif + } + case XML_CONTENT_TAG: + case XML_CONTENT_COMMENT: + case XML_CONTENT_NONE: { + return res; + } + default: { + ASSUME(false); + } + } +} + +IMXMLAPI bool xml_is_closing_tag_for (ImxmlString tag, ImxmlString opening_tag) { + ImxmlString str; + str.IMXML_STRITEMS = tag.IMXML_STRITEMS+1; + str.IMXML_STRCOUNT = tag.IMXML_STRCOUNT-1; + return *tag.IMXML_STRITEMS == '/' && imxml_streql(opening_tag, str); +} + +IMXMLAPI XmlContent xml_content (XmlParser* const p) { + /* kinda hacky, but necessary for NRVO */ + XmlContent res; + res.type = XML_CONTENT_NONE; + + imxml_exit_tag(p); + + if (*p->head == '<') { + p->head += 1; + + #ifdef IMXML_SUPPORT_COMMENTS + if (imxml_memeql_(p->head, "!--", 3)) { + p->head += 3; + res.data.IMXML_STRITEMS = p->head; + if (UNLIKELY(!xml_skip_comment(p))) return res; + res.data.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - 3 - res.data.IMXML_STRITEMS); + res.type = XML_CONTENT_COMMENT; + /* we return the actual comment text, since it doesn't cost much, + * and it may be useful in some cases */ + return res; + } + #endif + + #ifdef IMXML_SUPPORT_CDATA + if (imxml_memeql_(p->head, "![CDATA[", 8)) { + p->head += 8; + res.data.IMXML_STRITEMS = p->head; + if (UNLIKELY(!xml_skip_cdata(p))) return res; + res.data.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - 3 - res.data.IMXML_STRITEMS); + res.type = XML_CONTENT_TEXT; + return res; + } + #endif + + /* tag */ + res.type = XML_CONTENT_TAG; + + /* not optimal, but whatever */ + p->head -= 1; + p->in_tag = *p->head == '>'; + res.data = xml_tag(p); + + return res; + } + + #ifdef IMXML_SUPPORT_ENTITIES + if (*p->head == '&') { + p->head += 1; + res.data.IMXML_STRITEMS = p->head; + if (UNLIKELY(!imxml_seek_next_char_dense_raw_text_(p, ';'))) return res; + res.data.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - res.data.IMXML_STRITEMS); + p->head += 1; + res.type = XML_CONTENT_ENTITY; + return res; + } + #endif + + /* text */ + res.data.IMXML_STRITEMS = p->head; + #ifdef IMXML_SUPPORT_ENTITIES + if (UNLIKELY(!imxml_seek_next_char_default_raw_text_multi_(p, "<&", 2))) return res; + #else + if (UNLIKELY(!imxml_seek_next_char_default_raw_text_(p, '<'))) return res; + #endif /*IMXML_SUPPORT_ENTITIES*/ + res.type = XML_CONTENT_TEXT; + res.data.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - res.data.IMXML_STRITEMS); + return res; +} + +IMXMLAPI bool xml_tag_expect_str (XmlParser* const p, ImxmlString expected) { + ImxmlString actual = xml_tag(p); + return imxml_streql(actual, expected); +} +IMXMLAPI bool xml_attr_expect_str (XmlParser* const p, ImxmlString expected) { + ImxmlString actual = xml_attr(p); + return imxml_streql(actual, expected); +} + +IMXMLAPI bool xml_parse_doctype (XmlParser* const p, ImxmlEntityRegisterFunc register_entity) { + ImxmlString s; + imxml_strlit89(s, "!DOCTYPE"); + if (!xml_tag_expect_str(p, s)) return false; + + while (is_whitespace(*p->head)) { + p->head += 1; + } + /*ImxmlChar* docname_start = p->head;*/ + if (!imxml_seek_next_char_dense_raw_text_with_comments_multi_(p, " \t\r\n>[", 6)) return false; + /*ImxmlChar* docname_end = p->head;*/ + + while (true) { + #ifdef IMXML_CHECK_BOUNDS + if (*p->head == 0) return false; + #endif + if (*p->head == '>') { + #ifdef IMXML_SUPPORT_NAMESPACES + p->depth = 0; + #endif + return true; + } + if (*p->head == '[') { + #ifdef IMXML_SUPPORT_CUSTOM_ENTITIES + ImxmlString entity_key; + ImxmlString entity_value; + /* parse entities */ + while (imxml_seek_next_char_dense_raw_text_with_comments_multi_(p, "<]", 2)) { + #ifdef IMXML_CHECK_BOUNDS + if (*p->head == 0) return false; + #endif + if (*p->head == ']') break; + + imxml_strlit89(s, "!ENTITY"); + if (!xml_tag_expect_str(p, s)) return false; + + while (is_whitespace(*p->head)) { + p->head += 1; + } + + { + ImxmlCharSequence const entity_key_start = p->head; + if (!imxml_seek_next_char_dense_raw_text_multi_(p, " \t\r\n", 4)) return false; + entity_key.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - entity_key_start); + entity_key.IMXML_STRITEMS = entity_key_start; + } + + if (!imxml_seek_next_char_dense_raw_text_multi_(p, "\"'", 2)) return false; + p->head += 1; + { + ImxmlCharSequence const entity_value_start = p->head; + if (*(p->head - 1) == '"') { + if (!xml_skip_dstring(p)) return false; + } else { + ASSERT(*(p->head - 1) == '\''); + if (!xml_skip_sstring(p)) return false; + } + entity_value.IMXML_STRCOUNT = (ImxmlStrLen)(p->head - entity_value_start - 1); + entity_value.IMXML_STRITEMS = entity_value_start; + } + + if (register_entity) register_entity(entity_key, entity_value); + } + continue; + #else + (void)register_entity; + if (!imxml_seek_next_char_default(p, ']')) return false; + #endif /*IMXML_SUPPORT_CUSTOM_ENTITIES*/ + } + p->head += 1; + } + + #ifdef IMXML_SUPPORT_NAMESPACES + p->depth = 0; + #endif + return true; +} + +IMXMLAPI bool xml_parse_header (XmlParser* const p, ImxmlEntityRegisterFunc register_entity) { + ImxmlString s; + imxml_strlit89(s, "?xml"); + if (!xml_tag_expect_str(p, s)) return false; + + { + ImxmlCharSequence const tmp = p->head; + if (!xml_parse_doctype(p, register_entity)) { + p->head = tmp; + } + } + + #ifdef IMXML_SUPPORT_NAMESPACES + p->depth = 0; + #endif + return true; +} + +static inline size_t imxml_round_up_ (size_t n, size_t target) { + return ((n + target - 1) / target) * target; +} + +#ifdef IMXML_LINUX +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +IMXMLAPI char* imxml_linux_file_open ( + char const* const file_name, + size_t* const mapped_size, + bool populate +) { + int const flags = MAP_PRIVATE | MAP_FIXED | (populate ? MAP_POPULATE : 0); + char* file; + size_t map_size; + long page_size; + size_t file_size; + struct stat sb; + int fd = open(file_name, O_RDONLY); + if (fd < 0) goto err_open; + if (fstat(fd, &sb)) goto err_fstat; + file_size = (size_t)sb.st_size; + if (file_size == 0) goto err_fstat; + + page_size = sysconf(_SC_PAGESIZE); + if (page_size == -1) goto err_sysconf; + map_size = imxml_round_up_(file_size + 64 /*64 in case AVX512*/, (size_t)page_size); + + file = (char*)mmap(NULL, map_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if (file == (void*)-1) goto err_mmap_padding; + *mapped_size = map_size; + if (mmap(file, file_size, PROT_READ, flags, fd, 0) == (void*)-1) goto err_mmap_file; + close(fd); + + return file; + + err_mmap_file: + munmap(file, map_size); + err_mmap_padding: + err_sysconf: + err_fstat: + close(fd); + err_open: + return 0; +} +IMXMLAPI void imxml_linux_file_close (char* const file, size_t const file_size) { + munmap(file, file_size); +} +#endif /*IMXML_LINUX*/ + +#undef scalar_set1 +#undef scalar_loadu +#undef scalar_cmpeq +#undef scalar_or +#undef scalar_movemask + +#undef mmx_loadu + +#undef IF_BOUNDS +#undef IF_SINGLE_QUOTES +#undef IF_DOUBLE_QUOTES +#undef IF_COMMENTS +#undef IF_CDATA +#undef IF_COMMENTS_OR_CDATA +#undef IF_SEEK_MULTIPLE +#undef IF_NO_SEEK_MULTIPLE + +#undef SCALAR +#undef MMX +#undef SSE2 +#undef AVX2 + +#endif /*IMXML_IMPLEMENTATION*/ +#ifdef __cplusplus +} +#endif +#endif /*IMXML_H_*/ + +/* === REVISION HISTORY === + * 0.1.0 (2026-08-17) Experimental release +*/ + +/* === LICENSE === + * Copyright 2026 Steven Van Dorp + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the “Software”), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. +*/ + |