feat: publish Dever core with project scaffolding and versioned AI skills

test/native-runtime-abi/async-operations-driver.c

@@ -0,0 +1,470 @@
+#define _POSIX_C_SOURCE 200809L
+#include "runtime.h"
+
+#include <stdint.h>
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+static _Atomic int unit_destroy_count;
+static _Atomic int blocking_done_count;
+static _Atomic int group_sync_done_count;
+
+typedef struct {
+    DeverRtPollState *poll;
+    void *output;
+    void *fault;
+    DeverRtAsyncOp *operation;
+    DeverRtAsyncOp *blocked_send;
+    DeverRtAsyncTask *task;
+    DeverRtAsyncGroup *group;
+    DeverRtAsyncChannel *channel;
+    uint32_t phase;
+    uint8_t done;
+    uint8_t pending;
+    uint8_t group_pending;
+} Frame;
+
+static void move_int(void *source, void *destination) {
+    *(int64_t *)destination = *(int64_t *)source;
+    *(int64_t *)source = 0;
+}
+
+static void drop_int(void *value) { (void)value; }
+static void move_unit(void *source, void *destination) { (void)source; (void)destination; }
+static void drop_unit(void *value) { (void)value; }
+
+typedef struct {
+    uint8_t present;
+    int64_t value;
+} OptionalInt;
+
+static void move_optional(void *source, void *destination) {
+    OptionalInt *old = source;
+    OptionalInt *new_value = destination;
+    new_value->present = old->present;
+    new_value->value = old->value;
+    old->present = 0;
+    old->value = 0;
+}
+
+static const DeverRtOwnedType integer = { 8, 8, move_int, drop_int, 1 };
+static const DeverRtOwnedType unit = { 0, 1, move_unit, drop_unit, 1 };
+static const DeverRtOwnedType optional_integer = {
+    sizeof(OptionalInt), _Alignof(OptionalInt), move_optional, drop_int, 1
+};
+
+static void *create(DeverRtPollState *poll, const void *input, void *output, void *fault) {
+    (void)input;
+    Frame *frame = calloc(1, sizeof(*frame));
+    if (frame) {
+        frame->poll = poll;
+        frame->output = output;
+        frame->fault = fault;
+    }
+    return frame;
+}
+
+static void destroy(void *pointer) {
+    Frame *frame = pointer;
+    if (frame->operation) dever_rt_v1_async_op_release(frame->operation);
+    if (frame->blocked_send) dever_rt_v1_async_op_release(frame->blocked_send);
+    if (frame->task) dever_rt_v1_async_task_release(frame->task);
+    if (frame->group) dever_rt_v1_async_group_release(frame->group);
+    if (frame->channel) dever_rt_v1_async_channel_release(frame->channel);
+    free(frame);
+}
+
+static void destroy_unit(void *pointer) {
+    atomic_fetch_add(&unit_destroy_count, 1);
+    destroy(pointer);
+}
+
+static uint8_t done(void *pointer) { return ((Frame *)pointer)->done; }
+
+static void complete(Frame *frame, uint32_t status) {
+    frame->done = 1;
+    dever_rt_v1_async_complete(frame->poll, status);
+}
+
+static void resume_child(void *pointer, uint8_t has_value, int64_t delay) {
+    Frame *frame = pointer;
+    DeverRtBuffer error = { 0 };
+    if (!frame->operation) frame->operation = dever_rt_v1_async_sleep(delay);
+    uint32_t status = dever_rt_v1_async_op_poll(frame->poll, frame->operation,
+                                                 NULL, NULL, NULL, &error);
+    if (status == DEVER_RT_ASYNC_PENDING) return;
+    if (status != DEVER_RT_ASYNC_READY_OK) abort();
+    dever_rt_v1_async_op_release(frame->operation);
+    frame->operation = NULL;
+    if (has_value) *(int64_t *)frame->output = 7;
+    complete(frame, DEVER_RT_ASYNC_READY_OK);
+}
+
+static void value_resume(void *pointer) { resume_child(pointer, 1, 2); }
+static void unit_resume(void *pointer) { resume_child(pointer, 0, 1000); }
+static void fault_resume(void *pointer) {
+    Frame *frame = pointer;
+    *(int64_t *)frame->fault = 99;
+    complete(frame, DEVER_RT_ASYNC_READY_FAULT);
+}
+
+static const DeverRtAsyncFunction value_child = {
+    &integer, &integer, create, value_resume, destroy, done, 1
+};
+static const DeverRtAsyncFunction unit_child = {
+    &unit, &integer, create, unit_resume, destroy_unit, done, 1
+};
+static const DeverRtAsyncFunction fault_child = {
+    &unit, &integer, create, fault_resume, destroy, done, 1
+};
+
+static uint32_t twice(void *input, void *output, void *fault) {
+    (void)fault;
+    struct timespec delay = { 0, 80000000 };
+    nanosleep(&delay, NULL);
+    *(int64_t *)output = *(int64_t *)input * 2;
+    atomic_fetch_add(&blocking_done_count, 1);
+    return 0;
+}
+
+static const DeverRtSyncFunction synchronous_twice = {
+    &integer, &integer, &integer, twice, 1
+};
+
+static uint32_t group_sync(void *input, void *output, void *fault) {
+    (void)output;
+    (void)fault;
+    if (*(int64_t *)input != 21) abort();
+    atomic_fetch_add(&group_sync_done_count, 1);
+    return 0;
+}
+
+static const DeverRtSyncFunction synchronous_unit = {
+    &integer, &unit, &integer, group_sync, 1
+};
+
+static uint32_t poll(Frame *frame, DeverRtAsyncOp *operation, void *output,
+                     uint8_t *present, void *fault) {
+    DeverRtBuffer error = { 0 };
+    uint32_t status = dever_rt_v1_async_op_poll(frame->poll, operation,
+                                                 output, present, fault, &error);
+    if (status == DEVER_RT_ASYNC_PENDING) frame->pending = 1;
+    if (error.ptr) dever_rt_v1_buffer_free(error.ptr, error.len);
+    return status;
+}
+
+static void root_resume(void *pointer) {
+    Frame *frame = pointer;
+    DeverRtBuffer error = { 0 };
+    uint32_t status;
+    int64_t item;
+    int64_t fault_value;
+    OptionalInt optional;
+    uint8_t present;
+    for (;;) {
+        switch (frame->phase) {
+        case 0:
+            frame->operation = dever_rt_v1_async_task_run(&value_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 1;
+            break;
+        case 1:
+            status = poll(frame, frame->operation, &frame->task, NULL, NULL);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || !frame->task) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            DeverRtAsyncTask *task_alias = dever_rt_v1_async_task_retain(frame->task);
+            if (!task_alias) abort();
+            frame->operation = dever_rt_v1_async_task_wait(frame->task);
+            frame->task = NULL;
+            dever_rt_v1_async_task_release(task_alias);
+            frame->phase = 2;
+            break;
+        case 2:
+            status = poll(frame, frame->operation, &item, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || item != 7 || !frame->pending) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            frame->operation = dever_rt_v1_async_task_run(&unit_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 12;
+            break;
+        case 12:
+            status = poll(frame, frame->operation, &frame->task, NULL, NULL);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || !frame->task) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_task_stop(frame->task);
+            frame->task = NULL;
+            frame->phase = 13;
+            break;
+        case 13:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || atomic_load(&unit_destroy_count) < 1) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_task_run(&fault_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 14;
+            break;
+        case 14:
+            status = poll(frame, frame->operation, &frame->task, NULL, NULL);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || !frame->task) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_task_wait(frame->task);
+            frame->task = NULL;
+            frame->phase = 15;
+            break;
+        case 15:
+            status = poll(frame, frame->operation, NULL, NULL, &fault_value);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_FAULT || fault_value != 99) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            if (dever_rt_v1_async_group_new(1, &frame->group, &error) != DEVER_RT_ASYNC_PENDING) abort();
+            frame->operation = dever_rt_v1_async_group_run(frame->group, &unit_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 3;
+            break;
+        case 3:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_group_run(frame->group, &unit_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 4;
+            break;
+        case 4:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_PENDING) abort();
+            frame->group_pending = 1;
+            dever_rt_v1_async_op_release(frame->operation);
+            DeverRtAsyncGroup *group_alias = dever_rt_v1_async_group_retain(frame->group);
+            if (!group_alias) abort();
+            frame->operation = dever_rt_v1_async_group_stop(frame->group);
+            frame->group = NULL;
+            dever_rt_v1_async_group_release(group_alias);
+            frame->phase = 5;
+            break;
+        case 5:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || atomic_load(&unit_destroy_count) < 2) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            if (dever_rt_v1_async_group_new(1, &frame->group, &error) != DEVER_RT_ASYNC_PENDING) abort();
+            frame->operation = dever_rt_v1_async_group_run(frame->group, &fault_child, NULL, &error);
+            if (!frame->operation) abort();
+            frame->phase = 18;
+            break;
+        case 18:
+            status = poll(frame, frame->operation, NULL, NULL, &fault_value);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_group_wait(frame->group);
+            frame->group = NULL;
+            frame->phase = 19;
+            break;
+        case 19:
+            status = poll(frame, frame->operation, NULL, NULL, &fault_value);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_FAULT || fault_value != 99) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            if (dever_rt_v1_async_channel_new(1, &frame->channel, &error) != DEVER_RT_ASYNC_PENDING) abort();
+            item = 11;
+            frame->operation = dever_rt_v1_async_channel_send(frame->channel, &integer, &item, &error);
+            if (!frame->operation || item != 0) abort();
+            frame->phase = 6;
+            break;
+        case 6:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            item = 12;
+            frame->blocked_send = dever_rt_v1_async_channel_send(frame->channel, &integer, &item, &error);
+            if (!frame->blocked_send || item != 0) abort();
+            if (poll(frame, frame->blocked_send, NULL, NULL, frame->fault) != DEVER_RT_ASYNC_PENDING) abort();
+            frame->operation = dever_rt_v1_async_channel_receive(frame->channel);
+            frame->phase = 7;
+            break;
+        case 7:
+            status = poll(frame, frame->operation, &item, &present, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK || !present || item != 11) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            status = poll(frame, frame->blocked_send, NULL, NULL, frame->fault);
+            frame->phase = 11;
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->blocked_send);
+            frame->blocked_send = NULL;
+            frame->operation = dever_rt_v1_async_channel_close(frame->channel);
+            frame->phase = 8;
+            break;
+        case 11:
+            status = poll(frame, frame->blocked_send, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->blocked_send);
+            frame->blocked_send = NULL;
+            frame->operation = dever_rt_v1_async_channel_close(frame->channel);
+            frame->phase = 8;
+            break;
+        case 8:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_channel_receive(frame->channel);
+            frame->phase = 9;
+            break;
+        case 9:
+            status = poll(frame, frame->operation, &item, &present, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK || !present || item != 12) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_channel_receive(frame->channel);
+            frame->phase = 10;
+            break;
+        case 10:
+            status = poll(frame, frame->operation, &item, &present, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK || present) abort();
+            if (!frame->group_pending) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            dever_rt_v1_async_channel_release(frame->channel);
+            frame->channel = NULL;
+            if (dever_rt_v1_async_channel_new(1, &frame->channel, &error) != DEVER_RT_ASYNC_PENDING) abort();
+            optional.present = 0;
+            optional.value = 0;
+            frame->operation = dever_rt_v1_async_channel_send(frame->channel, &optional_integer, &optional, &error);
+            if (!frame->operation) abort();
+            frame->phase = 24;
+            break;
+        case 24:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_channel_close(frame->channel);
+            frame->phase = 25;
+            break;
+        case 25:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_channel_receive(frame->channel);
+            frame->phase = 26;
+            break;
+        case 26:
+            status = poll(frame, frame->operation, &optional, &present, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK || !present || optional.present) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_channel_receive(frame->channel);
+            frame->phase = 27;
+            break;
+        case 27:
+            status = poll(frame, frame->operation, &optional, &present, frame->fault);
+            if (status != DEVER_RT_ASYNC_READY_OK || present) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            dever_rt_v1_async_channel_release(frame->channel);
+            frame->channel = NULL;
+            item = 21;
+            frame->operation = dever_rt_v1_async_parallel(&synchronous_twice, &item, &error);
+            if (!frame->operation || item != 0) abort();
+            frame->phase = 16;
+            break;
+        case 16:
+            status = poll(frame, frame->operation, &item, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || item != 42) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            item = 21;
+            frame->operation = dever_rt_v1_async_task_run_sync(&synchronous_twice, &item, &error);
+            if (!frame->operation || item != 0) abort();
+            frame->phase = 20;
+            break;
+        case 20:
+            status = poll(frame, frame->operation, &frame->task, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || !frame->task) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_task_wait(frame->task);
+            frame->task = NULL;
+            frame->phase = 21;
+            break;
+        case 21:
+            status = poll(frame, frame->operation, &item, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || item != 42) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            if (dever_rt_v1_async_group_new(1, &frame->group, &error) != DEVER_RT_ASYNC_PENDING) abort();
+            item = 21;
+            frame->operation = dever_rt_v1_async_group_run_sync(frame->group, &synchronous_unit, &item, &error);
+            if (!frame->operation || item != 0) abort();
+            frame->phase = 22;
+            break;
+        case 22:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = dever_rt_v1_async_group_wait(frame->group);
+            frame->group = NULL;
+            frame->phase = 23;
+            break;
+        case 23:
+            status = poll(frame, frame->operation, NULL, NULL, frame->fault);
+            if (status == DEVER_RT_ASYNC_PENDING) return;
+            if (status != DEVER_RT_ASYNC_READY_OK || atomic_load(&group_sync_done_count) != 1) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            item = 21;
+            frame->operation = dever_rt_v1_async_blocking(&synchronous_twice, &item, &error);
+            if (!frame->operation || item != 0) abort();
+            frame->phase = 17;
+            break;
+        case 17:
+            status = poll(frame, frame->operation, &item, NULL, frame->fault);
+            if (status != DEVER_RT_ASYNC_PENDING) abort();
+            dever_rt_v1_async_op_release(frame->operation);
+            frame->operation = NULL;
+            *(int64_t *)frame->output = 42;
+            complete(frame, DEVER_RT_ASYNC_READY_OK);
+            return;
+        default:
+            abort();
+        }
+    }
+}
+
+static const DeverRtAsyncFunction root = {
+    &integer, &integer, create, root_resume, destroy, done, 0
+};
+
+int main(void) {
+    int64_t output = 0;
+    int64_t fault = 0;
+    DeverRtBuffer error = { 0 };
+    if (dever_rt_v1_async_op_poll(NULL, NULL, NULL, NULL, NULL, &error)
+        != DEVER_RT_ASYNC_INVALID_INPUT || !error.ptr) return 4;
+    dever_rt_v1_buffer_free(error.ptr, error.len);
+    error = (DeverRtBuffer){ 0 };
+    uint8_t unit_output = 7;
+    if (dever_rt_v1_time_sleep(0, &unit_output, &error) != DEVER_RT_OK
+        || unit_output != 0 || error.ptr) return 2;
+    unit_output = 7;
+    if (dever_rt_v1_time_sleep(-1, &unit_output, &error) != DEVER_RT_RUNTIME_ERROR
+        || unit_output != 7 || !error.ptr
+        || error.len != sizeof("sleep duration must not be negative") - 1
+        || memcmp(error.ptr, "sleep duration must not be negative", error.len)) return 3;
+    dever_rt_v1_buffer_free(error.ptr, error.len);
+    error = (DeverRtBuffer){ 0 };
+    uint32_t status = dever_rt_v1_async_root(&root, NULL, &output, &fault, &error);
+    if (error.ptr) dever_rt_v1_buffer_free(error.ptr, error.len);
+    return status == DEVER_RT_ASYNC_READY_OK && output == 42
+        && atomic_load(&blocking_done_count) == 3
+        && atomic_load(&group_sync_done_count) == 1 ? 0 : 1;
+}