mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 13:54:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

update standalone and incremental tests to new API

Browse source
This commit is contained in:
Andrew Kelley 2025-07-07 19:33:20 -07:00
parent c873c2eed9
commit d8e26275f2
72 changed files with 347 additions and 892 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
doc/langref.html.in
View file

@ -374,7 +374,8 @@
<p>
Most of the time, it is more appropriate to write to stderr rather than stdout, and
whether or not the message is successfully written to the stream is irrelevant.
For this common case, there is a simpler API:
Also, formatted printing often comes in handy. For this common case,
there is a simpler API:
</p>
{#code|hello_again.zig#}

2
doc/langref/bad_default_value.zig
View file

@ -17,7 +17,7 @@ pub fn main() !void {
.maximum = 0.20,
};
const category = threshold.categorize(0.90);
try std.io.getStdOut().writeAll(@tagName(category));
try std.fs.File.stdout().writeAll(@tagName(category));
}
const std = @import("std");

3
doc/langref/hello.zig
View file

@ -1,8 +1,7 @@
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, {s}!\n", .{"world"});
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
// exe=succeed

2
doc/langref/hello_again.zig
View file

@ -1,7 +1,7 @@
const std = @import("std");
pub fn main() void {
std.debug.print("Hello, world!\n", .{});
std.debug.print("Hello, {s}!\n", .{"World"});
}
// exe=succeed

27
lib/compiler/resinator/cli.zig
View file

@ -125,13 +125,12 @@ pub const Diagnostics = struct {
}
pub fn renderToStdErr(self: *Diagnostics, args: []const []const u8, config: std.io.tty.Config) void {
std.debug.lockStdErr();
defer std.debug.unlockStdErr();
const stderr = std.fs.File.stderr().deprecatedWriter();
const stderr = std.debug.lockStderrWriter(&.{});
defer std.debug.unlockStderrWriter();
self.renderToWriter(args, stderr, config) catch return;
}
pub fn renderToWriter(self: *Diagnostics, args: []const []const u8, writer: anytype, config: std.io.tty.Config) !void {
pub fn renderToWriter(self: *Diagnostics, args: []const []const u8, writer: *std.io.Writer, config: std.io.tty.Config) !void {
for (self.errors.items) |err_details| {
try renderErrorMessage(writer, config, err_details, args);
}
@ -1403,7 +1402,7 @@ test parsePercent {
try std.testing.expectError(error.InvalidFormat, parsePercent("~1"));
}
pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, err_details: Diagnostics.ErrorDetails, args: []const []const u8) !void {
pub fn renderErrorMessage(writer: *std.io.Writer, config: std.io.tty.Config, err_details: Diagnostics.ErrorDetails, args: []const []const u8) !void {
try config.setColor(writer, .dim);
try writer.writeAll("<cli>");
try config.setColor(writer, .reset);
@ -1481,27 +1480,27 @@ pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, err_detail
try writer.writeByte('\n');
try config.setColor(writer, .green);
try writer.writeByteNTimes(' ', prefix.len);
try writer.splatByteAll(' ', prefix.len);
// Special case for when the option is *only* a prefix (e.g. invalid option: -)
if (err_details.arg_span.prefix_len == arg_with_name.len) {
try writer.writeByteNTimes('^', err_details.arg_span.prefix_len);
try writer.splatByteAll('^', err_details.arg_span.prefix_len);
} else {
try writer.writeByteNTimes('~', err_details.arg_span.prefix_len);
try writer.writeByteNTimes(' ', err_details.arg_span.name_offset - err_details.arg_span.prefix_len);
try writer.splatByteAll('~', err_details.arg_span.prefix_len);
try writer.splatByteAll(' ', err_details.arg_span.name_offset - err_details.arg_span.prefix_len);
if (!err_details.arg_span.point_at_next_arg and err_details.arg_span.value_offset == 0) {
try writer.writeByte('^');
try writer.writeByteNTimes('~', name_slice.len - 1);
try writer.splatByteAll('~', name_slice.len - 1);
} else if (err_details.arg_span.value_offset > 0) {
try writer.writeByteNTimes('~', err_details.arg_span.value_offset - err_details.arg_span.name_offset);
try writer.splatByteAll('~', err_details.arg_span.value_offset - err_details.arg_span.name_offset);
try writer.writeByte('^');
if (err_details.arg_span.value_offset < arg_with_name.len) {
try writer.writeByteNTimes('~', arg_with_name.len - err_details.arg_span.value_offset - 1);
try writer.splatByteAll('~', arg_with_name.len - err_details.arg_span.value_offset - 1);
}
} else if (err_details.arg_span.point_at_next_arg) {
try writer.writeByteNTimes('~', arg_with_name.len - err_details.arg_span.name_offset + 1);
try writer.splatByteAll('~', arg_with_name.len - err_details.arg_span.name_offset + 1);
try writer.writeByte('^');
if (next_arg_len > 0) {
try writer.writeByteNTimes('~', next_arg_len - 1);
try writer.splatByteAll('~', next_arg_len - 1);
}
}
}

37
lib/compiler/resinator/errors.zig
View file

@ -62,9 +62,8 @@ pub const Diagnostics = struct {
}
pub fn renderToStdErr(self: *Diagnostics, cwd: std.fs.Dir, source: []const u8, tty_config: std.io.tty.Config, source_mappings: ?SourceMappings) void {
std.debug.lockStdErr();
defer std.debug.unlockStdErr();
const stderr = std.fs.File.stderr().deprecatedWriter();
const stderr = std.debug.lockStderrWriter(&.{});
defer std.debug.unlockStderrWriter();
for (self.errors.items) |err_details| {
renderErrorMessage(stderr, tty_config, cwd, err_details, source, self.strings.items, source_mappings) catch return;
}
@ -445,7 +444,7 @@ pub const ErrorDetails = struct {
pub fn render(self: ErrorDetails, writer: anytype, source: []const u8, strings: []const []const u8) !void {
switch (self.err) {
.unfinished_string_literal => {
return writer.print("unfinished string literal at '{s}', expected closing '\"'", .{self.fmtToken(source)});
return writer.print("unfinished string literal at '{f}', expected closing '\"'", .{self.fmtToken(source)});
},
.string_literal_too_long => {
return writer.print("string literal too long (max is currently {} characters)", .{self.extra.number});
@ -524,26 +523,26 @@ pub const ErrorDetails = struct {
return writer.print("unsupported code page '{s} (id={})' in #pragma code_page", .{ @tagName(code_page), number });
},
.unfinished_raw_data_block => {
return writer.print("unfinished raw data block at '{s}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
return writer.print("unfinished raw data block at '{f}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
},
.unfinished_string_table_block => {
return writer.print("unfinished STRINGTABLE block at '{s}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
return writer.print("unfinished STRINGTABLE block at '{f}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
},
.expected_token => {
return writer.print("expected '{s}', got '{s}'", .{ self.extra.expected.nameForErrorDisplay(), self.fmtToken(source) });
return writer.print("expected '{s}', got '{f}'", .{ self.extra.expected.nameForErrorDisplay(), self.fmtToken(source) });
},
.expected_something_else => {
try writer.writeAll("expected ");
try self.extra.expected_types.writeCommaSeparated(writer);
return writer.print("; got '{s}'", .{self.fmtToken(source)});
return writer.print("; got '{f}'", .{self.fmtToken(source)});
},
.resource_type_cant_use_raw_data => switch (self.type) {
.err, .warning => try writer.print("expected '<filename>', found '{s}' (resource type '{s}' can't use raw data)", .{ self.fmtToken(source), self.extra.resource.nameForErrorDisplay() }),
.note => try writer.print("if '{s}' is intended to be a filename, it must be specified as a quoted string literal", .{self.fmtToken(source)}),
.err, .warning => try writer.print("expected '<filename>', found '{f}' (resource type '{s}' can't use raw data)", .{ self.fmtToken(source), self.extra.resource.nameForErrorDisplay() }),
.note => try writer.print("if '{f}' is intended to be a filename, it must be specified as a quoted string literal", .{self.fmtToken(source)}),
.hint => return,
},
.id_must_be_ordinal => {
try writer.print("id of resource type '{s}' must be an ordinal (u16), got '{s}'", .{ self.extra.resource.nameForErrorDisplay(), self.fmtToken(source) });
try writer.print("id of resource type '{s}' must be an ordinal (u16), got '{f}'", .{ self.extra.resource.nameForErrorDisplay(), self.fmtToken(source) });
},
.name_or_id_not_allowed => {
try writer.print("name or id is not allowed for resource type '{s}'", .{self.extra.resource.nameForErrorDisplay()});
@ -559,7 +558,7 @@ pub const ErrorDetails = struct {
try writer.writeAll("ASCII character not equivalent to virtual key code");
},
.empty_menu_not_allowed => {
try writer.print("empty menu of type '{s}' not allowed", .{self.fmtToken(source)});
try writer.print("empty menu of type '{f}' not allowed", .{self.fmtToken(source)});
},
.rc_would_miscompile_version_value_padding => switch (self.type) {
.err, .warning => return writer.print("the padding before this quoted string value would be miscompiled by the Win32 RC compiler", .{}),
@ -624,7 +623,7 @@ pub const ErrorDetails = struct {
.string_already_defined => switch (self.type) {
.err, .warning => {
const language = self.extra.string_and_language.language;
return writer.print("string with id {d} (0x{X}) already defined for language {}", .{ self.extra.string_and_language.id, self.extra.string_and_language.id, language });
return writer.print("string with id {d} (0x{X}) already defined for language {f}", .{ self.extra.string_and_language.id, self.extra.string_and_language.id, language });
},
.note => return writer.print("previous definition of string with id {d} (0x{X}) here", .{ self.extra.string_and_language.id, self.extra.string_and_language.id }),
.hint => return,
@ -639,7 +638,7 @@ pub const ErrorDetails = struct {
try writer.print("unable to open file '{s}': {s}", .{ strings[self.extra.file_open_error.filename_string_index], @tagName(self.extra.file_open_error.err) });
},
.invalid_accelerator_key => {
try writer.print("invalid accelerator key '{s}': {s}", .{ self.fmtToken(source), @tagName(self.extra.accelerator_error.err) });
try writer.print("invalid accelerator key '{f}': {s}", .{ self.fmtToken(source), @tagName(self.extra.accelerator_error.err) });
},
.accelerator_type_required => {
try writer.writeAll("accelerator type [ASCII or VIRTKEY] required when key is an integer");
@ -895,7 +894,7 @@ fn cellCount(code_page: SupportedCodePage, source: []const u8, start_index: usiz
const truncated_str = "<...truncated...>";
pub fn renderErrorMessage(writer: anytype, tty_config: std.io.tty.Config, cwd: std.fs.Dir, err_details: ErrorDetails, source: []const u8, strings: []const []const u8, source_mappings: ?SourceMappings) !void {
pub fn renderErrorMessage(writer: *std.io.Writer, tty_config: std.io.tty.Config, cwd: std.fs.Dir, err_details: ErrorDetails, source: []const u8, strings: []const []const u8, source_mappings: ?SourceMappings) !void {
if (err_details.type == .hint) return;
const source_line_start = err_details.token.getLineStartForErrorDisplay(source);
@ -978,10 +977,10 @@ pub fn renderErrorMessage(writer: anytype, tty_config: std.io.tty.Config, cwd: s
try tty_config.setColor(writer, .green);
const num_spaces = truncated_visual_info.point_offset - truncated_visual_info.before_len;
try writer.writeByteNTimes(' ', num_spaces);
try writer.writeByteNTimes('~', truncated_visual_info.before_len);
try writer.splatByteAll(' ', num_spaces);
try writer.splatByteAll('~', truncated_visual_info.before_len);
try writer.writeByte('^');
try writer.writeByteNTimes('~', truncated_visual_info.after_len);
try writer.splatByteAll('~', truncated_visual_info.after_len);
try writer.writeByte('\n');
try tty_config.setColor(writer, .reset);
@ -1082,7 +1081,7 @@ const CorrespondingLines = struct {
buffered_reader: BufferedReaderType,
code_page: SupportedCodePage,
const BufferedReaderType = std.io.BufferedReader(512, std.fs.File.Reader);
const BufferedReaderType = std.io.BufferedReader(512, std.fs.File.DeprecatedReader);
pub fn init(cwd: std.fs.Dir, err_details: ErrorDetails, line_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {
// We don't do line comparison for this error, so don't print the note if the line

16
lib/compiler/resinator/main.zig
View file

@ -29,7 +29,7 @@ pub fn main() !void {
defer std.process.argsFree(allocator, args);
if (args.len < 2) {
try renderErrorMessage(stderr.deprecatedWriter(), stderr_config, .err, "expected zig lib dir as first argument", .{});
try renderErrorMessage(std.debug.lockStderrWriter(&.{}), stderr_config, .err, "expected zig lib dir as first argument", .{});
std.process.exit(1);
}
const zig_lib_dir = args[1];
@ -343,7 +343,7 @@ pub fn main() !void {
switch (err) {
error.DuplicateResource => {
const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
try error_handler.emitMessage(allocator, .err, "duplicate resource [id: {}, type: {}, language: {}]", .{
try error_handler.emitMessage(allocator, .err, "duplicate resource [id: {f}, type: {f}, language: {f}]", .{
duplicate_resource.name_value,
fmtResourceType(duplicate_resource.type_value),
duplicate_resource.language,
@ -352,7 +352,7 @@ pub fn main() !void {
error.ResourceDataTooLong => {
const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
try error_handler.emitMessage(allocator, .err, "resource has a data length that is too large to be written into a coff section", .{});
try error_handler.emitMessage(allocator, .note, "the resource with the invalid size is [id: {}, type: {}, language: {}]", .{
try error_handler.emitMessage(allocator, .note, "the resource with the invalid size is [id: {f}, type: {f}, language: {f}]", .{
overflow_resource.name_value,
fmtResourceType(overflow_resource.type_value),
overflow_resource.language,
@ -361,7 +361,7 @@ pub fn main() !void {
error.TotalResourceDataTooLong => {
const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
try error_handler.emitMessage(allocator, .err, "total resource data exceeds the maximum of the coff 'size of raw data' field", .{});
try error_handler.emitMessage(allocator, .note, "size overflow occurred when attempting to write this resource: [id: {}, type: {}, language: {}]", .{
try error_handler.emitMessage(allocator, .note, "size overflow occurred when attempting to write this resource: [id: {f}, type: {f}, language: {f}]", .{
overflow_resource.name_value,
fmtResourceType(overflow_resource.type_value),
overflow_resource.language,
@ -645,7 +645,9 @@ const ErrorHandler = union(enum) {
},
.tty => {
// extra newline to separate this line from the aro errors
try renderErrorMessage(std.fs.File.stderr().deprecatedWriter(), self.tty, .err, "{s}\n", .{fail_msg});
const stderr = std.debug.lockStderrWriter(&.{});
defer std.debug.unlockStderrWriter();
try renderErrorMessage(stderr, self.tty, .err, "{s}\n", .{fail_msg});
aro.Diagnostics.render(comp, self.tty);
},
}
@ -690,7 +692,9 @@ const ErrorHandler = union(enum) {
try server.serveErrorBundle(error_bundle);
},
.tty => {
try renderErrorMessage(std.fs.File.stderr().deprecatedWriter(), self.tty, msg_type, format, args);
const stderr = std.debug.lockStderrWriter(&.{});
defer std.debug.unlockStderrWriter();
try renderErrorMessage(stderr, self.tty, msg_type, format, args);
},
}
}

4
lib/compiler/resinator/res.zig
View file

@ -442,7 +442,7 @@ pub const NameOrOrdinal = union(enum) {
pub fn format(self: NameOrOrdinal, w: *std.io.Writer) !void {
switch (self) {
.name => |name| {
try w.print("{s}", .{std.unicode.fmtUtf16Le(name)});
try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
},
.ordinal => |ordinal| {
try w.print("{d}", .{ordinal});
@ -453,7 +453,7 @@ pub const NameOrOrdinal = union(enum) {
fn formatResourceType(self: NameOrOrdinal, w: *std.io.Writer) std.io.Writer.Error!void {
switch (self) {
.name => |name| {
try w.print("{s}", .{std.unicode.fmtUtf16Le(name)});
try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
},
.ordinal => |ordinal| {
if (std.enums.tagName(RT, @enumFromInt(ordinal))) |predefined_type_name| {

2
lib/compiler/resinator/utils.zig
View file

@ -86,7 +86,7 @@ pub const ErrorMessageType = enum { err, warning, note };
/// Used for generic colored errors/warnings/notes, more context-specific error messages
/// are handled elsewhere.
pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, msg_type: ErrorMessageType, comptime format: []const u8, args: anytype) !void {
pub fn renderErrorMessage(writer: *std.io.Writer, config: std.io.tty.Config, msg_type: ErrorMessageType, comptime format: []const u8, args: anytype) !void {
switch (msg_type) {
.err => {
try config.setColor(writer, .bold);

21
lib/fuzzer.zig
View file

@ -9,7 +9,8 @@ pub const std_options = std.Options{
.logFn = logOverride,
};
var log_file: ?std.fs.File = null;
var log_file_buffer: [256]u8 = undefined;
var log_file_writer: ?std.fs.File.Writer = null;
fn logOverride(
comptime level: std.log.Level,
@ -17,15 +18,17 @@ fn logOverride(
comptime format: []const u8,
args: anytype,
) void {
const f = if (log_file) |f| f else f: {
const fw = if (log_file_writer) |*f| f else f: {
const f = fuzzer.cache_dir.createFile("tmp/libfuzzer.log", .{}) catch
@panic("failed to open fuzzer log file");
log_file = f;
break :f f;
log_file_writer = f.writer(&log_file_buffer);
break :f &log_file_writer.?;
};
const prefix1 = comptime level.asText();
const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
f.writer().print(prefix1 ++ prefix2 ++ format ++ "\n", args) catch @panic("failed to write to fuzzer log");
fw.interface.print(prefix1 ++ prefix2 ++ format ++ "\n", args) catch
@panic("failed to write to fuzzer log");
fw.interface.flush() catch @panic("failed to flush fuzzer log");
}
/// Helps determine run uniqueness in the face of recursion.
@ -226,18 +229,18 @@ const Fuzzer = struct {
.read = true,
}) catch |e| switch (e) {
error.PathAlreadyExists => continue,
else => fatal("unable to create '{}{d}: {s}", .{ f.corpus_directory, i, @errorName(err) }),
else => fatal("unable to create '{f}{d}: {s}", .{ f.corpus_directory, i, @errorName(err) }),
};
errdefer input_file.close();
// Initialize the mmap for the current input.
f.input = MemoryMappedList.create(input_file, 0, std.heap.page_size_max) catch |e| {
fatal("unable to init memory map for input at '{}{d}': {s}", .{
fatal("unable to init memory map for input at '{f}{d}': {s}", .{
f.corpus_directory, i, @errorName(e),
});
};
break;
},
else => fatal("unable to read '{}{d}': {s}", .{ f.corpus_directory, i, @errorName(err) }),
else => fatal("unable to read '{f}{d}': {s}", .{ f.corpus_directory, i, @errorName(err) }),
};
errdefer gpa.free(input);
f.corpus.append(gpa, .{
@ -263,7 +266,7 @@ const Fuzzer = struct {
const sub_path = try std.fmt.allocPrint(gpa, "f/{s}", .{f.unit_test_name});
f.corpus_directory = .{
.handle = f.cache_dir.makeOpenPath(sub_path, .{}) catch |err|
fatal("unable to open corpus directory 'f/{s}': {s}", .{ sub_path, @errorName(err) }),
fatal("unable to open corpus directory 'f/{s}': {t}", .{ sub_path, err }),
.path = sub_path,
};
initNextInput(f);

10
lib/std/elf.zig
View file

@ -511,7 +511,7 @@ pub const Header = struct {
pub fn read(parse_source: anytype) !Header {
var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined;
try parse_source.seekableStream().seekTo(0);
try parse_source.reader().readNoEof(&hdr_buf);
try parse_source.deprecatedReader().readNoEof(&hdr_buf);
return Header.parse(&hdr_buf);
}
@ -586,7 +586,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
var phdr: Elf64_Phdr = undefined;
const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
try self.parse_source.seekableStream().seekTo(offset);
try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));
try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
// ELF endianness matches native endianness.
if (self.elf_header.endian == native_endian) return phdr;
@ -599,7 +599,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
var phdr: Elf32_Phdr = undefined;
const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
try self.parse_source.seekableStream().seekTo(offset);
try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));
try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
// ELF endianness does NOT match native endianness.
if (self.elf_header.endian != native_endian) {
@ -636,7 +636,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
var shdr: Elf64_Shdr = undefined;
const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
try self.parse_source.seekableStream().seekTo(offset);
try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));
try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
// ELF endianness matches native endianness.
if (self.elf_header.endian == native_endian) return shdr;
@ -649,7 +649,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
var shdr: Elf32_Shdr = undefined;
const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
try self.parse_source.seekableStream().seekTo(offset);
try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));
try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
// ELF endianness does NOT match native endianness.
if (self.elf_header.endian != native_endian) {

2
lib/std/io/Writer.zig
View file

@ -705,6 +705,8 @@ pub fn sendFileReading(w: *Writer, file_reader: *File.Reader, limit: Limit) File
return n;
}
/// Number of bytes logically written is returned. This excludes bytes from
/// `buffer` because they have already been logically written.
pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllError!usize {
var remaining = @intFromEnum(limit);
while (remaining > 0) {

5
lib/std/os/windows.zig
View file

@ -2812,9 +2812,8 @@ pub fn unexpectedError(err: Win32Error) UnexpectedError {
buf_wstr.len,
null,
);
std.debug.print("error.Unexpected: GetLastError({}): {}\n", .{
@intFromEnum(err),
std.unicode.fmtUtf16Le(buf_wstr[0..len]),
std.debug.print("error.Unexpected: GetLastError({d}): {f}\n", .{
err, std.unicode.fmtUtf16Le(buf_wstr[0..len]),
});
std.debug.dumpCurrentStackTrace(@returnAddress());
}

8
lib/std/zig/parser_test.zig
View file

@ -2744,11 +2744,11 @@ test "zig fmt: preserve spacing" {
\\const std = @import("std");
\\
\\pub fn main() !void {
\\ var stdout_file = std.io.getStdOut;
\\ var stdout_file = std.io.getStdOut;
\\ var stdout_file = std.lol.abcd;
\\ var stdout_file = std.lol.abcd;
\\
\\ var stdout_file = std.io.getStdOut;
\\ var stdout_file = std.io.getStdOut;
\\ var stdout_file = std.lol.abcd;
\\ var stdout_file = std.lol.abcd;
\\}
\\
);

12
src/main.zig
View file

@ -6074,7 +6074,7 @@ fn cmdAstCheck(
const tree = try Ast.parse(arena, source, mode);
var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
const stdout_bw = &stdout_writer.interface;
switch (mode) {
.zig => {
@ -6289,7 +6289,7 @@ fn detectNativeCpuWithLLVM(
}
fn printCpu(cpu: std.Target.Cpu) !void {
var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
const stdout_bw = &stdout_writer.interface;
if (cpu.model.llvm_name) |llvm_name| {
@ -6338,7 +6338,7 @@ fn cmdDumpLlvmInts(
const dl = tm.createTargetDataLayout();
const context = llvm.Context.create();
var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
const stdout_bw = &stdout_writer.interface;
for ([_]u16{ 1, 8, 16, 32, 64, 128, 256 }) |bits| {
const int_type = context.intType(bits);
@ -6367,7 +6367,7 @@ fn cmdDumpZir(
defer f.close();
const zir = try Zcu.loadZirCache(arena, f);
var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
const stdout_bw = &stdout_writer.interface;
{
@ -6453,7 +6453,7 @@ fn cmdChangelist(
var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;
try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);
var stdout_writer = fs.File.stdout().writer(&stdio_buffer);
var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
const stdout_bw = &stdout_writer.interface;
{
try stdout_bw.print("Instruction mappings:\n", .{});
@ -6913,7 +6913,7 @@ fn cmdFetch(
const name = switch (save) {
.no => {
var stdout = fs.File.stdout().writer(&stdio_buffer);
var stdout = fs.File.stdout().writerStreaming(&stdio_buffer);
try stdout.interface.print("{s}\n", .{package_hash_slice});
try stdout.interface.flush();
return cleanExit();

289
test/compare_output.zig
View file

@ -17,15 +17,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\}
, "Hello, world!" ++ if (@import("builtin").os.tag == .windows) "\r\n" else "\n");
cases.add("hello world without libc",
\\const io = @import("std").io;
\\
\\pub fn main() void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", .{@as(u32, 12), @as(u16, 0x12), @as(u8, 'a')}) catch unreachable;
\\}
, "Hello, world!\n 12 12 a\n");
cases.addC("number literals",
\\const std = @import("std");
\\const builtin = @import("builtin");
@ -158,24 +149,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\
);
cases.add("order-independent declarations",
\\const io = @import("std").io;
\\const z = io.stdin_fileno;
\\const x : @TypeOf(y) = 1234;
\\const y : u16 = 5678;
\\pub fn main() void {
\\ var x_local : i32 = print_ok(x);
\\ _ = &x_local;
\\}
\\fn print_ok(val: @TypeOf(x)) @TypeOf(foo) {
\\ _ = val;
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("OK\n", .{}) catch unreachable;
\\ return 0;
\\}
\\const foo : i32 = 0;
, "OK\n");
cases.addC("expose function pointer to C land",
\\const c = @cImport(@cInclude("stdlib.h"));
\\
@ -236,267 +209,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\}
, "3.25\n3\n3.00\n-0.40\n");
cases.add("same named methods in incomplete struct",
\\const io = @import("std").io;
\\
\\const Foo = struct {
\\ field1: Bar,
\\
\\ fn method(a: *const Foo) bool {
\\ _ = a;
\\ return true;
\\ }
\\};
\\
\\const Bar = struct {
\\ field2: i32,
\\
\\ fn method(b: *const Bar) bool {
\\ _ = b;
\\ return true;
\\ }
\\};
\\
\\pub fn main() void {
\\ const bar = Bar {.field2 = 13,};
\\ const foo = Foo {.field1 = bar,};
\\ const stdout = io.getStdOut().writer();
\\ if (!foo.method()) {
\\ stdout.print("BAD\n", .{}) catch unreachable;
\\ }
\\ if (!bar.method()) {
\\ stdout.print("BAD\n", .{}) catch unreachable;
\\ }
\\ stdout.print("OK\n", .{}) catch unreachable;
\\}
, "OK\n");
cases.add("defer with only fallthrough",
\\const io = @import("std").io;
\\pub fn main() void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("before\n", .{}) catch unreachable;
\\ defer stdout.print("defer1\n", .{}) catch unreachable;
\\ defer stdout.print("defer2\n", .{}) catch unreachable;
\\ defer stdout.print("defer3\n", .{}) catch unreachable;
\\ stdout.print("after\n", .{}) catch unreachable;
\\}
, "before\nafter\ndefer3\ndefer2\ndefer1\n");
cases.add("defer with return",
\\const io = @import("std").io;
\\const os = @import("std").os;
\\pub fn main() void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("before\n", .{}) catch unreachable;
\\ defer stdout.print("defer1\n", .{}) catch unreachable;
\\ defer stdout.print("defer2\n", .{}) catch unreachable;
\\ var gpa: @import("std").heap.GeneralPurposeAllocator(.{}) = .init;
\\ defer _ = gpa.deinit();
\\ var arena = @import("std").heap.ArenaAllocator.init(gpa.allocator());
\\ defer arena.deinit();
\\ var args_it = @import("std").process.argsWithAllocator(arena.allocator()) catch unreachable;
\\ if (args_it.skip() and !args_it.skip()) return;
\\ defer stdout.print("defer3\n", .{}) catch unreachable;
\\ stdout.print("after\n", .{}) catch unreachable;
\\}
, "before\ndefer2\ndefer1\n");
cases.add("errdefer and it fails",
\\const io = @import("std").io;
\\pub fn main() void {
\\ do_test() catch return;
\\}
\\fn do_test() !void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("before\n", .{}) catch unreachable;
\\ defer stdout.print("defer1\n", .{}) catch unreachable;
\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
\\ try its_gonna_fail();
\\ defer stdout.print("defer3\n", .{}) catch unreachable;
\\ stdout.print("after\n", .{}) catch unreachable;
\\}
\\fn its_gonna_fail() !void {
\\ return error.IToldYouItWouldFail;
\\}
, "before\ndeferErr\ndefer1\n");
cases.add("errdefer and it passes",
\\const io = @import("std").io;
\\pub fn main() void {
\\ do_test() catch return;
\\}
\\fn do_test() !void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print("before\n", .{}) catch unreachable;
\\ defer stdout.print("defer1\n", .{}) catch unreachable;
\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
\\ try its_gonna_pass();
\\ defer stdout.print("defer3\n", .{}) catch unreachable;
\\ stdout.print("after\n", .{}) catch unreachable;
\\}
\\fn its_gonna_pass() anyerror!void { }
, "before\nafter\ndefer3\ndefer1\n");
cases.addCase(x: {
var tc = cases.create("@embedFile",
\\const foo_txt = @embedFile("foo.txt");
\\const io = @import("std").io;
\\
\\pub fn main() void {
\\ const stdout = io.getStdOut().writer();
\\ stdout.print(foo_txt, .{}) catch unreachable;
\\}
, "1234\nabcd\n");
tc.addSourceFile("foo.txt", "1234\nabcd\n");
break :x tc;
});
cases.addCase(x: {
var tc = cases.create("parsing args",
\\const std = @import("std");
\\const io = std.io;
\\const os = std.os;
\\
\\pub fn main() !void {
\\ var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
\\ defer _ = gpa.deinit();
\\ var arena = std.heap.ArenaAllocator.init(gpa.allocator());
\\ defer arena.deinit();
\\ var args_it = try std.process.argsWithAllocator(arena.allocator());
\\ const stdout = io.getStdOut().writer();
\\ var index: usize = 0;
\\ _ = args_it.skip();
\\ while (args_it.next()) |arg| : (index += 1) {
\\ try stdout.print("{}: {s}\n", .{index, arg});
\\ }
\\}
,
\\0: first arg
\\1: 'a' 'b' \
\\2: bare
\\3: ba""re
\\4: "
\\5: last arg
\\
);
tc.setCommandLineArgs(&[_][]const u8{
"first arg",
"'a' 'b' \\",
"bare",
"ba\"\"re",
"\"",
"last arg",
});
break :x tc;
});
cases.addCase(x: {
var tc = cases.create("parsing args new API",
\\const std = @import("std");
\\const io = std.io;
\\const os = std.os;
\\
\\pub fn main() !void {
\\ var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
\\ defer _ = gpa.deinit();
\\ var arena = std.heap.ArenaAllocator.init(gpa.allocator());
\\ defer arena.deinit();
\\ var args_it = try std.process.argsWithAllocator(arena.allocator());
\\ const stdout = io.getStdOut().writer();
\\ var index: usize = 0;
\\ _ = args_it.skip();
\\ while (args_it.next()) |arg| : (index += 1) {
\\ try stdout.print("{}: {s}\n", .{index, arg});
\\ }
\\}
,
\\0: first arg
\\1: 'a' 'b' \
\\2: bare
\\3: ba""re
\\4: "
\\5: last arg
\\
);
tc.setCommandLineArgs(&[_][]const u8{
"first arg",
"'a' 'b' \\",
"bare",
"ba\"\"re",
"\"",
"last arg",
});
break :x tc;
});
// It is required to override the log function in order to print to stdout instead of stderr
cases.add("std.log per scope log level override",
\\const std = @import("std");
\\
\\pub const std_options: std.Options = .{
\\ .log_level = .debug,
\\
\\ .log_scope_levels = &.{
\\ .{ .scope = .a, .level = .warn },
\\ .{ .scope = .c, .level = .err },
\\ },
\\ .logFn = log,
\\};
\\
\\const loga = std.log.scoped(.a);
\\const logb = std.log.scoped(.b);
\\const logc = std.log.scoped(.c);
\\
\\pub fn main() !void {
\\ loga.debug("", .{});
\\ logb.debug("", .{});
\\ logc.debug("", .{});
\\
\\ loga.info("", .{});
\\ logb.info("", .{});
\\ logc.info("", .{});
\\
\\ loga.warn("", .{});
\\ logb.warn("", .{});
\\ logc.warn("", .{});
\\
\\ loga.err("", .{});
\\ logb.err("", .{});
\\ logc.err("", .{});
\\}
\\pub fn log(
\\ comptime level: std.log.Level,
\\ comptime scope: @TypeOf(.EnumLiteral),
\\ comptime format: []const u8,
\\ args: anytype,
\\) void {
\\ const level_txt = comptime level.asText();
\\ const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "):";
\\ const stdout = std.io.getStdOut().writer();
\\ nosuspend stdout.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return;
\\}
,
\\debug(b):
\\info(b):
\\warning(a):
\\warning(b):
\\error(a):
\\error(b):
\\error(c):
\\
);
cases.add("valid carriage return example", "const io = @import(\"std\").io;\r\n" ++ // Testing CRLF line endings are valid
cases.add("valid carriage return example", "const std = @import(\"std\");\r\n" ++ // Testing CRLF line endings are valid
"\r\n" ++
"pub \r fn main() void {\r\n" ++ // Testing isolated carriage return as whitespace is valid
" const stdout = io.getStdOut().writer();\r\n" ++
" var file_writer = std.fs.File.stdout().writerStreaming(&.{});\r\n" ++
" const stdout = &file_writer.interface;\r\n" ++
" stdout.print(\\\\A Multiline\r\n" ++ // testing CRLF at end of multiline string line is valid and normalises to \n in the output
" \\\\String\r\n" ++
" , .{}) catch unreachable;\r\n" ++

14
test/incremental/add_decl
View file

@ -6,7 +6,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(foo);
try std.fs.File.stdout().writeAll(foo);
}
const foo = "good morning\n";
#expect_stdout="good morning\n"
@ -15,7 +15,7 @@ const foo = "good morning\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(foo);
try std.fs.File.stdout().writeAll(foo);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -25,7 +25,7 @@ const bar = "good evening\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(bar);
try std.fs.File.stdout().writeAll(bar);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -35,17 +35,17 @@ const bar = "good evening\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(qux);
try std.fs.File.stdout().writeAll(qux);
}
const foo = "good morning\n";
const bar = "good evening\n";
#expect_error=main.zig:3:37: error: use of undeclared identifier 'qux'
#expect_error=main.zig:3:39: error: use of undeclared identifier 'qux'
#update=add missing declaration
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(qux);
try std.fs.File.stdout().writeAll(qux);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -56,7 +56,7 @@ const qux = "good night\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(qux);
try std.fs.File.stdout().writeAll(qux);
}
const qux = "good night\n";
#expect_stdout="good night\n"

14
test/incremental/add_decl_namespaced
View file

@ -6,7 +6,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().foo);
try std.fs.File.stdout().writeAll(@This().foo);
}
const foo = "good morning\n";
#expect_stdout="good morning\n"
@ -15,7 +15,7 @@ const foo = "good morning\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().foo);
try std.fs.File.stdout().writeAll(@This().foo);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -25,7 +25,7 @@ const bar = "good evening\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().bar);
try std.fs.File.stdout().writeAll(@This().bar);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -35,18 +35,18 @@ const bar = "good evening\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().qux);
try std.fs.File.stdout().writeAll(@This().qux);
}
const foo = "good morning\n";
const bar = "good evening\n";
#expect_error=main.zig:3:44: error: root source file struct 'main' has no member named 'qux'
#expect_error=main.zig:3:46: error: root source file struct 'main' has no member named 'qux'
#expect_error=main.zig:1:1: note: struct declared here
#update=add missing declaration
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().qux);
try std.fs.File.stdout().writeAll(@This().qux);
}
const foo = "good morning\n";
const bar = "good evening\n";
@ -57,7 +57,7 @@ const qux = "good night\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@This().qux);
try std.fs.File.stdout().writeAll(@This().qux);
}
const qux = "good night\n";
#expect_stdout="good night\n"

4
test/incremental/bad_import
View file

@ -7,7 +7,7 @@
#file=main.zig
pub fn main() !void {
_ = @import("foo.zig");
try std.io.getStdOut().writeAll("success\n");
try std.fs.File.stdout().writeAll("success\n");
}
const std = @import("std");
#file=foo.zig
@ -29,7 +29,7 @@ comptime {
#file=main.zig
pub fn main() !void {
//_ = @import("foo.zig");
try std.io.getStdOut().writeAll("success\n");
try std.fs.File.stdout().writeAll("success\n");
}
const std = @import("std");
#expect_stdout="success\n"

6
test/incremental/change_embed_file
View file

@ -7,7 +7,7 @@
const std = @import("std");
const string = @embedFile("string.txt");
pub fn main() !void {
try std.io.getStdOut().writeAll(string);
try std.fs.File.stdout().writeAll(string);
}
#file=string.txt
Hello, World!
@ -27,7 +27,7 @@ Hello again, World!
const std = @import("std");
const string = @embedFile("string.txt");
pub fn main() !void {
try std.io.getStdOut().writeAll("a hardcoded string\n");
try std.fs.File.stdout().writeAll("a hardcoded string\n");
}
#expect_stdout="a hardcoded string\n"
@ -36,7 +36,7 @@ pub fn main() !void {
const std = @import("std");
const string = @embedFile("string.txt");
pub fn main() !void {
try std.io.getStdOut().writeAll(string);
try std.fs.File.stdout().writeAll(string);
}
#expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound

9
test/incremental/change_enum_tag_type
View file

@ -14,7 +14,8 @@ const Foo = enum(Tag) {
pub fn main() !void {
var val: Foo = undefined;
val = .a;
try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
}
const std = @import("std");
#expect_stdout="a\n"
@ -31,7 +32,8 @@ const Foo = enum(Tag) {
pub fn main() !void {
var val: Foo = undefined;
val = .a;
try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
}
comptime {
// These can't be true at the same time; analysis should stop as soon as it sees `Foo`
@ -53,7 +55,8 @@ const Foo = enum(Tag) {
pub fn main() !void {
var val: Foo = undefined;
val = .a;
try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
}
const std = @import("std");
#expect_stdout="a\n"

18
test/incremental/change_exports
View file

@ -16,7 +16,8 @@ pub fn main() !void {
extern const bar: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{}\n", .{S.bar});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{}\n", .{S.bar});
}
const std = @import("std");
#expect_stdout="123\n"
@ -37,7 +38,8 @@ pub fn main() !void {
extern const other: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
}
const std = @import("std");
#expect_error=main.zig:6:5: error: exported symbol collision: foo
@ -59,7 +61,8 @@ pub fn main() !void {
extern const other: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
}
const std = @import("std");
#expect_stdout="123 456\n"
@ -83,7 +86,8 @@ pub fn main() !void {
extern const other: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
}
const std = @import("std");
#expect_stdout="123 456\n"
@ -128,7 +132,8 @@ pub fn main() !void {
extern const other: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
}
const std = @import("std");
#expect_stdout="123 456\n"
@ -152,7 +157,8 @@ pub fn main() !void {
extern const other: u32;
};
S.foo();
try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
}
const std = @import("std");
#expect_error=main.zig:5:5: error: exported symbol collision: bar

9
test/incremental/change_fn_type
View file

@ -7,7 +7,8 @@ pub fn main() !void {
try foo(123);
}
fn foo(x: u8) !void {
return std.io.getStdOut().writer().print("{d}\n", .{x});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
return stdout_writer.interface.print("{d}\n", .{x});
}
const std = @import("std");
#expect_stdout="123\n"
@ -18,7 +19,8 @@ pub fn main() !void {
try foo(123);
}
fn foo(x: i64) !void {
return std.io.getStdOut().writer().print("{d}\n", .{x});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
return stdout_writer.interface.print("{d}\n", .{x});
}
const std = @import("std");
#expect_stdout="123\n"
@ -29,7 +31,8 @@ pub fn main() !void {
try foo(-42);
}
fn foo(x: i64) !void {
return std.io.getStdOut().writer().print("{d}\n", .{x});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
return stdout_writer.interface.print("{d}\n", .{x});
}
const std = @import("std");
#expect_stdout="-42\n"

4
test/incremental/change_generic_line_number
View file

@ -6,7 +6,7 @@ const std = @import("std");
fn Printer(message: []const u8) type {
return struct {
fn print() !void {
try std.io.getStdOut().writeAll(message);
try std.fs.File.stdout().writeAll(message);
}
};
}
@ -22,7 +22,7 @@ const std = @import("std");
fn Printer(message: []const u8) type {
return struct {
fn print() !void {
try std.io.getStdOut().writeAll(message);
try std.fs.File.stdout().writeAll(message);
}
};
}

4
test/incremental/change_line_number
View file

@ -4,7 +4,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("foo\n");
try std.fs.File.stdout().writeAll("foo\n");
}
#expect_stdout="foo\n"
#update=change line number
@ -12,6 +12,6 @@ pub fn main() !void {
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("foo\n");
try std.fs.File.stdout().writeAll("foo\n");
}
#expect_stdout="foo\n"

9
test/incremental/change_panic_handler
View file

@ -11,7 +11,8 @@ pub fn main() !u8 {
}
pub const panic = std.debug.FullPanic(myPanic);
fn myPanic(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");
@ -27,7 +28,8 @@ pub fn main() !u8 {
}
pub const panic = std.debug.FullPanic(myPanic);
fn myPanic(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("new panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");
@ -43,7 +45,8 @@ pub fn main() !u8 {
}
pub const panic = std.debug.FullPanic(myPanicNew);
fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("third panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");

9
test/incremental/change_panic_handler_explicit
View file

@ -41,7 +41,8 @@ pub const panic = struct {
pub const noreturnReturned = no_panic.noreturnReturned;
};
fn myPanic(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");
@ -87,7 +88,8 @@ pub const panic = struct {
pub const noreturnReturned = no_panic.noreturnReturned;
};
fn myPanic(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("new panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");
@ -133,7 +135,8 @@ pub const panic = struct {
pub const noreturnReturned = no_panic.noreturnReturned;
};
fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
std.io.getStdOut().writer().print("third panic message: {s}\n", .{msg}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
std.process.exit(0);
}
const std = @import("std");

6
test/incremental/change_shift_op
View file

@ -8,7 +8,8 @@ pub fn main() !void {
try foo(0x1300);
}
fn foo(x: u16) !void {
try std.io.getStdOut().writer().print("0x{x}\n", .{x << 4});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("0x{x}\n", .{x << 4});
}
const std = @import("std");
#expect_stdout="0x3000\n"
@ -18,7 +19,8 @@ pub fn main() !void {
try foo(0x1300);
}
fn foo(x: u16) !void {
try std.io.getStdOut().writer().print("0x{x}\n", .{x >> 4});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("0x{x}\n", .{x >> 4});
}
const std = @import("std");
#expect_stdout="0x130\n"

9
test/incremental/change_struct_same_fields
View file

@ -10,7 +10,8 @@ pub fn main() !void {
try foo(&val);
}
fn foo(val: *const S) !void {
try std.io.getStdOut().writer().print(
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print(
"{d} {d}\n",
.{ val.x, val.y },
);
@ -26,7 +27,8 @@ pub fn main() !void {
try foo(&val);
}
fn foo(val: *const S) !void {
try std.io.getStdOut().writer().print(
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print(
"{d} {d}\n",
.{ val.x, val.y },
);
@ -42,7 +44,8 @@ pub fn main() !void {
try foo(&val);
}
fn foo(val: *const S) !void {
try std.io.getStdOut().writer().print(
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print(
"{d} {d}\n",
.{ val.x, val.y },
);

6
test/incremental/change_zon_file
View file

@ -7,7 +7,7 @@
const std = @import("std");
const message: []const u8 = @import("message.zon");
pub fn main() !void {
try std.io.getStdOut().writeAll(message);
try std.fs.File.stdout().writeAll(message);
}
#file=message.zon
"Hello, World!\n"
@ -28,7 +28,7 @@ pub fn main() !void {
const std = @import("std");
const message: []const u8 = @import("message.zon");
pub fn main() !void {
try std.io.getStdOut().writeAll("a hardcoded string\n");
try std.fs.File.stdout().writeAll("a hardcoded string\n");
}
#expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound
#expect_error=main.zig:2:37: note: file imported here
@ -43,6 +43,6 @@ pub fn main() !void {
const std = @import("std");
const message: []const u8 = @import("message.zon");
pub fn main() !void {
try std.io.getStdOut().writeAll(message);
try std.fs.File.stdout().writeAll(message);
}
#expect_stdout="We're back, World!\n"

2
test/incremental/change_zon_file_no_result_type
View file

@ -6,7 +6,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(@import("foo.zon").message);
try std.fs.File.stdout().writeAll(@import("foo.zon").message);
}
#file=foo.zon
.{

6
test/incremental/compile_log
View file

@ -7,7 +7,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_stdout="Hello, World!\n"
@ -15,7 +15,7 @@ pub fn main() !void {
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
@compileLog("this is a log");
}
#expect_error=main.zig:4:5: error: found compile log statement
@ -25,6 +25,6 @@ pub fn main() !void {
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_stdout="Hello, World!\n"

10
test/incremental/fix_astgen_failure
View file

@ -9,28 +9,28 @@ pub fn main() !void {
}
#file=foo.zig
pub fn hello() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_error=foo.zig:2:9: error: use of undeclared identifier 'std'
#update=fix the error
#file=foo.zig
const std = @import("std");
pub fn hello() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_stdout="Hello, World!\n"
#update=add new error
#file=foo.zig
const std = @import("std");
pub fn hello() !void {
try std.io.getStdOut().writeAll(hello_str);
try std.fs.File.stdout().writeAll(hello_str);
}
#expect_error=foo.zig:3:37: error: use of undeclared identifier 'hello_str'
#expect_error=foo.zig:3:39: error: use of undeclared identifier 'hello_str'
#update=fix the new error
#file=foo.zig
const std = @import("std");
const hello_str = "Hello, World! Again!\n";
pub fn hello() !void {
try std.io.getStdOut().writeAll(hello_str);
try std.fs.File.stdout().writeAll(hello_str);
}
#expect_stdout="Hello, World! Again!\n"

6
test/incremental/function_becomes_inline
View file

@ -7,7 +7,7 @@ pub fn main() !void {
try foo();
}
fn foo() !void {
try std.io.getStdOut().writer().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
const std = @import("std");
#expect_stdout="Hello, World!\n"
@ -18,7 +18,7 @@ pub fn main() !void {
try foo();
}
inline fn foo() !void {
try std.io.getStdOut().writer().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
const std = @import("std");
#expect_stdout="Hello, World!\n"
@ -29,7 +29,7 @@ pub fn main() !void {
try foo();
}
inline fn foo() !void {
try std.io.getStdOut().writer().writeAll("Hello, `inline` World!\n");
try std.fs.File.stdout().writeAll("Hello, `inline` World!\n");
}
const std = @import("std");
#expect_stdout="Hello, `inline` World!\n"

4
test/incremental/hello
View file

@ -6,13 +6,13 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("good morning\n");
try std.fs.File.stdout().writeAll("good morning\n");
}
#expect_stdout="good morning\n"
#update=change the string
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("おはようございます\n");
try std.fs.File.stdout().writeAll("おはようございます\n");
}
#expect_stdout="おはようございます\n"

4
test/incremental/make_decl_pub
View file

@ -11,7 +11,7 @@ pub fn main() !void {
#file=foo.zig
const std = @import("std");
fn hello() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_error=main.zig:3:12: error: 'hello' is not marked 'pub'
#expect_error=foo.zig:2:1: note: declared here
@ -20,6 +20,6 @@ fn hello() !void {
#file=foo.zig
const std = @import("std");
pub fn hello() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}
#expect_stdout="Hello, World!\n"

4
test/incremental/modify_inline_fn
View file

@ -7,7 +7,7 @@
const std = @import("std");
pub fn main() !void {
const str = getStr();
try std.io.getStdOut().writeAll(str);
try std.fs.File.stdout().writeAll(str);
}
inline fn getStr() []const u8 {
return "foo\n";
@ -18,7 +18,7 @@ inline fn getStr() []const u8 {
const std = @import("std");
pub fn main() !void {
const str = getStr();
try std.io.getStdOut().writeAll(str);
try std.fs.File.stdout().writeAll(str);
}
inline fn getStr() []const u8 {
return "bar\n";

34
test/incremental/move_src
View file

@ -6,23 +6,9 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writer().print("{d} {d}\n", .{ foo(), bar() });
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{d} {d}\n", .{ foo(), bar() });
}
fn foo() u32 {
return @src().line;
}
fn bar() u32 {
return 123;
}
#expect_stdout="6 123\n"
#update=add newline
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writer().print("{d} {d}\n", .{ foo(), bar() });
}
fn foo() u32 {
return @src().line;
}
@ -30,3 +16,19 @@ fn bar() u32 {
return 123;
}
#expect_stdout="7 123\n"
#update=add newline
#file=main.zig
const std = @import("std");
pub fn main() !void {
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{d} {d}\n", .{ foo(), bar() });
}
fn foo() u32 {
return @src().line;
}
fn bar() u32 {
return 123;
}
#expect_stdout="8 123\n"

4
test/incremental/no_change_preserves_tag_names
View file

@ -7,7 +7,7 @@
const std = @import("std");
var some_enum: enum { first, second } = .first;
pub fn main() !void {
try std.io.getStdOut().writeAll(@tagName(some_enum));
try std.fs.File.stdout().writeAll(@tagName(some_enum));
}
#expect_stdout="first"
#update=no change
@ -15,6 +15,6 @@ pub fn main() !void {
const std = @import("std");
var some_enum: enum { first, second } = .first;
pub fn main() !void {
try std.io.getStdOut().writeAll(@tagName(some_enum));
try std.fs.File.stdout().writeAll(@tagName(some_enum));
}
#expect_stdout="first"

4
test/incremental/recursive_function_becomes_non_recursive
View file

@ -8,7 +8,7 @@ pub fn main() !void {
try foo(false);
}
fn foo(recurse: bool) !void {
const stdout = std.io.getStdOut().writer();
const stdout = std.fs.File.stdout();
if (recurse) return foo(true);
try stdout.writeAll("non-recursive path\n");
}
@ -21,7 +21,7 @@ pub fn main() !void {
try foo(true);
}
fn foo(recurse: bool) !void {
const stdout = std.io.getStdOut().writer();
const stdout = std.fs.File.stdout();
if (recurse) return stdout.writeAll("x==1\n");
try stdout.writeAll("non-recursive path\n");
}

8
test/incremental/remove_enum_field
View file

@ -9,7 +9,8 @@ const MyEnum = enum(u8) {
bar = 2,
};
pub fn main() !void {
try std.io.getStdOut().writer().print("{}\n", .{@intFromEnum(MyEnum.foo)});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
}
const std = @import("std");
#expect_stdout="1\n"
@ -20,8 +21,9 @@ const MyEnum = enum(u8) {
bar = 2,
};
pub fn main() !void {
try std.io.getStdOut().writer().print("{}\n", .{@intFromEnum(MyEnum.foo)});
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
}
const std = @import("std");
#expect_error=main.zig:6:73: error: enum 'main.MyEnum' has no member named 'foo'
#expect_error=main.zig:7:69: error: enum 'main.MyEnum' has no member named 'foo'
#expect_error=main.zig:1:16: note: enum declared here

8
test/incremental/unreferenced_error
View file

@ -6,7 +6,7 @@
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(a);
try std.fs.File.stdout().writeAll(a);
}
const a = "Hello, World!\n";
#expect_stdout="Hello, World!\n"
@ -15,7 +15,7 @@ const a = "Hello, World!\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(a);
try std.fs.File.stdout().writeAll(a);
}
const a = @compileError("bad a");
#expect_error=main.zig:5:11: error: bad a
@ -24,7 +24,7 @@ const a = @compileError("bad a");
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(b);
try std.fs.File.stdout().writeAll(b);
}
const a = @compileError("bad a");
const b = "Hi there!\n";
@ -34,7 +34,7 @@ const b = "Hi there!\n";
#file=main.zig
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll(a);
try std.fs.File.stdout().writeAll(a);
}
const a = "Back to a\n";
const b = @compileError("bad b");

5
test/link/bss/main.zig
View file

@ -4,8 +4,11 @@ const std = @import("std");
var buffer: [0x1000000]u64 = [1]u64{0} ** 0x1000000;
pub fn main() anyerror!void {
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
buffer[0x10] = 1;
try std.io.getStdOut().writer().print("{d}, {d}, {d}\n", .{
try stdout_writer.interface.print("{d}, {d}, {d}\n", .{
// workaround the dreaded decl_val
(&buffer)[0],
(&buffer)[0x10],

8
test/link/elf.zig
View file

@ -1315,8 +1315,8 @@ fn testGcSectionsZig(b: *Build, opts: Options) *Step {
\\extern var live_var2: i32;
\\extern fn live_fn2() void;
\\pub fn main() void {
\\ const stdout = std.io.getStdOut();
\\ stdout.deprecatedWriter().print("{d} {d}\n", .{ live_var1, live_var2 }) catch unreachable;
\\ var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
\\ stdout_writer.interface.print("{d} {d}\n", .{ live_var1, live_var2 }) catch @panic("fail");
\\ live_fn2();
\\}
,
@ -1357,8 +1357,8 @@ fn testGcSectionsZig(b: *Build, opts: Options) *Step {
\\extern var live_var2: i32;
\\extern fn live_fn2() void;
\\pub fn main() void {
\\ const stdout = std.io.getStdOut();
\\ stdout.deprecatedWriter().print("{d} {d}\n", .{ live_var1, live_var2 }) catch unreachable;
\\ var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
\\ stdout_writer.interface.print("{d} {d}\n", .{ live_var1, live_var2 }) catch @panic("fail");
\\ live_fn2();
\\}
,

7
test/link/macho.zig
View file

@ -710,7 +710,7 @@ fn testHelloZig(b: *Build, opts: Options) *Step {
const exe = addExecutable(b, opts, .{ .name = "main", .zig_source_bytes =
\\const std = @import("std");
\\pub fn main() void {
\\ std.io.getStdOut().writer().print("Hello world!\n", .{}) catch unreachable;
\\ std.fs.File.stdout().writeAll("Hello world!\n") catch @panic("fail");
\\}
});
@ -2365,10 +2365,11 @@ fn testTlsZig(b: *Build, opts: Options) *Step {
\\threadlocal var x: i32 = 0;
\\threadlocal var y: i32 = -1;
\\pub fn main() void {
\\ std.io.getStdOut().writer().print("{d} {d}\n", .{x, y}) catch unreachable;
\\ var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
\\ stdout_writer.interface.print("{d} {d}\n", .{x, y}) catch unreachable;
\\ x -= 1;
\\ y += 1;
\\ std.io.getStdOut().writer().print("{d} {d}\n", .{x, y}) catch unreachable;
\\ stdout_writer.interface.print("{d} {d}\n", .{x, y}) catch unreachable;
\\}
});

4
test/link/wasm/extern/main.zig vendored
View file

@ -3,6 +3,6 @@ const std = @import("std");
extern const foo: u32;
pub fn main() void {
const std_out = std.io.getStdOut();
std_out.writer().print("Result: {d}", .{foo}) catch {};
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
stdout_writer.interface.print("Result: {d}", .{foo}) catch {};
}

2
test/src/check-stack-trace.zig
View file

@ -84,5 +84,5 @@ pub fn main() !void {
break :got_result try buf.toOwnedSlice();
};
try std.io.getStdOut().writeAll(got);
try std.fs.File.stdout().writeAll(got);
}

7
test/standalone/child_process/child.zig
View file

@ -27,12 +27,12 @@ fn run(allocator: std.mem.Allocator) !void {
}
// test stdout pipe; parent verifies
try std.io.getStdOut().writer().writeAll("hello from stdout");
try std.fs.File.stdout().writeAll("hello from stdout");
// test stdin pipe from parent
const hello_stdin = "hello from stdin";
var buf: [hello_stdin.len]u8 = undefined;
const stdin = std.io.getStdIn().reader();
const stdin: std.fs.File = .stdin();
const n = try stdin.readAll(&buf);
if (!std.mem.eql(u8, buf[0..n], hello_stdin)) {
testError("stdin: '{s}'; want '{s}'", .{ buf[0..n], hello_stdin });
@ -40,7 +40,8 @@ fn run(allocator: std.mem.Allocator) !void {
}
fn testError(comptime fmt: []const u8, args: anytype) void {
const stderr = std.io.getStdErr().writer();
var stderr_writer = std.fs.File.stderr().writer(&.{});
const stderr = &stderr_writer.interface;
stderr.print("CHILD TEST ERROR: ", .{}) catch {};
stderr.print(fmt, args) catch {};
if (fmt[fmt.len - 1] != '\n') {

7
test/standalone/child_process/main.zig
View file

@ -19,13 +19,13 @@ pub fn main() !void {
child.stderr_behavior = .Inherit;
try child.spawn();
const child_stdin = child.stdin.?;
try child_stdin.writer().writeAll("hello from stdin"); // verified in child
try child_stdin.writeAll("hello from stdin"); // verified in child
child_stdin.close();
child.stdin = null;
const hello_stdout = "hello from stdout";
var buf: [hello_stdout.len]u8 = undefined;
const n = try child.stdout.?.reader().readAll(&buf);
const n = try child.stdout.?.deprecatedReader().readAll(&buf);
if (!std.mem.eql(u8, buf[0..n], hello_stdout)) {
testError("child stdout: '{s}'; want '{s}'", .{ buf[0..n], hello_stdout });
}
@ -45,7 +45,8 @@ pub fn main() !void {
var parent_test_error = false;
fn testError(comptime fmt: []const u8, args: anytype) void {
const stderr = std.io.getStdErr().writer();
var stderr_writer = std.fs.File.stderr().writer(&.{});
const stderr = &stderr_writer.interface;
stderr.print("PARENT TEST ERROR: ", .{}) catch {};
stderr.print(fmt, args) catch {};
if (fmt[fmt.len - 1] != '\n') {

2
test/standalone/sigpipe/breakpipe.zig
View file

@ -10,7 +10,7 @@ pub fn main() !void {
std.posix.close(pipe[0]);
_ = std.posix.write(pipe[1], "a") catch |err| switch (err) {
error.BrokenPipe => {
try std.io.getStdOut().writer().writeAll("BrokenPipe\n");
try std.fs.File.stdout().writeAll("BrokenPipe\n");
std.posix.exit(123);
},
else => |e| return e,

292
test/standalone/simple/brace_expansion.zig
View file

@ -1,292 +0,0 @@
const std = @import("std");
const io = std.io;
const mem = std.mem;
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const ArrayList = std.ArrayList;
const maxInt = std.math.maxInt;
const Token = union(enum) {
Word: []const u8,
OpenBrace,
CloseBrace,
Comma,
Eof,
};
var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
var global_allocator = gpa.allocator();
fn tokenize(input: []const u8) !ArrayList(Token) {
const State = enum {
Start,
Word,
};
var token_list = ArrayList(Token).init(global_allocator);
errdefer token_list.deinit();
var tok_begin: usize = undefined;
var state = State.Start;
for (input, 0..) |b, i| {
switch (state) {
.Start => switch (b) {
'a'...'z', 'A'...'Z' => {
state = State.Word;
tok_begin = i;
},
'{' => try token_list.append(Token.OpenBrace),
'}' => try token_list.append(Token.CloseBrace),
',' => try token_list.append(Token.Comma),
else => return error.InvalidInput,
},
.Word => switch (b) {
'a'...'z', 'A'...'Z' => {},
'{', '}', ',' => {
try token_list.append(Token{ .Word = input[tok_begin..i] });
switch (b) {
'{' => try token_list.append(Token.OpenBrace),
'}' => try token_list.append(Token.CloseBrace),
',' => try token_list.append(Token.Comma),
else => unreachable,
}
state = State.Start;
},
else => return error.InvalidInput,
},
}
}
switch (state) {
State.Start => {},
State.Word => try token_list.append(Token{ .Word = input[tok_begin..] }),
}
try token_list.append(Token.Eof);
return token_list;
}
const Node = union(enum) {
Scalar: []const u8,
List: ArrayList(Node),
Combine: []Node,
fn deinit(self: Node) void {
switch (self) {
.Scalar => {},
.Combine => |pair| {
pair[0].deinit();
pair[1].deinit();
global_allocator.free(pair);
},
.List => |list| {
for (list.items) |item| {
item.deinit();
}
list.deinit();
},
}
}
};
const ParseError = error{
InvalidInput,
OutOfMemory,
};
fn parse(tokens: *const ArrayList(Token), token_index: *usize) ParseError!Node {
const first_token = tokens.items[token_index.*];
token_index.* += 1;
const result_node = switch (first_token) {
.Word => |word| Node{ .Scalar = word },
.OpenBrace => blk: {
var list = ArrayList(Node).init(global_allocator);
errdefer {
for (list.items) |node| node.deinit();
list.deinit();
}
while (true) {
try list.append(try parse(tokens, token_index));
const token = tokens.items[token_index.*];
token_index.* += 1;
switch (token) {
.CloseBrace => break,
.Comma => continue,
else => return error.InvalidInput,
}
}
break :blk Node{ .List = list };
},
else => return error.InvalidInput,
};
switch (tokens.items[token_index.*]) {
.Word, .OpenBrace => {
const pair = try global_allocator.alloc(Node, 2);
errdefer global_allocator.free(pair);
pair[0] = result_node;
pair[1] = try parse(tokens, token_index);
return Node{ .Combine = pair };
},
else => return result_node,
}
}
fn expandString(input: []const u8, output: *ArrayList(u8)) !void {
const tokens = try tokenize(input);
defer tokens.deinit();
if (tokens.items.len == 1) {
return output.resize(0);
}
var token_index: usize = 0;
const root = try parse(&tokens, &token_index);
defer root.deinit();
const last_token = tokens.items[token_index];
switch (last_token) {
Token.Eof => {},
else => return error.InvalidInput,
}
var result_list = ArrayList(ArrayList(u8)).init(global_allocator);
defer {
for (result_list.items) |*buf| buf.deinit();
result_list.deinit();
}
try expandNode(root, &result_list);
try output.resize(0);
for (result_list.items, 0..) |buf, i| {
if (i != 0) {
try output.append(' ');
}
try output.appendSlice(buf.items);
}
}
const ExpandNodeError = error{OutOfMemory};
fn expandNode(node: Node, output: *ArrayList(ArrayList(u8))) ExpandNodeError!void {
assert(output.items.len == 0);
switch (node) {
.Scalar => |scalar| {
var list = ArrayList(u8).init(global_allocator);
errdefer list.deinit();
try list.appendSlice(scalar);
try output.append(list);
},
.Combine => |pair| {
const a_node = pair[0];
const b_node = pair[1];
var child_list_a = ArrayList(ArrayList(u8)).init(global_allocator);
defer {
for (child_list_a.items) |*buf| buf.deinit();
child_list_a.deinit();
}
try expandNode(a_node, &child_list_a);
var child_list_b = ArrayList(ArrayList(u8)).init(global_allocator);
defer {
for (child_list_b.items) |*buf| buf.deinit();
child_list_b.deinit();
}
try expandNode(b_node, &child_list_b);
for (child_list_a.items) |buf_a| {
for (child_list_b.items) |buf_b| {
var combined_buf = ArrayList(u8).init(global_allocator);
errdefer combined_buf.deinit();
try combined_buf.appendSlice(buf_a.items);
try combined_buf.appendSlice(buf_b.items);
try output.append(combined_buf);
}
}
},
.List => |list| {
for (list.items) |child_node| {
var child_list = ArrayList(ArrayList(u8)).init(global_allocator);
errdefer for (child_list.items) |*buf| buf.deinit();
defer child_list.deinit();
try expandNode(child_node, &child_list);
for (child_list.items) |buf| {
try output.append(buf);
}
}
},
}
}
pub fn main() !void {
defer _ = gpa.deinit();
const stdin_file = io.getStdIn();
const stdout_file = io.getStdOut();
const stdin = try stdin_file.deprecatedReader().readAllAlloc(global_allocator, std.math.maxInt(usize));
defer global_allocator.free(stdin);
var result_buf = ArrayList(u8).init(global_allocator);
defer result_buf.deinit();
try expandString(stdin, &result_buf);
try stdout_file.writeAll(result_buf.items);
}
test "invalid inputs" {
global_allocator = std.testing.allocator;
try expectError("}ABC", error.InvalidInput);
try expectError("{ABC", error.InvalidInput);
try expectError("}{", error.InvalidInput);
try expectError("{}", error.InvalidInput);
try expectError("A,B,C", error.InvalidInput);
try expectError("{A{B,C}", error.InvalidInput);
try expectError("{A,}", error.InvalidInput);
try expectError("\n", error.InvalidInput);
}
fn expectError(test_input: []const u8, expected_err: anyerror) !void {
var output_buf = ArrayList(u8).init(global_allocator);
defer output_buf.deinit();
try testing.expectError(expected_err, expandString(test_input, &output_buf));
}
test "valid inputs" {
global_allocator = std.testing.allocator;
try expectExpansion("{x,y,z}", "x y z");
try expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
try expectExpansion("{A,B{x,y}}", "A Bx By");
try expectExpansion("{ABC}", "ABC");
try expectExpansion("{A,B,C}", "A B C");
try expectExpansion("ABC", "ABC");
try expectExpansion("", "");
try expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh");
try expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh");
try expectExpansion("{A,B}a", "Aa Ba");
try expectExpansion("{C,{x,y}}", "C x y");
try expectExpansion("z{C,{x,y}}", "zC zx zy");
try expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg");
try expectExpansion("a{x,y}b", "axb ayb");
try expectExpansion("z{{a,b}}", "za zb");
try expectExpansion("a{b}", "ab");
}
fn expectExpansion(test_input: []const u8, expected_result: []const u8) !void {
var result = ArrayList(u8).init(global_allocator);
defer result.deinit();
expandString(test_input, &result) catch unreachable;
try testing.expectEqualSlices(u8, expected_result, result.items);
}

4
test/standalone/simple/build.zig
View file

@ -109,10 +109,6 @@ const cases = [_]Case{
//.{
// .src_path = "issue_9693/main.zig",
//},
.{
.src_path = "brace_expansion.zig",
.is_test = true,
},
.{
.src_path = "issue_7030.zig",
.target = .{

20
test/standalone/simple/cat/main.zig
View file

@ -1,42 +1,42 @@
const std = @import("std");
const io = std.io;
const process = std.process;
const fs = std.fs;
const mem = std.mem;
const warn = std.log.warn;
const fatal = std.process.fatal;
pub fn main() !void {
var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
const args = try process.argsAlloc(arena);
const args = try std.process.argsAlloc(arena);
const exe = args[0];
var catted_anything = false;
const stdout_file = io.getStdOut();
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
const stdout = &stdout_writer.interface;
var stdin_reader = std.fs.File.stdin().reader(&.{});
const cwd = fs.cwd();
for (args[1..]) |arg| {
if (mem.eql(u8, arg, "-")) {
catted_anything = true;
try stdout_file.writeFileAll(io.getStdIn(), .{});
_ = try stdout.sendFileAll(&stdin_reader, .unlimited);
} else if (mem.startsWith(u8, arg, "-")) {
return usage(exe);
} else {
const file = cwd.openFile(arg, .{}) catch |err| {
warn("Unable to open file: {s}\n", .{@errorName(err)});
return err;
};
const file = cwd.openFile(arg, .{}) catch |err| fatal("unable to open file: {t}\n", .{err});
defer file.close();
catted_anything = true;
try stdout_file.writeFileAll(file, .{});
var file_reader = file.reader(&.{});
_ = try stdout.sendFileAll(&file_reader, .unlimited);
}
}
if (!catted_anything) {
try stdout_file.writeFileAll(io.getStdIn(), .{});
_ = try stdout.sendFileAll(&stdin_reader, .unlimited);
}
}

24
test/standalone/simple/guess_number/main.zig
View file

@ -1,37 +1,35 @@
const builtin = @import("builtin");
const std = @import("std");
const io = std.io;
const fmt = std.fmt;
pub fn main() !void {
const stdout = io.getStdOut().writer();
const stdin = io.getStdIn();
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
const out = &stdout_writer.interface;
const stdin: std.fs.File = .stdin();
try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
try out.writeAll("Welcome to the Guess Number Game in Zig.\n");
const answer = std.crypto.random.intRangeLessThan(u8, 0, 100) + 1;
while (true) {
try stdout.print("\nGuess a number between 1 and 100: ", .{});
try out.writeAll("\nGuess a number between 1 and 100: ");
var line_buf: [20]u8 = undefined;
const amt = try stdin.read(&line_buf);
if (amt == line_buf.len) {
try stdout.print("Input too long.\n", .{});
try out.writeAll("Input too long.\n");
continue;
}
const line = std.mem.trimEnd(u8, line_buf[0..amt], "\r\n");
const guess = fmt.parseUnsigned(u8, line, 10) catch {
try stdout.print("Invalid number.\n", .{});
const guess = std.fmt.parseUnsigned(u8, line, 10) catch {
try out.writeAll("Invalid number.\n");
continue;
};
if (guess > answer) {
try stdout.print("Guess lower.\n", .{});
try out.writeAll("Guess lower.\n");
} else if (guess < answer) {
try stdout.print("Guess higher.\n", .{});
try out.writeAll("Guess higher.\n");
} else {
try stdout.print("You win!\n", .{});
try out.writeAll("You win!\n");
return;
}
}

2
test/standalone/simple/hello_world/hello.zig
View file

@ -1,5 +1,5 @@
const std = @import("std");
pub fn main() !void {
try std.io.getStdOut().writeAll("Hello, World!\n");
try std.fs.File.stdout().writeAll("Hello, World!\n");
}

1
test/standalone/simple/std_enums_big_enums.zig
View file

@ -6,6 +6,7 @@ pub fn main() void {
const Big = @Type(.{ .@"enum" = .{
.tag_type = u16,
.fields = make_fields: {
@setEvalBranchQuota(500000);
var fields: [1001]std.builtin.Type.EnumField = undefined;
for (&fields, 0..) |*field, i| {
field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };

3
test/standalone/windows_bat_args/echo-args.zig
View file

@ -5,7 +5,8 @@ pub fn main() !void {
defer arena_state.deinit();
const arena = arena_state.allocator();
const stdout = std.io.getStdOut().writer();
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
const stdout = &stdout_writer.interface;
var args = try std.process.argsAlloc(arena);
for (args[1..], 1..) |arg, i| {
try stdout.writeAll(arg);

3
test/standalone/windows_spawn/hello.zig
View file

@ -1,6 +1,7 @@
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
const stdout = &stdout_writer.interface;
try stdout.writeAll("hello from exe\n");
}

3
tools/docgen.zig
View file

@ -43,8 +43,7 @@ pub fn main() !void {
while (args_it.next()) |arg| {
if (mem.startsWith(u8, arg, "-")) {
if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
const stdout = io.getStdOut().writer();
try stdout.writeAll(usage);
try fs.File.stdout().writeAll(usage);
process.exit(0);
} else if (mem.eql(u8, arg, "--code-dir")) {
if (args_it.next()) |param| {

2
tools/doctest.zig
View file

@ -44,7 +44,7 @@ pub fn main() !void {
while (args_it.next()) |arg| {
if (mem.startsWith(u8, arg, "-")) {
if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
try std.io.getStdOut().writeAll(usage);
try std.fs.File.stdout().writeAll(usage);
process.exit(0);
} else if (mem.eql(u8, arg, "-i")) {
opt_input = args_it.next() orelse fatal("expected parameter after -i", .{});

7
tools/dump-cov.zig
View file

@ -48,8 +48,9 @@ pub fn main() !void {
fatal("failed to load coverage file {}: {s}", .{ cov_path, @errorName(err) });
};
var bw = std.io.bufferedWriter(std.io.getStdOut().writer());
const stdout = bw.writer();
var stdout_buffer: [4000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
const stdout = &stdout_writer.interface;
const header: *SeenPcsHeader = @ptrCast(cov_bytes);
try stdout.print("{any}\n", .{header.*});
@ -83,5 +84,5 @@ pub fn main() !void {
});
}
try bw.flush();
try stdout.flush();
}

15
tools/fetch_them_macos_headers.zig
View file

@ -5,6 +5,8 @@ const mem = std.mem;
const process = std.process;
const assert = std.debug.assert;
const tmpDir = std.testing.tmpDir;
const fatal = std.process.fatal;
const info = std.log.info;
const Allocator = mem.Allocator;
const OsTag = std.Target.Os.Tag;
@ -245,19 +247,6 @@ const ArgsIterator = struct {
}
};
fn info(comptime format: []const u8, args: anytype) void {
const msg = std.fmt.allocPrint(gpa, "info: " ++ format ++ "\n", args) catch return;
std.io.getStdOut().writeAll(msg) catch {};
}
fn fatal(comptime format: []const u8, args: anytype) noreturn {
ret: {
const msg = std.fmt.allocPrint(gpa, "fatal: " ++ format ++ "\n", args) catch break :ret;
std.io.getStdErr().writeAll(msg) catch {};
}
std.process.exit(1);
}
const Version = struct {
major: u16,
minor: u8,

26
tools/gen_macos_headers_c.zig
View file

@ -1,5 +1,7 @@
const std = @import("std");
const assert = std.debug.assert;
const info = std.log.info;
const fatal = std.process.fatal;
const Allocator = std.mem.Allocator;
@ -13,19 +15,6 @@ const usage =
\\-h, --help Print this help and exit
;
fn info(comptime format: []const u8, args: anytype) void {
const msg = std.fmt.allocPrint(gpa, "info: " ++ format ++ "\n", args) catch return;
std.io.getStdOut().writeAll(msg) catch {};
}
fn fatal(comptime format: []const u8, args: anytype) noreturn {
ret: {
const msg = std.fmt.allocPrint(gpa, "fatal: " ++ format ++ "\n", args) catch break :ret;
std.io.getStdErr().writeAll(msg) catch {};
}
std.process.exit(1);
}
pub fn main() anyerror!void {
var arena_allocator = std.heap.ArenaAllocator.init(gpa);
defer arena_allocator.deinit();
@ -58,16 +47,19 @@ pub fn main() anyerror!void {
std.mem.sort([]const u8, paths.items, {}, SortFn.lessThan);
const stdout = std.io.getStdOut().writer();
try stdout.writeAll("#define _XOPEN_SOURCE\n");
var buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);
const w = &stdout_writer.interface;
try w.writeAll("#define _XOPEN_SOURCE\n");
for (paths.items) |path| {
try stdout.print("#include <{s}>\n", .{path});
try w.print("#include <{s}>\n", .{path});
}
try stdout.writeAll(
try w.writeAll(
\\int main(int argc, char **argv) {
\\ return 0;
\\}
);
try w.flush();
}
fn findHeaders(

7
tools/gen_outline_atomics.zig
View file

@ -17,8 +17,9 @@ pub fn main() !void {
//const args = try std.process.argsAlloc(arena);
var bw = std.io.bufferedWriter(std.io.getStdOut().writer());
const w = bw.writer();
var stdout_buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
const w = &stdout_writer.interface;
try w.writeAll(
\\//! This file is generated by tools/gen_outline_atomics.zig.
@ -57,7 +58,7 @@ pub fn main() !void {
try w.writeAll(footer.items);
try w.writeAll("}\n");
try bw.flush();
try w.flush();
}
fn writeFunction(

21
tools/gen_spirv_spec.zig
View file

@ -91,9 +91,10 @@ pub fn main() !void {
try readExtRegistry(&exts, a, std.fs.cwd(), args[2]);
var bw = std.io.bufferedWriter(std.io.getStdOut().writer());
try render(bw.writer(), a, core_spec, exts.items);
try bw.flush();
var buffer: [4000]u8 = undefined;
var w = std.fs.File.stdout().writerStreaming(&buffer);
try render(&w, a, core_spec, exts.items);
try w.flush();
}
fn readExtRegistry(exts: *std.ArrayList(Extension), a: Allocator, dir: std.fs.Dir, sub_path: []const u8) !void {
@ -166,7 +167,7 @@ fn tagPriorityScore(tag: []const u8) usize {
}
}
fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []const Extension) !void {
fn render(writer: *std.io.Writer, a: Allocator, registry: CoreRegistry, extensions: []const Extension) !void {
try writer.writeAll(
\\//! This file is auto-generated by tools/gen_spirv_spec.zig.
\\
@ -188,15 +189,10 @@ fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []c
\\ none,
\\ _,
\\
\\ pub fn format(
\\ self: IdResult,
\\ comptime _: []const u8,
\\ _: std.fmt.FormatOptions,
\\ writer: anytype,
\\ ) @TypeOf(writer).Error!void {
\\ pub fn format(self: IdResult, writer: *std.io.Writer) std.io.Writer.Error!void {
\\ switch (self) {
\\ .none => try writer.writeAll("(none)"),
\\ else => try writer.print("%{}", .{@intFromEnum(self)}),
\\ else => try writer.print("%{d}", .{@intFromEnum(self)}),
\\ }
\\ }
\\};
@ -899,7 +895,8 @@ fn parseHexInt(text: []const u8) !u31 {
}
fn usageAndExit(arg0: []const u8, code: u8) noreturn {
std.io.getStdErr().writer().print(
const stderr = std.debug.lockStderrWriter(&.{});
stderr.print(
\\Usage: {s} <SPIRV-Headers repository path> <path/to/zig/src/codegen/spirv/extinst.zig.grammar.json>
\\
\\Generates Zig bindings for SPIR-V specifications found in the SPIRV-Headers

6
tools/gen_stubs.zig
View file

@ -333,7 +333,9 @@ pub fn main() !void {
}
}
const stdout = std.io.getStdOut().writer();
var stdout_buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
const stdout = &stdout_writer.interface;
try stdout.writeAll(
\\#ifdef PTR64
\\#define WEAK64 .weak
@ -533,6 +535,8 @@ pub fn main() !void {
.all => {},
.single, .multi, .family, .time32 => try stdout.writeAll("#endif\n"),
}
try stdout.flush();
}
fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: builtin.Endian) !void {

6
tools/generate_JSONTestSuite.zig
View file

@ -6,7 +6,9 @@ pub fn main() !void {
var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
var allocator = gpa.allocator();
var output = std.io.getStdOut().writer();
var stdout_buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
const output = &stdout_writer.interface;
try output.writeAll(
\\// This file was generated by _generate_JSONTestSuite.zig
\\// These test cases are sourced from: https://github.com/nst/JSONTestSuite
@ -44,6 +46,8 @@ pub fn main() !void {
try writeString(output, contents);
try output.writeAll(");\n}\n");
}
try output.flush();
}
const i_structure_500_nested_arrays = "[" ** 500 ++ "]" ** 500;

11
tools/generate_c_size_and_align_checks.zig
View file

@ -42,20 +42,23 @@ pub fn main() !void {
const query = try std.Target.Query.parse(.{ .arch_os_abi = args[1] });
const target = try std.zig.system.resolveTargetQuery(query);
const stdout = std.io.getStdOut().writer();
var buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);
const w = &stdout_writer.interface;
inline for (@typeInfo(std.Target.CType).@"enum".fields) |field| {
const c_type: std.Target.CType = @enumFromInt(field.value);
try stdout.print("_Static_assert(sizeof({0s}) == {1d}, \"sizeof({0s}) == {1d}\");\n", .{
try w.print("_Static_assert(sizeof({0s}) == {1d}, \"sizeof({0s}) == {1d}\");\n", .{
cName(c_type),
target.cTypeByteSize(c_type),
});
try stdout.print("_Static_assert(_Alignof({0s}) == {1d}, \"_Alignof({0s}) == {1d}\");\n", .{
try w.print("_Static_assert(_Alignof({0s}) == {1d}, \"_Alignof({0s}) == {1d}\");\n", .{
cName(c_type),
target.cTypeAlignment(c_type),
});
try stdout.print("_Static_assert(__alignof({0s}) == {1d}, \"__alignof({0s}) == {1d}\");\n\n", .{
try w.print("_Static_assert(__alignof({0s}) == {1d}, \"__alignof({0s}) == {1d}\");\n\n", .{
cName(c_type),
target.cTypePreferredAlignment(c_type),
});
}
try w.flush();
}

20
tools/generate_linux_syscalls.zig
View file

@ -666,13 +666,16 @@ pub fn main() !void {
const allocator = arena.allocator();
const args = try std.process.argsAlloc(allocator);
if (args.len < 3 or mem.eql(u8, args[1], "--help"))
usageAndExit(std.io.getStdErr(), args[0], 1);
if (args.len < 3 or mem.eql(u8, args[1], "--help")) {
usage(std.debug.lockStderrWriter(&.{}), args[0]) catch std.process.exit(2);
std.process.exit(1);
}
const zig_exe = args[1];
const linux_path = args[2];
var buf_out = std.io.bufferedWriter(std.io.getStdOut().writer());
const writer = buf_out.writer();
var stdout_buffer: [2000]u8 = undefined;
var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
const writer = &stdout_writer.interface;
var linux_dir = try std.fs.cwd().openDir(linux_path, .{});
defer linux_dir.close();
@ -714,17 +717,16 @@ pub fn main() !void {
}
}
try buf_out.flush();
try writer.flush();
}
fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
file.writer().print(
fn usage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
try w.print(
\\Usage: {s} /path/to/zig /path/to/linux
\\Alternative Usage: zig run /path/to/git/zig/tools/generate_linux_syscalls.zig -- /path/to/zig /path/to/linux
\\
\\Generates the list of Linux syscalls for each supported cpu arch, using the Linux development tree.
\\Prints to stdout Zig code which you can use to replace the file lib/std/os/linux/syscalls.zig.
\\
, .{arg0}) catch std.process.exit(1);
std.process.exit(code);
, .{arg0});
}

42
tools/update_clang_options.zig
View file

@ -634,25 +634,25 @@ pub fn main() anyerror!void {
const allocator = arena.allocator();
const args = try std.process.argsAlloc(allocator);
if (args.len <= 1) {
usageAndExit(std.io.getStdErr(), args[0], 1);
}
var stdout_buffer: [4000]u8 = undefined;
var stdout_writer = fs.stdout().writerStreaming(&stdout_buffer);
const stdout = &stdout_writer.interface;
if (args.len <= 1) printUsageAndExit(args[0]);
if (std.mem.eql(u8, args[1], "--help")) {
usageAndExit(std.io.getStdOut(), args[0], 0);
}
if (args.len < 3) {
usageAndExit(std.io.getStdErr(), args[0], 1);
printUsage(stdout, args[0]) catch std.process.exit(2);
stdout.flush() catch std.process.exit(2);
std.process.exit(0);
}
if (args.len < 3) printUsageAndExit(args[0]);
const llvm_tblgen_exe = args[1];
if (std.mem.startsWith(u8, llvm_tblgen_exe, "-")) {
usageAndExit(std.io.getStdErr(), args[0], 1);
}
if (std.mem.startsWith(u8, llvm_tblgen_exe, "-")) printUsageAndExit(args[0]);
const llvm_src_root = args[2];
if (std.mem.startsWith(u8, llvm_src_root, "-")) {
usageAndExit(std.io.getStdErr(), args[0], 1);
}
if (std.mem.startsWith(u8, llvm_src_root, "-")) printUsageAndExit(args[0]);
var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(allocator);
@ -719,8 +719,6 @@ pub fn main() anyerror!void {
// "W" and "Wl,". So we sort this list in order of descending priority.
std.mem.sort(*json.ObjectMap, all_objects.items, {}, objectLessThan);
var buffered_stdout = std.io.bufferedWriter(std.io.getStdOut().writer());
const stdout = buffered_stdout.writer();
try stdout.writeAll(
\\// This file is generated by tools/update_clang_options.zig.
\\// zig fmt: off
@ -815,7 +813,7 @@ pub fn main() anyerror!void {
\\
);
try buffered_stdout.flush();
try stdout.flush();
}
// TODO we should be able to import clang_options.zig but currently this is problematic because it will
@ -966,13 +964,17 @@ fn objectLessThan(context: void, a: *json.ObjectMap, b: *json.ObjectMap) bool {
return std.mem.lessThan(u8, a_key, b_key);
}
fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
file.writer().print(
fn printUsageAndExit(arg0: []const u8) noreturn {
printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
std.process.exit(1);
}
fn printUsage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
try w.print(
\\Usage: {s} /path/to/llvm-tblgen /path/to/git/llvm/llvm-project
\\Alternative Usage: zig run /path/to/git/zig/tools/update_clang_options.zig -- /path/to/llvm-tblgen /path/to/git/llvm/llvm-project
\\
\\Prints to stdout Zig code which you can use to replace the file src/clang_options_data.zig.
\\
, .{arg0}) catch std.process.exit(1);
std.process.exit(code);
, .{arg0});
}

4
tools/update_cpu_features.zig
View file

@ -2082,8 +2082,8 @@ fn processOneTarget(job: Job) void {
}
fn usageAndExit(arg0: []const u8, code: u8) noreturn {
const stderr = std.io.getStdErr();
stderr.writer().print(
const stderr = std.debug.lockStderrWriter(&.{});
stderr.print(
\\Usage: {s} /path/to/llvm-tblgen /path/git/llvm-project /path/git/zig [zig_name filter]
\\
\\Updates lib/std/target/<target>.zig from llvm/lib/Target/<Target>/<Target>.td .

20
tools/update_crc_catalog.zig
View file

@ -11,14 +11,10 @@ pub fn main() anyerror!void {
const arena = arena_state.allocator();
const args = try std.process.argsAlloc(arena);
if (args.len <= 1) {
usageAndExit(std.io.getStdErr(), args[0], 1);
}
if (args.len <= 1) printUsageAndExit(args[0]);
const zig_src_root = args[1];
if (mem.startsWith(u8, zig_src_root, "-")) {
usageAndExit(std.io.getStdErr(), args[0], 1);
}
if (mem.startsWith(u8, zig_src_root, "-")) printUsageAndExit(args[0]);
var zig_src_dir = try fs.cwd().openDir(zig_src_root, .{});
defer zig_src_dir.close();
@ -193,10 +189,14 @@ pub fn main() anyerror!void {
}
}
fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
file.writer().print(
fn printUsageAndExit(arg0: []const u8) noreturn {
printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
std.process.exit(1);
}
fn printUsage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
return w.print(
\\Usage: {s} /path/git/zig
\\
, .{arg0}) catch std.process.exit(1);
std.process.exit(code);
, .{arg0});
}