Tons of INI parser fixes to realy make it work. (0.37.40)

src/vm.c

@@ -48,6 +48,11 @@
 // Optional by extensions commonly used code. #ifdef's are in each single file.
 #include "external/curl.c"
 #include "external/ini.c"
+#ifdef FUN_WITH_INI
+/* Central INI handle registry and helpers */
+#include "vm/ini/handles.c"
+#endif
+/* Note: INI opcode handlers are included below; changes in vm/ini/*.c require vm.c to rebuild. */
 #include "external/json.c"
 #include "external/libsql.c"
 #include "external/pcsc.c"

src/vm/ini/get_bool.c

@@ -23,8 +23,37 @@ case OP_INI_GET_BOOL: {
     dictionary *d = ini_get(h);
     int outb = def;
     if (d && sec && key) {
-        char full[1024]; ini_make_full_key(full, sizeof(full), sec, key);
-        outb = iniparser_getboolean(d, full, def);
+        char full[1024]; char alt[1024];
+        ini_make_full_key(full, sizeof(full), sec, key);
+        memcpy(alt, full, sizeof(alt));
+        for (size_t i = 0; i < sizeof(alt) && alt[i]; ++i) { if (alt[i] == ':') { alt[i] = '.'; break; } }
+        const char *s = iniparser_getstring(d, full, NULL);
+        if (!s) s = iniparser_getstring(d, alt, NULL);
+        if (s) {
+            /* normalize and parse boolean */
+            char buf[256];
+            size_t n = strlen(s);
+            if (n >= 2 && ((s[0]=='"' && s[n-1]=='"') || (s[0]=='\'' && s[n-1]=='\''))) {
+                size_t copy = (n-2) < sizeof(buf)-1 ? (n-2) : sizeof(buf)-1;
+                memcpy(buf, s+1, copy); buf[copy] = '\0';
+                s = buf;
+            }
+            /* trim spaces */
+            while (*s && (unsigned char)*s <= ' ') s++;
+            /* lower copy for textual booleans */
+            char lb[256]; size_t li=0; for (; s[li] && li < sizeof(lb)-1; ++li) lb[li] = (char)tolower((unsigned char)s[li]); lb[li]='\0';
+            if (strcmp(lb, "true")==0 || strcmp(lb, "yes")==0 || strcmp(lb, "on")==0) {
+                outb = 1;
+            } else if (strcmp(lb, "false")==0 || strcmp(lb, "no")==0 || strcmp(lb, "off")==0) {
+                outb = 0;
+            } else {
+                /* numeric */
+                char *endp=NULL; long v = strtol(lb, &endp, 10);
+                outb = (endp && endp!=lb) ? (v!=0) : def;
+            }
+        } else {
+            outb = def;
+        }
     }
     free_value(vdef); free_value(vkey); free_value(vsec); free_value(vh);
     push_value(vm, make_int(outb ? 1 : 0));

src/vm/ini/get_double.c

@@ -23,8 +23,27 @@ case OP_INI_GET_DOUBLE: {
     dictionary *d = ini_get(h);
     double outd = def;
     if (d && sec && key) {
-        char full[1024]; ini_make_full_key(full, sizeof(full), sec, key);
-        outd = iniparser_getdouble(d, full, def);
+        char full[1024]; char alt[1024];
+        ini_make_full_key(full, sizeof(full), sec, key);
+        memcpy(alt, full, sizeof(alt));
+        for (size_t i = 0; i < sizeof(alt) && alt[i]; ++i) { if (alt[i] == ':') { alt[i] = '.'; break; } }
+        const char *s = iniparser_getstring(d, full, NULL);
+        if (!s) s = iniparser_getstring(d, alt, NULL);
+        if (s) {
+            char buf[256];
+            size_t n = strlen(s);
+            if (n >= 2 && ((s[0]=='"' && s[n-1]=='"') || (s[0]=='\'' && s[n-1]=='\''))) {
+                size_t copy = (n-2) < sizeof(buf)-1 ? (n-2) : sizeof(buf)-1;
+                memcpy(buf, s+1, copy); buf[copy] = '\0';
+                s = buf;
+            }
+            while (*s && (unsigned char)*s <= ' ') s++;
+            char *endp = NULL;
+            double v = strtod(s, &endp);
+            if (endp && endp != s) outd = v; else outd = def;
+        } else {
+            outd = def;
+        }
     }
     free_value(vdef); free_value(vkey); free_value(vsec); free_value(vh);
     push_value(vm, make_float(outd));

src/vm/ini/get_int.c

@@ -23,8 +23,29 @@ case OP_INI_GET_INT: {
     dictionary *d = ini_get(h);
     int outi = def;
     if (d && sec && key) {
-        char full[1024]; ini_make_full_key(full, sizeof(full), sec, key);
-        outi = iniparser_getint(d, full, def);
+        char full[1024]; char alt[1024];
+        ini_make_full_key(full, sizeof(full), sec, key);
+        memcpy(alt, full, sizeof(alt));
+        for (size_t i = 0; i < sizeof(alt) && alt[i]; ++i) { if (alt[i] == ':') { alt[i] = '.'; break; } }
+        const char *s = iniparser_getstring(d, full, NULL);
+        if (!s) s = iniparser_getstring(d, alt, NULL);
+        if (s) {
+            /* strip optional quotes and parse */
+            char buf[256];
+            size_t n = strlen(s);
+            if (n >= 2 && ((s[0]=='"' && s[n-1]=='"') || (s[0]=='\'' && s[n-1]=='\''))) {
+                size_t copy = (n-2) < sizeof(buf)-1 ? (n-2) : sizeof(buf)-1;
+                memcpy(buf, s+1, copy); buf[copy] = '\0';
+                s = buf;
+            }
+            /* skip leading spaces */
+            while (*s && (unsigned char)*s <= ' ') s++;
+            char *endp = NULL;
+            long v = strtol(s, &endp, 10);
+            if (endp && endp != s) outi = (int)v; else outi = def;
+        } else {
+            outi = def;
+        }
     }
     free_value(vdef); free_value(vkey); free_value(vsec); free_value(vh);
     push_value(vm, make_int(outi));

src/vm/ini/get_string.c

@@ -23,8 +23,19 @@ case OP_INI_GET_STRING: {
     dictionary *d = ini_get(h);
     const char *res = def;
     if (d && sec && key) {
-        char full[1024]; ini_make_full_key(full, sizeof(full), sec, key);
+        char full[1024]; char alt[1024];
+        ini_make_full_key(full, sizeof(full), sec, key);
+        /* Build alternate with dot separator for robustness */
+        ini_make_full_key(alt, sizeof(alt), sec, key);
+        size_t flen = strlen(full);
+        if (flen < sizeof(alt) && flen > 0) { /* create dot version in alt */
+            memcpy(alt, full, flen + 1);
+            for (size_t i = 0; i < flen; ++i) if (alt[i] == ':') { alt[i] = '.'; break; }
+        }
         const char *s = iniparser_getstring(d, full, def);
+        if (s == def) { /* not found, try alternate dot form */
+            s = iniparser_getstring(d, alt, def);
+        }
         res = s ? s : "";
     }
     free_value(vdef); free_value(vkey); free_value(vsec); free_value(vh);

src/vm/ini/handles.c

@@ -0,0 +1,63 @@
+/*
+ * This file is part of the Fun programming language.
+ * https://fun-lang.xyz/
+ *
+ * Copyright 2025 Johannes Findeisen <you@hanez.org>
+ * Licensed under the terms of the Apache-2.0 license.
+ * https://opensource.org/license/apache-2-0
+ */
+
+#ifdef FUN_WITH_INI
+#if defined(__has_include)
+#  if __has_include(<iniparser/iniparser.h>)
+#    include <iniparser/iniparser.h>
+#    include <iniparser/dictionary.h>
+#  elif __has_include(<iniparser.h>)
+#    include <iniparser.h>
+#    include <dictionary.h>
+#  else
+#    error "iniparser headers not found"
+#  endif
+#else
+#  include <iniparser/iniparser.h>
+#  include <iniparser/dictionary.h>
+#endif
+
+#include <ctype.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "handles.h"
+
+IniSlot g_ini[64];
+
+int ini_alloc_handle(dictionary *d) {
+    if (!d) return 0;
+    for (int i = 1; i < (int)(sizeof(g_ini)/sizeof(g_ini[0])); ++i) {
+        if (!g_ini[i].in_use) { g_ini[i].in_use = 1; g_ini[i].dict = d; return i; }
+    }
+    return 0;
+}
+
+dictionary* ini_get(int h) {
+    if (h > 0 && h < (int)(sizeof(g_ini)/sizeof(g_ini[0])) && g_ini[h].in_use) return g_ini[h].dict;
+    return NULL;
+}
+
+int ini_free_handle(int h) {
+    if (h <= 0 || h >= (int)(sizeof(g_ini)/sizeof(g_ini[0])) || !g_ini[h].in_use) return 0;
+    if (g_ini[h].dict) iniparser_freedict(g_ini[h].dict);
+    g_ini[h].dict = NULL;
+    g_ini[h].in_use = 0;
+    return 1;
+}
+
+void ini_make_full_key(char *buf, size_t cap, const char *sec, const char *key) {
+    if (!buf || cap == 0) return;
+    if (!sec) sec = "";
+    if (!key) key = "";
+    /* iniparser expects section:key; lookup is case-insensitive internally */
+    snprintf(buf, cap, "%s:%s", sec, key);
+}
+
+#endif /* FUN_WITH_INI */

src/vm/ini/handles.h

@@ -27,35 +27,18 @@
 #  include <iniparser/iniparser.h>
 #  include <iniparser/dictionary.h>
 #endif
-#include <stdio.h> /* snprintf for helper */
+#include <stddef.h>
 
 typedef struct { dictionary *dict; int in_use; } IniSlot;
-static IniSlot g_ini[64];
 
-static int ini_alloc_handle(dictionary *d) {
-    for (int i = 1; i < (int)(sizeof(g_ini)/sizeof(g_ini[0])); ++i) {
-        if (!g_ini[i].in_use) { g_ini[i].in_use = 1; g_ini[i].dict = d; return i; }
-    }
-    return 0;
-}
-static dictionary* ini_get(int h) {
-    if (h > 0 && h < (int)(sizeof(g_ini)/sizeof(g_ini[0])) && g_ini[h].in_use) return g_ini[h].dict;
-    return NULL;
-}
-static int ini_free_handle(int h) {
-    if (h <= 0 || h >= (int)(sizeof(g_ini)/sizeof(g_ini[0])) || !g_ini[h].in_use) return 0;
-    if (g_ini[h].dict) iniparser_freedict(g_ini[h].dict);
-    g_ini[h].dict = NULL;
-    g_ini[h].in_use = 0;
-    return 1;
-}
+/* Single global registry (defined in handles.c) */
+extern IniSlot g_ini[64];
 
-/* Helper to build section:key string safely into provided buffer */
-static inline void ini_make_full_key(char *buf, size_t cap, const char *sec, const char *key) {
-    if (!buf || cap == 0) return;
-    if (!sec) sec = "";
-    if (!key) key = "";
-    /* iniparser expects "section:key" */
-    snprintf(buf, cap, "%s:%s", sec, key);
-}
+/* Registry API (implemented in handles.c) */
+int ini_alloc_handle(dictionary *d);
+dictionary* ini_get(int h);
+int ini_free_handle(int h);
+
+/* Helper to build section:key string safely into provided buffer (implemented in handles.c) */
+void ini_make_full_key(char *buf, size_t cap, const char *sec, const char *key);
 #endif /* FUN_WITH_INI */

src/vm/ini/set.c

@@ -23,9 +23,16 @@ case OP_INI_SET: {
     if (d && sec && key) {
         char *valstr = value_to_string_alloc(&vval);
         if (valstr) {
-            char full[1024]; snprintf(full, sizeof(full), "%s:%s", sec, key);
+            char full[1024]; char alt[1024];
+            ini_make_full_key(full, sizeof(full), sec, key);
+            memcpy(alt, full, sizeof(alt));
+            for (size_t i = 0; i < sizeof(alt) && alt[i]; ++i) { if (alt[i] == ':') { alt[i] = '.'; break; } }
             /* iniparser 4.x does not expose iniparser_set; use dictionary_set */
-            if (dictionary_set(d, full, valstr) == 0) ok = 1; /* 0 means success */
+            if (dictionary_set(d, full, valstr) == 0) {
+                ok = 1; /* 0 means success */
+            } else if (dictionary_set(d, alt, valstr) == 0) {
+                ok = 1;
+            }
             free(valstr);
         }
     }

src/vm/ini/unset.c

@@ -20,9 +20,13 @@ case OP_INI_UNSET: {
     const char *sec = (vsec.type==VAL_STRING)?vsec.s:NULL;
     int ok = 0;
     if (d && sec && key) {
-        char full[1024]; snprintf(full, sizeof(full), "%s:%s", sec, key);
-        /* iniparser 4.2.6 dictionary_unset returns void; assume success if inputs are valid */
+        char full[1024]; char alt[1024];
+        ini_make_full_key(full, sizeof(full), sec, key);
+        memcpy(alt, full, sizeof(alt));
+        for (size_t i = 0; i < sizeof(alt) && alt[i]; ++i) { if (alt[i] == ':') { alt[i] = '.'; break; } }
+        /* iniparser 4.2.6 dictionary_unset returns void; remove both forms */
         dictionary_unset(d, full);
+        dictionary_unset(d, alt);
         ok = 1;
     }
     free_value(vkey); free_value(vsec); free_value(vh);