1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
// SPDX-License-Identifier: MPL-2.0
// (c) Hare authors <https://harelang.org>
use errors;
use rt;
// This is an opaque type which encloses an OS-level file handle resource. It
// can be used as a [[handle]] in most situations, but there are some APIs which
// require a [[file]] with some OS-level handle backing it - this type is used
// for such APIs.
//
// On Linux, [[file]] is a file descriptor.
export type file = int;
// Opens a Unix file descriptor as a file. This is a low-level interface, to
// open files most programs will use something like [[os::open]]. This function
// is not portable.
export fn fdopen(fd: int) file = fd;
fn fd_read(fd: file, buf: []u8) (size | EOF | error) = {
match (rt::read(fd, buf: *[*]u8, len(buf))) {
case let err: rt::errno =>
return errors::errno(err);
case let n: size =>
switch (n) {
case 0 =>
return EOF;
case =>
return n;
};
};
};
fn fd_write(fd: file, buf: const []u8) (size | error) = {
match (rt::write(fd, buf: *const [*]u8, len(buf))) {
case let err: rt::errno =>
return errors::errno(err);
case let n: size =>
return n;
};
};
fn fd_close(fd: file) (void | error) = {
match (rt::close(fd)) {
case void => void;
case let err: rt::errno =>
return errors::errno(err);
};
};
fn fd_seek(
fd: file,
offs: off,
whence: whence,
) (off | error) = {
match (rt::lseek(fd, offs: i64, whence: int)) {
case let err: rt::errno =>
return errors::errno(err);
case let n: i64 =>
return n: off;
};
};
def SENDFILE_MAX: size = 2147479552z;
fn fd_copy(to: file, from: file) (size | error) = {
let sum = 0z;
for (true) match (rt::sendfile(to, from, null, SENDFILE_MAX)) {
case let err: rt::errno =>
if (err == rt::EINVAL && sum == 0) {
return errors::unsupported;
};
return errors::errno(err);
case let n: size =>
if (n == 0) break;
sum += n;
};
return sum;
};
fn fd_lock(fd: file, flags: int) (bool | error) = {
match (rt::flock(fd: int, flags)) {
case void => return true;
case let e: rt::errno =>
if (e == rt::EWOULDBLOCK: rt::errno) {
return false;
} else {
return errors::errno(e);
};
};
};
fn fd_trunc(fd: file, ln: size) (void | error) = {
match (rt::ftruncate(fd: int, ln: rt::off_t)) {
case void => void;
case let e: rt::errno => return errors::errno(e);
};
};
|
