authorgravatar for rpkak@noreply.codeberg.orgrpkak <rpkak@noreply.codeberg.org> 2026-08-16 19:28:35+02:00
committergravatar for rpkak@noreply.codeberg.orgrpkak <rpkak@noreply.codeberg.org> 2026-08-16 19:28:35+02:00
log00af3bfc40c2e4e13757d93a88d17fe9e3073beb
tree589a1467a277ec0168225473e33348f2e8b8cd50
parent99e540dc39ba45365eaa82db0459a0d7acc251eb
signaturebadge-check Signed by SSH key SHA256:A2g6ATENrgLKQcUdthsn72P0njmQxnHSimzwnyJsZzo

remove RunTranslatedC.zig and TranslateC.zig

Unused since 1bdcdbd996 of #24497

2 files changed, 0 insertions(+), 238 deletions(-)

test/src/RunTranslatedC.zig deleted-108
......@@ -1,108 +0,0 @@
1b: *std.Build,
2step: *std.Build.Step,
3test_index: usize,
4test_filters: []const []const u8,
5target: std.Build.ResolvedTarget,
6
7const TestCase = struct {
8 name: []const u8,
9 sources: std.array_list.Managed(SourceFile),
10 expected_stdout: []const u8,
11 allow_warnings: bool,
12
13 const SourceFile = struct {
14 filename: []const u8,
15 source: []const u8,
16 };
17
18 pub fn addSourceFile(self: *TestCase, filename: []const u8, source: []const u8) void {
19 self.sources.append(SourceFile{
20 .filename = filename,
21 .source = source,
22 }) catch unreachable;
23 }
24};
25
26pub fn create(
27 self: *RunTranslatedCContext,
28 allow_warnings: bool,
29 filename: []const u8,
30 name: []const u8,
31 source: []const u8,
32 expected_stdout: []const u8,
33) *TestCase {
34 const tc = self.b.allocator.create(TestCase) catch unreachable;
35 tc.* = TestCase{
36 .name = name,
37 .sources = std.array_list.Managed(TestCase.SourceFile).init(self.b.allocator),
38 .expected_stdout = expected_stdout,
39 .allow_warnings = allow_warnings,
40 };
41
42 tc.addSourceFile(filename, source);
43 return tc;
44}
45
46pub fn add(
47 self: *RunTranslatedCContext,
48 name: []const u8,
49 source: []const u8,
50 expected_stdout: []const u8,
51) void {
52 const tc = self.create(false, "source.c", name, source, expected_stdout);
53 self.addCase(tc);
54}
55
56pub fn addAllowWarnings(
57 self: *RunTranslatedCContext,
58 name: []const u8,
59 source: []const u8,
60 expected_stdout: []const u8,
61) void {
62 const tc = self.create(true, "source.c", name, source, expected_stdout);
63 self.addCase(tc);
64}
65
66pub fn addCase(self: *RunTranslatedCContext, case: *const TestCase) void {
67 const b = self.b;
68
69 const annotated_case_name = fmt.allocPrint(self.b.allocator, "run-translated-c {s}", .{case.name}) catch unreachable;
70 for (self.test_filters) |test_filter| {
71 if (mem.find(u8, annotated_case_name, test_filter)) |_| break;
72 } else if (self.test_filters.len > 0) return;
73
74 const write_src = b.addWriteFiles();
75 const first_case = case.sources.items[0];
76 const root_source_file = write_src.add(first_case.filename, first_case.source);
77 for (case.sources.items[1..]) |src_file| {
78 _ = write_src.add(src_file.filename, src_file.source);
79 }
80 const translate_c = b.addTranslateC(.{
81 .root_source_file = root_source_file,
82 .target = b.graph.host,
83 .optimize = .Debug,
84 });
85
86 translate_c.step.name = b.fmt("{s} translate-c", .{annotated_case_name});
87 const exe = b.addExecutable(.{
88 .name = "translated_c",
89 .root_module = translate_c.createModule(),
90 });
91 exe.step.name = b.fmt("{s} build-exe", .{annotated_case_name});
92 exe.root_module.link_libc = true;
93 const run = b.addRunArtifact(exe);
94 run.step.name = b.fmt("{s} run", .{annotated_case_name});
95 if (!case.allow_warnings) {
96 run.expectStdErrEqual("");
97 }
98 run.expectStdOutEqual(case.expected_stdout);
99 run.skip_foreign_checks = true;
100
101 self.step.dependOn(&run.step);
102}
103
104const RunTranslatedCContext = @This();
105const std = @import("std");
106const fmt = std.fmt;
107const mem = std.mem;
108const fs = std.fs;
test/src/TranslateC.zig deleted-130
......@@ -1,130 +0,0 @@
1b: *std.Build,
2step: *std.Build.Step,
3test_index: usize,
4test_filters: []const []const u8,
5test_target_filters: []const []const u8,
6
7const TestCase = struct {
8 name: []const u8,
9 sources: std.array_list.Managed(SourceFile),
10 expected_lines: std.array_list.Managed([]const u8),
11 allow_warnings: bool,
12 target: std.Target.Query = .{},
13
14 const SourceFile = struct {
15 filename: []const u8,
16 source: []const u8,
17 };
18
19 pub fn addSourceFile(self: *TestCase, filename: []const u8, source: []const u8) void {
20 self.sources.append(SourceFile{
21 .filename = filename,
22 .source = source,
23 }) catch unreachable;
24 }
25
26 pub fn addExpectedLine(self: *TestCase, text: []const u8) void {
27 self.expected_lines.append(text) catch unreachable;
28 }
29};
30
31pub fn create(
32 self: *TranslateCContext,
33 allow_warnings: bool,
34 filename: []const u8,
35 name: []const u8,
36 source: []const u8,
37 expected_lines: []const []const u8,
38) *TestCase {
39 const tc = self.b.allocator.create(TestCase) catch unreachable;
40 tc.* = TestCase{
41 .name = name,
42 .sources = std.array_list.Managed(TestCase.SourceFile).init(self.b.allocator),
43 .expected_lines = std.array_list.Managed([]const u8).init(self.b.allocator),
44 .allow_warnings = allow_warnings,
45 };
46
47 tc.addSourceFile(filename, source);
48 var arg_i: usize = 0;
49 while (arg_i < expected_lines.len) : (arg_i += 1) {
50 tc.addExpectedLine(expected_lines[arg_i]);
51 }
52 return tc;
53}
54
55pub fn add(
56 self: *TranslateCContext,
57 name: []const u8,
58 source: []const u8,
59 expected_lines: []const []const u8,
60) void {
61 const tc = self.create(false, "source.h", name, source, expected_lines);
62 self.addCase(tc);
63}
64
65pub fn addWithTarget(
66 self: *TranslateCContext,
67 name: []const u8,
68 target: std.Target.Query,
69 source: []const u8,
70 expected_lines: []const []const u8,
71) void {
72 const tc = self.create(false, "source.h", name, source, expected_lines);
73 tc.target = target;
74 self.addCase(tc);
75}
76
77pub fn addAllowWarnings(
78 self: *TranslateCContext,
79 name: []const u8,
80 source: []const u8,
81 expected_lines: []const []const u8,
82) void {
83 const tc = self.create(true, "source.h", name, source, expected_lines);
84 self.addCase(tc);
85}
86
87pub fn addCase(self: *TranslateCContext, case: *const TestCase) void {
88 const b = self.b;
89
90 const translate_c_cmd = "translate-c";
91 const annotated_case_name = fmt.allocPrint(self.b.allocator, "{s} {s}", .{ translate_c_cmd, case.name }) catch unreachable;
92 for (self.test_filters) |test_filter| {
93 if (mem.find(u8, annotated_case_name, test_filter)) |_| break;
94 } else if (self.test_filters.len > 0) return;
95
96 const target = b.resolveTargetQuery(case.target);
97
98 if (self.test_target_filters.len > 0) {
99 const triple_txt = target.query.zigTriple(b.allocator) catch @panic("OOM");
100
101 for (self.test_target_filters) |filter| {
102 if (std.mem.find(u8, triple_txt, filter) != null) break;
103 } else return;
104 }
105
106 const write_src = b.addWriteFiles();
107 const first_src = case.sources.items[0];
108 const root_source_file = write_src.add(first_src.filename, first_src.source);
109 for (case.sources.items[1..]) |src_file| {
110 _ = write_src.add(src_file.filename, src_file.source);
111 }
112
113 const translate_c = b.addTranslateC(.{
114 .root_source_file = root_source_file,
115 .target = target,
116 .optimize = .Debug,
117 });
118
119 translate_c.step.name = annotated_case_name;
120
121 const check_file = translate_c.addCheckFile(case.expected_lines.items);
122
123 self.step.dependOn(&check_file.step);
124}
125
126const TranslateCContext = @This();
127const std = @import("std");
128const fmt = std.fmt;
129const mem = std.mem;
130const fs = std.fs;