zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/external/inih/ini.h

@@ -0,0 +1,157 @@
+/* inih -- simple .INI file parser
+
+SPDX-License-Identifier: BSD-3-Clause
+
+Copyright (C) 2009-2020, Ben Hoyt
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#ifndef INI_H
+#define INI_H
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Nonzero if ini_handler callback should accept lineno parameter. */
+#ifndef INI_HANDLER_LINENO
+#define INI_HANDLER_LINENO 0
+#endif
+
+/* Typedef for prototype of handler function. */
+#if INI_HANDLER_LINENO
+typedef int (*ini_handler)(void* user, const char* section,
+                           const char* name, const char* value,
+                           int lineno);
+#else
+typedef int (*ini_handler)(void* user, const char* section,
+                           const char* name, const char* value);
+#endif
+
+/* Typedef for prototype of fgets-style reader function. */
+typedef char* (*ini_reader)(char* str, int num, void* stream);
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+   (whitespace stripped), and comments starting with ';' (semicolon). Section
+   is "" if name=value pair parsed before any section heading. name:value
+   pairs are also supported as a concession to Python's configparser.
+
+   For each name=value pair parsed, call handler function with given user
+   pointer as well as section, name, and value (data only valid for duration
+   of handler call). Handler should return nonzero on success, zero on error.
+
+   Returns 0 on success, line number of first error on parse error (doesn't
+   stop on first error), -1 on file open error, or -2 on memory allocation
+   error (only when INI_USE_STACK is zero).
+*/
+int ini_parse(const char* filename, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+   close the file when it's finished -- the caller must do that. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes an ini_reader function pointer instead of
+   filename. Used for implementing custom or string-based I/O (see also
+   ini_parse_string). */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user);
+
+/* Same as ini_parse(), but takes a zero-terminated string with the INI data
+instead of a file. Useful for parsing INI data from a network socket or
+already in memory. */
+int ini_parse_string(const char* string, ini_handler handler, void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+   configparser. If allowed, ini_parse() will call the handler with the same
+   name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+   the file. See https://github.com/benhoyt/inih/issues/21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+/* Chars that begin a start-of-line comment. Per Python configparser, allow
+   both ; and # comments at the start of a line by default. */
+#ifndef INI_START_COMMENT_PREFIXES
+#define INI_START_COMMENT_PREFIXES ";#"
+#endif
+
+/* Nonzero to allow inline comments (with valid inline comment characters
+   specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
+   Python 3.2+ configparser behaviour. */
+#ifndef INI_ALLOW_INLINE_COMMENTS
+#define INI_ALLOW_INLINE_COMMENTS 1
+#endif
+#ifndef INI_INLINE_COMMENT_PREFIXES
+#define INI_INLINE_COMMENT_PREFIXES ";"
+#endif
+
+/* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
+#ifndef INI_USE_STACK
+#define INI_USE_STACK 1
+#endif
+
+/* Maximum line length for any line in INI file (stack or heap). Note that
+   this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
+#ifndef INI_MAX_LINE
+#define INI_MAX_LINE 200
+#endif
+
+/* Nonzero to allow heap line buffer to grow via realloc(), zero for a
+   fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
+   zero. */
+#ifndef INI_ALLOW_REALLOC
+#define INI_ALLOW_REALLOC 0
+#endif
+
+/* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
+   is zero. */
+#ifndef INI_INITIAL_ALLOC
+#define INI_INITIAL_ALLOC 200
+#endif
+
+/* Stop parsing on first error (default is to keep parsing). */
+#ifndef INI_STOP_ON_FIRST_ERROR
+#define INI_STOP_ON_FIRST_ERROR 0
+#endif
+
+/* Nonzero to call the handler at the start of each new section (with
+   name and value NULL). Default is to only call the handler on
+   each name=value pair. */
+#ifndef INI_CALL_HANDLER_ON_NEW_SECTION
+#define INI_CALL_HANDLER_ON_NEW_SECTION 0
+#endif
+
+/* Nonzero to allow a name without a value (no '=' or ':' on the line) and
+   call the handler with value NULL in this case. Default is to treat
+   no-value lines as an error. */
+#ifndef INI_ALLOW_NO_VALUE
+#define INI_ALLOW_NO_VALUE 0
+#endif
+
+/* Nonzero to use custom ini_malloc, ini_free, and ini_realloc memory
+   allocation functions (INI_USE_STACK must also be 0). These functions must
+   have the same signatures as malloc/free/realloc and behave in a similar
+   way. ini_realloc is only needed if INI_ALLOW_REALLOC is set. */
+#ifndef INI_CUSTOM_ALLOCATOR
+#define INI_CUSTOM_ALLOCATOR 0
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INI_H */

data/ext/zsv/vendor/zsv-1.3.0/app/external/json_writer-1.01/json_numeric.c

@@ -0,0 +1,177 @@
+#include <stdbool.h> // For bool, true, false
+#include <stddef.h>  // For size_t
+#include <ctype.h>   // For isdigit
+
+/**
+ * @brief Checks if a buffer segment represents a valid JSON number (RFC 8259 compliant).
+ *
+ * Follows RFC 8259 Section 6 rules strictly. Numbers MUST have an integer part.
+ * Operates on a character buffer `str` of explicit `length`.
+ * Assumes `str` is NOT null-terminated and reads exactly `length` bytes.
+ * Accessing memory beyond `str + length - 1` is avoided.
+ *
+ * JSON Number Format (RFC 8259):
+ * number = [ minus ] int [ frac ] [ exp ]
+ * int = zero / ( digit1-9 *DIGIT )
+ * frac = decimal-point 1*DIGIT
+ * exp = e [ minus / plus ] 1*DIGIT
+ *
+ * @param str Pointer to the start of the character buffer.
+ * @param length The exact number of characters in the buffer segment to validate.
+ * @return true if the buffer segment [str, str + length) is a valid JSON number
+ * per RFC 8259, false otherwise.
+ */
+bool is_valid_json_number(const char *str, size_t length) {
+    // 1. Handle NULL pointer or Zero Length
+    if (str == NULL || length == 0) {
+        return false;
+    }
+
+    const char *p = str;
+    const char * const end = str + length; // Pointer to one position *after* the last valid char
+
+    // 2. Optional Minus Sign
+    // Check bounds before dereferencing
+    if (p < end && *p == '-') {
+        p++; // Advance pointer
+    }
+
+    // 3. Integer Part (Mandatory per RFC 8259)
+    // Check if we are already at the end (e.g., input was "-" or empty after sign)
+    if (p >= end) {
+         return false;
+    }
+
+    if (*p == '0') {
+        p++; // Consumed '0'
+        // Check bounds *before* looking at the next character for leading zero violation
+        if (p < end && isdigit((unsigned char)*p)) {
+             return false; // Leading zero rule violation (e.g., "01")
+        }
+        // '0' must be followed by '.', 'e', 'E', or the end of the buffer.
+    } else if (isdigit((unsigned char)*p)) { // Starts with 1-9
+        p++; // Consume the first digit (1-9)
+        // Consume subsequent digits, checking bounds in the loop
+        while (p < end && isdigit((unsigned char)*p)) {
+            p++;
+        }
+    } else {
+        // Did not start with '0' or '1'-'9' after optional sign. Invalid.
+        // Correctly rejects ".2", "-.2" etc. even with length check.
+        return false;
+    }
+    // If we reached here, a valid integer part was parsed up to the current 'p'.
+
+    // 4. Optional Fractional Part
+    // Check bounds before checking for '.'
+    if (p < end && *p == '.') {
+        p++; // Consumed '.'
+        // Check bounds *before* looking for the mandatory digit after '.'
+        if (p >= end || !isdigit((unsigned char)*p)) {
+             // Reached end immediately after '.', or next char not a digit (e.g., "1.", "0.")
+             return false;
+        }
+        p++; // Consumed the first digit after '.'
+        // Consume subsequent digits, checking bounds in the loop
+        while (p < end && isdigit((unsigned char)*p)) {
+             p++;
+        }
+    }
+
+    // 5. Optional Exponent Part
+    // Check bounds before checking for 'e'/'E'
+    if (p < end && (*p == 'e' || *p == 'E')) {
+        p++; // Consumed 'e' or 'E'
+        // Check bounds before checking for optional sign
+        if (p < end && (*p == '+' || *p == '-')) {
+            p++; // Consumed optional sign
+        }
+        // Check bounds *before* looking for the mandatory digit after exponent part
+        if (p >= end || !isdigit((unsigned char)*p)) {
+             // Reached end immediately after 'e'/'E'/sign, or next char not a digit (e.g., "1e", "1E+")
+             return false;
+        }
+        p++; // Consumed the first digit after exponent part
+        // Consume subsequent digits, checking bounds in the loop
+        while (p < end && isdigit((unsigned char)*p)) {
+             p++;
+        }
+    }
+
+    // 6. Final Check: Must have consumed exactly 'length' characters
+    // If p == end, we successfully processed all characters from str to str + length - 1
+    // according to the JSON number rules.
+    return p == end;
+}
+
+#ifdef JSON_NUMERIC_TEST
+
+// --- Example Usage ---
+#include <stdio.h>
+#include <string.h> // For strlen in test driver ONLY
+
+// Updated test function to use length
+void test_json_number_len(const char* str, size_t len) {
+     // Create a temporary non-null terminated buffer for printing if needed,
+     // or just print the pointer and length. Be careful printing non-terminated strings.
+     // Using printf("%.*s", (int)len, str) is safer for printing.
+    printf("\"%.*s\" (len %zu) -> %s\n", (int)len, str ? str : "(null)", len,
+           is_valid_json_number(str, len) ? "VALID" : "INVALID");
+}
+
+// Helper for testing null-terminated strings using the length-based function
+void test_json_number_nul(const char* str) {
+    if (str == NULL) {
+        printf("NULL (len 0) -> %s\n", is_valid_json_number(NULL, 0) ? "VALID" : "INVALID");
+        return;
+    }
+    size_t len = strlen(str); // Use strlen JUST for the test case driver
+    test_json_number_len(str, len);
+}
+
+
+int main() {
+    printf("--- Testing with NUL-terminated strings ---\n");
+    printf("--- Valid Examples (RFC 8259 Compliant) ---\n");
+    test_json_number_nul("0");
+    test_json_number_nul("1");
+    test_json_number_nul("-1");
+    test_json_number_nul("12345");
+    test_json_number_nul("0.5");
+    test_json_number_nul("1.234");
+    test_json_number_nul("1e5");
+    test_json_number_nul("1E-5");
+    test_json_number_nul("1.2E+10");
+    test_json_number_nul("-0.123e-4");
+
+    printf("\n--- Invalid Examples (RFC 8259 Compliant) ---\n");
+    test_json_number_nul(NULL);
+    test_json_number_nul("");
+    test_json_number_nul("-");
+    test_json_number_nul(".");
+    test_json_number_nul(".2");
+    test_json_number_nul("1.");
+    test_json_number_nul("01");
+    test_json_number_nul("1e");
+    test_json_number_nul("1e+");
+    test_json_number_nul("1.2a");
+    test_json_number_nul("1.2e5 "); // Trailing space
+
+    printf("\n--- Testing with specific lengths ---\n");
+    test_json_number_len("12345", 3);   // "123" -> VALID (Consumes exactly 3)
+    test_json_number_len("12a45", 2);   // "12" -> VALID (Consumes exactly 2)
+    test_json_number_len("12a45", 3);   // "12a" -> INVALID (a is not part of num, doesn't consume exactly 3 as num)
+    test_json_number_len("1.5x", 3);    // "1.5" -> VALID (Consumes exactly 3)
+    test_json_number_len("1.5x", 4);    // "1.5x" -> INVALID (x is extra)
+    test_json_number_len("1.", 1);      // "1" -> VALID (Consumes exactly 1)
+    test_json_number_len("1.", 2);      // "1." -> INVALID (Needs digit after .)
+    test_json_number_len("-", 1);       // "-" -> INVALID (No digits)
+    test_json_number_len("-1", 1);      // "-" -> INVALID (Only consumes 1, needs the digit too)
+    test_json_number_len("-1", 2);      // "-1" -> VALID (Consumes exactly 2)
+    test_json_number_len("0", 1);       // "0" -> VALID
+    test_json_number_len("0", 0);       // "" -> INVALID (Zero length handled)
+    test_json_number_len(NULL, 0);      // NULL -> INVALID
+
+    return 0;
+}
+#endif