update to writergate changes

Author: Vexu

build.zig

@@ -30,6 +30,10 @@ pub fn build(b: *std.Build) void {
     translate_c_module.addImport("helpers", helpers);
     translate_c_module.addImport("c_builtins", c_builtins);
 
+    if (target.result.os.tag == .windows) {
+        translate_c_module.linkSystemLibrary("advapi32", .{});
+    }
+
     const translate_c_exe = b.addExecutable(.{
         .name = "translate-c",
         .root_module = translate_c_module,

build.zig.zon

@@ -5,12 +5,12 @@
 
     .fingerprint = 0x1c84f6455a54f043, // Changing this has security and trust implications.
 
-    .minimum_zig_version = "0.15.0-dev.870+710632b45",
+    .minimum_zig_version = "0.15.0-dev.1145+3ae0ba096",
 
     .dependencies = .{
         .aro = .{
-            .url = "git+https://github.com/Vexu/arocc#1916d00fe055af0a33783378d76571cfc9561761",
-            .hash = "aro-0.0.0-JSD1QuUuJwCtUthXWuwlmnWBMRaoKB_6Uy1nLkrgMQ0A",
+            .url = "git+https://github.com/Vexu/arocc#c9af66bcba770beb36c0602a59f4adfe58996468",
+            .hash = "aro-0.0.0-JSD1Qlc4JwBHqaS3T676PyNbYKF0mVWf5h_KEhB9Huvo",
         },
     },
 

examples/use_static_lib/build.zig

@@ -72,7 +72,7 @@ fn buildLibfoo(
         .root = b.path("libfoo"),
         .files = &.{ "add.c", "print.c" },
     });
-    const lib = b.addStaticLibrary(.{
+    const lib = b.addLibrary(.{
         .name = "foo",
         .root_module = mod,
     });

src/MacroTranslator.zig

@@ -387,7 +387,7 @@ fn zigifyEscapeSequences(mt: *MacroTranslator, slice: []const u8) ![]const u8 {
             break;
         }
     } else return source;
-    var bytes = try mt.t.arena.alloc(u8, source.len * 2);
+    const bytes = try mt.t.arena.alloc(u8, source.len * 2);
     var state: enum {
         start,
         escape,
@@ -497,7 +497,7 @@ fn zigifyEscapeSequences(mt: *MacroTranslator, slice: []const u8) ![]const u8 {
                         num += c - 'A' + 10;
                     },
                     else => {
-                        i += std.fmt.formatIntBuf(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
+                        i += std.fmt.printInt(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
                         num = 0;
                         if (c == '\\')
                             state = .escape
@@ -523,7 +523,7 @@ fn zigifyEscapeSequences(mt: *MacroTranslator, slice: []const u8) ![]const u8 {
                     };
                     num += c - '0';
                 } else {
-                    i += std.fmt.formatIntBuf(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
+                    i += std.fmt.printInt(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
                     num = 0;
                     count = 0;
                     if (c == '\\')
@@ -537,7 +537,7 @@ fn zigifyEscapeSequences(mt: *MacroTranslator, slice: []const u8) ![]const u8 {
         }
     }
     if (state == .hex or state == .octal) {
-        i += std.fmt.formatIntBuf(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
+        i += std.fmt.printInt(bytes[i..], num, 16, .lower, .{ .fill = '0', .width = 2 });
     }
 
     return bytes[0..i];
@@ -553,10 +553,10 @@ fn escapeUnprintables(mt: *MacroTranslator) ![]const u8 {
     const zigified = try mt.zigifyEscapeSequences(slice);
     if (std.unicode.utf8ValidateSlice(zigified)) return zigified;
 
-    const formatter = std.fmt.fmtSliceEscapeLower(zigified);
-    const encoded_size = @as(usize, @intCast(std.fmt.count("{s}", .{formatter})));
+    const formatter = std.ascii.hexEscape(zigified, .lower);
+    const encoded_size = @as(usize, @intCast(std.fmt.count("{f}", .{formatter})));
     const output = try mt.t.arena.alloc(u8, encoded_size);
-    return std.fmt.bufPrint(output, "{s}", .{formatter}) catch |err| switch (err) {
+    return std.fmt.bufPrint(output, "{f}", .{formatter}) catch |err| switch (err) {
         error.NoSpaceLeft => unreachable,
         else => |e| return e,
     };
@@ -577,7 +577,7 @@ fn parseCPrimaryExpr(mt: *MacroTranslator, scope: *Scope) ParseError!ZigNode {
             } else {
                 mt.i += 1;
 
-                const str = try std.fmt.allocPrint(mt.t.arena, "0x{s}", .{std.fmt.fmtSliceHexLower(slice[1 .. slice.len - 1])});
+                const str = try std.fmt.allocPrint(mt.t.arena, "0x{x}", .{slice[1 .. slice.len - 1]});
                 return ZigTag.integer_literal.create(mt.t.arena, str);
             }
         },

src/Translator.zig

@@ -172,7 +172,7 @@ pub const Options = struct {
     module_libs: bool,
 };
 
-pub fn translate(options: Options) ![]u8 {
+pub fn translate(options: Options) mem.Allocator.Error![]u8 {
     const gpa = options.gpa;
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
@@ -217,32 +217,32 @@ pub fn translate(options: Options) ![]u8 {
 
     try translator.global_scope.processContainerMemberFns();
 
-    var buf: std.ArrayList(u8) = .init(gpa);
-    defer buf.deinit();
+    var allocating: std.Io.Writer.Allocating = .init(gpa);
+    defer allocating.deinit();
 
     if (options.module_libs) {
-        try buf.appendSlice(
+        allocating.writer.writeAll(
             \\pub const __builtin = @import("c_builtins");
             \\pub const __helpers = @import("helpers");
             \\
             \\
-        );
+        ) catch return error.OutOfMemory;
     } else {
-        try buf.appendSlice(
+        allocating.writer.writeAll(
             \\pub const __builtin = @import("c_builtins.zig");
             \\pub const __helpers = @import("helpers.zig");
             \\
             \\
-        );
+        ) catch return error.OutOfMemory;
     }
 
     var zig_ast = try ast.render(gpa, translator.global_scope.nodes.items);
     defer {
         gpa.free(zig_ast.source);
         zig_ast.deinit(gpa);
     }
-    try zig_ast.renderToArrayList(&buf, .{});
-    return buf.toOwnedSlice();
+    zig_ast.render(gpa, &allocating.writer, .{}) catch return error.OutOfMemory;
+    return allocating.toOwnedSlice();
 }
 
 fn prepopulateGlobalNameTable(t: *Translator) !void {
@@ -1006,17 +1006,16 @@ fn transStaticAssert(t: *Translator, scope: *Scope, static_assert: Node.StaticAs
         const str_qt = message.qt(t.tree);
 
         const bytes = t.comp.interner.get(str_val.ref()).bytes;
-        var buf = std.ArrayList(u8).init(t.gpa);
-        defer buf.deinit();
+        var allocating: std.Io.Writer.Allocating = .init(t.gpa);
+        defer allocating.deinit();
 
-        try buf.appendSlice("\"static assertion failed \\");
+        allocating.writer.writeAll("\"static assertion failed \\") catch return error.OutOfMemory;
 
-        try buf.ensureUnusedCapacity(bytes.len);
-        try aro.Value.printString(bytes, str_qt, t.comp, buf.writer());
-        _ = buf.pop(); // printString adds a terminating " so we need to remove it
-        try buf.appendSlice("\\\"\"");
+        aro.Value.printString(bytes, str_qt, t.comp, &allocating.writer) catch return error.OutOfMemory;
+        allocating.writer.end -= 1; // printString adds a terminating " so we need to remove it
+        allocating.writer.writeAll("\\\"\"") catch return error.OutOfMemory;
 
-        break :str try ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, buf.items));
+        break :str try ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, allocating.getWritten()));
     } else try ZigTag.string_literal.create(t.arena, "\"static assertion failed\"");
 
     const assert_node = try ZigTag.static_assert.create(t.arena, .{ .lhs = condition, .rhs = diagnostic });
@@ -1027,11 +1026,11 @@ fn transGlobalAsm(t: *Translator, scope: *Scope, global_asm: Node.SimpleAsm) Err
     const asm_string = t.tree.value_map.get(global_asm.asm_str).?;
     const bytes = t.comp.interner.get(asm_string.ref()).bytes;
 
-    var buf = std.ArrayList(u8).init(t.gpa);
-    defer buf.deinit();
-    try aro.Value.printString(bytes, global_asm.asm_str.qt(t.tree), t.comp, buf.writer());
+    var allocating: std.Io.Writer.Allocating = try .initCapacity(t.gpa, bytes.len);
+    defer allocating.deinit();
+    aro.Value.printString(bytes, global_asm.asm_str.qt(t.tree), t.comp, &allocating.writer) catch return error.OutOfMemory;
 
-    const str_node = try ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, buf.items));
+    const str_node = try ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, allocating.getWritten()));
 
     const asm_node = try ZigTag.asm_simple.create(t.arena, str_node);
     const block = try ZigTag.block_single.create(t.arena, asm_node);
@@ -1045,11 +1044,10 @@ fn transGlobalAsm(t: *Translator, scope: *Scope, global_asm: Node.SimpleAsm) Err
 // ================
 
 fn getTypeStr(t: *Translator, qt: QualType) ![]const u8 {
-    var buf: std.ArrayListUnmanaged(u8) = .empty;
-    defer buf.deinit(t.gpa);
-    const w = buf.writer(t.gpa);
-    try qt.print(t.comp, w);
-    return t.arena.dupe(u8, buf.items);
+    var allocating: std.Io.Writer.Allocating = .init(t.gpa);
+    defer allocating.deinit();
+    qt.print(t.comp, &allocating.writer) catch return error.OutOfMemory;
+    return t.arena.dupe(u8, allocating.getWritten());
 }
 
 fn transType(t: *Translator, scope: *Scope, qt: QualType, source_loc: TokenIndex) TypeError!ZigNode {
@@ -3353,12 +3351,11 @@ fn transFloatLiteral(
     const val = t.tree.value_map.get(literal_index).?;
     const float_literal = literal_index.get(t.tree).float_literal;
 
-    var buf: std.ArrayListUnmanaged(u8) = .empty;
-    defer buf.deinit(t.gpa);
-    const w = buf.writer(t.gpa);
-    _ = try val.print(float_literal.qt, t.comp, w);
+    var allocating: std.Io.Writer.Allocating = .init(t.gpa);
+    defer allocating.deinit();
+    _ = val.print(float_literal.qt, t.comp, &allocating.writer) catch return error.OutOfMemory;
 
-    const float_lit_node = try ZigTag.float_literal.create(t.arena, try t.arena.dupe(u8, buf.items));
+    const float_lit_node = try ZigTag.float_literal.create(t.arena, try t.arena.dupe(u8, allocating.getWritten()));
     if (suppress_as == .no_as) {
         return t.maybeSuppressResult(used, float_lit_node);
     }
@@ -3398,13 +3395,12 @@ fn transNarrowStringLiteral(
     const val = t.tree.value_map.get(expr).?;
 
     const bytes = t.comp.interner.get(val.ref()).bytes;
-    var buf = std.ArrayList(u8).init(t.gpa);
-    defer buf.deinit();
+    var allocating: std.Io.Writer.Allocating = try .initCapacity(t.gpa, bytes.len);
+    defer allocating.deinit();
 
-    try buf.ensureUnusedCapacity(bytes.len);
-    try aro.Value.printString(bytes, literal.qt, t.comp, buf.writer());
+    aro.Value.printString(bytes, literal.qt, t.comp, &allocating.writer) catch return error.OutOfMemory;
 
-    return ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, buf.items));
+    return ZigTag.string_literal.create(t.arena, try t.arena.dupe(u8, allocating.getWritten()));
 }
 
 /// Translate a string literal that is initializing an array. In general narrow string
@@ -3887,7 +3883,7 @@ fn createNumberNode(t: *Translator, num: anytype, num_kind: enum { int, float })
 
 fn createCharLiteralNode(t: *Translator, narrow: bool, val: u32) TransError!ZigNode {
     return ZigTag.char_literal.create(t.arena, if (narrow)
-        try std.fmt.allocPrint(t.arena, "'{'}'", .{std.zig.fmtEscapes(&.{@as(u8, @intCast(val))})})
+        try std.fmt.allocPrint(t.arena, "'{f}'", .{std.zig.fmtChar(&.{@as(u8, @intCast(val))})})
     else
         try std.fmt.allocPrint(t.arena, "'\\u{{{x}}}'", .{val}));
 }

src/ast.zig

@@ -866,7 +866,7 @@ const Context = struct {
 
     fn addTokenFmt(c: *Context, tag: TokenTag, comptime format: []const u8, args: anytype) Allocator.Error!TokenIndex {
         const start_index = c.buf.items.len;
-        try c.buf.writer().print(format ++ " ", args);
+        try c.buf.print(format ++ " ", args);
 
         try c.tokens.append(c.gpa, .{
             .tag = tag,
@@ -883,7 +883,7 @@ const Context = struct {
     fn addIdentifier(c: *Context, bytes: []const u8) Allocator.Error!TokenIndex {
         if (std.zig.primitives.isPrimitive(bytes))
             return c.addTokenFmt(.identifier, "@\"{s}\"", .{bytes});
-        return c.addTokenFmt(.identifier, "{p}", .{std.zig.fmtId(bytes)});
+        return c.addTokenFmt(.identifier, "{f}", .{std.zig.fmtId(bytes)});
     }
 
     fn listToSpan(c: *Context, list: []const NodeIndex) Allocator.Error!NodeSubRange {
@@ -1212,7 +1212,7 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
 
             const compile_error_tok = try c.addToken(.builtin, "@compileError");
             _ = try c.addToken(.l_paren, "(");
-            const err_msg_tok = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(payload.mangled)});
+            const err_msg_tok = try c.addTokenFmt(.string_literal, "\"{f}\"", .{std.zig.fmtString(payload.mangled)});
             const err_msg = try c.addNode(.{
                 .tag = .string_literal,
                 .main_token = err_msg_tok,
@@ -2185,7 +2185,7 @@ fn renderContainer(c: *Context, node: Node) !NodeIndex {
     defer c.gpa.free(members);
 
     for (payload.fields, 0..) |field, i| {
-        const name_tok = try c.addTokenFmt(.identifier, "{p}", .{std.zig.fmtId(field.name)});
+        const name_tok = try c.addTokenFmt(.identifier, "{f}", .{std.zig.fmtIdFlags(field.name, .{ .allow_primitive = true })});
         _ = try c.addToken(.colon, ":");
         const type_expr = try renderNode(c, field.type);
 
@@ -2282,7 +2282,7 @@ fn renderFieldAccess(c: *Context, lhs: NodeIndex, field_name: []const u8) !NodeI
         .tag = .field_access,
         .main_token = try c.addToken(.period, "."),
         .data = .{ .node_and_token = .{
-            lhs, try c.addTokenFmt(.identifier, "{p}", .{std.zig.fmtId(field_name)}),
+            lhs, try c.addTokenFmt(.identifier, "{f}", .{std.zig.fmtIdFlags(field_name, .{ .allow_primitive = true })}),
         } },
     });
 }
@@ -2766,7 +2766,7 @@ fn renderVar(c: *Context, node: Node) !NodeIndex {
         _ = try c.addToken(.l_paren, "(");
         const res = try c.addNode(.{
             .tag = .string_literal,
-            .main_token = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(some)}),
+            .main_token = try c.addTokenFmt(.string_literal, "\"{f}\"", .{std.zig.fmtString(some)}),
             .data = undefined,
         });
         _ = try c.addToken(.r_paren, ")");
@@ -2852,7 +2852,7 @@ fn renderFunc(c: *Context, node: Node) !NodeIndex {
         _ = try c.addToken(.l_paren, "(");
         const res = try c.addNode(.{
             .tag = .string_literal,
-            .main_token = try c.addTokenFmt(.string_literal, "\"{}\"", .{std.zig.fmtEscapes(some)}),
+            .main_token = try c.addTokenFmt(.string_literal, "\"{f}\"", .{std.zig.fmtString(some)}),
             .data = undefined,
         });
         _ = try c.addToken(.r_paren, ")");