Merge pull request #19826 from jacobly0/outdirarg

Run: add output directory arguments

doc/langref/Assembly Syntax Explained.zig

@@ -15,44 +15,44 @@ pub fn syscall1(number: usize, arg1: usize) usize {
  // the below code, this is not used. A literal `%` can be
  // obtained by escaping it with a double percent: `%%`.
  // Often multiline string syntax comes in handy here.
- \\syscall
- // Next is the output. It is possible in the future Zig will
- // support multiple outputs, depending on how
- // https://github.com/ziglang/zig/issues/215 is resolved.
- // It is allowed for there to be no outputs, in which case
- // this colon would be directly followed by the colon for the inputs.
+  \\syscall
+  // Next is the output. It is possible in the future Zig will
+  // support multiple outputs, depending on how
+  // https://github.com/ziglang/zig/issues/215 is resolved.
+  // It is allowed for there to be no outputs, in which case
+  // this colon would be directly followed by the colon for the inputs.
  :
- // This specifies the name to be used in `%[ret]` syntax in
- // the above assembly string. This example does not use it,
- // but the syntax is mandatory.
- [ret]
- // Next is the output constraint string. This feature is still
- // considered unstable in Zig, and so LLVM/GCC documentation
- // must be used to understand the semantics.
- // http://releases.llvm.org/10.0.0/docs/LangRef.html#inline-asm-constraint-string
- // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html
- // In this example, the constraint string means "the result value of
- // this inline assembly instruction is whatever is in $rax".
- "={rax}"
- // Next is either a value binding, or `->` and then a type. The
- // type is the result type of the inline assembly expression.
- // If it is a value binding, then `%[ret]` syntax would be used
- // to refer to the register bound to the value.
- (-> usize),
- // Next is the list of inputs.
- // The constraint for these inputs means, "when the assembly code is
- // executed, $rax shall have the value of `number` and $rdi shall have
- // the value of `arg1`". Any number of input parameters is allowed,
- // including none.
+  // This specifies the name to be used in `%[ret]` syntax in
+  // the above assembly string. This example does not use it,
+  // but the syntax is mandatory.
+  [ret]
+  // Next is the output constraint string. This feature is still
+  // considered unstable in Zig, and so LLVM/GCC documentation
+  // must be used to understand the semantics.
+  // http://releases.llvm.org/10.0.0/docs/LangRef.html#inline-asm-constraint-string
+  // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html
+  // In this example, the constraint string means "the result value of
+  // this inline assembly instruction is whatever is in $rax".
+  "={rax}"
+  // Next is either a value binding, or `->` and then a type. The
+  // type is the result type of the inline assembly expression.
+  // If it is a value binding, then `%[ret]` syntax would be used
+  // to refer to the register bound to the value.
+  (-> usize),
+  // Next is the list of inputs.
+  // The constraint for these inputs means, "when the assembly code is
+  // executed, $rax shall have the value of `number` and $rdi shall have
+  // the value of `arg1`". Any number of input parameters is allowed,
+  // including none.
  : [number] "{rax}" (number),
-  [arg1] "{rdi}" (arg1),
- // Next is the list of clobbers. These declare a set of registers whose
- // values will not be preserved by the execution of this assembly code.
- // These do not include output or input registers. The special clobber
- // value of "memory" means that the assembly writes to arbitrary undeclared
- // memory locations - not only the memory pointed to by a declared indirect
- // output. In this example we list $rcx and $r11 because it is known the
- // kernel syscall does not preserve these registers.
+ [arg1] "{rdi}" (arg1),
+  // Next is the list of clobbers. These declare a set of registers whose
+  // values will not be preserved by the execution of this assembly code.
+  // These do not include output or input registers. The special clobber
+  // value of "memory" means that the assembly writes to arbitrary undeclared
+  // memory locations - not only the memory pointed to by a declared indirect
+  // output. In this example we list $rcx and $r11 because it is known the
+  // kernel syscall does not preserve these registers.
  : "rcx", "r11"
  );
 }

doc/langref/build.zig

@@ -4,7 +4,7 @@ pub fn build(b: *std.Build) void {
  const optimize = b.standardOptimizeOption(.{});
  const exe = b.addExecutable(.{
  .name = "example",
- .root_source_file = .{ .path = "example.zig" },
+ .root_source_file = b.path("example.zig"),
  .optimize = optimize,
  });
  b.default_step.dependOn(&exe.step);

doc/langref/build_c.zig

@@ -3,13 +3,13 @@ const std = @import("std");
 pub fn build(b: *std.Build) void {
  const lib = b.addSharedLibrary(.{
  .name = "mathtest",
- .root_source_file = .{ .path = "mathtest.zig" },
+ .root_source_file = b.path("mathtest.zig"),
  .version = .{ .major = 1, .minor = 0, .patch = 0 },
  });
  const exe = b.addExecutable(.{
  .name = "test",
  });
- exe.addCSourceFile(.{ .file = .{ .path = "test.c" }, .flags = &.{"-std=c99"} });
+ exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
  exe.linkLibrary(lib);
  exe.linkSystemLibrary("c");
 

doc/langref/build_object.zig

@@ -3,13 +3,13 @@ const std = @import("std");
 pub fn build(b: *std.Build) void {
  const obj = b.addObject(.{
  .name = "base64",
- .root_source_file = .{ .path = "base64.zig" },
+ .root_source_file = b.path("base64.zig"),
  });
 
  const exe = b.addExecutable(.{
  .name = "test",
  });
- exe.addCSourceFile(.{ .file = .{ .path = "test.c" }, .flags = &.{"-std=c99",} });
+ exe.addCSourceFile(.{ .file = b.path("test.c"), .flags = &.{"-std=c99"} });
  exe.addObject(obj);
  exe.linkSystemLibrary("c");
  b.installArtifact(exe);

doc/langref/checking_null_in_zig.zig

@@ -1,11 +1,13 @@
-const Foo = struct{};
-fn doSomethingWithFoo(foo: *Foo) void { _ = foo; }
+const Foo = struct {};
+fn doSomethingWithFoo(foo: *Foo) void {
+ _ = foo;
+}
 
 fn doAThing(optional_foo: ?*Foo) void {
  // do some stuff
 
  if (optional_foo) |foo| {
- doSomethingWithFoo(foo);
+  doSomethingWithFoo(foo);
  }
 
  // do some stuff

doc/langref/doc_comments.zig

@@ -2,7 +2,7 @@
 /// multiline doc comment).
 const Timestamp = struct {
  /// The number of seconds since the epoch (this is also a doc comment).
- seconds: i64,  // signed so we can represent pre-1970 (not a doc comment)
+ seconds: i64, // signed so we can represent pre-1970 (not a doc comment)
  /// The number of nanoseconds past the second (doc comment again).
  nanos: u32,
 

doc/langref/enum_export.zig

@@ -1,4 +1,6 @@
 const Foo = enum(c_int) { a, b, c };
-export fn entry(foo: Foo) void { _ = foo; }
+export fn entry(foo: Foo) void {
+ _ = foo;
+}
 
 // obj

doc/langref/enum_export_error.zig

@@ -1,4 +1,6 @@
 const Foo = enum { a, b, c };
-export fn entry(foo: Foo) void { _ = foo; }
+export fn entry(foo: Foo) void {
+ _ = foo;
+}
 
 // obj=parameter of type 'enum_export_error.Foo' not allowed in function with calling convention 'C'

doc/langref/error_union_parsing_u64.zig

@@ -26,9 +26,9 @@ pub fn parseU64(buf: []const u8, radix: u8) !u64 {
 
 fn charToDigit(c: u8) u8 {
  return switch (c) {
- '0' ... '9' => c - '0',
- 'A' ... 'Z' => c - 'A' + 10,
- 'a' ... 'z' => c - 'a' + 10,
+ '0'...'9' => c - '0',
+ 'A'...'Z' => c - 'A' + 10,
+ 'a'...'z' => c - 'a' + 10,
  else => maxInt(u8),
  };
 }

doc/langref/identifiers.zig

@@ -6,8 +6,8 @@ pub extern "c" fn @"error"() void;
 pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int;
 
 const Color = enum {
- red,
- @"really red",
+  red,
+  @"really red",
 };
 const color: Color = .@"really red";
 

doc/langref/print.zig

@@ -4,7 +4,7 @@ const a_number: i32 = 1234;
 const a_string = "foobar";
 
 pub fn main() void {
- print("here is a string: '{s}' here is a number: {}\n", .{a_string, a_number});
+ print("here is a string: '{s}' here is a number: {}\n", .{ a_string, a_number });
 }
 
 // exe=succeed

doc/langref/print_comptime-known_format.zig

@@ -5,7 +5,7 @@ const a_string = "foobar";
 const fmt = "here is a string: '{s}' here is a number: {}\n";
 
 pub fn main() void {
- print(fmt, .{a_string, a_number});
+ print(fmt, .{ a_string, a_number });
 }
 
 // exe=succeed

doc/langref/single_value_error_set.zig

@@ -1,3 +1,3 @@
-const err = (error {FileNotFound}).FileNotFound;
+const err = (error{FileNotFound}).FileNotFound;
 
 // syntax

doc/langref/string_literals.zig

@@ -3,19 +3,19 @@ const mem = @import("std").mem; // will be used to compare bytes
 
 pub fn main() void {
  const bytes = "hello";
- print("{}\n", .{@TypeOf(bytes)});  // *const [5:0]u8
- print("{d}\n", .{bytes.len});  // 5
- print("{c}\n", .{bytes[1]});  // 'e'
- print("{d}\n", .{bytes[5]});  // 0
- print("{}\n", .{'e' == '\x65'});  // true
- print("{d}\n", .{'\u{1f4a9}'});  // 128169
- print("{d}\n", .{'💯'});  // 128175
+ print("{}\n", .{@TypeOf(bytes)}); // *const [5:0]u8
+ print("{d}\n", .{bytes.len}); // 5
+ print("{c}\n", .{bytes[1]}); // 'e'
+ print("{d}\n", .{bytes[5]}); // 0
+ print("{}\n", .{'e' == '\x65'}); // true
+ print("{d}\n", .{'\u{1f4a9}'}); // 128169
+ print("{d}\n", .{'💯'}); // 128175
  print("{u}\n", .{'⚡'});
- print("{}\n", .{mem.eql(u8, "hello", "h\x65llo")});  // true
+ print("{}\n", .{mem.eql(u8, "hello", "h\x65llo")}); // true
  print("{}\n", .{mem.eql(u8, "💯", "\xf0\x9f\x92\xaf")}); // also true
- const invalid_utf8 = "\xff\xfe";  // non-UTF-8 strings are possible with \xNN notation.
+ const invalid_utf8 = "\xff\xfe"; // non-UTF-8 strings are possible with \xNN notation.
  print("0x{x}\n", .{invalid_utf8[1]}); // indexing them returns individual bytes...
- print("0x{x}\n", .{"💯"[1]});  // ...as does indexing part-way through non-ASCII characters
+ print("0x{x}\n", .{"💯"[1]}); // ...as does indexing part-way through non-ASCII characters
 }
 
 // exe=succeed

doc/langref/test_call_builtin.zig

@@ -1,7 +1,7 @@
 const expect = @import("std").testing.expect;
 
 test "noinline function call" {
- try expect(@call(.auto, add, .{3, 9}) == 12);
+ try expect(@call(.auto, add, .{ 3, 9 }) == 12);
 }
 
 fn add(a: i32, b: i32) i32 {

doc/langref/test_coerce_error_subset_to_superset.zig

@@ -1,12 +1,12 @@
 const std = @import("std");
 
-const FileOpenError = error {
+const FileOpenError = error{
  AccessDenied,
  OutOfMemory,
  FileNotFound,
 };
 
-const AllocationError = error {
+const AllocationError = error{
  OutOfMemory,
 };
 

doc/langref/test_coerce_error_superset_to_subset.zig

@@ -1,10 +1,10 @@
-const FileOpenError = error {
+const FileOpenError = error{
  AccessDenied,
  OutOfMemory,
  FileNotFound,
 };
 
-const AllocationError = error {
+const AllocationError = error{
  OutOfMemory,
 };
 

doc/langref/test_coerce_tuples_arrays.zig

@@ -1,11 +1,11 @@
 const std = @import("std");
 const expect = std.testing.expect;
 
-const Tuple = struct{ u8, u8 };
+const Tuple = struct { u8, u8 };
 test "coercion from homogenous tuple to array" {
- const tuple: Tuple = .{5, 6};
- const array: [2]u8 = tuple;
- _ = array;
+ const tuple: Tuple = .{ 5, 6 };
+ const array: [2]u8 = tuple;
+ _ = array;
 }
 
 // test

doc/langref/test_comptime_evaluation.zig

@@ -2,17 +2,23 @@ const expect = @import("std").testing.expect;
 
 const CmdFn = struct {
  name: []const u8,
- func: fn(i32) i32,
+ func: fn (i32) i32,
 };
 
 const cmd_fns = [_]CmdFn{
- CmdFn {.name = "one", .func = one},
- CmdFn {.name = "two", .func = two},
- CmdFn {.name = "three", .func = three},
+ CmdFn{ .name = "one", .func = one },
+ CmdFn{ .name = "two", .func = two },
+ CmdFn{ .name = "three", .func = three },
 };
-fn one(value: i32) i32 { return value + 1; }
-fn two(value: i32) i32 { return value + 2; }
-fn three(value: i32) i32 { return value + 3; }
+fn one(value: i32) i32 {
+ return value + 1;
+}
+fn two(value: i32) i32 {
+ return value + 2;
+}
+fn three(value: i32) i32 {
+ return value + 3;
+}
 
 fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
  var result: i32 = start_value;

doc/langref/test_errdefer_loop.zig

@@ -1,9 +1,7 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
-const Foo = struct {
- data: *u32
-};
+const Foo = struct { data: *u32 };
 
 fn getData() !u32 {
  return 666;

doc/langref/test_errdefer_loop_leak.zig

@@ -1,9 +1,7 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
-const Foo = struct {
- data: *u32
-};
+const Foo = struct { data: *u32 };
 
 fn getData() !u32 {
  return 666;
@@ -19,7 +17,7 @@ fn genFoos(allocator: Allocator, num: usize) ![]Foo {
  errdefer allocator.destroy(foo.data);
 
  // The data for the first 3 foos will be leaked
- if(i >= 3) return error.TooManyFoos;
+ if (i >= 3) return error.TooManyFoos;
 
  foo.data.* = try getData();
  }

doc/langref/test_for.zig

@@ -1,7 +1,7 @@
 const expect = @import("std").testing.expect;
 
 test "for basics" {
- const items = [_]i32 { 4, 5, 3, 4, 0 };
+ const items = [_]i32{ 4, 5, 3, 4, 0 };
  var sum: i32 = 0;
 
  // For loops iterate over slices and arrays.
@@ -31,7 +31,7 @@ test "for basics" {
 
  // To iterate over consecutive integers, use the range syntax.
  // Unbounded range is always a compile error.
- var sum3 : usize = 0;
+ var sum3: usize = 0;
  for (0..5) |i| {
  sum3 += i;
  }