blob: e75faa5ba89a7a9642994412d3d6ef45c5e6f94d [file]
/*
Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Sofia Rodrigues
*/
#include "runtime/uv/signal.h"
namespace lean {
#ifndef LEAN_EMSCRIPTEN
using namespace std;
// The finalizer of the `Signal`.
void lean_uv_signal_finalizer(void* ptr) {
lean_uv_signal_object * signal = (lean_uv_signal_object*) ptr;
if (signal->m_promise != NULL) {
lean_dec(signal->m_promise);
}
event_loop_lock(&global_ev);
uv_close((uv_handle_t*)signal->m_uv_signal, [](uv_handle_t* handle) {
free(handle);
});
event_loop_unlock(&global_ev);
free(signal);
}
void initialize_libuv_signal() {
g_uv_signal_external_class = lean_register_external_class(lean_uv_signal_finalizer, [](void* obj, lean_object* f) {
if (((lean_uv_signal_object*)obj)->m_promise != NULL) {
lean_inc(f);
lean_apply_1(f, ((lean_uv_signal_object*)obj)->m_promise);
}
});
}
static bool signal_promise_is_finished(lean_uv_signal_object * signal) {
return signal->m_promise == NULL || lean_io_get_task_state_core((lean_object *)lean_to_promise(signal->m_promise)->m_result) == 2;
}
void handle_signal_event(uv_signal_t* handle, int signum) {
lean_object * obj = (lean_object*)handle->data;
lean_uv_signal_object * signal = lean_to_uv_signal(obj);
lean_assert(signal->m_state == SIGNAL_STATE_RUNNING);
if (signal->m_repeating) {
if (!signal_promise_is_finished(signal)) {
lean_object* res = lean_io_promise_resolve(lean_box(signum), signal->m_promise);
lean_dec(res);
}
} else {
if (signal->m_promise != NULL) {
lean_object* res = lean_io_promise_resolve(lean_box(signum), signal->m_promise);
lean_dec(res);
}
uv_signal_stop(signal->m_uv_signal);
signal->m_state = SIGNAL_STATE_FINISHED;
lean_dec(obj);
}
}
/* Std.Internal.UV.Signal.mk (signum : Int32) (repeating : Bool) : IO Signal */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_mk(uint32_t signum_obj, uint8_t repeating) {
int signum = (int)(int32_t)signum_obj;
lean_uv_signal_object * signal = (lean_uv_signal_object*)malloc(sizeof(lean_uv_signal_object));
signal->m_signum = signum;
signal->m_repeating = repeating;
signal->m_state = SIGNAL_STATE_INITIAL;
signal->m_promise = NULL;
uv_signal_t * uv_signal = (uv_signal_t*)malloc(sizeof(uv_signal_t));
event_loop_lock(&global_ev);
int result = uv_signal_init(global_ev.loop, uv_signal);
event_loop_unlock(&global_ev);
if (result != 0) {
free(uv_signal);
free(signal);
return lean_io_result_mk_error(lean_decode_uv_error(result, NULL));
}
signal->m_uv_signal = uv_signal;
lean_object * obj = lean_uv_signal_new(signal);
lean_mark_mt(obj);
signal->m_uv_signal->data = obj;
return lean_io_result_mk_ok(obj);
}
/* Std.Internal.UV.Signal.next (signal : @& Signal) : IO (IO.Promise Int) */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_next(b_obj_arg obj) {
lean_uv_signal_object * signal = lean_to_uv_signal(obj);
auto setup_signal = [obj, signal]() {
lean_assert(signal->m_promise == NULL);
lean_object* promise = lean_io_promise_new();
signal->m_promise = promise;
signal->m_state = SIGNAL_STATE_RUNNING;
// The event loop must keep the signal alive for the duration of the run time.
lean_inc(obj);
lean_inc(promise);
int result;
if (signal->m_repeating) {
result = uv_signal_start(
signal->m_uv_signal,
handle_signal_event,
signal->m_signum
);
} else {
result = uv_signal_start_oneshot(
signal->m_uv_signal,
handle_signal_event,
signal->m_signum
);
}
if (result != 0) {
lean_dec(obj);
lean_dec(promise);
event_loop_unlock(&global_ev);
return lean_io_result_mk_error(lean_decode_uv_error(result, NULL));
}
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(promise);
};
event_loop_lock(&global_ev);
if (signal->m_repeating) {
switch (signal->m_state) {
case SIGNAL_STATE_INITIAL:
{
return setup_signal();
}
case SIGNAL_STATE_RUNNING:
{
if (signal_promise_is_finished(signal)) {
if (signal->m_promise != NULL) {
lean_dec(signal->m_promise);
}
signal->m_promise = lean_io_promise_new();
}
lean_inc(signal->m_promise);
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(signal->m_promise);
}
case SIGNAL_STATE_FINISHED:
{
if (signal->m_promise == NULL) {
lean_object* finished_promise = lean_io_promise_new();
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(finished_promise);
}
lean_inc(signal->m_promise);
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(signal->m_promise);
}
}
} else {
if (signal->m_state == SIGNAL_STATE_INITIAL) {
return setup_signal();
} else if (signal->m_promise != NULL) {
lean_inc(signal->m_promise);
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(signal->m_promise);
} else {
lean_object* finished_promise = lean_io_promise_new();
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(finished_promise);
}
}
}
/* Std.Internal.UV.Signal.stop (signal : @& Signal) : IO Unit */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_stop(b_obj_arg obj) {
lean_uv_signal_object * signal = lean_to_uv_signal(obj);
if (signal->m_state == SIGNAL_STATE_RUNNING) {
event_loop_lock(&global_ev);
int result = uv_signal_stop(signal->m_uv_signal);
event_loop_unlock(&global_ev);
if (signal->m_promise != NULL) {
lean_dec(signal->m_promise);
signal->m_promise = NULL;
}
signal->m_state = SIGNAL_STATE_FINISHED;
// The loop does not need to keep the signal alive anymore.
lean_dec(obj);
if (result != 0) {
return lean_io_result_mk_error(lean_decode_uv_error(result, NULL));
} else {
return lean_io_result_mk_ok(lean_box(0));
}
} else {
return lean_io_result_mk_ok(lean_box(0));
}
}
/* Std.Internal.UV.Signal.cancel (signal : @& Signal) : IO Unit */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_cancel(b_obj_arg obj) {
lean_uv_signal_object * signal = lean_to_uv_signal(obj);
// It's locking here to avoid changing the state during other operations.
event_loop_lock(&global_ev);
if (signal->m_state == SIGNAL_STATE_RUNNING && signal->m_promise != NULL) {
if (signal->m_repeating) {
lean_dec(signal->m_promise);
signal->m_promise = NULL;
} else {
uv_signal_stop(signal->m_uv_signal);
lean_dec(signal->m_promise);
signal->m_promise = NULL;
signal->m_state = SIGNAL_STATE_INITIAL;
lean_dec(obj);
}
}
event_loop_unlock(&global_ev);
return lean_io_result_mk_ok(lean_box(0));
}
#else
/* Std.Internal.UV.Signal.mk (signum : Int32) (repeating : Bool) : IO Signal */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_mk(uint32_t signum_obj, uint8_t repeating) {
lean_always_assert(
false && ("Please build a version of Lean4 with libuv to invoke this.")
);
}
/* Std.Internal.UV.Signal.next (signal : @& Signal) : IO (IO.Promise Int) */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_next(b_obj_arg signal) {
lean_always_assert(
false && ("Please build a version of Lean4 with libuv to invoke this.")
);
}
/* Std.Internal.UV.Signal.stop (signal : @& Signal) : IO Unit */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_stop(b_obj_arg signal) {
lean_always_assert(
false && ("Please build a version of Lean4 with libuv to invoke this.")
);
}
/* Std.Internal.UV.Signal.cancel (signal : @& Signal) : IO Unit */
extern "C" LEAN_EXPORT lean_obj_res lean_uv_signal_cancel(b_obj_arg obj) {
lean_always_assert(
false && ("Please build a version of Lean4 with libuv to invoke this.")
);
}
#endif
}