leptris 1.9.240.0-arm-linux → 1.9.242.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00ff54ac605733a6358ab6333805404fbd03161a48e92cf1632f6608e1b6a86d
-  data.tar.gz: 6489d53b6cc0ae82ae80d0e6e5b11a3307b486a902d97f2880a4f0c3645221fc
+  metadata.gz: 9d1a44bcb9b87e137cca02085c471687608686aadcd088b2ed86fa4c6672ecbd
+  data.tar.gz: 6452f8b7f0edee415c282848ed7087e31217b75ce2287295285a03df65a24692
 SHA512:
-  metadata.gz: 2a2ee88380d3fdcee757da1c64edd61a807c1ec38020522c2a1e38632e93508ffeb8ced7f59aefdf86c556cf6005726c5609439e12044d947e29512ab59636d3
-  data.tar.gz: '09c3d9ba5513fea1ee1248dc6882bf89f4c17d9f79c3ce41c9e51fbf22460915060d506a1d4b79d8cce8f9606b77ea4ccd25c845adf3fee97fcb6d69e96085d6'
+  metadata.gz: b530353e1813d05f92ca751a1af56ab8c13571750918eb1ca926e778918e27e1e3eaaa70b82952b588d311be64393e31d104ecdcf433e115e5de6807cf74aa19
+  data.tar.gz: bb61aa1cbb666aa98d41db3810751d9a741cb7b97d96ef7fb81adc9bd54ce6383fc6f05bbdbc4ab8f14d0ae15a60d21e56cc9e0b9e410f7d30190fcd11589914

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.241.0] - 2026-09-25
+
+### Fixed
+
+- Vendored libleptris 1.9.241 (riding 1.9.240 + 1.9.241):
+  - The interleaved parse lane now applies the same §2.11 EOL
+    normalization as the classic lane (#1357) — both lanes
+    spec-identical; the lane stays env-gated off by default.
+  - xquery: order by — only a genuinely empty-sequence key takes
+    the empty mode (an empty STRING key sorts by value);
+    fn:distinct-values compares xs:duration-family members in the
+    value space and spells survivors canonically.
+  - xquery: shortest round-trip plain spelling for numbers — the
+    15-digit plain budget collided distinct decimals
+    (1.2000000000000001 vs 1.2); the branch now discovers minimal
+    significant digits and renders fixed-point uncapped.
+- Repairs the Rakefile engine pin, left at 1.9.239 by the last
+  release's version-only bump, back in lockstep with version.rb.
+
 ## [1.9.239.0] - 2026-09-25
 
 ### Fixed

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.239"
+LIBLEPTRIS_VERSION = "1.9.246"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.240.0"
+  VERSION = "1.9.242.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.239
+- libleptris v1.9.246
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,75 @@
 ## [Unreleased]
 
+## [1.9.246] - 2026-09-25
+
+### Added
+
+- exact decimal lexical carrier (xquery)
+
+
+
+## [1.9.245] - 2026-09-25
+
+### Added
+
+- array:remove + NaN subsequence 2-arg adoption (xquery)
+- attribute ctor carriers + derived-string deep-equal class (xquery)
+
+
+
+## [1.9.244] - 2026-09-25
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.243] - 2026-09-25
+
+<!-- Edit this section with the actual release notes. -->
+<!-- See https://keepachangelog.com for format guidance. -->
+
+### Changed
+
+- (describe changes here)
+
+
+## [1.9.242] - 2026-09-25
+
+### Added
+
+- QT3 maps/arrays slice — empty-aggregate arity guard + canonical map order (xquery)
+
+
+
+## [1.9.241] - 2026-09-25
+
+### Fixed
+
+- xquery: shortest round-trip plain spelling for XQuery numbers.
+  The plain branch kept a 15-digit budget, so `1.2000000000000001`
+  and `1.2` collided into one spelling and fn:distinct-values
+  deduped distinct xs:decimals. The branch now discovers the minimal
+  significant digits via the same e-form loop (float-aware) and
+  renders fixed-point with `decimals = prec - exp10` — uncapped, or
+  tiny plain-range values (`1e-18`) truncate to "0".
+- QT3 corpus: distinct-values 93→94 adopted; pins-off reds 67→59.
+
+
+
+## [1.9.240] - 2026-09-25
+
+### Fixed
+
+- order-by empty-string keys, duration-typed distinct-values (xquery)
+- qualifier casts in the plan free path (descriptor)
+- §2.11 EOL normalization in the interleaved lane (#326) (dom)
+
+
+
 ## [1.9.239] - 2026-09-24
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.239
+    VERSION 1.9.246
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -244,7 +244,7 @@ static void dp_plan_free(LeptrisPlan p) {
     for (uint32_t i = 0; i < p->plan_count; i++) {
         dp_plan* d = &p->plans[i];
         for (uint32_t a = 0; a < d->attribute_count; a++) {
-            free(d->attribute_plans[a].wire_name);
+            free((char *)d->attribute_plans[a].wire_name);
             for (uint16_t pi = 0;
                  pi < d->attribute_plans[a].predicate_count; pi++) {
                 free((char*)d->attribute_plans[a]
@@ -255,7 +255,7 @@ static void dp_plan_free(LeptrisPlan p) {
             free((leptris_attr_predicate*)d->attribute_plans[a].predicates);
         }
         for (uint32_t c = 0; c < d->child_count; c++) {
-            free(d->child_plans[c].wire_name);
+            free((char *)d->child_plans[c].wire_name);
             for (uint16_t pi = 0;
                  pi < d->child_plans[c].predicate_count; pi++) {
                 free((char*)d->child_plans[c]

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -2290,6 +2290,23 @@ int leptris_il_scan(char* s, size_t len, int drop_ws, IlCtx* c,
             j = (size_t)(vend - s) + 1;
             IlAttr a = { (uint32_t)a0, (uint32_t)al,
                          (uint32_t)v0, (uint32_t)vl, aws };
+            /* XML 1.0 §3.1: duplicate attributes are a fatal error —
+             * the classic lane reports "Attribute %s redefined" and
+             * the SAX callback path records an ERROR event, but the
+             * record table has no error channel. A dup-containing
+             * document is therefore outside the scannable subset:
+             * bail so callers fall back to the callback path (#281,
+             * leptris-ruby#331 adoption). Same-element prior attrs
+             * are the contiguous range [r.first_attr, nattr). */
+            if (acount > 0) {
+                for (uint32_t k = r.first_attr; k < (uint32_t)c->nattr;
+                     k++) {
+                    const IlAttr* p = &c->attrs[k];
+                    if (p->name_len == (uint32_t)al &&
+                        memcmp(s + p->name_off, s + a0, al) == 0)
+                        return 0;
+                }
+            }
             if (!il_push_attr(c, &a)) return 0;
             if (acount == 0) r.first_attr = (uint32_t)(c->nattr - 1);
             acount++;
@@ -2560,12 +2577,22 @@ static struct leptris_document* dp_il_build(
                             pool, a->val_len + 1);
                         if (!norm) { free(smap); free(rdepth);
                                      free(lc); goto oom_pool; }
+                        /* §2.11 (#326): CRLF is ONE line break — one
+                         * space, same collapse as the classic lane. */
+                        size_t nw = 0;
                         for (uint32_t w = 0; w < a->val_len; w++) {
                             char ch = scratch[a->val_off + w];
-                            norm[w] = (ch == '\t' || ch == '\n' ||
-                                       ch == '\r') ? ' ' : ch;
+                            if (ch == '\r') {
+                                norm[nw++] = ' ';
+                                if (w + 1 < a->val_len &&
+                                    scratch[a->val_off + w + 1] == '\n')
+                                    w++;
+                            } else {
+                                norm[nw++] = (ch == '\t' || ch == '\n')
+                                                 ? ' ' : ch;
+                            }
                         }
-                        norm[a->val_len] = '\0';
+                        norm[nw] = '\0';
                         leptris_attr_value_set_heap(
                             at, leptris_sv_from_cstr(norm));
                     } else {
@@ -2672,12 +2699,37 @@ static struct leptris_document* dp_il_build(
         } else {
             LeptrisTextNode* tn = &tblk[ntext++];
             const char* content = scratch + r->off;
+            size_t content_len = r->len;
             scratch[r->off + r->len] = '\0';
+            /* §2.11 (#326), interleaved lane: same pre-expansion
+             * CRLF/CR -> LF normalization as the classic lane;
+             * CR-free runs stay in scratch. */
+            if (memchr(content, '\r', content_len)) {
+                char* norm =
+                    (char*)leptris_pool_alloc(pool, content_len + 1);
+                if (!norm) { free(smap); free(rdepth);
+                             free(lc); goto oom_pool; }
+                char* w = norm;
+                const char* rr = content;
+                const char* r_end = content + content_len;
+                while (rr < r_end) {
+                    if (*rr == '\r') {
+                        *w++ = '\n';
+                        if (rr + 1 < r_end && rr[1] == '\n') rr++;
+                    } else {
+                        *w++ = *rr;
+                    }
+                    rr++;
+                }
+                *w = '\0';
+                content = norm;
+                content_len = (size_t)(w - norm);
+            }
             tn->base.type = LEPTRIS_NODE_TYPE_TEXT;
             tn->base.frozen = 1;
             tn->base.line = r->line;
             leptris_textnode_set_content_ptr_doc(tn, content, doc);
-            tn->content_len = r->len;
+            tn->content_len = (uint32_t)content_len;
             /* (slice 4: pool/borrowed fields gone; the il scratch
              * run is already NUL-terminated at carve) */
             tn->parent_off = 0;

data/vendor-src/libleptris/src/leptris/leptris_internal.h

@@ -659,6 +659,12 @@ struct leptris_xpath_result {
      * round-trip E form instead of the libxml2-parity XPath
      * spelling. Cleared in result_new (free-list recycle). */
     int xq_spelling;
+    /* Canonical decimal lexical: set by the xs:decimal ctor — the
+     * double carrier cannot hold 30 significant digits, so
+     * eq-based functions (distinct-values, index-of, deep-equal)
+     * key on the canonical form instead (decimal-lex slice). OWNED
+     * — freed in result_free, cleared in result_new (recycle). */
+    char* decimal_lex;
 };
 
 /* Namespace mapping for XPath context (v0.8.0) */

data/vendor-src/libleptris/src/leptris/xpath/evaluator.c

@@ -744,6 +744,7 @@ struct leptris_xpath_result* xpath_result_new(XPathResultType type) {
     result->is_int = 0;   /* free-list recycling would leak it */
     result->atomic_type = NULL;
     result->xq_spelling = 0;
+    result->decimal_lex = NULL;   /* free-list recycling would leak it */
 
     /* Initialize union based on type. XPATH_RESULT_CACHED is the
      * free-list sentinel — a fresh result never carries it. */
@@ -773,6 +774,11 @@ void xpath_result_free(struct leptris_xpath_result* result) {
      * no-op, never a second payload release. */
     if (result->type == XPATH_RESULT_CACHED) return;
 
+    if (result->decimal_lex) {
+        LEPTRIS_FREE(result->decimal_lex);
+        result->decimal_lex = NULL;
+    }
+
     /* Release the payload through locals: after this block the
      * union slot is dead, and parking the free-list next-pointer
      * into it cannot alias the memory just released. */

data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c

@@ -418,7 +418,9 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         op0 != XPATH_OP_ELEMENT_CTOR &&
         op0 != XPATH_OP_ATTRIBUTE_CTOR &&
         op0 != XPATH_OP_TEXT_CTOR &&
-        op0 != XPATH_OP_DOCUMENT_CTOR)
+        op0 != XPATH_OP_DOCUMENT_CTOR &&
+        op0 != XPATH_OP_ARRAY_CONSTRUCTOR &&
+        op0 != XPATH_OP_MAP_CONSTRUCTOR)
         return NULL;
 
     XPathOperatorType op = (XPathOperatorType)ast->number_value;
@@ -1597,6 +1599,38 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 if (v) xpath_result_free(v);
             }
             if (!s) s = leptris_strdup("");
+            if (op == XPATH_OP_ATTRIBUTE_CTOR) {
+                /* Top-level attribute ctor keeps its name: one
+                 * synthetic member carrying "\x03A" name "\x01"
+                 * value — deep-equal compares name+value
+                 * (K2-SeqDeepEqualFunc-25/31/32), string consumers
+                 * strip to the value. \x01 cannot occur in XML
+                 * content. */
+                const char* an = ast->value ? ast->value : "";
+                size_t alen = strlen(an), vlen = strlen(s);
+                size_t clen = alen + vlen + 3;
+                char* carrier = (char*)malloc(clen + 1);
+                if (!carrier) { free(s); return NULL; }
+                carrier[0] = '\x03';
+                carrier[1] = 'A';
+                memcpy(carrier + 2, an, alen);
+                carrier[2 + alen] = '\x01';
+                memcpy(carrier + 3 + alen, s, vlen + 1);
+                free(s);
+                XPathNodeSet* ns = xpath_nodeset_new();
+                if (!ns) { free(carrier); return NULL; }
+                ns->owns_synthetic_text = 1;
+                ns->is_sequence = 1;
+                XPathTextNode* tn = synth_text(carrier, clen);
+                free(carrier);
+                if (!tn) { xpath_nodeset_free(ns); return NULL; }
+                xpath_nodeset_add(ns, tn);
+                struct leptris_xpath_result* out =
+                    xpath_result_new(XPATH_RESULT_NODESET);
+                if (!out) { xpath_nodeset_free(ns); return NULL; }
+                out->value.nodeset_value = ns;
+                return out;
+            }
             struct leptris_xpath_result* out =
                 xpath_result_new(XPATH_RESULT_STRING);
             if (!out) { free(s); return NULL; }
@@ -1903,6 +1937,81 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
             free(v);
         }
         buf[len] = '\0';
+        /* Canonical entry order: sort by key so deep-equal and the
+         * serialized carrier are key-order-insensitive (maps-4:
+         * {1:a, 2:b} = {2:b, 1:a}); map iteration order is
+         * implementation-defined in XQuery. */
+        {
+            size_t body_len = len - 4;   /* past "\x03MAP" */
+            char* body = buf + 4;
+            size_t count = 0;
+            for (size_t i = 0; i < body_len; i++)
+                if (body[i] == '\x02') count++;
+            if (count > 1) {
+                char** keys = (char**)malloc(count * sizeof(char*));
+                size_t* klens = (size_t*)malloc(count * sizeof(size_t));
+                char** vals = (char**)malloc(count * sizeof(char*));
+                size_t* vlens = (size_t*)malloc(count * sizeof(size_t));
+                if (keys && klens && vals && vlens) {
+                    size_t n = 0, p = 0;
+                    while (p < body_len) {
+                        if (body[p] != '\x02') { p++; continue; }
+                        p++;
+                        size_t ks = p;
+                        while (p < body_len && body[p] != '\x01') p++;
+                        keys[n] = body + ks;
+                        klens[n] = p - ks;
+                        p++;
+                        size_t vs = p;
+                        while (p < body_len && body[p] != '\x02') p++;
+                        vals[n] = body + vs;
+                        vlens[n] = p - vs;
+                        n++;
+                    }
+                    for (size_t a = 1; a < n; a++) {
+                        char* ek = keys[a]; size_t ekl = klens[a];
+                        char* ev = vals[a]; size_t evl = vlens[a];
+                        size_t b2 = a;
+                        while (b2 > 0) {
+                            int c = strncmp(keys[b2 - 1], ek,
+                                            klens[b2 - 1] < ekl
+                                                ? klens[b2 - 1] : ekl);
+                            if (c == 0)
+                                c = klens[b2 - 1] < ekl ? -1
+                                    : klens[b2 - 1] > ekl ? 1 : 0;
+                            if (c <= 0) break;
+                            keys[b2] = keys[b2 - 1];
+                            klens[b2] = klens[b2 - 1];
+                            vals[b2] = vals[b2 - 1];
+                            vlens[b2] = vlens[b2 - 1];
+                            b2--;
+                        }
+                        keys[b2] = ek; klens[b2] = ekl;
+                        vals[b2] = ev; vlens[b2] = evl;
+                    }
+                    /* Sort-order permutes segments in place: write
+                     * through a scratch (a forward write clobbers a
+                     * not-yet-copied source segment). */
+                    char* scratch = (char*)malloc(body_len + 1);
+                    if (scratch) {
+                        size_t w2 = 0;
+                        for (size_t e = 0; e < n; e++) {
+                            scratch[w2++] = '\x02';
+                            memcpy(scratch + w2, keys[e], klens[e]);
+                            w2 += klens[e];
+                            scratch[w2++] = '\x01';
+                            memcpy(scratch + w2, vals[e], vlens[e]);
+                            w2 += vlens[e];
+                        }
+                        memcpy(body, scratch, w2);
+                        len = 4 + w2;
+                        buf[len] = '\0';
+                        free(scratch);
+                    }
+                }
+                free(keys); free(klens); free(vals); free(vlens);
+            }
+        }
         XPathNodeSet* out = xpath_nodeset_new();
         if (!out) { free(buf); return NULL; }
         out->owns_synthetic_text = 1;
@@ -2319,12 +2428,17 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                 is->owns_synthetic_text = 0;
             } else {
                 char* piece =
-                    (ctx->xquery_spelling &&
-                     item->type == XPATH_RESULT_NUMBER &&
-                     !item->is_int)
-                        ? xpath_number_to_string_xq(
-                              item->value.number_value)
-                        : xpath_to_string(item);
+                    item->decimal_lex
+                        ? leptris_strdup(item->decimal_lex)
+                        : (ctx->xquery_spelling &&
+                           item->type == XPATH_RESULT_NUMBER &&
+                           !item->is_int)
+                              ? xpath_number_to_string_xq_typed(
+                                    item->value.number_value,
+                                    item->atomic_type &&
+                                        strcmp(item->atomic_type,
+                                               "xs:float") == 0)
+                              : xpath_to_string(item);
                 if (item->type == XPATH_RESULT_NUMBER) {
                     /* "\x03N" marks numeric members for per-member
                      * type checks (instance of); get_node_text

data/vendor-src/libleptris/src/leptris/xpath/evaluator_types.c

@@ -136,17 +136,32 @@ char* xpath_number_to_string_xq_typed(double number, int float_prec) {
         snprintf(work, sizeof(work), "%sE%s", mant, exp);
         return leptris_strdup(work);
     } else {
-        /* Fraction budget: integer digits first, the fraction spends
-         * the remaining significant digits (33 places floor for the
-         * 1e-18 tail). */
-        int integer_place = (int)floor(log10(absolute_value));
-        int fraction_place = integer_place > 0
-                                 ? 15 - integer_place - 1
-                                 : 15 - integer_place;
-        if (fraction_place > 33) fraction_place = 33;
-        if (fraction_place < 0) fraction_place = 0;
-        size = (int)snprintf(work, sizeof(work), "%0.*f",
-                             fraction_place, number);
+        /* Shortest round-trip PLAIN spelling: discover the minimal
+         * significant-digit count via the e-form (float-aware like
+         * the scientific branch), then render fixed-point. The old
+         * 15-digit budget truncated the 17th digit, colliding
+         * distinct xs:decimals ("1.2" vs "1.2000000000000002")
+         * into one spelling. */
+        char mant[64];
+        int prec;
+        for (prec = 1; prec <= 17; prec++) {
+            snprintf(mant, sizeof(mant), "%.*e", prec, number);
+            double back = strtod(mant, NULL);
+            if (float_prec) back = (double)((float)back);
+            if (back == number) break;
+        }
+        int exp10 = 0;
+        char* e = strchr(mant, 'e');
+        if (e) exp10 = atoi(e + 1);
+        /* %.*e prints `prec` digits AFTER the mantissa point, so
+         * fixed-point decimals = prec - exp10 ("2.5e+00" -> 1). */
+        int decimals = prec - exp10;
+        if (decimals < 0) decimals = 0;
+        /* tiny plain-range values (1e-18) need exp10 digits of
+         * fraction — no 17 cap here or they truncate to "0" */
+        if (decimals > 40) decimals = 40;
+        size = (int)snprintf(work, sizeof(work), "%.*f",
+                             decimals, number);
     }
 
     char* start = work;
@@ -261,11 +276,18 @@ char* get_node_text(void* node) {
              * per-member type checks (instance of). \x03 is invalid
              * in XML 1.0 text, so it can never collide with real
              * content — strip it for every string consumer. */
-            if (c[0] == '\x03' &&
-                (c[1] == 'N' || c[1] == 'B' || c[1] == 'D' ||
-                 (c[1] == 'F' &&
-                  !((c[2] == 'N' && c[3] == '\x02') || c[2] == 'R'))))
-                c += 2;
+            if (c[0] == '\x03') {
+                if (c[1] == 'A') {
+                    /* attribute ctor carrier: string value is the
+                     * part after the "\x01" separator */
+                    const char* sep = strchr(c, '\x01');
+                    return leptris_strdup(sep ? sep + 1 : "");
+                }
+                if (c[1] == 'N' || c[1] == 'B' || c[1] == 'D' ||
+                    (c[1] == 'F' &&
+                     !((c[2] == 'N' && c[3] == '\x02') || c[2] == 'R')))
+                    c += 2;
+            }
             return leptris_strdup(c);
         }
 
@@ -284,8 +306,30 @@ int xpath_to_boolean(struct leptris_xpath_result* result) {
             return result->value.number_value != 0.0 && !isnan(result->value.number_value);
         case XPATH_RESULT_STRING:
             return result->value.string_value && result->value.string_value[0] != '\0';
-        case XPATH_RESULT_NODESET:
-            return xpath_nodeset_count(result->value.nodeset_value) > 0;
+        case XPATH_RESULT_NODESET: {
+            XPathNodeSet* ns = result->value.nodeset_value;
+            size_t cnt = ns ? xpath_nodeset_count(ns) : 0;
+            /* XQuery sequence EBV: a singleton atomic carries the
+             * item's EBV (fn:remove round-trips a false boolean as
+             * falsy), while XPath node-existence EBV applies to
+             * real nodes and multi-item sequences. */
+            if (!ns || !ns->is_sequence) return cnt > 0;
+            if (cnt != 1) return cnt > 0;
+            void* nd = ns->nodes[0];
+            if (!nd || XPATH_NODE_TYPE(nd) != LEPTRIS_NODE_TEXT)
+                return 1;
+            const char* c = ((XPathTextNode*)nd)->content;
+            if (!c) return 1;
+            if (c[0] == '\x03') {
+                if (c[1] == 'B') return c[2] == 't';
+                if (c[1] == 'N' || c[1] == 'F' || c[1] == 'D') {
+                    double d = strtod(c + 2, NULL);
+                    return d != 0.0 && !isnan(d);
+                }
+                return 1;
+            }
+            return c[0] != '\0';
+        }
         default:
             return 0;
     }