blob: 24589c99416285cb9d223051213e9292de38e2ae [file]
/*
Copyright (c) 2018 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
*/
#if defined(LEAN_WINDOWS)
#include <windows.h>
#elif defined(__APPLE__)
#include <mach-o/dyld.h>
#include <unistd.h>
#else
// Linux include files
#include <unistd.h> // NOLINT
#include <sys/mman.h>
#include <fcntl.h>
#endif
#include <iostream>
#include <chrono>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <cctype>
#include <sys/stat.h>
#include "util/io.h"
#include <lean/utf8.h>
#include <lean/object.h>
#include <lean/thread.h>
#include <lean/allocprof.h>
#ifdef _MSC_VER
#define S_ISDIR(mode) ((mode & _S_IFDIR) != 0)
#else
#include <dirent.h>
#endif
namespace lean {
extern "C" lean_object* lean_mk_io_error_already_exists(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_eof(lean_object*);
extern "C" lean_object* lean_mk_io_error_hardware_fault(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_illegal_operation(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_inappropriate_type(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_inappropriate_type_file(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_interrupted(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_invalid_argument(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_invalid_argument_file(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_no_file_or_directory(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_no_such_thing(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_no_such_thing_file(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_other_error(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_permission_denied(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_permission_denied_file(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_protocol_error(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_resource_busy(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_resource_exhausted(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_resource_exhausted_file(lean_object*, uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_resource_vanished(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_time_expired(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_unsatisfied_constraints(uint32_t, lean_object*);
extern "C" lean_object* lean_mk_io_error_unsupported_operation(uint32_t, lean_object*);
extern "C" void lean_io_result_show_error(b_obj_arg r) {
object * err = io_result_get_error(r);
inc_ref(err);
object * str = lean_io_error_to_string(err);
std::cerr << "uncaught exception: " << string_cstr(str) << std::endl;
dec_ref(str);
}
obj_res set_io_result(obj_arg a) {
object * new_r = alloc_cnstr(0, 2, 0);
cnstr_set(new_r, 0, a);
cnstr_set(new_r, 1, box(0));
return new_r;
}
obj_res set_io_error(obj_arg e) {
object * new_r = alloc_cnstr(1, 2, 0);
cnstr_set(new_r, 0, e);
cnstr_set(new_r, 1, box(0));
return new_r;
}
extern "C" object * mk_io_user_error(object * str);
obj_res set_io_error(char const * msg) {
return set_io_error(mk_io_user_error(mk_string(msg)));
}
obj_res set_io_error(std::string const & msg) {
return set_io_error(mk_io_user_error(mk_string(msg)));
}
static bool g_initializing = true;
extern "C" void lean_io_mark_end_initialization() {
g_initializing = false;
}
static obj_res mk_file_not_found_error(b_obj_arg fname) {
inc(fname);
int errnum = ENOENT;
object * details = mk_string("");
return set_io_error(lean_mk_io_error_no_file_or_directory(fname, errnum, details));
}
extern "C" obj_res lean_io_initializing(obj_arg) {
return set_io_result(box(g_initializing));
}
static lean_external_class * g_io_handle_external_class = nullptr;
static void io_handle_finalizer(void * h) {
fclose(static_cast<FILE *>(h));
}
static void io_handle_foreach(void * /* mod */, b_obj_arg /* fn */) {
}
static lean_object * io_wrap_handle(FILE *hfile) {
return lean_alloc_external(g_io_handle_external_class, hfile);
}
static object * g_handle_stdin = nullptr;
static object * g_handle_stdout = nullptr;
static object * g_handle_stderr = nullptr;
/* stdin : IO FS.Handle */
extern "C" obj_res lean_get_stdin(obj_arg /* w */) {
inc_ref(g_handle_stdin);
return set_io_result(g_handle_stdin);
}
/* stdout : IO FS.Handle */
extern "C" obj_res lean_get_stdout(obj_arg /* w */) {
inc_ref(g_handle_stdout);
return set_io_result(g_handle_stdout);
}
/* stderr : IO FS.Handle */
extern "C" obj_res lean_get_stderr(obj_arg /* w */) {
inc_ref(g_handle_stderr);
return set_io_result(g_handle_stderr);
}
static FILE * io_get_handle(lean_object * hfile) {
return static_cast<FILE *>(lean_get_external_data(hfile));
}
void with_isolated_streams(std::string & streams_out, std::function<void()> fn) {
// When running `#eval`, we want to temporarily close stdin and capture stdout/stderr of the evaluated program
// so it doesn't interfere with the server I/O. We could do this on the Lean API level (i.e. `IO.getLine/putStr`),
// but that wouldn't affect direct access to `IO.stdin/...` nor FFI-called code. Instead, we directly work on file
// descriptors.
// Create a fresh file descriptor we can point stdout/stderr to
#if defined(__linux__)
// On Linux, we can simply open an anonymous file in memory
int buf_fd = memfd_create("lean-eval", 0);
#elif 0
// On macOS, we can open exclusive shared memory object, guessing a hopefully unique name
// ...or at least we should be able to, but it doesn't work for some reason.
// NOTE: what doesn't work: `funopen` returns a `FILE *` stream without a file descriptor
std::string shm_name = (sstream() << "lean-eval-" << getpid()).str();
int buf_fd = shm_open(shm_name.c_str(), O_RDWR | O_CREAT | O_EXCL, S_IRWXU);
lean_always_assert(shm_unlink(shm_name.c_str()) == 0);
#else
// On Windows we can open an actual file I guess
FILE * buf_f = tmpfile(); lean_always_assert(buf_f != nullptr);
int buf_fd = fileno(buf_f);
#endif
lean_always_assert(buf_fd >= 0);
// NOTE: what doesn't work: `pipe` creates file descriptors, but we would need a separate consumer thread so
// the evaluated program doesn't block on a full pipe
// make sure to drain user-level buffers
fflush(stdout); fflush(stderr);
// copy stdout/stderr, then set them to `buf_fd`
#ifdef __linux__
// On Linux, we also redirect stdin so it appears as empty. This doesn't seem to work on other platforms.
// NOTE: Since we can't flush stdin, this only really works if we are on a line ending (assuming stdin is line buffered).
// This should be the case for the server, which is line-based.
int old_stdin = dup(STDIN_FILENO); lean_always_assert(old_stdin >= 0); lean_always_assert(dup2(buf_fd, STDIN_FILENO) >= 0);
#endif
int old_stdout = dup(STDOUT_FILENO); lean_always_assert(old_stdout >= 0); lean_always_assert(dup2(buf_fd, STDOUT_FILENO) >= 0);
int old_stderr = dup(STDERR_FILENO); lean_always_assert(old_stderr >= 0); lean_always_assert(dup2(buf_fd, STDERR_FILENO) >= 0);
std::function<void()> finally = [&]() {
fflush(stdout); fflush(stderr);
// restore old streams
#ifdef __linux__
lean_always_assert(dup2(old_stdin, STDIN_FILENO) >= 0); lean_always_assert(close(old_stdin) == 0);
#endif
lean_always_assert(dup2(old_stdout, STDOUT_FILENO) >= 0); lean_always_assert(close(old_stdout) == 0);
lean_always_assert(dup2(old_stderr, STDERR_FILENO) >= 0); lean_always_assert(close(old_stderr) == 0);
// write `buf_fd` contents to `out`
off_t buf_sz = lseek(buf_fd, 0, SEEK_CUR);
lseek(buf_fd, 0, SEEK_SET);
std::string buf_s(buf_sz, '\0');
lean_always_assert(read(buf_fd, static_cast<void *>(&buf_s[0]), buf_sz) == buf_sz);
lean_always_assert(close(buf_fd) == 0);
streams_out = buf_s;
};
try {
fn();
} catch (exception &) {
finally();
throw;
}
finally();
}
/* withIsolatedStreams {α : Type} : IO α → IO (String × Except IO.Error α) */
extern "C" obj_res lean_with_isolated_streams(obj_arg act, obj_arg w) {
std::string streams_out;
object_ref act_res;
with_isolated_streams(streams_out, [&]() { act_res = object_ref(apply_1(act, w)); });
if (io_result_is_ok(act_res.raw())) {
return set_io_result(mk_cnstr(0, mk_string(streams_out), mk_except_ok(object_ref(io_result_get_value(act_res.raw()), true))).steal());
} else {
return set_io_result(mk_cnstr(0, mk_string(streams_out), mk_except_error(object_ref(io_result_get_error(act_res.raw()), true))).steal());
}
}
obj_res decode_io_error(int errnum, b_obj_arg fname) {
object * details = mk_string(strerror(errnum));
switch (errnum) {
case EINTR:
lean_assert(fname != nullptr);
inc_ref(fname);
return lean_mk_io_error_interrupted(fname, errnum, details);
case ELOOP: case ENAMETOOLONG: case EDESTADDRREQ:
case EBADF: case EDOM: case EINVAL: case EILSEQ:
case ENOEXEC: case ENOSTR: case ENOTCONN:
case ENOTSOCK:
if (fname == nullptr) {
return lean_mk_io_error_invalid_argument(errnum, details);
} else {
inc_ref(fname);
return lean_mk_io_error_invalid_argument_file(fname, errnum, details);
}
case ENOENT:
lean_assert(fname != nullptr);
inc_ref(fname);
return lean_mk_io_error_no_file_or_directory(fname, errnum, details);
case EACCES: case EROFS: case ECONNABORTED: case EFBIG:
case EPERM:
if (fname == nullptr) {
return lean_mk_io_error_permission_denied(errnum, details);
} else {
inc_ref(fname);
return lean_mk_io_error_permission_denied_file(fname, errnum, details);
}
case EMFILE: case ENFILE: case ENOSPC:
case E2BIG: case EAGAIN: case EMLINK:
case EMSGSIZE: case ENOBUFS: case ENOLCK:
case ENOMEM: case ENOSR:
if (fname == nullptr) {
return lean_mk_io_error_resource_exhausted(errnum, details);
} else {
inc_ref(fname);
return lean_mk_io_error_resource_exhausted_file(fname, errnum, details);
}
case EISDIR: case EBADMSG: case ENOTDIR:
if (fname == nullptr) {
return lean_mk_io_error_inappropriate_type(errnum, details);
} else {
inc_ref(fname);
return lean_mk_io_error_inappropriate_type_file(fname, errnum, details);
}
case ENXIO: case EHOSTUNREACH: case ENETUNREACH:
case ECHILD: case ECONNREFUSED: case ENODATA:
case ENOMSG: case ESRCH:
if (fname == nullptr) {
return lean_mk_io_error_no_such_thing(errnum, details);
} else {
inc_ref(fname);
return lean_mk_io_error_no_such_thing_file(fname, errnum, details);
}
case EEXIST: case EINPROGRESS: case EISCONN:
lean_assert(fname == nullptr);
return lean_mk_io_error_already_exists(errnum, details);
case EIO:
lean_assert(fname == nullptr);
return lean_mk_io_error_hardware_fault(errnum, details);
case ENOTEMPTY:
lean_assert(fname == nullptr);
return lean_mk_io_error_unsatisfied_constraints(errnum, details);
case ENOTTY:
lean_assert(fname == nullptr);
return lean_mk_io_error_illegal_operation(errnum, details);
case ECONNRESET: case EIDRM: case ENETDOWN: case ENETRESET:
case ENOLINK: case EPIPE:
lean_assert(fname == nullptr);
return lean_mk_io_error_resource_vanished(errnum, details);
case EPROTO: case EPROTONOSUPPORT: case EPROTOTYPE:
lean_assert(fname == nullptr);
return lean_mk_io_error_protocol_error(errnum, details);
case ETIME: case ETIMEDOUT:
lean_assert(fname == nullptr);
return lean_mk_io_error_time_expired(errnum, details);
case EADDRINUSE: case EBUSY: case EDEADLK: case ETXTBSY:
lean_assert(fname == nullptr);
return lean_mk_io_error_resource_busy(errnum, details);
case EADDRNOTAVAIL: case EAFNOSUPPORT: case ENODEV:
case ENOPROTOOPT: case ENOSYS: case EOPNOTSUPP:
case ERANGE: case ESPIPE: case EXDEV:
lean_assert(fname == nullptr);
return lean_mk_io_error_unsupported_operation(errnum, details);
case EFAULT:
default:
lean_assert(fname == nullptr);
return lean_mk_io_error_other_error(errnum, details);
}
}
/* IO.setAccessRights (filename : @& String) (mode : UInt32) : IO Handle */
extern "C" obj_res lean_chmod (b_obj_arg filename, uint32_t mode, obj_arg /* w */) {
if (!chmod(lean_string_cstr(filename), mode)) {
return set_io_result(box(0));
} else {
return set_io_error(decode_io_error(errno, filename));
}
}
/* Handle.mk (filename : @& String) (mode : @& String) : IO Handle */
extern "C" obj_res lean_io_prim_handle_mk(b_obj_arg filename, b_obj_arg modeStr, obj_arg /* w */) {
FILE *fp = fopen(lean_string_cstr(filename), lean_string_cstr(modeStr));
if (!fp) {
return set_io_error(decode_io_error(errno, filename));
} else {
return set_io_result(io_wrap_handle(fp));
}
}
/* Handle.isEof : (@& Handle) → IO Bool */
extern "C" obj_res lean_io_prim_handle_is_eof(b_obj_arg h, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
return set_io_result(box(std::feof(fp) != 0));
}
/* Handle.flush : (@& Handle) → IO Bool */
extern "C" obj_res lean_io_prim_handle_flush(b_obj_arg h, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
if (!std::fflush(fp)) {
return set_io_result(box(0));
} else {
return set_io_error(decode_io_error(errno, nullptr));
}
}
static object * g_io_error_eof = nullptr;
/* Handle.read : (@& Handle) → USize → IO ByteArray */
extern "C" obj_res lean_io_prim_handle_read(b_obj_arg h, usize nbytes, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
if (feof(fp)) {
return set_io_error(g_io_error_eof);
}
obj_res res = lean_alloc_sarray(1, 0, nbytes);
usize n = std::fread(lean_sarray_cptr(res), 1, nbytes, fp);
if (n > 0) {
lean_sarray_set_size(res, n);
return set_io_result(res);
} else if (feof(fp)) {
dec_ref(res);
return set_io_result(alloc_sarray(1, 0, 0));
} else {
dec_ref(res);
return set_io_error(decode_io_error(errno, nullptr));
}
}
/* Handle.write : (@& Handle) → (@& ByteArray) → IO unit */
extern "C" obj_res lean_io_prim_handle_write(b_obj_arg h, b_obj_arg buf, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
usize n = lean_sarray_size(buf);
usize m = std::fwrite(lean_sarray_cptr(buf), 1, n, fp);
if (m == n) {
return set_io_result(box(0));
} else {
return set_io_error(decode_io_error(errno, nullptr));
}
}
static object * g_io_error_getline = nullptr;
/*
Handle.getLine : (@& Handle) → IO Unit
The line returned by `lean_io_prim_handle_get_line`
is truncated at the first '\0' character and the
rest of the line is discarded. */
extern "C" obj_res lean_io_prim_handle_get_line(b_obj_arg h, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
if (feof(fp)) {
return set_io_result(mk_string(""));
}
const int buf_sz = 64;
char buf_str[buf_sz]; // NOLINT
std::string result;
bool first = true;
while (true) {
char * out = std::fgets(buf_str, buf_sz, fp);
if (out != nullptr) {
if (strlen(buf_str) < buf_sz-1 || buf_str[buf_sz-2] == '\n') {
if (first) {
return set_io_result(mk_string(out));
} else {
result.append(out);
return set_io_result(mk_string(result));
}
}
result.append(out);
} else if (std::feof(fp)) {
return set_io_result(mk_string(result));
} else {
return set_io_error(g_io_error_getline);
}
first = false;
}
}
/* Handle.putStr : (@& Handle) → (@& String) → IO Unit */
extern "C" obj_res lean_io_prim_handle_put_str(b_obj_arg h, b_obj_arg s, obj_arg /* w */) {
FILE * fp = io_get_handle(h);
if (std::fputs(lean_string_cstr(s), fp) != EOF) {
return set_io_result(box(0));
} else {
return set_io_error(decode_io_error(errno, nullptr));
}
}
/* timeit {α : Type} (msg : @& String) (fn : IO α) : IO α */
extern "C" obj_res lean_io_timeit(b_obj_arg msg, obj_arg fn, obj_arg w) {
auto start = std::chrono::steady_clock::now();
w = apply_1(fn, w);
auto end = std::chrono::steady_clock::now();
auto diff = std::chrono::duration<double>(end - start);
std::ostream & out = std::cerr; // TODO(Leo): replace?
out << std::setprecision(3);
if (diff < std::chrono::duration<double>(1)) {
out << string_cstr(msg) << " " << std::chrono::duration<double, std::milli>(diff).count() << "ms\n";
} else {
out << string_cstr(msg) << " " << diff.count() << "s\n";
}
return w;
}
/* allocprof {α : Type} (msg : @& String) (fn : IO α) : IO α */
extern "C" obj_res lean_io_allocprof(b_obj_arg msg, obj_arg fn, obj_arg w) {
std::ostream & out = std::cerr; // TODO(Leo): replace?
allocprof prof(out, string_cstr(msg));
return apply_1(fn, w);
}
extern "C" obj_res lean_io_getenv(b_obj_arg env_var, obj_arg) {
char * val = std::getenv(string_cstr(env_var));
if (val) {
return set_io_result(mk_option_some(mk_string(val)));
} else {
return set_io_result(mk_option_none());
}
}
extern "C" obj_res lean_io_realpath(obj_arg fname, obj_arg) {
#if defined(LEAN_EMSCRIPTEN)
return set_io_result(fname);
#elif defined(LEAN_WINDOWS)
constexpr unsigned BufferSize = 8192;
char buffer[BufferSize];
DWORD retval = GetFullPathName(string_cstr(fname), BufferSize, buffer, nullptr);
if (retval == 0 || retval > BufferSize) {
return set_io_result(fname);
} else {
dec_ref(fname);
// Hack for making sure disk is lower case
// TODO(Leo): more robust solution
if (strlen(buffer) >= 2 && buffer[1] == ':') {
buffer[0] = tolower(buffer[0]);
}
return set_io_result(mk_string(buffer));
}
#else
constexpr unsigned BufferSize = 8192;
char buffer[BufferSize];
char * tmp = realpath(string_cstr(fname), buffer);
if (tmp) {
obj_res s = mk_string(tmp);
dec_ref(fname);
return set_io_result(s);
} else {
obj_res res = mk_file_not_found_error(fname);
dec_ref(fname);
return res;
}
#endif
}
extern "C" obj_res lean_io_is_dir(b_obj_arg fname, obj_arg) {
struct stat st;
if (stat(string_cstr(fname), &st) == 0) {
bool b = S_ISDIR(st.st_mode);
return set_io_result(box(b));
} else {
return set_io_result(box(0));
}
}
extern "C" obj_res lean_io_file_exists(b_obj_arg fname, obj_arg) {
bool b = !!std::ifstream(string_cstr(fname));
return set_io_result(box(b));
}
extern "C" obj_res lean_io_app_dir(obj_arg) {
#if defined(LEAN_WINDOWS)
HMODULE hModule = GetModuleHandleW(NULL);
WCHAR path[MAX_PATH];
GetModuleFileNameW(hModule, path, MAX_PATH);
std::wstring pathwstr(path);
std::string pathstr(pathwstr.begin(), pathwstr.end());
// Hack for making sure disk is lower case
// TODO(Leo): more robust solution
if (pathstr.size() >= 2 && pathstr[1] == ':') {
pathstr[0] = tolower(pathstr[0]);
}
return set_io_result(mk_string(pathstr));
#elif defined(__APPLE__)
char buf1[PATH_MAX];
char buf2[PATH_MAX];
uint32_t bufsize = PATH_MAX;
if (_NSGetExecutablePath(buf1, &bufsize) != 0)
return set_io_error("failed to locate application");
if (!realpath(buf1, buf2))
return set_io_error("failed to resolve symbolic links when locating application");
return set_io_result(mk_string(buf2));
#else
// Linux version
char path[PATH_MAX];
char dest[PATH_MAX];
memset(dest, 0, PATH_MAX);
pid_t pid = getpid();
snprintf(path, PATH_MAX, "/proc/%d/exe", pid);
if (readlink(path, dest, PATH_MAX) == -1) {
return set_io_error("failed to locate application");
} else {
return set_io_result(mk_string(dest));
}
#endif
}
extern "C" obj_res lean_io_current_dir(obj_arg) {
char buffer[PATH_MAX];
char * cwd = getcwd(buffer, sizeof(buffer));
if (cwd) {
return set_io_result(mk_string(cwd));
} else {
return set_io_error("failed to retrieve current working directory");
}
}
// =======================================
// IO ref primitives
extern "C" obj_res lean_io_mk_ref(obj_arg a, obj_arg) {
lean_ref_object * o = (lean_ref_object*)lean_alloc_small_object(sizeof(lean_ref_object));
lean_set_st_header((lean_object*)o, LeanRef, 0);
o->m_value = a;
return set_io_result((lean_object*)o);
}
static object * g_io_error_nullptr_read = nullptr;
static inline atomic<object*> * mt_ref_val_addr(object * o) {
return reinterpret_cast<atomic<object*> *>(&(lean_to_ref(o)->m_value));
}
/*
Important: we have added support for initializing global constants
at program startup. This feature is particularly useful for
initializing `IO.Ref` values. Any `IO.Ref` value created during
initialization will be marked as persistent. Thus, to make `IO.Ref`
API thread-safe, we must treat persistent `IO.Ref` objects created
during initialization as a multi-threaded object. Then, whenever we store
a value `val` into a global `IO.Ref`, we have to mark `va`l as a multi-threaded
object as we do for multi-threaded `IO.Ref`s. It makes sense since
the global `IO.Ref` may be used to communicate data between threads.
*/
static inline bool ref_maybe_mt(b_obj_arg ref) { return lean_is_mt(ref) || lean_is_persistent(ref); }
extern "C" obj_res lean_io_ref_get(b_obj_arg ref, obj_arg) {
if (ref_maybe_mt(ref)) {
atomic<object *> * val_addr = mt_ref_val_addr(ref);
object * val = val_addr->exchange(nullptr);
if (val == nullptr)
return set_io_error(g_io_error_nullptr_read);
inc(val);
object * tmp = val_addr->exchange(val);
if (tmp != nullptr) {
/* this may happen if another thread wrote `ref` */
dec(tmp);
}
return set_io_result(val);
} else {
object * val = lean_to_ref(ref)->m_value;
if (val == nullptr)
return set_io_error(g_io_error_nullptr_read);
inc(val);
return set_io_result(val);
}
}
static_assert(sizeof(atomic<unsigned short>) == sizeof(unsigned short), "`atomic<unsigned short>` and `unsigned short` must have the same size"); // NOLINT
extern "C" obj_res lean_io_ref_reset(b_obj_arg ref, obj_arg) {
if (ref_maybe_mt(ref)) {
atomic<object *> * val_addr = mt_ref_val_addr(ref);
object * old_a = val_addr->exchange(nullptr);
if (old_a != nullptr)
dec(old_a);
return set_io_result(box(0));
} else {
if (lean_to_ref(ref)->m_value != nullptr)
dec(lean_to_ref(ref)->m_value);
lean_to_ref(ref)->m_value = nullptr;
return set_io_result(box(0));
}
}
extern "C" obj_res lean_io_ref_set(b_obj_arg ref, obj_arg a, obj_arg) {
if (ref_maybe_mt(ref)) {
/* We must mark `a` as multi-threaded if `ref` is marked as multi-threaded.
Reason: our runtime relies on the fact that a single-threaded object
cannot be reached from a multi-thread object. */
mark_mt(a);
atomic<object *> * val_addr = mt_ref_val_addr(ref);
object * old_a = val_addr->exchange(a);
if (old_a != nullptr)
dec(old_a);
return set_io_result(box(0));
} else {
if (lean_to_ref(ref)->m_value != nullptr)
dec(lean_to_ref(ref)->m_value);
lean_to_ref(ref)->m_value = a;
return set_io_result(box(0));
}
}
extern "C" obj_res lean_io_ref_swap(b_obj_arg ref, obj_arg a, obj_arg) {
if (ref_maybe_mt(ref)) {
/* See io_ref_write */
mark_mt(a);
atomic<object *> * val_addr = mt_ref_val_addr(ref);
object * old_a = val_addr->exchange(a);
if (old_a == nullptr)
return set_io_error(g_io_error_nullptr_read);
return set_io_result(old_a);
} else {
object * old_a = lean_to_ref(ref)->m_value;
if (old_a == nullptr)
return set_io_error(g_io_error_nullptr_read);
lean_to_ref(ref)->m_value = a;
return set_io_result(old_a);
}
}
extern "C" obj_res lean_io_ref_ptr_eq(b_obj_arg ref1, b_obj_arg ref2, obj_arg) {
// TODO(Leo): ref_maybe_mt
bool r = lean_to_ref(ref1)->m_value == lean_to_ref(ref2)->m_value;
return set_io_result(box(r));
}
void initialize_io() {
g_io_error_nullptr_read = mk_io_user_error(mk_string("null reference read"));
mark_persistent(g_io_error_nullptr_read);
g_io_error_getline = mk_io_user_error(mk_string("getLine failed"));
mark_persistent(g_io_error_getline);
g_io_error_eof = lean_mk_io_error_eof(lean_box(0));
mark_persistent(g_io_error_eof);
g_io_handle_external_class = lean_register_external_class(io_handle_finalizer, io_handle_foreach);
g_handle_stdout = io_wrap_handle(stdout);
mark_persistent(g_handle_stdout);
g_handle_stderr = io_wrap_handle(stderr);
mark_persistent(g_handle_stderr);
g_handle_stdin = io_wrap_handle(stdin);
mark_persistent(g_handle_stdin);
}
void finalize_io() {
}
}