0b5bcd2f56
* `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
88 lines
3.2 KiB
Zig
88 lines
3.2 KiB
Zig
const std = @import("../std.zig");
|
|
const builtin = @import("builtin");
|
|
const root = @import("root");
|
|
const mem = std.mem;
|
|
|
|
pub const default_stack_size = 1 * 1024 * 1024;
|
|
pub const stack_size: usize = if (@hasDecl(root, "stack_size_std_io_OutStream"))
|
|
root.stack_size_std_io_OutStream
|
|
else
|
|
default_stack_size;
|
|
|
|
pub fn OutStream(comptime WriteError: type) type {
|
|
return struct {
|
|
const Self = @This();
|
|
pub const Error = WriteError;
|
|
pub const WriteFn = if (std.io.is_async)
|
|
async fn (self: *Self, bytes: []const u8) Error!void
|
|
else
|
|
fn (self: *Self, bytes: []const u8) Error!void;
|
|
|
|
writeFn: WriteFn,
|
|
|
|
pub fn write(self: *Self, bytes: []const u8) Error!void {
|
|
if (std.io.is_async) {
|
|
// Let's not be writing 0xaa in safe modes for upwards of 4 MiB for every stream write.
|
|
@setRuntimeSafety(false);
|
|
var stack_frame: [stack_size]u8 align(std.Target.stack_align) = undefined;
|
|
return await @asyncCall(&stack_frame, {}, self.writeFn, self, bytes);
|
|
} else {
|
|
return self.writeFn(self, bytes);
|
|
}
|
|
}
|
|
|
|
pub fn print(self: *Self, comptime format: []const u8, args: var) Error!void {
|
|
return std.fmt.format(self, Error, write, format, args);
|
|
}
|
|
|
|
pub fn writeByte(self: *Self, byte: u8) Error!void {
|
|
const array = [1]u8{byte};
|
|
return self.write(&array);
|
|
}
|
|
|
|
pub fn writeByteNTimes(self: *Self, byte: u8, n: usize) Error!void {
|
|
var bytes: [256]u8 = undefined;
|
|
mem.set(u8, bytes[0..], byte);
|
|
|
|
var remaining: usize = n;
|
|
while (remaining > 0) {
|
|
const to_write = std.math.min(remaining, bytes.len);
|
|
try self.write(bytes[0..to_write]);
|
|
remaining -= to_write;
|
|
}
|
|
}
|
|
|
|
/// Write a native-endian integer.
|
|
pub fn writeIntNative(self: *Self, comptime T: type, value: T) Error!void {
|
|
var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
|
|
mem.writeIntNative(T, &bytes, value);
|
|
return self.write(&bytes);
|
|
}
|
|
|
|
/// Write a foreign-endian integer.
|
|
pub fn writeIntForeign(self: *Self, comptime T: type, value: T) Error!void {
|
|
var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
|
|
mem.writeIntForeign(T, &bytes, value);
|
|
return self.write(&bytes);
|
|
}
|
|
|
|
pub fn writeIntLittle(self: *Self, comptime T: type, value: T) Error!void {
|
|
var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
|
|
mem.writeIntLittle(T, &bytes, value);
|
|
return self.write(&bytes);
|
|
}
|
|
|
|
pub fn writeIntBig(self: *Self, comptime T: type, value: T) Error!void {
|
|
var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
|
|
mem.writeIntBig(T, &bytes, value);
|
|
return self.write(&bytes);
|
|
}
|
|
|
|
pub fn writeInt(self: *Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {
|
|
var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
|
|
mem.writeInt(T, &bytes, value, endian);
|
|
return self.write(&bytes);
|
|
}
|
|
};
|
|
}
|