@zigc/lib 0.16.0-test.1 → 0.16.0

package/compiler/translate-c/ast.zig

@@ -50,6 +50,7 @@ pub const Node = extern union {
         break_val,
         @"return",
         field_access,
+        field_builtin,
         array_access,
         call,
         var_decl,
@@ -371,6 +372,7 @@ pub const Node = extern union {
                 .div_exact,
                 .offset_of,
                 .static_assert,
+                .field_builtin,
                 => Payload.BinOp,
 
                 .integer_literal,
@@ -455,14 +457,14 @@ pub const Node = extern union {
         return .{ .ptr_otherwise = payload };
     }
 
-    pub fn isNoreturn(node: Node, break_counts: bool) bool {
-        switch (node.tag()) {
+    pub fn isNoreturn(node: Node) bool {
+        return switch (node.tag()) {
             .block => {
                 const block_node = node.castTag(.block).?;
                 if (block_node.data.stmts.len == 0) return false;
 
                 const last = block_node.data.stmts[block_node.data.stmts.len - 1];
-                return last.isNoreturn(break_counts);
+                return last.isNoreturn();
             },
             .@"switch" => {
                 const switch_node = node.castTag(.@"switch").?;
@@ -475,15 +477,16 @@ pub const Node = extern union {
                     else
                         unreachable;
 
-                    if (!body.isNoreturn(break_counts)) return false;
+                    if (!body.isNoreturn()) return false;
                 }
                 return true;
             },
-            .@"return", .return_void => return true,
-            .@"break" => if (break_counts) return true,
-            else => {},
-        }
-        return false;
+            .@"return", .return_void => true,
+            .@"break" => true,
+            .@"continue" => true,
+            .@"unreachable" => true,
+            else => false,
+        };
     }
 
     pub fn isBoolRes(res: Node) bool {
@@ -2015,6 +2018,10 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
             const lhs = try renderNodeGrouped(c, payload.lhs);
             return renderFieldAccess(c, lhs, payload.field_name);
         },
+        .field_builtin => {
+            const payload = node.castTag(.field_builtin).?.data;
+            return renderBuiltinCall(c, "@field", &.{ payload.lhs, payload.rhs });
+        },
         .@"struct", .@"union", .@"opaque" => return renderContainer(c, node),
         .enum_constant => {
             const payload = node.castTag(.enum_constant).?.data;
@@ -2424,7 +2431,7 @@ fn renderNullSentinelArrayType(c: *Context, len: u64, elem_type: Node) !NodeInde
 fn addSemicolonIfNeeded(c: *Context, node: Node) !void {
     switch (node.tag()) {
         .warning => unreachable,
-        .var_decl, .var_simple, .arg_redecl, .alias, .block, .empty_block, .block_single, .@"switch", .wrapped_local, .mut_str => {},
+        .static_assert, .var_decl, .var_simple, .arg_redecl, .alias, .block, .empty_block, .block_single, .@"switch", .wrapped_local, .mut_str => {},
         .while_true => {
             const payload = node.castTag(.while_true).?.data;
             return addSemicolonIfNotBlock(c, payload);
@@ -2532,6 +2539,8 @@ fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex {
         .trunc,
         .floor,
         .root_ref,
+        .field_builtin,
+        .@"switch",
         => {
             // no grouping needed
             return renderNode(c, node);
@@ -2594,7 +2603,6 @@ fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex {
         .pub_var_simple,
         .enum_constant,
         .@"while",
-        .@"switch",
         .@"break",
         .break_val,
         .pub_inline_fn,

package/compiler/translate-c/main.zig

@@ -1,15 +1,17 @@
 const std = @import("std");
-const Io = std.Io;
 const assert = std.debug.assert;
 const mem = std.mem;
 const process = std.process;
+const Io = std.Io;
+
 const aro = @import("aro");
 const compiler_util = @import("../util.zig");
+
 const Translator = @import("Translator.zig");
 
 const fast_exit = @import("builtin").mode != .Debug;
 
-pub fn main(init: std.process.Init) u8 {
+pub fn main(init: process.Init) u8 {
     const gpa = init.gpa;
     const arena = init.arena.allocator();
     const io = init.io;
@@ -33,16 +35,20 @@ pub fn main(init: std.process.Init) u8 {
     var stderr = Io.File.stderr().writer(io, &stderr_buf);
     var diagnostics: aro.Diagnostics = switch (zig_integration) {
         false => .{ .output = .{ .to_writer = .{
-            .mode = Io.Terminal.Mode.detect(io, stderr.file, NO_COLOR, CLICOLOR_FORCE) catch unreachable,
+            .mode = Io.Terminal.Mode.detect(io, stderr.file, NO_COLOR, CLICOLOR_FORCE) catch .no_color,
             .writer = &stderr.interface,
         } } },
-        true => .{ .output = .{ .to_list = .{
-            .arena = .init(gpa),
-        } } },
+        true => .{ .output = .{ .to_list = .{ .arena = .init(gpa) } } },
     };
     defer diagnostics.deinit();
 
-    var comp = aro.Compilation.initDefault(gpa, arena, io, &diagnostics, .cwd(), environ_map) catch |err| switch (err) {
+    var comp = aro.Compilation.init(.{
+        .gpa = gpa,
+        .arena = arena,
+        .io = io,
+        .diagnostics = &diagnostics,
+        .environ_map = environ_map,
+    }) catch |err| switch (err) {
         error.OutOfMemory => {
             std.debug.print("ran out of memory initializing C compilation\n", .{});
             if (fast_exit) process.exit(1);
@@ -82,7 +88,6 @@ pub fn main(init: std.process.Init) u8 {
             return 1;
         },
     };
-
     assert(comp.diagnostics.errors == 0 or !zig_integration);
     if (fast_exit) process.exit(@intFromBool(comp.diagnostics.errors != 0));
     return @intFromBool(comp.diagnostics.errors != 0);
@@ -107,10 +112,23 @@ pub const usage =
     \\Usage {s}: [options] file [CC options]
     \\
     \\Options:
-    \\  --help              Print this message
-    \\  --version           Print translate-c version
-    \\  -fmodule-libs       Import libraries as modules
-    \\  -fno-module-libs    (default) Install libraries next to output file
+    \\  --help                      Print this message
+    \\  --version                   Print translate-c version
+    \\  -fmodule-libs               Import libraries as modules
+    \\  -fno-module-libs            (default) Install libraries next to output file
+    \\  -fpub-static                (default) Translate static functions as pub
+    \\  -fno-pub-static             Do not translate static functions as pub
+    \\  -ffunc-bodies               (default) Translate function bodies
+    \\  -fno-func-bodies            Do not translate function bodies
+    \\  -fkeep-macro-literals       (default) Preserve macro names for literals
+    \\  -fno-keep-macro-literals    Do not preserve macro names for literals
+    \\  -fdefault-init              Default initialize struct fields
+    \\  -fno-default-init           (default) Do not default initialize struct fields
+    \\  -fstrict-flex-arrays=<n>    Control when to treat a trailing array as a flexible array member (default: 2)
+    \\                                0: any trailing array
+    \\                                1: size [0]/[1]/[]
+    \\                                2: size [0]/[]
+    \\                                3: [] only
     \\
     \\
 ;
@@ -119,7 +137,14 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
     const gpa = d.comp.gpa;
     const io = d.comp.io;
 
-    var aro_args: std.ArrayList([:0]const u8) = .empty;
+    var module_libs = true;
+    var pub_static = true;
+    var func_bodies = true;
+    var keep_macro_literals = true;
+    var default_init = true;
+    var strict_flex_arrays: Translator.StrictFlexArraysLevel = .@"2";
+
+    var aro_args: std.ArrayList([:0]const u8) = try .initCapacity(gpa, args.len);
     defer aro_args.deinit(gpa);
 
     for (args, 0..) |arg, i| {
@@ -139,8 +164,34 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
         } else if (mem.eql(u8, arg, "--zig-integration")) {
             if (i != 1 or !zig_integration)
                 return d.fatal("--zig-integration must be the first argument", .{});
+        } else if (mem.eql(u8, arg, "-fmodule-libs")) {
+            module_libs = true;
+        } else if (mem.eql(u8, arg, "-fno-module-libs")) {
+            module_libs = false;
+        } else if (mem.eql(u8, arg, "-fpub-static")) {
+            pub_static = true;
+        } else if (mem.eql(u8, arg, "-fno-pub-static")) {
+            pub_static = false;
+        } else if (mem.eql(u8, arg, "-ffunc-bodies")) {
+            func_bodies = true;
+        } else if (mem.eql(u8, arg, "-fno-func-bodies")) {
+            func_bodies = false;
+        } else if (mem.eql(u8, arg, "-fkeep-macro-literals")) {
+            keep_macro_literals = true;
+        } else if (mem.eql(u8, arg, "-fno-keep-macro-literals")) {
+            keep_macro_literals = false;
+        } else if (mem.eql(u8, arg, "-fdefault-init")) {
+            default_init = true;
+        } else if (mem.eql(u8, arg, "-fno-default-init")) {
+            default_init = false;
+        } else if (mem.startsWith(u8, arg, "-fstrict-flex-arrays=")) {
+            const val_str = arg["-fstrict-flex-arrays=".len..];
+            if (val_str.len != 1 or val_str[0] < '0' or val_str[0] > '3') {
+                return d.fatal("-fstrict-flex-arrays= requires a value of '0', '1', '2', or '3'", .{});
+            }
+            strict_flex_arrays = @enumFromInt(val_str[0] - '0');
         } else {
-            try aro_args.append(gpa, arg);
+            aro_args.appendAssumeCapacity(arg);
         }
     }
     const user_macros = macros: {
@@ -148,7 +199,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
         defer macro_buf.deinit(gpa);
 
         var discard_buf: [256]u8 = undefined;
-        var discarding: std.Io.Writer.Discarding = .init(&discard_buf);
+        var discarding: Io.Writer.Discarding = .init(&discard_buf);
         assert(!try d.parseArgs(&discarding.writer, &macro_buf, aro_args.items));
         if (macro_buf.items.len > std.math.maxInt(u32)) {
             return d.fatal("user provided macro source exceeded max size", .{});
@@ -185,7 +236,9 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
         else => |e| return e,
     };
 
-    var pp = try aro.Preprocessor.initDefault(d.comp);
+    var pp = try aro.Preprocessor.init(d.comp, .{
+        .base_file = source.id,
+    });
     defer pp.deinit();
 
     var name_buf: [std.fs.max_name_bytes]u8 = undefined;
@@ -235,6 +288,12 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig
         .comp = d.comp,
         .pp = &pp,
         .tree = &c_tree,
+        .module_libs = module_libs,
+        .pub_static = pub_static,
+        .func_bodies = func_bodies,
+        .keep_macro_literals = keep_macro_literals,
+        .default_init = default_init,
+        .strict_flex_arrays = strict_flex_arrays,
     });
     defer gpa.free(rendered_zig);
 

package/compiler_rt/cos.zig

@@ -1,19 +1,30 @@
+//! Ported from musl, which is licensed under the MIT license:
+//! https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
+//!
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cosf.c
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cos.c
+//! https://git.musl-libc.org/cgit/musl/tree/src/math/cosl.c
+
 const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+const expectApproxEqAbs = std.testing.expectApproxEqAbs;
 
 const compiler_rt = @import("../compiler_rt.zig");
 const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
+const rem_pio2l = @import("rem_pio2l.zig").rem_pio2l;
+const ld = @import("long_double.zig");
 
 comptime {
-    symbol(&__cosh, "__cosh");
+    symbol(&cosh, "__cosh");
+    symbol(&cosl, "__cosl");
     symbol(&cosf, "cosf");
     symbol(&cos, "cos");
-    symbol(&__cosx, "__cosx");
+    symbol(&cosx, "__cosx");
     if (compiler_rt.want_ppc_abi) {
         symbol(&cosq, "cosf128");
     }
@@ -21,7 +32,7 @@ comptime {
     symbol(&cosl, "cosl");
 }
 
-pub fn __cosh(a: f16) callconv(.c) f16 {
+pub fn cosh(a: f16) callconv(.c) f16 {
     // TODO: more efficient implementation
     return @floatCast(cosf(a));
 }
@@ -43,27 +54,27 @@ pub fn cosf(x: f32) callconv(.c) f32 {
             if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
-        return trig.__cosdf(x);
+        return trig.cosdf(x);
     }
     if (ix <= 0x407b53d1) { // |x| ~<= 5*pi/4
         if (ix > 0x4016cbe3) { // |x|  ~> 3*pi/4
-            return -trig.__cosdf(if (sign) x + c2pio2 else x - c2pio2);
+            return -trig.cosdf(if (sign) x + c2pio2 else x - c2pio2);
         } else {
             if (sign) {
-                return trig.__sindf(x + c1pio2);
+                return trig.sindf(x + c1pio2);
             } else {
-                return trig.__sindf(c1pio2 - x);
+                return trig.sindf(c1pio2 - x);
             }
         }
     }
     if (ix <= 0x40e231d5) { // |x| ~<= 9*pi/4
         if (ix > 0x40afeddf) { // |x| ~> 7*pi/4
-            return trig.__cosdf(if (sign) x + c4pio2 else x - c4pio2);
+            return trig.cosdf(if (sign) x + c4pio2 else x - c4pio2);
         } else {
             if (sign) {
-                return trig.__sindf(-x - c3pio2);
+                return trig.sindf(-x - c3pio2);
             } else {
-                return trig.__sindf(x - c3pio2);
+                return trig.sindf(x - c3pio2);
             }
         }
     }
@@ -76,10 +87,10 @@ pub fn cosf(x: f32) callconv(.c) f32 {
     var y: f64 = undefined;
     const n = rem_pio2f(x, &y);
     return switch (n & 3) {
-        0 => trig.__cosdf(y),
-        1 => trig.__sindf(-y),
-        2 => -trig.__cosdf(y),
-        else => trig.__sindf(y),
+        0 => trig.cosdf(y),
+        1 => trig.sindf(-y),
+        2 => -trig.cosdf(y),
+        else => trig.sindf(y),
     };
 }
 
@@ -94,7 +105,7 @@ pub fn cos(x: f64) callconv(.c) f64 {
             if (compiler_rt.want_float_exceptions) mem.doNotOptimizeAway(x + 0x1p120);
             return 1.0;
         }
-        return trig.__cos(x, 0);
+        return trig.cos(x, 0);
     }
 
     // cos(Inf or NaN) is NaN
@@ -105,66 +116,144 @@ pub fn cos(x: f64) callconv(.c) f64 {
     var y: [2]f64 = undefined;
     const n = rem_pio2(x, &y);
     return switch (n & 3) {
-        0 => trig.__cos(y[0], y[1]),
-        1 => -trig.__sin(y[0], y[1], 1),
-        2 => -trig.__cos(y[0], y[1]),
-        else => trig.__sin(y[0], y[1], 1),
+        0 => trig.cos(y[0], y[1]),
+        1 => -trig.sin(y[0], y[1], 1),
+        2 => -trig.cos(y[0], y[1]),
+        else => trig.sin(y[0], y[1], 1),
     };
 }
 
-pub fn __cosx(a: f80) callconv(.c) f80 {
-    // TODO: more efficient implementation
-    return @floatCast(cosq(a));
+pub fn cosx(x: f80) callconv(.c) f80 {
+    const se = ld.signExponent(x) & 0x7fff;
+    if (se == 0x7fff) {
+        return x - x;
+    }
+
+    if (@abs(x) < trig.pi_4) {
+        if (se < 0x3fff - math.floatMantissaBits(f80)) {
+            // raise inexact if x!=0
+            return 1.0 + x;
+        }
+        return trig.cosx(x, 0.0);
+    }
+
+    var y: [2]f80 = undefined;
+    const n = rem_pio2l(f80, x, &y);
+    return switch (n & 3) {
+        0 => trig.cosx(y[0], y[1]),
+        1 => -trig.sinx(y[0], y[1], 1),
+        2 => -trig.cosx(y[0], y[1]),
+        else => trig.sinx(y[0], y[1], 1),
+    };
 }
 
-pub fn cosq(a: f128) callconv(.c) f128 {
-    // TODO: more correct implementation
-    return cos(@floatCast(a));
+pub fn cosq(x: f128) callconv(.c) f128 {
+    const se = ld.signExponent(x) & 0x7fff;
+    if (se == 0x7fff) {
+        return x - x;
+    }
+
+    if (@abs(x) < trig.pi_4) {
+        if (se < 0x3fff - math.floatMantissaBits(f128)) {
+            // raise inexact if x!=0
+            return 1.0 + x;
+        }
+        return trig.cosq(x, 0.0);
+    }
+
+    var y: [2]f128 = undefined;
+    const n = rem_pio2l(f128, x, &y);
+    return switch (n & 3) {
+        0 => trig.cosq(y[0], y[1]),
+        1 => -trig.sinq(y[0], y[1], 1),
+        2 => -trig.cosq(y[0], y[1]),
+        else => trig.sinq(y[0], y[1], 1),
+    };
 }
 
 pub fn cosl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __cosh(x),
+        16 => return cosh(x),
         32 => return cosf(x),
         64 => return cos(x),
-        80 => return __cosx(x),
+        80 => return cosx(x),
         128 => return cosq(x),
         else => @compileError("unreachable"),
     }
 }
 
-test "cos32" {
-    const epsilon = 0.00001;
+fn testCosSpecial(comptime T: type) !void {
+    const f = switch (T) {
+        f32 => cosf,
+        f64 => cos,
+        f80 => cosx,
+        f128 => cosq,
+        else => @compileError("unimplemented"),
+    };
 
-    try expect(math.approxEqAbs(f32, cosf(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f32, cosf(89.123), 0.400798, epsilon));
+    try expect(f(0.0) == 1.0);
+    try expect(f(-0.0) == 1.0);
+    try expect(math.isNan(f(math.inf(T))));
+    try expect(math.isNan(f(-math.inf(T))));
+    try expect(math.isNan(f(math.nan(T))));
 }
 
-test "cos64" {
-    const epsilon = 0.000001;
-
-    try expect(math.approxEqAbs(f64, cos(0.0), 1.0, epsilon));
-    try expect(math.approxEqAbs(f64, cos(0.2), 0.980067, epsilon));
-    try expect(math.approxEqAbs(f64, cos(0.8923), 0.627623, epsilon));
-    try expect(math.approxEqAbs(f64, cos(1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos(-1.5), 0.070737, epsilon));
-    try expect(math.approxEqAbs(f64, cos(37.45), 0.969132, epsilon));
-    try expect(math.approxEqAbs(f64, cos(89.123), 0.40080, epsilon));
+test "cos32.normal" {
+    const epsilon = math.floatEps(f32);
+    try expectApproxEqAbs(@as(f32, 1.0), cosf(0.0), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.9800666), cosf(0.2), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.6276231), cosf(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.0707372), cosf(1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.0707372), cosf(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.96913195), cosf(37.45), epsilon);
+    try expectApproxEqAbs(@as(f32, 0.40079966), cosf(89.123), epsilon);
 }
 
 test "cos32.special" {
-    try expect(math.isNan(cosf(math.inf(f32))));
-    try expect(math.isNan(cosf(-math.inf(f32))));
-    try expect(math.isNan(cosf(math.nan(f32))));
+    try testCosSpecial(f32);
+}
+
+test "cos64.normal" {
+    const epsilon = math.floatEps(f64);
+    try expectApproxEqAbs(@as(f64, 1.0), cos(0.0), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9800665778412416), cos(0.2), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.6276230983360804), cos(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.0707372016677029), cos(1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.0707372016677029), cos(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.9691317730707778), cos(37.45), epsilon);
+    try expectApproxEqAbs(@as(f64, 0.4008006809354791), cos(89.123), epsilon);
 }
 
 test "cos64.special" {
-    try expect(math.isNan(cos(math.inf(f64))));
-    try expect(math.isNan(cos(-math.inf(f64))));
-    try expect(math.isNan(cos(math.nan(f64))));
+    try testCosSpecial(f64);
+}
+
+test "cos80.normal" {
+    const epsilon = math.floatEps(f80);
+    try expectApproxEqAbs(@as(f80, 1.0), cosx(0.0), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.98006657784124163112419651674816888), cosx(0.2), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.62762309833608037003563995939286067), cosx(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.070737201667702910088189851434268747), cosx(1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.070737201667702910088189851434268747), cosx(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.9691317730707771246), cosx(37.45), epsilon);
+    try expectApproxEqAbs(@as(f80, 0.4008006809354834001), cosx(89.123), epsilon);
+}
+
+test "cos80.special" {
+    try testCosSpecial(f80);
+}
+
+test "cos128.normal" {
+    const epsilon = math.floatEps(f128);
+    try expectApproxEqAbs(@as(f128, 1.0), cosq(0.0), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.98006657784124163112419651674816888), cosq(0.2), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.62762309833608037003563995939286067), cosq(0.8923), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.070737201667702910088189851434268747), cosq(1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.070737201667702910088189851434268747), cosq(-1.5), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.96913177307077712443149563847233230), cosq(37.45), epsilon);
+    try expectApproxEqAbs(@as(f128, 0.40080068093548339848199454493704702), cosq(89.123), epsilon);
+}
+
+test "cos128.special" {
+    try testCosSpecial(f128);
 }