Merge branch 'master' into zon-stop-on-node

Author: MasonRemaley

CMakeLists.txt

@@ -559,7 +559,7 @@ set(ZIG_STAGE2_SOURCES
     src/arch/x86_64/abi.zig
     src/arch/x86_64/bits.zig
     src/arch/x86_64/encoder.zig
-    src/arch/x86_64/encodings.zig
+    src/arch/x86_64/encodings.zon
     src/clang.zig
     src/clang_options.zig
     src/clang_options_data.zig

doc/langref.html.in

@@ -0,0 +1,18 @@
+//! Because this file contains fields, it is a type which is intended to be instantiated, and so
+//! is named in TitleCase instead of snake_case by convention.
+
+foo: u32,
+bar: u64,
+
+/// `@This()` can be used to refer to this struct type. In files with fields, it is quite common to
+/// name the type here, so it can be easily referenced by other declarations in this file.
+const TopLevelFields = @This();
+
+pub fn init(val: u32) TopLevelFields {
+    return .{
+        .foo = val,
+        .bar = val * 10,
+    };
+}
+
+// syntax

doc/langref/TopLevelFields.zig

@@ -0,0 +1,20 @@
+/// `std.start` imports this file using `@import("root")`, and uses this declaration as the program's
+/// user-provided entry point. It can return any of the following types:
+/// * `void`
+/// * `E!void`, for any error set `E`
+/// * `u8`
+/// * `E!u8`, for any error set `E`
+/// Returning a `void` value from this function will exit with code 0.
+/// Returning a `u8` value from this function will exit with the given status code.
+/// Returning an error value from this function will print an Error Return Trace and exit with code 1.
+pub fn main() void {
+    std.debug.print("Hello, World!\n", .{});
+}
+
+// If uncommented, this declaration would suppress the usual std.start logic, causing
+// the `main` declaration above to be ignored.
+//pub const _start = {};
+
+const std = @import("std");
+
+// exe=succeed

doc/langref/entry_point.zig

@@ -0,0 +1,10 @@
+pub export fn main(argc: c_int, argv: [*]const [*:0]const u8) c_int {
+    const args = argv[0..@intCast(argc)];
+    std.debug.print("Hello! argv[0] is '{s}'\n", .{args[0]});
+    return 0;
+}
+
+const std = @import("std");
+
+// exe=succeed
+// link_libc

doc/langref/libc_export_entry_point.zig

@@ -0,0 +1,18 @@
+pub fn main() void {
+    @setRuntimeSafety(true);
+    var x: u8 = 255;
+    // Let's overflow this integer!
+    x += 1;
+}
+
+pub const panic = std.debug.FullPanic(myPanic);
+
+fn myPanic(msg: []const u8, first_trace_addr: ?usize) noreturn {
+    _ = first_trace_addr;
+    std.debug.print("Panic! {s}\n", .{msg});
+    std.process.exit(1);
+}
+
+const std = @import("std");
+
+// exe=fail

doc/langref/panic_handler.zig

@@ -0,0 +1,25 @@
+/// The presence of this declaration allows the program to override certain behaviors of the standard library.
+/// For a full list of available options, see the documentation for `std.Options`.
+pub const std_options: std.Options = .{
+    // By default, in safe build modes, the standard library will attach a segfault handler to the program to
+    // print a helpful stack trace if a segmentation fault occurs. Here, we can disable this, or even enable
+    // it in unsafe build modes.
+    .enable_segfault_handler = true,
+    // This is the logging function used by `std.log`.
+    .logFn = myLogFn,
+};
+
+fn myLogFn(
+    comptime level: std.log.Level,
+    comptime scope: @Type(.enum_literal),
+    comptime format: []const u8,
+    args: anytype,
+) void {
+    // We could do anything we want here!
+    // ...but actually, let's just call the default implementation.
+    std.log.defaultLog(level, scope, format, args);
+}
+
+const std = @import("std");
+
+// syntax

doc/langref/std_options.zig

@@ -2,7 +2,7 @@ test "@setRuntimeSafety" {
     // The builtin applies to the scope that it is called in. So here, integer overflow
     // will not be caught in ReleaseFast and ReleaseSmall modes:
     // var x: u8 = 255;
-    // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes.
+    // x += 1; // Unchecked Illegal Behavior in ReleaseFast/ReleaseSmall modes.
     {
         // However this block has safety enabled, so safety checks happen here,
         // even in ReleaseFast and ReleaseSmall modes.
@@ -15,7 +15,7 @@ test "@setRuntimeSafety" {
             // would not be caught in any build mode.
             @setRuntimeSafety(false);
             // var x: u8 = 255;
-            // x += 1; // undefined behavior in all build modes.
+            // x += 1; // Unchecked Illegal Behavior in all build modes.
         }
     }
 }

doc/langref/test_undefined_behavior.zig renamed to doc/langref/test_illegal_behavior.zig

@@ -979,7 +979,7 @@ fn decl(p: *Parser) Error!bool {
         _ = try p.expectToken(.semicolon);
         if (decl_spec.ty.is(.@"enum") or
             (decl_spec.ty.isRecord() and !decl_spec.ty.isAnonymousRecord(p.comp) and
-            !decl_spec.ty.isTypeof())) // we follow GCC and clang's behavior here
+                !decl_spec.ty.isTypeof())) // we follow GCC and clang's behavior here
         {
             const specifier = decl_spec.ty.canonicalize(.standard).specifier;
             const attrs = p.attr_buf.items(.attr)[attr_buf_top..];

doc/langref/test_setRuntimeSafety_builtin.zig

@@ -114,9 +114,9 @@ fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex
 
     const gcc_pragma = std.meta.stringToEnum(Directive, pp.expandedSlice(directive_tok)) orelse
         return pp.comp.addDiagnostic(.{
-        .tag = .unknown_gcc_pragma,
-        .loc = directive_tok.loc,
-    }, pp.expansionSlice(start_idx + 1));
+            .tag = .unknown_gcc_pragma,
+            .loc = directive_tok.loc,
+        }, pp.expansionSlice(start_idx + 1));
 
     switch (gcc_pragma) {
         .warning, .@"error" => {