fix: use strtod for double parsing on macOS, bump to 1.1.2

macOS libc++ does not support std::from_chars for floating-point types.
Replace with strtod using a stack buffer for typical numeric values.

Author: jorgeMFS

CITATION.cff

@@ -1,7 +1,7 @@
 cff-version: 1.2.0
 message: "If you use this software, please cite it."
 title: "VCFX: A Minimalist, Modular Toolkit for Streamlined Variant Analysis"
-version: "1.1.1"
+version: "1.1.2"
 authors:
   - family-names: Silva
     given-names: Jorge Miguel

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 # Set version information
 set(VCFX_VERSION_MAJOR 1)
 set(VCFX_VERSION_MINOR 1)
-set(VCFX_VERSION_PATCH 1)
+set(VCFX_VERSION_PATCH 2)
 set(VCFX_VERSION "${VCFX_VERSION_MAJOR}.${VCFX_VERSION_MINOR}.${VCFX_VERSION_PATCH}")
 
 add_compile_definitions(VCFX_VERSION="${VCFX_VERSION}")

src/VCFX_record_filter/VCFX_record_filter.cpp

@@ -140,10 +140,24 @@ static bool parseSingleCriterion(std::string_view token, FilterCriterion& crit)
         crit.target = TargetField::INFO_KEY;
     }
 
-    // Try to parse as numeric using fast charconv
+    // Try to parse as numeric using strtod (from_chars for double unavailable on macOS)
     double d;
-    auto result = std::from_chars(valPart.data(), valPart.data() + valPart.size(), d);
-    if (result.ec == std::errc{} && result.ptr == valPart.data() + valPart.size()) {
+    char buf[64];
+    bool isNumeric = false;
+    if (valPart.size() < sizeof(buf)) {
+        std::memcpy(buf, valPart.data(), valPart.size());
+        buf[valPart.size()] = '\0';
+        char* endptr;
+        d = std::strtod(buf, &endptr);
+        isNumeric = (endptr == buf + valPart.size());
+    } else {
+        std::string tmp(valPart);
+        char* endptr;
+        d = std::strtod(tmp.c_str(), &endptr);
+        isNumeric = (endptr == tmp.c_str() + tmp.size());
+    }
+
+    if (isNumeric) {
         crit.fieldType = FieldType::NUMERIC;
         crit.numericValue = d;
         crit.stringValue.clear();
@@ -253,12 +267,35 @@ bool VCFXRecordFilter::extractInfoValue(std::string_view info, std::string_view
 }
 
 // ============================================================================
-// Fast numeric parsing using std::from_chars (no exceptions, no allocations)
+// Fast numeric parsing - uses strtod with careful bounds checking
+// (std::from_chars for double is not available on macOS libc++)
 // ============================================================================
 bool VCFXRecordFilter::parseDouble(std::string_view sv, double& out) {
     if (sv.empty()) return false;
-    auto result = std::from_chars(sv.data(), sv.data() + sv.size(), out);
-    return result.ec == std::errc{} && result.ptr == sv.data() + sv.size();
+
+    // Fast path: check if the string_view is null-terminated or followed by
+    // a non-numeric character (common case for VCF parsing)
+    const char* start = sv.data();
+    const char* end = start + sv.size();
+
+    // Need a null-terminated string for strtod
+    // Use a small stack buffer for typical numeric values
+    char buf[64];
+    if (sv.size() < sizeof(buf)) {
+        std::memcpy(buf, start, sv.size());
+        buf[sv.size()] = '\0';
+        start = buf;
+    } else {
+        // Unlikely: very long numeric string
+        std::string tmp(sv);
+        char* endptr;
+        out = std::strtod(tmp.c_str(), &endptr);
+        return endptr == tmp.c_str() + tmp.size();
+    }
+
+    char* endptr;
+    out = std::strtod(start, &endptr);
+    return endptr == start + sv.size();
 }
 
 bool VCFXRecordFilter::parseInt(std::string_view sv, int64_t& out) {