@neoanaloglabkk/lensfun-wasm 0.1.1

package/native/src/glib_compat.cpp

@@ -0,0 +1,799 @@
+#include "glib.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include <algorithm>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "tinyxml2.h"
+#include "utf8proc.h"
+
+struct _GDir
+{
+    DIR *dir = nullptr;
+    struct dirent *entry = nullptr;
+};
+
+struct _GPatternSpec
+{
+    std::string pattern;
+};
+
+struct _GMarkupParseContext
+{
+    const GMarkupParser *parser = nullptr;
+    gpointer user_data = nullptr;
+    GDestroyNotify user_data_dnotify = nullptr;
+    std::vector<std::string> element_stack;
+    gint current_line = 1;
+    gint current_column = 0;
+};
+
+static std::string vformat(const char *format, va_list args)
+{
+    va_list copy;
+    va_copy(copy, args);
+    const int needed = vsnprintf(nullptr, 0, format, copy);
+    va_end(copy);
+
+    if (needed <= 0)
+    {
+        return std::string();
+    }
+
+    std::string out(static_cast<size_t>(needed), '\0');
+    vsnprintf(out.data(), out.size() + 1, format, args);
+    return out;
+}
+
+static std::string xml_escape(const std::string &input)
+{
+    std::string out;
+    out.reserve(input.size());
+    for (char c : input)
+    {
+        switch (c)
+        {
+        case '&':
+            out += "&amp;";
+            break;
+        case '<':
+            out += "&lt;";
+            break;
+        case '>':
+            out += "&gt;";
+            break;
+        case '\"':
+            out += "&quot;";
+            break;
+        case '\'':
+            out += "&apos;";
+            break;
+        default:
+            out.push_back(c);
+            break;
+        }
+    }
+    return out;
+}
+
+extern "C" {
+
+void g_assertion_message(const char *expr, const char *file, int line)
+{
+    fprintf(stderr, "[glib-compat] assertion failed: %s (%s:%d)\n", expr, file, line);
+    abort();
+}
+
+void *g_malloc(gsize n_bytes)
+{
+    const gsize size = n_bytes == 0 ? 1 : n_bytes;
+    void *ptr = malloc(size);
+    if (!ptr)
+    {
+        fprintf(stderr, "[glib-compat] out of memory\n");
+        abort();
+    }
+    return ptr;
+}
+
+void *g_realloc(gpointer mem, gsize n_bytes)
+{
+    const gsize size = n_bytes == 0 ? 1 : n_bytes;
+    void *ptr = realloc(mem, size);
+    if (!ptr)
+    {
+        fprintf(stderr, "[glib-compat] out of memory\n");
+        abort();
+    }
+    return ptr;
+}
+
+void g_free(gpointer mem)
+{
+    free(mem);
+}
+
+gchar *g_strdup(const gchar *str)
+{
+    if (!str)
+    {
+        return nullptr;
+    }
+    const size_t len = strlen(str) + 1;
+    auto *copy = static_cast<gchar *>(g_malloc(len));
+    memcpy(copy, str, len);
+    return copy;
+}
+
+void g_mutex_lock(GMutex *mutex)
+{
+    if (mutex)
+    {
+        mutex->lock.lock();
+    }
+}
+
+void g_mutex_unlock(GMutex *mutex)
+{
+    if (mutex)
+    {
+        mutex->lock.unlock();
+    }
+}
+
+void g_static_mutex_lock(GStaticMutex *mutex)
+{
+    if (mutex)
+    {
+        mutex->lock.lock();
+    }
+}
+
+void g_static_mutex_unlock(GStaticMutex *mutex)
+{
+    if (mutex)
+    {
+        mutex->lock.unlock();
+    }
+}
+
+gchar *g_build_filename(const gchar *first_element, ...)
+{
+    if (!first_element)
+    {
+        return g_strdup("");
+    }
+
+    std::vector<std::string> parts;
+    va_list args;
+    va_start(args, first_element);
+
+    const gchar *part = first_element;
+    while (part)
+    {
+        if (*part)
+        {
+            parts.emplace_back(part);
+        }
+        part = va_arg(args, const gchar *);
+    }
+
+    va_end(args);
+
+    if (parts.empty())
+    {
+        return g_strdup("");
+    }
+
+    std::string out;
+    out.reserve(128);
+    for (size_t i = 0; i < parts.size(); ++i)
+    {
+        const std::string &p = parts[i];
+        if (i > 0 && !out.empty() && out.back() != '/')
+        {
+            out.push_back('/');
+        }
+        if (i > 0 && !p.empty() && p.front() == '/')
+        {
+            out += p.substr(1);
+        }
+        else
+        {
+            out += p;
+        }
+    }
+
+    return g_strdup(out.c_str());
+}
+
+const gchar *g_get_user_data_dir(void)
+{
+    static const char *path = "/tmp";
+    return path;
+}
+
+int g_open(const char *filename, int flags, int mode)
+{
+    return open(filename, flags, mode);
+}
+
+gboolean g_file_test(const gchar *filename, GFileTest test)
+{
+    if (!filename)
+    {
+        return FALSE;
+    }
+
+    struct stat st;
+    if (stat(filename, &st) != 0)
+    {
+        return FALSE;
+    }
+
+    if (test == G_FILE_TEST_IS_DIR)
+    {
+        return S_ISDIR(st.st_mode) ? TRUE : FALSE;
+    }
+
+    return FALSE;
+}
+
+gboolean g_file_get_contents(const gchar *filename, gchar **contents, gsize *length, GError **error)
+{
+    if (!filename || !contents)
+    {
+        if (error)
+        {
+            g_set_error(error, G_FILE_ERROR, G_FILE_ERROR_NOENT, "Invalid filename");
+        }
+        return FALSE;
+    }
+
+    std::ifstream in(filename, std::ios::binary);
+    if (!in)
+    {
+        const int code = (errno == EACCES) ? G_FILE_ERROR_ACCES : G_FILE_ERROR_NOENT;
+        if (error)
+        {
+            g_set_error(error, G_FILE_ERROR, code, "Cannot read file %s", filename);
+        }
+        return FALSE;
+    }
+
+    std::string data((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+
+    auto *buf = static_cast<gchar *>(g_malloc(data.size() + 1));
+    if (!data.empty())
+    {
+        memcpy(buf, data.data(), data.size());
+    }
+    buf[data.size()] = '\0';
+
+    *contents = buf;
+    if (length)
+    {
+        *length = data.size();
+    }
+
+    return TRUE;
+}
+
+GDir *g_dir_open(const gchar *path, guint, GError **error)
+{
+    DIR *dir = opendir(path);
+    if (!dir)
+    {
+        if (error)
+        {
+            g_set_error(error, G_FILE_ERROR, errno == EACCES ? G_FILE_ERROR_ACCES : G_FILE_ERROR_NOENT, "Cannot open directory %s", path);
+        }
+        return nullptr;
+    }
+
+    auto *gdir = static_cast<GDir *>(g_malloc(sizeof(GDir)));
+    gdir->dir = dir;
+    gdir->entry = nullptr;
+    return gdir;
+}
+
+const gchar *g_dir_read_name(GDir *dir)
+{
+    if (!dir || !dir->dir)
+    {
+        return nullptr;
+    }
+
+    while ((dir->entry = readdir(dir->dir)) != nullptr)
+    {
+        const char *name = dir->entry->d_name;
+        if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
+        {
+            continue;
+        }
+        return name;
+    }
+
+    return nullptr;
+}
+
+void g_dir_close(GDir *dir)
+{
+    if (!dir)
+    {
+        return;
+    }
+    if (dir->dir)
+    {
+        closedir(dir->dir);
+    }
+    g_free(dir);
+}
+
+GPatternSpec *g_pattern_spec_new(const gchar *pattern)
+{
+    auto *spec = static_cast<GPatternSpec *>(g_malloc(sizeof(GPatternSpec)));
+    new (&spec->pattern) std::string(pattern ? pattern : "");
+    return spec;
+}
+
+gboolean g_pattern_match(GPatternSpec *pspec, gsize, const gchar *string, const gchar *)
+{
+    if (!pspec || !string)
+    {
+        return FALSE;
+    }
+    return fnmatch(pspec->pattern.c_str(), string, 0) == 0 ? TRUE : FALSE;
+}
+
+void g_pattern_spec_free(GPatternSpec *pspec)
+{
+    if (!pspec)
+    {
+        return;
+    }
+    pspec->pattern.~basic_string();
+    g_free(pspec);
+}
+
+GString *g_string_sized_new(gsize dfl_size)
+{
+    auto *str = static_cast<GString *>(g_malloc(sizeof(GString)));
+    str->allocated_len = std::max<gsize>(dfl_size + 1, 16);
+    str->len = 0;
+    str->str = static_cast<gchar *>(g_malloc(str->allocated_len));
+    str->str[0] = '\0';
+    return str;
+}
+
+GString *g_string_append(GString *string, const gchar *val)
+{
+    if (!string || !val)
+    {
+        return string;
+    }
+    const gsize add_len = strlen(val);
+    const gsize needed = string->len + add_len + 1;
+    if (needed > string->allocated_len)
+    {
+        gsize next = string->allocated_len;
+        while (next < needed)
+        {
+            next *= 2;
+        }
+        string->str = static_cast<gchar *>(g_realloc(string->str, next));
+        string->allocated_len = next;
+    }
+
+    memcpy(string->str + string->len, val, add_len + 1);
+    string->len += add_len;
+    return string;
+}
+
+gchar *g_string_free(GString *string, gboolean free_segment)
+{
+    if (!string)
+    {
+        return nullptr;
+    }
+
+    gchar *segment = string->str;
+    if (free_segment)
+    {
+        g_free(segment);
+        segment = nullptr;
+    }
+
+    g_free(string);
+    return segment;
+}
+
+GPtrArray *g_ptr_array_new(void)
+{
+    auto *array = static_cast<GPtrArray *>(g_malloc(sizeof(GPtrArray)));
+    array->pdata = nullptr;
+    array->len = 0;
+    array->allocated_len = 0;
+    return array;
+}
+
+void g_ptr_array_set_size(GPtrArray *array, gint length)
+{
+    if (!array || length < 0)
+    {
+        return;
+    }
+
+    const guint target = static_cast<guint>(length);
+    if (target > array->allocated_len)
+    {
+        guint next = array->allocated_len == 0 ? 8U : array->allocated_len;
+        while (next < target)
+        {
+            next *= 2U;
+        }
+        array->pdata = static_cast<gpointer *>(g_realloc(array->pdata, sizeof(gpointer) * next));
+        for (guint i = array->allocated_len; i < next; ++i)
+        {
+            array->pdata[i] = nullptr;
+        }
+        array->allocated_len = next;
+    }
+
+    if (target > array->len)
+    {
+        for (guint i = array->len; i < target; ++i)
+        {
+            array->pdata[i] = nullptr;
+        }
+    }
+
+    array->len = target;
+}
+
+gpointer *g_ptr_array_free(GPtrArray *array, gboolean free_segment)
+{
+    if (!array)
+    {
+        return nullptr;
+    }
+
+    gpointer *segment = array->pdata;
+    if (free_segment)
+    {
+        g_free(segment);
+        segment = nullptr;
+    }
+
+    g_free(array);
+    return segment;
+}
+
+void g_warning(const gchar *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    std::string message = vformat(format, args);
+    va_end(args);
+    fprintf(stderr, "%s\n", message.c_str());
+}
+
+void g_set_error(GError **err, gint domain, gint code, const gchar *format, ...)
+{
+    if (!err)
+    {
+        return;
+    }
+
+    va_list args;
+    va_start(args, format);
+    std::string message = vformat(format, args);
+    va_end(args);
+
+    auto *e = static_cast<GError *>(g_malloc(sizeof(GError)));
+    e->domain = domain;
+    e->code = code;
+    e->message = g_strdup(message.c_str());
+    *err = e;
+}
+
+gunichar g_utf8_get_char(const gchar *p)
+{
+    if (!p || *p == '\0')
+    {
+        return 0;
+    }
+
+    utf8proc_int32_t codepoint = 0;
+    utf8proc_ssize_t len = utf8proc_iterate(reinterpret_cast<const utf8proc_uint8_t *>(p), -1, &codepoint);
+    if (len < 0)
+    {
+        return static_cast<gunichar>(*reinterpret_cast<const unsigned char *>(p));
+    }
+    return static_cast<gunichar>(codepoint);
+}
+
+const gchar *g_utf8_next_char(const gchar *p)
+{
+    if (!p || *p == '\0')
+    {
+        return p;
+    }
+
+    const int width = utf8proc_charwidth(static_cast<utf8proc_int8_t>(*p));
+    if (width <= 0)
+    {
+        return p + 1;
+    }
+    return p + width;
+}
+
+gchar *g_utf8_casefold(const gchar *str, gssize len)
+{
+    if (!str)
+    {
+        return nullptr;
+    }
+
+    utf8proc_uint8_t *mapped = nullptr;
+    utf8proc_ssize_t rc = utf8proc_map(
+        reinterpret_cast<const utf8proc_uint8_t *>(str),
+        static_cast<utf8proc_ssize_t>(len),
+        &mapped,
+        static_cast<utf8proc_option_t>(UTF8PROC_CASEFOLD | UTF8PROC_STABLE));
+
+    if (rc < 0 || !mapped)
+    {
+        return g_strdup("");
+    }
+
+    return reinterpret_cast<gchar *>(mapped);
+}
+
+gboolean g_unichar_isspace(gunichar c)
+{
+    if (c <= 0x7F)
+    {
+        return (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f' || c == '\v') ? TRUE : FALSE;
+    }
+
+    const utf8proc_category_t cat = utf8proc_category(static_cast<utf8proc_int32_t>(c));
+    return (cat == UTF8PROC_CATEGORY_ZS || cat == UTF8PROC_CATEGORY_ZL || cat == UTF8PROC_CATEGORY_ZP) ? TRUE : FALSE;
+}
+
+gunichar g_unichar_tolower(gunichar c)
+{
+    return static_cast<gunichar>(utf8proc_tolower(static_cast<utf8proc_int32_t>(c)));
+}
+
+static gboolean walk_element(
+    GMarkupParseContext *context,
+    tinyxml2::XMLElement *element,
+    GError **error)
+{
+    context->element_stack.emplace_back(element->Name() ? element->Name() : "");
+    context->current_line = element->GetLineNum();
+    context->current_column = 0;
+
+    std::vector<const gchar *> attr_names;
+    std::vector<const gchar *> attr_values;
+
+    for (const tinyxml2::XMLAttribute *attr = element->FirstAttribute(); attr; attr = attr->Next())
+    {
+        attr_names.push_back(attr->Name());
+        attr_values.push_back(attr->Value());
+    }
+    attr_names.push_back(nullptr);
+    attr_values.push_back(nullptr);
+
+    if (context->parser && context->parser->start_element)
+    {
+        context->parser->start_element(
+            context,
+            context->element_stack.back().c_str(),
+            attr_names.data(),
+            attr_values.data(),
+            context->user_data,
+            error);
+
+        if (error && *error)
+        {
+            context->element_stack.pop_back();
+            return FALSE;
+        }
+    }
+
+    for (tinyxml2::XMLNode *child = element->FirstChild(); child; child = child->NextSibling())
+    {
+        if (auto *text = child->ToText())
+        {
+            if (context->parser && context->parser->text)
+            {
+                const char *value = text->Value();
+                if (value)
+                {
+                    context->current_line = text->GetLineNum();
+                    context->parser->text(context, value, strlen(value), context->user_data, error);
+                    if (error && *error)
+                    {
+                        context->element_stack.pop_back();
+                        return FALSE;
+                    }
+                }
+            }
+            continue;
+        }
+
+        if (auto *nested = child->ToElement())
+        {
+            if (!walk_element(context, nested, error))
+            {
+                context->element_stack.pop_back();
+                return FALSE;
+            }
+        }
+    }
+
+    if (context->parser && context->parser->end_element)
+    {
+        context->parser->end_element(
+            context,
+            context->element_stack.back().c_str(),
+            context->user_data,
+            error);
+        if (error && *error)
+        {
+            context->element_stack.pop_back();
+            return FALSE;
+        }
+    }
+
+    context->element_stack.pop_back();
+    return TRUE;
+}
+
+GMarkupParseContext *g_markup_parse_context_new(
+    const GMarkupParser *parser,
+    GMarkupParseFlags,
+    gpointer user_data,
+    GDestroyNotify user_data_dnotify)
+{
+    auto *ctx = static_cast<GMarkupParseContext *>(g_malloc(sizeof(GMarkupParseContext)));
+    new (ctx) GMarkupParseContext();
+    ctx->parser = parser;
+    ctx->user_data = user_data;
+    ctx->user_data_dnotify = user_data_dnotify;
+    return ctx;
+}
+
+gboolean g_markup_parse_context_parse(
+    GMarkupParseContext *context,
+    const gchar *text,
+    gssize text_len,
+    GError **error)
+{
+    if (!context || !text)
+    {
+        if (error)
+        {
+            g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "Invalid markup input");
+        }
+        return FALSE;
+    }
+
+    tinyxml2::XMLDocument doc;
+    tinyxml2::XMLError rc;
+    if (text_len < 0)
+    {
+        rc = doc.Parse(text);
+    }
+    else
+    {
+        rc = doc.Parse(text, static_cast<size_t>(text_len));
+    }
+
+    if (rc != tinyxml2::XML_SUCCESS)
+    {
+        context->current_line = doc.ErrorLineNum();
+        if (error)
+        {
+            g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "%s", doc.ErrorStr());
+        }
+        return FALSE;
+    }
+
+    for (tinyxml2::XMLElement *root = doc.FirstChildElement(); root; root = root->NextSiblingElement())
+    {
+        if (!walk_element(context, root, error))
+        {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+void g_markup_parse_context_free(GMarkupParseContext *context)
+{
+    if (!context)
+    {
+        return;
+    }
+
+    if (context->user_data_dnotify)
+    {
+        context->user_data_dnotify(context->user_data);
+    }
+
+    context->~_GMarkupParseContext();
+    g_free(context);
+}
+
+const gchar *g_markup_parse_context_get_element(GMarkupParseContext *context)
+{
+    if (!context || context->element_stack.empty())
+    {
+        return nullptr;
+    }
+
+    return context->element_stack.back().c_str();
+}
+
+void g_markup_parse_context_get_position(GMarkupParseContext *context, gint *line_number, gint *char_number)
+{
+    if (!context)
+    {
+        if (line_number)
+        {
+            *line_number = 1;
+        }
+        if (char_number)
+        {
+            *char_number = 0;
+        }
+        return;
+    }
+
+    if (line_number)
+    {
+        *line_number = context->current_line;
+    }
+    if (char_number)
+    {
+        *char_number = context->current_column;
+    }
+}
+
+gchar *g_markup_vprintf_escaped(const gchar *format, va_list args)
+{
+    if (!format)
+    {
+        return g_strdup("");
+    }
+
+    std::string raw = vformat(format, args);
+    std::string escaped = xml_escape(raw);
+    return g_strdup(escaped.c_str());
+}
+
+gchar *g_markup_printf_escaped(const gchar *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    gchar *result = g_markup_vprintf_escaped(format, args);
+    va_end(args);
+    return result;
+}
+
+} // extern "C"