leptris 1.9.201.1-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/libleptris/src/leptris/common/simd_text_neon.c

@@ -0,0 +1,280 @@
+/* common/simd_text_neon.c — NEON implementations (TODO 175).
+ *
+ * On aarch64 NEON is architectural baseline — no runtime detection
+ * needed and no special compile flags. Compiled unconditionally on
+ * arm64 targets.
+ *
+ * Safety: processes full 16-byte chunks only while 16+ bytes remain,
+ * then a scalar tail. Never reads past s+len.
+ */
+#include "simd_text.h"
+#include "cpu.h"
+#include "port.h"  /* LEPTRIS_CTZ (MSVC has no __builtin_ctz, issue #487) */
+
+#if defined(LEPTRIS_ARCH_ARM) && defined(__aarch64__)
+
+#include <arm_neon.h>
+
+int leptris_text_contains_neon(const char* s, size_t len, char c) {
+    const char* p = s;
+    const char* end = s + len;
+    const uint8x16_t needle = vdupq_n_u8((uint8_t)c);
+
+    while (end - p >= 16) {
+        uint8x16_t v = vld1q_u8((const uint8_t*)p);
+        uint8x16_t eq = vceqq_u8(v, needle);
+        if (vmaxvq_u8(eq) != 0) return 1;
+        p += 16;
+    }
+    while (p < end) {
+        if (*p == c) return 1;
+        p++;
+    }
+    return 0;
+}
+
+/* Three-byte sequence search. cand[i] must equal eq0[i] & eq1[i+1] &
+ * eq2[i+2], so eq1/eq2 shift LEFT by 1/2 bytes: L_k(x)[i] = x[i+k],
+ * expressed as vextq_u8(x, zero, k) — result[i] = x[i+k] within the
+ * chunk, zero-filled past the end. Chunks advance 14 bytes (16 - 2)
+ * so boundary-straddling triples are re-checked next iteration. */
+ptrdiff_t leptris_text_find3_neon(const char* s, size_t len,
+                                  char c0, char c1, char c2) {
+    if (len < 3) return -1;
+    const uint8x16_t n0 = vdupq_n_u8((uint8_t)c0);
+    const uint8x16_t n1 = vdupq_n_u8((uint8_t)c1);
+    const uint8x16_t n2 = vdupq_n_u8((uint8_t)c2);
+    const uint8x16_t zero = vdupq_n_u8(0);
+
+    size_t i = 0;
+    for (; len - i >= 16; i += 14) {
+        uint8x16_t v = vld1q_u8((const uint8_t*)(s + i));
+        uint8x16_t eq0 = vceqq_u8(v, n0);
+        uint8x16_t eq1 = vceqq_u8(v, n1);
+        uint8x16_t eq2 = vceqq_u8(v, n2);
+        uint8x16_t s1 = vextq_u8(eq1, zero, 1);  /* result[i] = eq1[i+1] */
+        uint8x16_t s2 = vextq_u8(eq2, zero, 2);  /* result[i] = eq2[i+2] */
+        uint8x16_t cand = vandq_u8(vandq_u8(eq0, s1), s2);
+        if (vmaxvq_u8(cand) != 0) {
+            /* Locate the byte; only in-chunk starts (first 14). */
+            uint8_t bytes[16];
+            vst1q_u8(bytes, cand);
+            for (int k = 0; k < 14; k++) {
+                if (bytes[k]) return (ptrdiff_t)(i + (size_t)k);
+            }
+        }
+    }
+    /* Scalar tail (also re-covers the 2 overlap bytes). */
+    for (size_t j = i; j + 2 < len; j++) {
+        if (s[j] == c0 && s[j + 1] == c1 && s[j + 2] == c2) {
+            return (ptrdiff_t)j;
+        }
+    }
+    return -1;
+}
+
+/* Byte-population count. vceqq gives 0xFF per match, but ADDV.16b
+ * accumulates in a BYTE register — the raw sum overflows mod 256
+ * (density ≥2 per chunk truncates to garbage). Widen pairwise first
+ * (vpaddlq_u8 → u16 lanes ≤510), then vaddvq_u16 (u16 accumulator,
+ * max 4080) — sum/255 is the match count. Scalar tail. */
+size_t leptris_text_count_char_neon(const char* s, size_t len, char c) {
+    const char* p = s;
+    const char* end = s + len;
+    const uint8x16_t needle = vdupq_n_u8((uint8_t)c);
+    size_t n = 0;
+
+    while (end - p >= 16) {
+        uint8x16_t v = vld1q_u8((const uint8_t*)p);
+        uint8x16_t eq = vceqq_u8(v, needle);
+        n += (size_t)(vaddvq_u16(vpaddlq_u8(eq)) / 255);
+        p += 16;
+    }
+    while (p < end) {
+        if (*p == c) n++;
+        p++;
+    }
+    return n;
+}
+
+/* Three counters in one memory pass — the sizing pre-scan shape.
+ * S10: per-char u16 accumulators with a horizontal reduce only every
+ * 1024 chunks (lane ceiling 2048, far under u16). The old form paid
+ * vaddvq horizontal reductions per vector per char — counting, not
+ * the copy, capped the kernel at ~16 GB/s while memcpy runs 5x+ that.
+ * Counts saturate no lane; flush cadence keeps every u16 lane < 2048. */
+void leptris_text_count3_neon(const char* s, size_t len,
+                             char c0, char c1, char c2,
+                             size_t* n0, size_t* n1, size_t* n2) {
+    const char* p = s;
+    const char* end = s + len;
+    const uint8x16_t k0 = vdupq_n_u8((uint8_t)c0);
+    const uint8x16_t k1 = vdupq_n_u8((uint8_t)c1);
+    const uint8x16_t k2 = vdupq_n_u8((uint8_t)c2);
+    size_t a = 0, b = 0, c = 0;
+    uint16x8_t a0 = vdupq_n_u16(0), a1 = vdupq_n_u16(0), a2 = vdupq_n_u16(0);
+    size_t since_flush = 0;
+
+    while (end - p >= 16) {
+        uint8x16_t v = vld1q_u8((const uint8_t*)p);
+        a0 = vpadalq_u8(a0, vshrq_n_u8(vceqq_u8(v, k0), 7));
+        a1 = vpadalq_u8(a1, vshrq_n_u8(vceqq_u8(v, k1), 7));
+        a2 = vpadalq_u8(a2, vshrq_n_u8(vceqq_u8(v, k2), 7));
+        p += 16;
+        if (++since_flush == 1024) {
+            a += (size_t)vaddvq_u16(a0);
+            b += (size_t)vaddvq_u16(a1);
+            c += (size_t)vaddvq_u16(a2);
+            a0 = a1 = a2 = vdupq_n_u16(0);
+            since_flush = 0;
+        }
+    }
+    a += (size_t)vaddvq_u16(a0);
+    b += (size_t)vaddvq_u16(a1);
+    c += (size_t)vaddvq_u16(a2);
+    while (p < end) {
+        unsigned char ch = (unsigned char)*p;
+        if (ch == (unsigned char)c0) a++;
+        if (ch == (unsigned char)c1) b++;
+        if (ch == (unsigned char)c2) c++;
+        p++;
+    }
+    *n0 = a;
+    *n1 = b;
+    *n2 = c;
+}
+
+/* Fused copy + three counters in ONE memory pass (TODO 188). The
+ * parser's owns-copy path used to stream the document twice — a
+ * count3 pre-scan for arena sizing, then the memcpy into the
+ * buffer copy. This kernel loads each chunk once, stores it to
+ * dst, and counts all three chars from the same registers.
+ * S10: same accumulator/flush form as count3_neon — the copy is
+ * cheap; the reductions were the cost. */
+void leptris_copy_count3_neon(char* dst, const char* src, size_t len,
+                             char c0, char c1, char c2,
+                             size_t* n0, size_t* n1, size_t* n2) {
+    const char* p = src;
+    const char* end = src + len;
+    char* q = dst;
+    const uint8x16_t k0 = vdupq_n_u8((uint8_t)c0);
+    const uint8x16_t k1 = vdupq_n_u8((uint8_t)c1);
+    const uint8x16_t k2 = vdupq_n_u8((uint8_t)c2);
+    size_t a = 0, b = 0, c = 0;
+    uint16x8_t a0 = vdupq_n_u16(0), a1 = vdupq_n_u16(0), a2 = vdupq_n_u16(0);
+    size_t since_flush = 0;
+
+    while (end - p >= 32) {
+        uint8x16_t v0 = vld1q_u8((const uint8_t*)p);
+        uint8x16_t v1 = vld1q_u8((const uint8_t*)p + 16);
+        vst1q_u8((uint8_t*)q, v0);
+        vst1q_u8((uint8_t*)q + 16, v1);
+        a0 = vpadalq_u8(a0, vpaddq_u8(vshrq_n_u8(vceqq_u8(v0, k0), 7),
+                                       vshrq_n_u8(vceqq_u8(v1, k0), 7)));
+        a1 = vpadalq_u8(a1, vpaddq_u8(vshrq_n_u8(vceqq_u8(v0, k1), 7),
+                                       vshrq_n_u8(vceqq_u8(v1, k1), 7)));
+        a2 = vpadalq_u8(a2, vpaddq_u8(vshrq_n_u8(vceqq_u8(v0, k2), 7),
+                                       vshrq_n_u8(vceqq_u8(v1, k2), 7)));
+        p += 32;
+        q += 32;
+        if (++since_flush == 1024) {
+            a += (size_t)vaddvq_u16(a0);
+            b += (size_t)vaddvq_u16(a1);
+            c += (size_t)vaddvq_u16(a2);
+            a0 = a1 = a2 = vdupq_n_u16(0);
+            since_flush = 0;
+        }
+    }
+    a += (size_t)vaddvq_u16(a0);
+    b += (size_t)vaddvq_u16(a1);
+    c += (size_t)vaddvq_u16(a2);
+    while (p < end) {
+        unsigned char ch = (unsigned char)*p;
+        *q = (char)ch;
+        if (ch == (unsigned char)c0) a++;
+        if (ch == (unsigned char)c1) b++;
+        if (ch == (unsigned char)c2) c++;
+        p++;
+        q++;
+    }
+    *n0 = a;
+    *n1 = b;
+    *n2 = c;
+}
+
+#endif /* LEPTRIS_ARCH_ARM && __aarch64__ */
+
+/* Structural span scan (TODO 193 Phase 1). Marker detection is 8
+ * vector compares per 16-byte chunk ('<','>','/','\'','"','=','&'
+ * plus a c<=' ' range test for whitespace); the per-hit class comes
+ * from the shared 256-byte table — hits are ~1 per 8-15 bytes in
+ * real XML, so the scalar lookups are noise. The 16-bit mask is
+ * built with the bit-weight + horizontal-add trick: no NEON
+ * movemask exists, and weights sum to the exact bitmask because
+ * each bit appears once (no carries). */
+size_t leptris_text_scan_events_neon(const char* buf, size_t len,
+                                    LeptrisScanEvent* out, size_t max) {
+    extern void leptris_dp_class_table_init(void);
+    leptris_dp_class_table_init();
+    const uint8x16_t k_lt   = vdupq_n_u8('<');
+    const uint8x16_t k_gt   = vdupq_n_u8('>');
+    const uint8x16_t k_sl   = vdupq_n_u8('/');
+    const uint8x16_t k_eq   = vdupq_n_u8('=');
+    const uint8x16_t k_qs   = vdupq_n_u8('\'');
+    const uint8x16_t k_qd   = vdupq_n_u8('"');
+    const uint8x16_t k_amp  = vdupq_n_u8('&');
+    const uint8x16_t k_sp   = vdupq_n_u8(' ');
+    /* vshlq_u16 takes an int16x8_t shift vector per the ARM ACLE;
+     * lanes 0..7 are fine as signed. Apple clang accepts the
+     * unsigned form silently, GCC rejects it (issue #487). */
+    static const int16_t sh8[8] = {0,1,2,3,4,5,6,7};
+    const int16x8_t sh8v = vld1q_s16(sh8);
+
+    size_t n = 0;
+    const unsigned char* p = (const unsigned char*)buf;
+    const unsigned char* end = p + len;
+    size_t base = 0;
+
+    while (end - p >= 16 && n < max) {
+        uint8x16_t v = vld1q_u8(p);
+        uint8x16_t m = vorrq_u8(vceqq_u8(v, k_lt), vceqq_u8(v, k_gt));
+        m = vorrq_u8(m, vceqq_u8(v, k_sl));
+        m = vorrq_u8(m, vceqq_u8(v, k_eq));
+        m = vorrq_u8(m, vceqq_u8(v, k_qs));
+        m = vorrq_u8(m, vceqq_u8(v, k_qd));
+        m = vorrq_u8(m, vceqq_u8(v, k_amp));
+        m = vorrq_u8(m, vcltq_u8(v, k_sp));   /* c < ' ' = ctrl/ws */
+        m = vorrq_u8(m, vceqq_u8(v, k_sp));
+        if (vmaxvq_u8(m) != 0) {
+            /* NEON has no movemask: widen both halves, shift each
+             * lane by its own index (vector shift), reduce. */
+            uint8x16_t bits = vshrq_n_u8(m, 7);
+            uint16x8_t lo16 = vshlq_u16(vmovl_u8(vget_low_u8(bits)), sh8v);
+            uint16x8_t hi16 = vshlq_u16(vmovl_u8(vget_high_u8(bits)), sh8v);
+            unsigned mask =
+                (unsigned)vaddvq_u16(lo16) | ((unsigned)vaddvq_u16(hi16) << 8);
+            while (mask) {
+                if (n >= max) return max;
+                unsigned bit = mask & (unsigned)(-(int)mask);
+                unsigned idx = (unsigned)LEPTRIS_CTZ(mask);
+                out[n].offset = (uint32_t)(base + idx);
+                out[n].cls = leptris_dp_class_table[p[idx]];
+                n++;
+                mask ^= bit;
+            }
+        }
+        p += 16;
+        base += 16;
+    }
+    /* Tail: scalar, same table. */
+    while (p < end && n < max) {
+        unsigned char cls = leptris_dp_class_table[*p];
+        if (cls) {
+            out[n].offset = (uint32_t)((size_t)(p - (const unsigned char*)buf));
+            out[n].cls = cls;
+            n++;
+        }
+        p++;
+    }
+    return n;
+}

data/vendor-src/libleptris/src/leptris/common/string_view.c

@@ -0,0 +1,204 @@
+#include "../memory/pool.h"
+#include "string_view.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* ============================================================================
+ * Pointer Validation - Detects obviously corrupted pointers
+ * ============================================================================ */
+
+/* ============================================================================
+ * SIMD Support Detection and Includes
+ * ============================================================================ */
+
+/* Detect platform and include appropriate SIMD headers */
+#if defined(__ARM_NEON) || defined(__ARM_NEON__)
+    #define LEPTRIS_HAS_NEON 1
+    #include <arm_neon.h>
+#elif defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)
+    /* Gate on __SSE2__, not __i386__: SSE2 is baseline on x86_64 but
+     * NOT on i686 (#1174) — there it needs -msse2 and plain -m32
+     * builds must take the scalar path. */
+    #define LEPTRIS_HAS_SSE2 1
+    #include <emmintrin.h>
+#else
+    #define LEPTRIS_HAS_SIMD 0
+#endif
+
+/* ============================================================================
+ * SIMD-Optimized String Comparison
+ * ============================================================================ */
+
+/**
+ * SIMD-accelerated memory comparison (16-byte at a time)
+ *
+ * Uses NEON (ARM) or SSE2 (x86) for 8-way parallel comparison.
+ * Falls back to memcmp for remaining bytes.
+ *
+ * @param a First buffer
+ * @param b Second buffer
+ * @param len Length to compare (must be > 0)
+ * @return 1 if equal, 0 if different
+ */
+static inline int leptris_simd_memcmp(const char* a, const char* b, size_t len) {
+    /* Process 16 bytes at a time using SIMD */
+    size_t i = 0;
+
+#if defined(LEPTRIS_HAS_NEON)
+    /* ARM NEON implementation - 16 bytes per iteration */
+    for (; i + 16 <= len; i += 16) {
+        /* Load 16 bytes from each buffer */
+        uint8x16_t va = vld1q_u8((const uint8_t*)(a + i));
+        uint8x16_t vb = vld1q_u8((const uint8_t*)(b + i));
+
+        /* Compare all 16 bytes */
+        uint8x16_t cmp = vceqq_u8(va, vb);
+
+        /* Check if all bytes are equal (all bits set) */
+        if (vminvq_u8(cmp) == 0) {
+            return 0;  /* Not equal */
+        }
+    }
+#elif defined(LEPTRIS_HAS_SSE2)
+    /* x86 SSE2 implementation - 16 bytes per iteration */
+    for (; i + 16 <= len; i += 16) {
+        /* Load 16 bytes from each buffer */
+        __m128i va = _mm_loadu_si128((const __m128i*)(a + i));
+        __m128i vb = _mm_loadu_si128((const __m128i*)(b + i));
+
+        /* Compare all 16 bytes */
+        __m128i cmp = _mm_cmpeq_epi8(va, vb);
+
+        /* Check if all bytes are equal (all bits set) */
+        if (_mm_movemask_epi8(cmp) != 0xFFFF) {
+            return 0;  /* Not equal */
+        }
+    }
+#endif
+
+    /* Handle remaining bytes (0-15 bytes) */
+    if (i < len) {
+        return memcmp(a + i, b + i, len - i) == 0;
+    }
+
+    return 1;  /* All bytes equal */
+}
+
+/* Creation from pointer + length */
+/* Creation from NULL-terminated C string */
+/* Create empty StringView */
+/* Query: Check if empty */
+int leptris_sv_is_empty(const LeptrisStringView* sv) {
+    return !sv || !sv->data || sv->length == 0;
+}
+
+/* Query: Get length */
+size_t leptris_sv_length(const LeptrisStringView* sv) {
+    return sv ? sv->length : 0;
+}
+
+/* Comparison: Compare two StringViews (SIMD-accelerated) */
+int leptris_sv_equals(const LeptrisStringView* a, const LeptrisStringView* b) {
+    if (!a || !b) return 0;
+    if (a->length != b->length) return 0;
+    if (a->length == 0) return 1;
+
+    /* Use SIMD-accelerated comparison for longer strings */
+    if (a->length >= 16) {
+        return leptris_simd_memcmp(a->data, b->data, a->length);
+    }
+
+    /* For short strings, use memcmp (faster due to no SIMD overhead) */
+    return memcmp(a->data, b->data, a->length) == 0;
+}
+
+/* Comparison: Compare StringView with C string (SIMD-accelerated) */
+int leptris_sv_equals_cstr(const LeptrisStringView* sv, const char* str) {
+    if (!sv || !str) return 0;
+    size_t str_len = strlen(str);
+    if (sv->length != str_len) return 0;
+    if (sv->length == 0) return 1;
+
+    /* Use SIMD-accelerated comparison for longer strings */
+    if (sv->length >= 16) {
+        return leptris_simd_memcmp(sv->data, str, str_len);
+    }
+
+    /* For short strings, use memcmp */
+    return memcmp(sv->data, str, str_len) == 0;
+}
+
+/* Hash: FNV-1a hash algorithm (fast, good distribution) */
+size_t leptris_sv_hash(const LeptrisStringView* sv) {
+    if (!sv || !sv->data) return 0;
+
+    const size_t FNV_offset_basis = 14695981039346656037ULL;
+    const size_t FNV_prime = 1099511628211ULL;
+
+    size_t hash = FNV_offset_basis;
+    for (size_t i = 0; i < sv->length; i++) {
+        hash ^= (unsigned char)sv->data[i];
+        hash *= FNV_prime;
+    }
+    return hash;
+}
+
+/* Convert to NULL-terminated C string (allocates!) */
+char* leptris_sv_to_cstr(const LeptrisStringView* sv) {
+    if (!sv || sv->length == 0 || !sv->data) {
+        return strdup("");
+    }
+
+    char* str = malloc(sv->length + 1);
+    if (!str) return NULL;
+
+    memcpy(str, sv->data, sv->length);
+    str[sv->length] = '\0';
+    return str;
+}
+
+/* Convert to NULL-terminated C string using pool (fast!) */
+char* leptris_sv_to_cstr_pooled(const LeptrisStringView* sv, LeptrisMemoryPool* pool) {
+    if (!sv || sv->length == 0) {
+        /* For empty strings, allocate from pool if available */
+        if (pool) {
+            char* str = (char*)leptris_pool_alloc(pool, 1);
+            if (str) str[0] = '\0';
+            return str;
+        }
+        return strdup("");
+    }
+
+    if (!pool) {
+        /* No pool - fall back to malloc */
+        return leptris_sv_to_cstr(sv);
+    }
+
+    /* Use string interning if pool has hash table (deduplication!) */
+    if (pool->string_cache) {
+        return leptris_pool_intern_string(pool, sv);
+    }
+
+    /* No hash table - allocate directly from pool (no deduplication) */
+    char* str = (char*)leptris_pool_alloc(pool, sv->length + 1);
+    if (!str) return NULL;
+
+    memcpy(str, sv->data, sv->length);
+    str[sv->length] = '\0';
+    return str;
+}
+
+/* Copy to buffer with NULL-termination */
+size_t leptris_sv_to_buffer(const LeptrisStringView* sv, char* buf, size_t buf_size) {
+    if (!sv || !buf || buf_size == 0) return 0;
+    if (sv->length == 0) {
+        buf[0] = '\0';
+        return 0;
+    }
+
+    size_t copy_len = sv->length < buf_size - 1 ? sv->length : buf_size - 1;
+    memcpy(buf, sv->data, copy_len);
+    buf[copy_len] = '\0';
+    return copy_len;
+}

data/vendor-src/libleptris/src/leptris/common/string_view.h

@@ -0,0 +1,68 @@
+#ifndef LEPTRIS_STRING_VIEW_H
+#define LEPTRIS_STRING_VIEW_H
+
+#include <stddef.h>
+#include <string.h>
+
+/* Forward declaration - defined in pool.h */
+struct leptris_memory_pool;
+
+/**
+ * StringView - Length-aware string (no NULL-termination required)
+ *
+ * Points to substring in a buffer. Does NOT own memory.
+ * Perfect for zero-copy: strings live in XML buffer.
+ *
+ * Guarded so re-including this header doesn't trigger C99
+ * typedef-redefinition warnings.  See TODO 12.
+ */
+#ifndef LEPTRIS_STRING_VIEW_DEFINED
+#define LEPTRIS_STRING_VIEW_DEFINED
+typedef struct leptris_string_view {
+    const char* data;    /* Start of string (may not be NULL-terminated!) */
+    size_t length;       /* Length in bytes */
+} LeptrisStringView;
+#endif
+
+/* Creation */
+/* Constructors are header-inline (round 12): these are pure
+ * two-field initializers on the hottest paths in the library —
+ * leptris_parse alone calls sv_from_ptr twice PER ATTRIBUTE, and as
+ * out-of-line definitions in another TU they cost a function call
+ * each (~4ns/attr, the bulk of the measured gap vs pugixml). */
+static inline LeptrisStringView leptris_sv_from_ptr(const char* data,
+                                                  size_t length) {
+    LeptrisStringView sv = { data, length };
+    return sv;
+}
+
+static inline LeptrisStringView leptris_sv_from_cstr(const char* str) {
+    LeptrisStringView sv = { str ? str : NULL, str ? strlen(str) : 0 };
+    return sv;
+}
+
+static inline LeptrisStringView leptris_sv_empty(void) {
+    LeptrisStringView sv = { NULL, 0 };
+    return sv;
+}
+
+/* Query */
+int leptris_sv_is_empty(const LeptrisStringView* sv);
+size_t leptris_sv_length(const LeptrisStringView* sv);
+
+/* Comparison */
+int leptris_sv_equals(const LeptrisStringView* a, const LeptrisStringView* b);
+int leptris_sv_equals_cstr(const LeptrisStringView* sv, const char* str);
+
+/* Hash (for hash table operations) */
+size_t leptris_sv_hash(const LeptrisStringView* sv);
+
+/* Literal macro (compile-time StringView from string literal) */
+#define LEPTRIS_SV_LIT(lit) ((LeptrisStringView){(lit), sizeof(lit) - 1})
+
+/* Conversion (allocates) */
+char* leptris_sv_to_cstr(const LeptrisStringView* sv);
+char* leptris_sv_to_cstr_pooled(const LeptrisStringView* sv, struct leptris_memory_pool* pool);
+size_t leptris_sv_to_buffer(const LeptrisStringView* sv, char* buf, size_t buf_size);
+
+#endif /* LEPTRIS_STRING_VIEW_H */

data/vendor-src/libleptris/src/leptris/common/types_internal.h

@@ -0,0 +1,31 @@
+/* lib/src/common/types_internal.h — single source of truth for internal
+ * typedefs shared across libleptris modules.
+ *
+ * The C standard (C99) disallows redefining a typedef in the same scope
+ * (C11 relaxes this).  Without a central header, every internal module
+ * that needed to reference LeptrisMemoryPool / LeptrisDTD ended up
+ * re-typedef'ing them, producing a flood of -Wtypedef-redefinition
+ * warnings and risking drift.  See TODO 12.
+ *
+ * Include this file FIRST in any internal header that needs these
+ * types.  Do NOT redefine them locally.
+ */
+
+#ifndef LEPTRIS_COMMON_TYPES_INTERNAL_H
+#define LEPTRIS_COMMON_TYPES_INTERNAL_H
+
+/* Memory pool — full definition in memory/pool.h */
+typedef struct leptris_memory_pool LeptrisMemoryPool;
+
+/* DTD container — full definition in dtd/model.h.  Guard matches the
+ * public dtd.h so the two headers can be included in either order. */
+#ifndef LEPTRIS_TYPEDEF_DTD_DECLARED
+#define LEPTRIS_TYPEDEF_DTD_DECLARED
+typedef struct LeptrisDTD LeptrisDTD;
+#endif
+
+/* Document opaque handle — pointer type, matches public types.h.
+ * Do NOT redefine as `struct leptris_document` here; the public API
+ * exposes `typedef struct leptris_document* LeptrisDocument`. */
+
+#endif /* LEPTRIS_COMMON_TYPES_INTERNAL_H */