149 lines
3.7 KiB
Plaintext
149 lines
3.7 KiB
Plaintext
include "std/str.zr"
|
|
include "std/os.zr"
|
|
|
|
func panic[msg: str] : void
|
|
io.printf("PANIC: %s\n", msg)
|
|
// for gdb backtrace
|
|
_builtin_syscall(SYS_kill, os.getpid(), SIGABRT)
|
|
os.exit(1)
|
|
|
|
func io.printf[..] : void
|
|
s := _var_arg(0) as ptr
|
|
i := 1
|
|
|
|
while s[0]
|
|
if s[0] == '%'
|
|
s += 1
|
|
|
|
if s[0] == 'd'
|
|
io.print_i64(_var_arg(i) as i64)
|
|
i += 1
|
|
else if s[0] == 'x'
|
|
io.print_i64_hex(_var_arg(i) as i64)
|
|
i += 1
|
|
else if s[0] == 's'
|
|
io.print(_var_arg(i) as str)
|
|
i += 1
|
|
else if s[0] == 'c'
|
|
io.print_char(_var_arg(i) as u8)
|
|
i += 1
|
|
else if s[0] == 'f'
|
|
io.print_f64(_var_arg(i) as i64)
|
|
i += 1
|
|
else if s[0] == '%'
|
|
io.print_char('%')
|
|
else if s[0] == 0
|
|
break
|
|
else
|
|
panic("io.printf: unrecognized format")
|
|
else
|
|
io.print_char(s[0])
|
|
s += 1
|
|
|
|
func io.print_sized[x: ptr, size: i64] : void
|
|
_builtin_syscall(SYS_write, STDOUT_FILENO, x, size)
|
|
|
|
func io.print[x: str] : void
|
|
io.print_sized(x as ptr, x->len())
|
|
|
|
func io.println[x: str] : void
|
|
io.print(x)
|
|
io.print("\n")
|
|
|
|
func io.print_char[x: u8] : void
|
|
io.print_sized(^x, 1)
|
|
|
|
func io.print_bool[x: bool] : void
|
|
if x
|
|
io.print("true")
|
|
else
|
|
io.print("false")
|
|
|
|
func io.print_i64[x: i64] : void
|
|
s := _stackalloc(21)
|
|
x->to_str_buf(s)
|
|
io.print(s as str)
|
|
|
|
func io.print_i64_hex[x: i64] : void
|
|
s := _stackalloc(17)
|
|
x->to_hex_str_buf(s)
|
|
io.print(s as str)
|
|
|
|
func io.println_i64[x: i64] : void
|
|
s := _stackalloc(21)
|
|
x->to_str_buf(s)
|
|
io.println(s as str)
|
|
|
|
// TODO: fix when we implement f64 params
|
|
func io.print_f64[x: i64] : void
|
|
s := _stackalloc(64)
|
|
f64.to_str_buf(x, s)
|
|
io.print(s as str)
|
|
|
|
func io.read_char[] : u8
|
|
c := 0 as u8
|
|
_builtin_syscall(SYS_read, STDIN_FILENO, ^c, 1)
|
|
return c
|
|
|
|
func io.read_line[] : str
|
|
b := new str.Builder
|
|
while true
|
|
c := io.read_char()
|
|
if c == '\n'
|
|
break
|
|
b->append_char(c)
|
|
return b->build_and_free_buffer()
|
|
|
|
func io.read_text_file[path: str] : str, bool
|
|
fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_RDONLY, 0)
|
|
if fd < 0
|
|
return 0 as str, false
|
|
|
|
size := _builtin_syscall(SYS_lseek, fd, 0, SEEK_END)
|
|
_builtin_syscall(SYS_lseek, fd, 0, SEEK_SET)
|
|
|
|
buffer := mem.alloc(size + 1)
|
|
n := _builtin_syscall(SYS_read, fd, buffer, size)
|
|
_builtin_syscall(SYS_close, fd)
|
|
|
|
if n != size
|
|
buffer->free()
|
|
return 0 as str, false
|
|
|
|
buffer[n] = 0
|
|
return buffer as str, true
|
|
|
|
func io.read_binary_file[path: str] : Blob, bool
|
|
fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_RDONLY, 0)
|
|
if fd < 0
|
|
return 0 as Blob, false
|
|
|
|
buf := new* Blob
|
|
buf->size = _builtin_syscall(SYS_lseek, fd, 0, SEEK_END)
|
|
_builtin_syscall(SYS_lseek, fd, 0, SEEK_SET)
|
|
|
|
buf->data = mem.alloc(buf->size)
|
|
|
|
n := _builtin_syscall(SYS_read, fd, buf->data, buf->size)
|
|
_builtin_syscall(SYS_close, fd)
|
|
|
|
if n != buf->size
|
|
buf->free()
|
|
return 0 as Blob, false
|
|
|
|
return buf, true
|
|
|
|
func io.write_file[path: str, content: str] : bool
|
|
return io.write_binary_file(path, content as ptr, content->len())
|
|
|
|
func io.write_binary_file[path: str, content: ptr, size: i64] : bool
|
|
fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_WRONLY|O_CREAT|O_TRUNC, math.octal_to_decimal(644))
|
|
if fd < 0
|
|
return false
|
|
|
|
n := _builtin_syscall(SYS_write, fd, content, size)
|
|
_builtin_syscall(SYS_close, fd)
|
|
if n != size
|
|
return false
|
|
return true
|