Added support for libSQL as an compatible alternative for SQLite. (0.33.0)

src/bytecode.c

@@ -152,6 +152,10 @@ static const char *opcode_name(OpCode op) {
         case OP_SQLITE_CLOSE: return "SQLITE_CLOSE";
         case OP_SQLITE_EXEC: return "SQLITE_EXEC";
         case OP_SQLITE_QUERY: return "SQLITE_QUERY";
+        case OP_LIBSQL_OPEN: return "LIBSQL_OPEN";
+        case OP_LIBSQL_CLOSE: return "LIBSQL_CLOSE";
+        case OP_LIBSQL_EXEC: return "LIBSQL_EXEC";
+        case OP_LIBSQL_QUERY: return "LIBSQL_QUERY";
         case OP_PCSC_ESTABLISH: return "PCSC_ESTABLISH";
         case OP_PCSC_RELEASE: return "PCSC_RELEASE";
         case OP_PCSC_LIST_READERS: return "PCSC_LIST_READERS";

src/bytecode.h

@@ -158,6 +158,12 @@ typedef enum {
     OP_SQLITE_EXEC,      // pops sql, handle; pushes sqlite rc (0=OK)
     OP_SQLITE_QUERY,     // pops sql, handle; pushes array<map>
 
+    // libsql (optional, independent)
+    OP_LIBSQL_OPEN,      // pops url/path; pushes handle (>0) or 0
+    OP_LIBSQL_CLOSE,     // pops handle; pushes Nil
+    OP_LIBSQL_EXEC,      // pops sql, handle; pushes rc (0=OK)
+    OP_LIBSQL_QUERY,     // pops sql, handle; pushes array<map>
+
     // PCSC (smart card) opcodes
     OP_PCSC_ESTABLISH,    // returns context id (>0) or 0
     OP_PCSC_RELEASE,      // pops ctx id; returns 1/0

src/parser.c

@@ -824,6 +824,43 @@ static int emit_primary(Bytecode *bc, const char *src, size_t len, size_t *pos)
                 free(name);
                 return 1;
             }
+            /* libsql builtins (independent extension) */
+            if (strcmp(name, "libsql_open") == 0) {
+                (*pos)++; /* '(' */
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_open expects (url_or_path)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ')')) { parser_fail(*pos, "Expected ')' after libsql_open arg"); free(name); return 0; }
+                bytecode_add_instruction(bc, OP_LIBSQL_OPEN, 0);
+                free(name);
+                return 1;
+            }
+            if (strcmp(name, "libsql_close") == 0) {
+                (*pos)++; /* '(' */
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_close expects (handle)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ')')) { parser_fail(*pos, "Expected ')' after libsql_close arg"); free(name); return 0; }
+                bytecode_add_instruction(bc, OP_LIBSQL_CLOSE, 0);
+                free(name);
+                return 1;
+            }
+            if (strcmp(name, "libsql_exec") == 0) {
+                (*pos)++; /* '(' */
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_exec expects (handle, sql)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ',')) { parser_fail(*pos, "libsql_exec expects (handle, sql)"); free(name); return 0; }
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_exec expects (handle, sql)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ')')) { parser_fail(*pos, "Expected ')' after libsql_exec args"); free(name); return 0; }
+                bytecode_add_instruction(bc, OP_LIBSQL_EXEC, 0);
+                free(name);
+                return 1;
+            }
+            if (strcmp(name, "libsql_query") == 0) {
+                (*pos)++; /* '(' */
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_query expects (handle, sql)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ',')) { parser_fail(*pos, "libsql_query expects (handle, sql)"); free(name); return 0; }
+                if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "libsql_query expects (handle, sql)"); free(name); return 0; }
+                if (!consume_char(src, len, pos, ')')) { parser_fail(*pos, "Expected ')' after libsql_query args"); free(name); return 0; }
+                bytecode_add_instruction(bc, OP_LIBSQL_QUERY, 0);
+                free(name);
+                return 1;
+            }
             if (strcmp(name, "curl_post") == 0) {
                 (*pos)++; /* '(' */
                 if (!emit_expression(bc, src, len, pos)) { parser_fail(*pos, "curl_post expects (url, body)"); free(name); return 0; }

src/vm.c

@@ -17,6 +17,10 @@
 #include <sqlite3.h>
 #include "vm/sqlite/common.c"
 #endif
+#ifdef FUN_WITH_LIBSQL
+#include <sqlite3.h> /* libsql exposes sqlite3-compatible C API */
+#include "vm/libsql/common.c"
+#endif
 #include "vm.h"
 #include "value.h"
 #include <stdio.h>
@@ -713,6 +717,12 @@ void vm_run(VM *vm, Bytecode *entry) {
             #include "vm/sqlite/exec.c"
             #include "vm/sqlite/query.c"
 
+            /* libsql ops (independent) */
+            #include "vm/libsql/open.c"
+            #include "vm/libsql/close.c"
+            #include "vm/libsql/exec.c"
+            #include "vm/libsql/query.c"
+
             /* PCRE2 ops */
             #include "vm/pcre2/test.c"
             #include "vm/pcre2/match.c"

src/vm.h

@@ -41,6 +41,7 @@ static const char *opcode_names[] = {
     "JSON_PARSE","JSON_STRINGIFY","JSON_FROM_FILE","JSON_TO_FILE",
     "CURL_GET","CURL_POST","CURL_DOWNLOAD",
     "SQLITE_OPEN","SQLITE_CLOSE","SQLITE_EXEC","SQLITE_QUERY",
+    "LIBSQL_OPEN","LIBSQL_CLOSE","LIBSQL_EXEC","LIBSQL_QUERY",
     "PCSC_ESTABLISH","PCSC_RELEASE","PCSC_LIST_READERS","PCSC_CONNECT","PCSC_DISCONNECT","PCSC_TRANSMIT",
     "PCRE2_TEST","PCRE2_MATCH","PCRE2_FINDALL",
     "SOCK_TCP_LISTEN","SOCK_TCP_ACCEPT","SOCK_TCP_CONNECT","SOCK_SEND","SOCK_RECV","SOCK_CLOSE","SOCK_UNIX_LISTEN","SOCK_UNIX_CONNECT",

src/vm/libsql/close.c

@@ -0,0 +1,32 @@
+/*
+ * 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
+ *
+ * Added: 2025-11-26
+ */
+
+/**
+ * OP_LIBSQL_CLOSE: (handle:int) -> Nil
+ */
+case OP_LIBSQL_CLOSE: {
+#ifdef FUN_WITH_LIBSQL
+    Value vh = pop_value(vm);
+    int hid = (int)vh.i;
+    free_value(vh);
+    LibSqlHandle *h = libsql_reg_get(hid);
+    if (h && h->db) {
+        sqlite3_close(h->db);
+        h->db = NULL;
+        libsql_reg_del(hid);
+    }
+    push_value(vm, make_nil());
+#else
+    Value v = pop_value(vm); free_value(v);
+    push_value(vm, make_nil());
+#endif
+    break;
+}

src/vm/libsql/common.c

@@ -0,0 +1,55 @@
+/*
+ * 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
+ *
+ * Added: 2025-11-26
+ */
+
+#ifdef FUN_WITH_LIBSQL
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sqlite3.h> /* libsql provides a sqlite3-compatible C API */
+
+typedef struct LibSqlHandle {
+    int id;
+    sqlite3 *db;
+    struct LibSqlHandle *next;
+} LibSqlHandle;
+
+static LibSqlHandle *g_libsql_handles = NULL;
+static int g_libsql_next_id = 1;
+
+static LibSqlHandle *libsql_reg_add(sqlite3 *db) {
+    LibSqlHandle *h = (LibSqlHandle*)malloc(sizeof(LibSqlHandle));
+    if (!h) return NULL;
+    h->id = g_libsql_next_id++;
+    h->db = db;
+    h->next = g_libsql_handles;
+    g_libsql_handles = h;
+    return h;
+}
+
+static LibSqlHandle *libsql_reg_get(int id) {
+    LibSqlHandle *p = g_libsql_handles;
+    while (p) { if (p->id == id) return p; p = p->next; }
+    return NULL;
+}
+
+static void libsql_reg_del(int id) {
+    LibSqlHandle **pp = &g_libsql_handles;
+    while (*pp) {
+        if ((*pp)->id == id) {
+            LibSqlHandle *dead = *pp;
+            *pp = (*pp)->next;
+            free(dead);
+            return;
+        }
+        pp = &((*pp)->next);
+    }
+}
+#endif /* FUN_WITH_LIBSQL */

src/vm/libsql/exec.c

@@ -0,0 +1,36 @@
+/*
+ * 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
+ *
+ * Added: 2025-11-26
+ */
+
+/**
+ * OP_LIBSQL_EXEC: (handle:int, sql:string) -> int rc (0=OK)
+ */
+case OP_LIBSQL_EXEC: {
+#ifdef FUN_WITH_LIBSQL
+    Value vsql = pop_value(vm);
+    Value vh = pop_value(vm);
+    int hid = (int)vh.i;
+    char *sql = value_to_string_alloc(&vsql);
+    free_value(vh);
+    free_value(vsql);
+    LibSqlHandle *h = libsql_reg_get(hid);
+    if (!h || !h->db || !sql) { if (sql) free(sql); push_value(vm, make_int(SQLITE_MISUSE)); break; }
+    char *errmsg = NULL;
+    int rc = sqlite3_exec(h->db, sql, NULL, NULL, &errmsg);
+    if (errmsg) sqlite3_free(errmsg);
+    free(sql);
+    push_value(vm, make_int(rc));
+#else
+    Value v1 = pop_value(vm); free_value(v1);
+    Value v2 = pop_value(vm); free_value(v2);
+    push_value(vm, make_int(-1));
+#endif
+    break;
+}

src/vm/libsql/open.c

@@ -0,0 +1,37 @@
+/*
+ * 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
+ *
+ * Added: 2025-11-26
+ */
+
+/**
+ * OP_LIBSQL_OPEN: (url_or_path:string) -> handle:int (>0) or 0 on error
+ */
+case OP_LIBSQL_OPEN: {
+#ifdef FUN_WITH_LIBSQL
+    Value vpath = pop_value(vm);
+    char *path = value_to_string_alloc(&vpath);
+    free_value(vpath);
+    if (!path) { push_value(vm, make_int(0)); break; }
+    sqlite3 *db = NULL;
+    int rc = sqlite3_open(path, &db);
+    free(path);
+    if (rc != SQLITE_OK || !db) {
+        if (db) sqlite3_close(db);
+        push_value(vm, make_int(0));
+        break;
+    }
+    LibSqlHandle *h = libsql_reg_add(db);
+    if (!h) { sqlite3_close(db); push_value(vm, make_int(0)); break; }
+    push_value(vm, make_int(h->id));
+#else
+    Value v = pop_value(vm); free_value(v);
+    push_value(vm, make_int(0));
+#endif
+    break;
+}

src/vm/libsql/query.c

@@ -0,0 +1,60 @@
+/*
+ * 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
+ *
+ * Added: 2025-11-26
+ */
+
+/**
+ * OP_LIBSQL_QUERY: (handle:int, sql:string) -> array<map<string,any>>
+ */
+case OP_LIBSQL_QUERY: {
+#ifdef FUN_WITH_LIBSQL
+    Value vsql = pop_value(vm);
+    Value vh = pop_value(vm);
+    int hid = (int)vh.i;
+    char *sql = value_to_string_alloc(&vsql);
+    free_value(vh);
+    free_value(vsql);
+    LibSqlHandle *h = libsql_reg_get(hid);
+    if (!h || !h->db || !sql) { if (sql) free(sql); push_value(vm, make_array_from_values(NULL, 0)); break; }
+    sqlite3_stmt *stmt = NULL;
+    if (sqlite3_prepare_v2(h->db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        free(sql);
+        push_value(vm, make_array_from_values(NULL, 0));
+        break;
+    }
+    free(sql);
+    Value rows = make_array_from_values(NULL, 0);
+    int ncols = sqlite3_column_count(stmt);
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        Value row = make_map_empty();
+        for (int i = 0; i < ncols; i++) {
+            const char *name = sqlite3_column_name(stmt, i);
+            int type = sqlite3_column_type(stmt, i);
+            Value kv;
+            switch (type) {
+                case SQLITE_INTEGER: kv = make_int((int64_t)sqlite3_column_int64(stmt, i)); break;
+                case SQLITE_FLOAT:   kv = make_float(sqlite3_column_double(stmt, i)); break;
+                case SQLITE_TEXT:    kv = make_string((const char*)sqlite3_column_text(stmt, i)); break;
+                case SQLITE_NULL:    kv = make_nil(); break;
+                default:             kv = make_nil(); break; /* ignore blobs for now */
+            }
+            (void)map_set(&row, name ? name : "", kv);
+        }
+        (void)array_push(&rows, row);
+        /* Do NOT free 'row' here; owned by rows array. */
+    }
+    sqlite3_finalize(stmt);
+    push_value(vm, rows);
+#else
+    Value v1 = pop_value(vm); free_value(v1);
+    Value v2 = pop_value(vm); free_value(v2);
+    push_value(vm, make_array_from_values(NULL, 0));
+#endif
+    break;
+}