CppSharp/src/Generator/Generators/QuickJS/Runtime/CppSharp_QuickJS.h

// ----------------------------------------------------------------------------
// <auto-generated>
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
// </auto-generated>
// ----------------------------------------------------------------------------

extern "C"
{

#include <quickjs.h>
#include <cutils.h>

#if defined(__GNUC__) || defined(__clang__)
#define js_force_inline       inline __attribute__((always_inline))
#else
#define js_force_inline  inline
#endif

#define countof(x) (sizeof(x) / sizeof((x)[0]))

enum
{
    __JS_ATOM_NULL = JS_ATOM_NULL,
#define DEF(name, str) JS_ATOM_ ## name,
#include <quickjs-atom.h>
#undef DEF
    JS_ATOM_END,
};

struct JS_SignalContext
{
    // TODO: List
    JSValue function;
    JSValue link;
    JSContext *ctx;
};

typedef int JS_EventId;
typedef int JS_ClassId;
typedef DynBuf JS_EventMap;

struct JS_EventEntry
{
    JS_EventId eventId;
    JSValue value;
};

static JS_EventMap* JS_Interop_InitEventMap(JS_EventMap* map)
{
    dbuf_init(map);
    return map;
}

static void JS_Interop_FreeEventMap(JSContext* ctx, JS_EventMap* map)
{
    JS_EventEntry* events = (JS_EventEntry*) map->buf;
    int numEvents = (map->size / sizeof(JS_EventEntry));
    for (int i = 0; i < numEvents; i++)
        if (!JS_IsUndefined(events[i].value))
            JS_FreeValue(ctx, events[i].value);

    dbuf_free(map);
}

static int JS_Interop_BinarySearch(JS_EventEntry* arr, int l, int r, JS_EventId id)
{
    if (r >= l) {
        int mid = l + (r - l) / 2;

        // If the element is present at the middle itself
        if (arr[mid].eventId == id)
            return mid;

        // If element is smaller than mid, then it can only be present in left subarray
        if (arr[mid].eventId > id)
            return JS_Interop_BinarySearch(arr, l, mid - 1, id);

        // Else the element can only be present in right subarray
        return JS_Interop_BinarySearch(arr, mid + 1, r, id);
    }

    // We reach here when element is not present in array
    return -1;
}

static JSValue JS_Interop_FindEvent(JS_EventMap* map, JS_EventId eventId)
{
    JS_EventEntry* events = (JS_EventEntry*) map->buf;
    int numEvents = (map->size / sizeof(JS_EventEntry));
    if (numEvents == 0)
        return JS_UNDEFINED;

    int index = JS_Interop_BinarySearch(events, 0, numEvents, eventId);
    return index >= 0 ? events[index].value : JS_UNDEFINED;
}

static int JS_Interop_InsertEvent(JS_EventMap* map, JS_EventId eventId,
    JSValue value)
{
    JS_EventEntry* events = (JS_EventEntry*) map->buf;
    int numEvents = (map->size / sizeof(JS_EventEntry));

    int index = 0;
    for (int i = 0; i < numEvents; i++)
    {
        if (events[i].eventId == eventId) { index=-1; break; }
        if (events[i].eventId > eventId) { index = i; break; }
        index++;
    }

    if (index == -1)
        return -1;

    JS_EventEntry entry;
    entry.eventId = eventId;
    entry.value = value;

    dbuf_write(map, index * sizeof(JS_EventEntry), (const uint8_t*) &entry,
        sizeof(JS_EventEntry));

    return 0;
}

static JSValue JS_Interop_InvokeConstructor(JSContext *ctx, JS_ClassId eventId,
    JSValue argv[], int argc)
{
    // TODO: Error handling.
    JSValue proto = JS_GetClassProto(ctx, eventId);
    JSValue ctor = JS_GetProperty(ctx, proto, JS_ATOM_constructor);
    JSValue instance = JS_CallConstructor(ctx, ctor, argc, argv);
    JS_FreeValue(ctx, ctor);
    JS_FreeValue(ctx, proto);

    return instance;
}

enum JS_Interop_InstanceKind
{
    JS_INTEROP_INSTANCE_RAW_POINTER = 1,
    JS_INTEROP_INSTANCE_SIGNAL_CONTEXT,
};

struct JS_Interop_ClassData
{
    void* instance;
    JSContext* ctx;
    JS_EventMap events;
};

static JSValue JS_Interop_InitObject(JSContext *ctx, JSValue obj, JS_Interop_InstanceKind kind,
    void* instance)
{
    switch (kind)
    {
    case JS_INTEROP_INSTANCE_RAW_POINTER:
        JS_SetOpaque(obj, instance);
        return obj;
    case JS_INTEROP_INSTANCE_SIGNAL_CONTEXT:
        JS_Interop_ClassData* data = (JS_Interop_ClassData*) js_mallocz(ctx, \
            sizeof(JS_Interop_ClassData));
        data->ctx = ctx;
        data->instance = instance;
        JS_Interop_InitEventMap(&data->events);
        JS_SetOpaque(obj, data);
        return obj;
    }

    return JS_UNDEFINED;
}

static JSValue JS_Interop_CleanupObject(JSValue obj, JS_Interop_InstanceKind kind)
{
    switch (kind)
    {
    case JS_INTEROP_INSTANCE_SIGNAL_CONTEXT:
    {
        JS_Interop_ClassData* data = (JS_Interop_ClassData*) JS_GetOpaque(obj, JS_GetClassID(obj));
        if (data)
        {
            JS_Interop_FreeEventMap(data->ctx, &data->events);
            js_free(data->ctx, data);
        }
        break;
    }
    case JS_INTEROP_INSTANCE_RAW_POINTER:
        break;
    }

    return JS_UNDEFINED;
}

static void* JS_Interop_GetInstance(JSValue obj, JS_ClassId classId, JS_Interop_InstanceKind kind)
{
    switch (kind)
    {
    case JS_INTEROP_INSTANCE_RAW_POINTER:
        return JS_GetOpaque(obj, classId);
    case JS_INTEROP_INSTANCE_SIGNAL_CONTEXT:
        JS_Interop_ClassData* data = (JS_Interop_ClassData*) JS_GetOpaque(obj, classId);
        return data != nullptr ? data->instance : nullptr;
    }

    return nullptr;
}

static JSValue JS_Interop_CreateFromInstance(JSContext* ctx, JS_ClassId classId,
    JS_Interop_InstanceKind kind, void* instance)
{
    if (instance == nullptr)
        return JS_NULL;

    // TODO: Error handling.
    JSValue obj = JS_NewObjectClass(ctx, classId);
    JS_Interop_InitObject(ctx, obj, kind, instance);

    return obj;
}

static inline JS_BOOL JS_IsInt(JSValueConst v)
{
    return JS_IsNumber(v);
}

static inline JS_BOOL JS_IsInt8(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsUInt8(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsInt16(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsUInt16(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsInt32(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsUInt32(JSValueConst v)
{
    return JS_IsInt(v);
}

static inline JS_BOOL JS_IsFloat(JSValueConst v)
{
    int tag = JS_VALUE_GET_TAG(v);
    return JS_TAG_IS_FLOAT64(tag);
}

void register_CppSharp_QuickJS(JSContext *ctx, JSModuleDef *m, bool set, int phase);

#undef js_force_inline

} // extern "C"