mirror of
https://github.com/roc-lang/roc.git
synced 2025-07-27 16:33:47 +00:00
118 lines
4.1 KiB
Zig
118 lines
4.1 KiB
Zig
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const testing = std.testing;
|
|
const expectEqual = testing.expectEqual;
|
|
const expect = testing.expect;
|
|
const maxInt = std.math.maxInt;
|
|
|
|
const mem = std.mem;
|
|
const Allocator = mem.Allocator;
|
|
|
|
// NOTE the LLVM backend expects this signature
|
|
// extern fn roc__mainForHost_1_exposed(i64, *i64) void;
|
|
extern fn roc__mainForHost_1_exposed(i64) i64;
|
|
|
|
const Align = 2 * @alignOf(usize);
|
|
extern fn malloc(size: usize) callconv(.C) ?*align(Align) anyopaque;
|
|
extern fn realloc(c_ptr: [*]align(Align) u8, size: usize) callconv(.C) ?*anyopaque;
|
|
extern fn free(c_ptr: [*]align(Align) u8) callconv(.C) void;
|
|
extern fn memcpy(dst: [*]u8, src: [*]u8, size: usize) callconv(.C) void;
|
|
extern fn memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void;
|
|
|
|
const DEBUG: bool = false;
|
|
|
|
export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*anyopaque {
|
|
if (DEBUG) {
|
|
var ptr = malloc(size);
|
|
const stdout = std.io.getStdOut().writer();
|
|
stdout.print("alloc: {d} (alignment {d}, size {d})\n", .{ ptr, alignment, size }) catch unreachable;
|
|
return ptr;
|
|
} else {
|
|
return malloc(size);
|
|
}
|
|
}
|
|
|
|
export fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*anyopaque {
|
|
if (DEBUG) {
|
|
const stdout = std.io.getStdOut().writer();
|
|
stdout.print("realloc: {d} (alignment {d}, old_size {d})\n", .{ c_ptr, alignment, old_size }) catch unreachable;
|
|
}
|
|
|
|
return realloc(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))), new_size);
|
|
}
|
|
|
|
export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void {
|
|
if (DEBUG) {
|
|
const stdout = std.io.getStdOut().writer();
|
|
stdout.print("dealloc: {d} (alignment {d})\n", .{ c_ptr, alignment }) catch unreachable;
|
|
}
|
|
|
|
free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr))));
|
|
}
|
|
|
|
export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void {
|
|
_ = tag_id;
|
|
|
|
const stderr = std.io.getStdErr().writer();
|
|
const msg = @as([*:0]const u8, @ptrCast(c_ptr));
|
|
stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable;
|
|
std.process.exit(0);
|
|
}
|
|
|
|
export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void {
|
|
return memset(dst, value, size);
|
|
}
|
|
|
|
extern fn kill(pid: c_int, sig: c_int) c_int;
|
|
extern fn shm_open(name: *const i8, oflag: c_int, mode: c_uint) c_int;
|
|
extern fn mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) *anyopaque;
|
|
extern fn getppid() c_int;
|
|
|
|
fn roc_getppid() callconv(.C) c_int {
|
|
return getppid();
|
|
}
|
|
|
|
fn roc_getppid_windows_stub() callconv(.C) c_int {
|
|
return 0;
|
|
}
|
|
|
|
fn roc_shm_open(name: *const i8, oflag: c_int, mode: c_uint) callconv(.C) c_int {
|
|
return shm_open(name, oflag, mode);
|
|
}
|
|
fn roc_mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) callconv(.C) *anyopaque {
|
|
return mmap(addr, length, prot, flags, fd, offset);
|
|
}
|
|
|
|
comptime {
|
|
if (builtin.os.tag == .macos or builtin.os.tag == .linux) {
|
|
@export(roc_getppid, .{ .name = "roc_getppid", .linkage = .Strong });
|
|
@export(roc_mmap, .{ .name = "roc_mmap", .linkage = .Strong });
|
|
@export(roc_shm_open, .{ .name = "roc_shm_open", .linkage = .Strong });
|
|
}
|
|
|
|
if (builtin.os.tag == .windows) {
|
|
@export(roc_getppid_windows_stub, .{ .name = "roc_getppid", .linkage = .Strong });
|
|
}
|
|
}
|
|
|
|
pub export fn main() u8 {
|
|
const stdout = std.io.getStdOut().writer();
|
|
|
|
var timer = std.time.Timer.start() catch unreachable;
|
|
|
|
const result = roc__mainForHost_1_exposed(10);
|
|
|
|
const nanos = timer.read();
|
|
const seconds = (@as(f64, @floatFromInt(nanos)) / 1_000_000_000.0);
|
|
|
|
stdout.print("{d}\n", .{result}) catch unreachable;
|
|
|
|
const stderr = std.io.getStdErr().writer();
|
|
stderr.print("runtime: {d:.3}ms\n", .{seconds * 1000}) catch unreachable;
|
|
|
|
return 0;
|
|
}
|
|
|
|
fn to_seconds(tms: std.os.timespec) f64 {
|
|
return @as(f64, @floatFromInt(tms.tv_sec)) + (@as(f64, @floatFromInt(tms.tv_nsec)) / 1_000_000_000.0);
|
|
}
|