srctree

 

 

 

\\ /:auto-includes <value> Set the automatic include path detection behavior.

\\ any (default) Use MSVC if available, fall back to MinGW

\\ msvc Use MSVC include paths (must be present on the system)

\\ none Do not use any autodetected include paths

\\

\\Note: For compatibility reasons, all custom options start with :

\\

debug: bool = false,

print_help_and_exit: bool = false,

auto_includes: AutoIncludes = .any,

 

pub const AutoIncludes = enum { any, msvc, gnu, none };

pub const Preprocess = enum { no, yes, only };

pub const SymbolAction = enum { define, undefine };

pub const SymbolValue = union(SymbolAction) {

cwd.access(options.input_filename, .{}) catch |err| switch (err) {

error.FileNotFound => {

var filename_bytes = try options.allocator.alloc(u8, options.input_filename.len + 3);

@memcpy(filename_bytes[filename_bytes.len - 3 ..], ".rc");

options.allocator.free(options.input_filename);

options.input_filename = filename_bytes;

entry.value_ptr.deinit(self.allocator);

}

self.symbols.deinit(self.allocator);

}

 

pub fn dumpVerbose(self: *const Options, writer: anytype) !void {

var output_filename: ?[]const u8 = null;

var output_filename_context: Arg.Context = undefined;

 

next_arg: while (arg_i < args.len) {

var arg = Arg.fromString(args[arg_i]) orelse break;

if (arg.name().len == 0) {

if (std.ascii.startsWithIgnoreCase(arg_name, ":no-preprocess")) {

options.preprocess = .no;

arg.name_offset += ":no-preprocess".len;

} else if (std.ascii.startsWithIgnoreCase(arg_name, ":auto-includes")) {

const value = arg.value(":auto-includes".len, arg_i, args) catch {

var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };

};

arg_i += value.index_increment;

continue :next_arg;

} else if (std.ascii.startsWithIgnoreCase(arg_name, "nologo")) {

// No-op, we don't display any 'logo' to suppress

arg.name_offset += "nologo".len;

try diagnostics.append(err_details);

 

const last_arg = args[args.len - 1];

var note_details = Diagnostics.ErrorDetails{ .type = .note, .print_args = true, .arg_index = arg_i - 1 };

var note_writer = note_details.msg.writer(allocator);

try note_writer.writeAll("if this argument was intended to be the input filename, then -- should be specified in front of it to exclude it from option parsing");

}

 

test "parse errors: basic" {

\\<cli>: error: invalid option: /

\\ ... /

\\ ^

\\

\\

);

\\<cli>: error: missing language tag after /ln option

\\ ... /ln

\\ ~~~~^

\\

\\

);

\\<cli>: error: missing language tag after -ln option

\\ ... -vln

\\ ~ ~~~^

\\

\\

);

\\<cli>: error: invalid option: /_not-an-option

\\ ... /_not-an-option

\\ ~^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: invalid option: -_not-an-option

\\ ... -_not-an-option

\\ ~^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: invalid option: --_not-an-option

\\ ... --_not-an-option

\\ ~~^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: invalid option: /_not-an-option

\\ ... /v_not-an-option

\\ ~ ^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: invalid option: -_not-an-option

\\ ... -v_not-an-option

\\ ~ ^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: invalid option: --_not-an-option

\\ ... --v_not-an-option

\\ ~~ ^~~~~~~~~~~~~~

\\

\\

);

\\<cli>: error: the /s option is unsupported

\\ ... /some/absolute/path/parsed/as/an/option.rc

\\ ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

}

 

test "parse errors: /ln" {

\\<cli>: error: invalid language tag: invalid

\\ ... /ln invalid ...

\\ ~~~~^~~~~~~

\\

);

\\<cli>: error: invalid language tag: invalid

\\ ... /lninvalid ...

\\ ~~~^~~~~~~

 

test "parse: options" {

{

defer options.deinit();

 

try std.testing.expectEqual(true, options.verbose);

try std.testing.expectEqualStrings("foo.res", options.output_filename);

}

{

defer options.deinit();

 

try std.testing.expectEqual(true, options.verbose);

try std.testing.expectEqualStrings("foo.res", options.output_filename);

}

{

defer options.deinit();

 

try std.testing.expectEqual(true, options.verbose);

try std.testing.expectEqualStrings("foo.res", options.output_filename);

}

{

defer options.deinit();

 

try std.testing.expectEqual(true, options.verbose);

 

test "parse: define and undefine" {

{

defer options.deinit();

 

const action = options.symbols.get("foo").?;

try std.testing.expectEqualStrings("1", action.define);

}

{

defer options.deinit();

 

const action = options.symbols.get("foo").?;

try std.testing.expectEqualStrings("baz", action.define);

}

{

defer options.deinit();

 

const action = options.symbols.get("foo").?;

}

{

// Once undefined, future defines are ignored

defer options.deinit();

 

const action = options.symbols.get("foo").?;

}

{

// Undefined always takes precedence

defer options.deinit();

 

const action = options.symbols.get("foo").?;

{

// Warn + ignore invalid identifiers

var options = try testParseWarning(

\\<cli>: warning: symbol "foo bar" is not a valid identifier and therefore cannot be defined

\\ ... /dfoo bar ...

\\ ~~^~~~~~~

}

 

test "parse: /sl" {

\\<cli>: error: percent out of range: 0 (parsed from '0')

\\ ... /sl 0 ...

\\ ~~~~^

\\

\\

);

\\<cli>: error: invalid percent format 'abcd'

\\ ... /sl abcd ...

\\ ~~~~^~~~

\\

);

{

defer options.deinit();

 

try std.testing.expectEqual(@as(u15, lex.default_max_string_literal_codepoints), options.max_string_literal_codepoints);

}

{

defer options.deinit();

 

try std.testing.expectEqual(@as(u15, max_string_literal_length_100_percent), options.max_string_literal_codepoints);

}

{

defer options.deinit();

 

try std.testing.expectEqual(@as(u15, 2703), options.max_string_literal_codepoints);

}

{

defer options.deinit();

 

try std.testing.expectEqual(@as(u15, 1228), options.max_string_literal_codepoints);

}

 

test "parse: unsupported MUI-related options" {

\\<cli>: error: the /q option is unsupported

\\ ... /q ...

\\ ~^

}

 

test "parse: unsupported LCX/LCE-related options" {

\\<cli>: error: the /t option is unsupported

\\ ... /t ...

\\ ~^

var tmp = std.testing.tmpDir(.{});

defer tmp.cleanup();

 

defer options.deinit();

try std.testing.expectEqualStrings("foo", options.input_filename);

 

 

pub const Utf8 = struct {

/// Implements decoding with rejection of ill-formed UTF-8 sequences based on section

/// D92 of Chapter 3 of the Unicode standard (Table 3-7 specifically).

pub const WellFormedDecoder = struct {

/// Like std.unicode.utf8ByteSequenceLength, but:

/// - Rejects non-well-formed first bytes, i.e. C0-C1, F5-FF

// Only include the byte in the invalid sequence if it's in the range

// of a continuation byte. All other values should not be included in the

// invalid sequence.

if (isContinuationByte(byte)) len += 1;

return .{ .value = Codepoint.invalid, .byte_len = len };

}

}, CodePage.utf8.codepointAt(1, invalid_utf8).?);

try std.testing.expectEqual(@as(?Codepoint, null), CodePage.windows1252.codepointAt(2, invalid_utf8));

}

}

 

test "codepointAt utf8 encoded" {

 

 

/// `buf` must be at least as long as `source`

/// In-place transformation is supported (i.e. `source` and `buf` can be the same slice)

std.debug.assert(buf.len >= source.len);

var result = UncheckedSliceWriter{ .slice = buf };

const State = enum {

else => {},

},

.multiline_comment => switch (c) {

'\n' => {

_ = line_handler.incrementLineNumber(index);

result.write(c);

},

.multiline_comment_end => switch (c) {

'\r' => {

// We only want to treat this as a newline if it's part of a CRLF pair. If it's

// not, then we still want to stay in .multiline_comment_end, so that e.g. `*<\r>/` still

// functions as a `*/` comment ending. Kinda crazy, but that's how the Win32 implementation works.

index: usize,

result: *UncheckedSliceWriter,

source_mappings: ?*SourceMappings,

// Note: Bare \r within a multiline comment should *not* be treated as a line ending for the

// purposes of removing comments, but *should* be treated as a line ending for the

// purposes of line counting/source mapping

_ = line_handler.incrementLineNumber(index);

result.write('\r');

}

// And otherwise, we want to collapse the source mapping so that we can still know which

// the next collapse acts on the first of the collapsed line numbers

line_handler.line_number -= 1;

if (source_mappings) |mappings| {

}

}

}

pub fn removeCommentsAlloc(allocator: Allocator, source: []const u8, source_mappings: ?*SourceMappings) ![]u8 {

const buf = try allocator.alloc(u8, source.len);

errdefer allocator.free(buf);

return allocator.realloc(buf, result.len);

}

 

try testRemoveComments("\r\n", "//comment\r\n");

}

 

test "crazy" {

try testRemoveComments(

\\blah"/*som*/\""BLAH

var mut_source = "blah/*\rcommented line*\r/blah".*;

var mappings = SourceMappings{};

_ = try mappings.files.put(allocator, "test.rc");

defer mappings.deinit(allocator);

 

 

try std.testing.expectEqualStrings("blahblah", result);

}

 

test "in place" {

var mut_source = "blah /* comment */ blah".*;

try std.testing.expectEqualStrings("blah blah", result);

}

 

 

return buf.toOwnedSlice();

},

}

},

.binary_expression => {

return first_error orelse error.FileNotFound;

}

 

pub fn writeResourceExternal(self: *Compiler, node: *Node.ResourceExternal, writer: anytype) !void {

// Init header with data size zero for now, will need to fill it in later

var header = try self.resourceHeader(node.id, node.type, .{});

// DLGINCLUDE has special handling that doesn't actually need the file to exist

if (maybe_predefined_type != null and maybe_predefined_type.? == .DLGINCLUDE) {

const filename_token = node.filename.cast(.literal).?.token;

defer self.allocator.free(parsed_filename);

 

header.applyMemoryFlags(node.common_resource_attributes, self.source);

try header.write(writer, .{ .diagnostics = self.diagnostics, .token = node.id });

try writer.writeByte(0);

try writeDataPadding(writer, header.data_size);

return;

errdefer self.allocator.free(parsed_string);

return .{ .wide_string = parsed_string };

},

}

},

.binary_expression, .grouped_expression => {

return .{ .number = result };

},

.not_expression => unreachable,

}

}

 

};

}

 

const data_size: u32 = @intCast(data_buffer.items.len);

var header = try self.resourceHeader(node.id, node.type, .{

.data_size = data_size,

try data_writer.writeInt(u16, 1, .little);

try data_writer.writeInt(u16, button_width.asWord(), .little);

try data_writer.writeInt(u16, button_height.asWord(), .little);

try data_writer.writeInt(u16, @as(u16, @intCast(node.buttons.len)), .little);

 

for (node.buttons) |button_or_sep| {

);

}

 

fn addErrorDetails(self: *Compiler, details: ErrorDetails) Allocator.Error!void {

try self.diagnostics.append(details);

}

}

break :ids buf;

};

var random = prng.random();

random.shuffle(u16, &ids);

 

 

rc_would_miscompile_version_value_byte_count,

code_page_pragma_in_included_file,

nested_resource_level_exceeds_max,

nested_expression_level_exceeds_max,

close_paren_expression,

unary_plus_expression,

.note => return writer.print("max {s} nesting level exceeded here", .{self.extra.resource.nameForErrorDisplay()}),

.hint => return,

},

.hint => return,

},

.nested_expression_level_exceeds_max => switch (self.type) {

pub fn renderErrorMessage(allocator: std.mem.Allocator, writer: anytype, tty_config: std.io.tty.Config, cwd: std.fs.Dir, err_details: ErrorDetails, source: []const u8, strings: []const []const u8, source_mappings: ?SourceMappings) !void {

if (err_details.type == .hint) return;

 

// Treat tab stops as 1 column wide for error display purposes,

// and add one to get a 1-based column

const column = err_details.token.calculateColumn(source, 1, source_line_start) + 1;

 

else

null;

const corresponding_file: ?[]const u8 = if (source_mappings != null and corresponding_span != null)

return;

}

 

const visual_info = err_details.visualTokenInfo(source_line_start, source_line_start + source_line.len);

 

// Need this to determine if the 'line originated from' note is worth printing

lines: std.ArrayListUnmanaged(u8) = .{},

lines_is_error_message: bool = false,

 

var corresponding_lines = CorrespondingLines{};

 

// We don't do line comparison for this error, so don't print the note if the line

 

pub fn writeLinesFromStream(writer: anytype, input: anytype, start_line: usize, end_line: usize) !void {

var line_num: usize = 1;

while (try readByteOrEof(input)) |byte| {

switch (byte) {

},

else => {

if (line_num >= start_line) try writeSourceByte(writer, byte);

},

}

}

if (line_num != end_line) {

return error.LinesNotFound;

 

 

writer.writeAll(parsed_sort.suffix.?) catch unreachable;

const expected_field_name = comptime field: {

var name_buf: [5]u8 = undefined;

name_buf[2] = '_';

@memcpy(name_buf[3..], parsed_sort.country_code.?);

break :field name_buf;

 

 

/// Returns 0-based column

pub fn calculateColumn(token: Token, source: []const u8, tab_columns: usize, maybe_line_start: ?usize) usize {

 

var i: usize = line_start;

var column: usize = 0;

return column;

}

 

// (the TODO in currentIndexFormsLineEndingPair should be taken into account as well)

const line_start = line_start: {

if (token.start != 0) {

// start checking at the byte before the token

return line_start;

}

 

 

 

return source[line_start..line_end];

}

 

 

 

pub const ParsedCodepoint = struct {

codepoint: u21,

from_escaped_integer: bool = false,

};

 

.wide => 4,

};

 

const c = codepoint.value;

defer {

if (c == '\t') {

self.column += columnsUntilTabStop(self.column, 8);

} else {

.newline => switch (c) {

'\r', ' ', '\t', '\n', '\x0b', '\x0c', '\xa0' => {},

else => {

backtrack = true;

// <space><newline>

self.pending_codepoint = '\n';

return .{ .codepoint = ' ' };

},

else => switch (self.declared_string_type) {

.wide => {}, // invalid escape sequences are skipped in wide strings

.ascii => {

backtrack = true;

return .{ .codepoint = '\\' };

},

},

'\r' => {},

'\n' => state = .escaped_newlines,

else => {

backtrack = true;

return .{ .codepoint = '\\' };

},

},

string_escape_n +%= std.fmt.charToDigit(@intCast(c), 8) catch unreachable;

string_escape_i += 1;

if (string_escape_i == max_octal_escape_digits) {

self.index += codepoint.byte_len;

}

},

else => {

backtrack = true;

// write out whatever byte we have parsed so far

},

},

.escaped_hex => switch (c) {

string_escape_n += std.fmt.charToDigit(@intCast(c), 16) catch unreachable;

string_escape_i += 1;

if (string_escape_i == max_hex_escape_digits) {

self.index += codepoint.byte_len;

}

},

else => {

backtrack = true;

// write out whatever byte we have parsed so far

// (even with 0 actual digits, \x alone parses to 0)

return .{ .codepoint = escaped_value, .from_escaped_integer = true };

},

},

},

.escaped, .escaped_cr => return .{ .codepoint = '\\' },

.escaped_octal, .escaped_hex => {

},

.quote => unreachable, // this is a bug in the lexer

}

while (try iterative_parser.next()) |parsed| {

const c = parsed.codepoint;

if (parsed.from_escaped_integer) {

} else {

switch (literal_type) {

.ascii => switch (options.output_code_page) {

return parseQuotedString(.wide, allocator, bytes, options);

}

 

test "parse quoted ascii string" {

var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);

defer arena_allocator.deinit();

.{ .slice = "\"\xF2\xAF\xBA\xB4\"", .code_page = .utf8 },

.{ .output_code_page = .utf8 },

));

}

 

test "parse quoted wide string" {

 

 

} },

});

}

const value_node = try self.state.arena.create(Node.Literal);

value_node.* = .{

.token = value,

const identifier = self.state.token;

try self.nextToken(.whitespace_delimiter_only);

try self.check(.literal);

const value_node = try self.state.arena.create(Node.Literal);

value_node.* = .{

.token = self.state.token,

// be able to be written into the relevant field in the .res data.

if (controls.items.len >= std.math.maxInt(u16)) {

try self.addErrorDetails(.{

.token = id_token,

.extra = .{ .resource = resource },

});

return self.addErrorDetailsAndFail(.{

.type = .note,

.token = control_node.getFirstToken(),

.token_span_end = control_node.getLastToken(),

try self.check(.begin);

 

var buttons = std.ArrayListUnmanaged(*Node){};

while (try self.parseToolbarButtonStatement()) |button_node| {

}

 

try self.nextToken(.normal);

.button_width = button_width,

.button_height = button_height,

.begin_token = begin_token,

.end_token = end_token,

};

return &node.base;

 

 

 

const parsed = maybe_parsed orelse return null;

if (parsed.codepoint == Codepoint.invalid) return 0xFFFD;

if (parsed.from_escaped_integer and self.string_type == .ascii) {

}

return parsed.codepoint;

}

 

const std = @import("std");

const Allocator = std.mem.Allocator;

 

pub const ParseLineCommandsResult = struct {

result: []u8,

},

'\r', '\n' => {

const is_crlf = formsLineEndingPair(source, c, index + 1);

if (!current_mapping.ignore_contents) {

result.write(c);

if (is_crlf) result.write(source[index + 1]);

line_number += 1;

if (std.mem.startsWith(u8, preprocessor_str, "#line")) {

try handleLineCommand(allocator, preprocessor_str, &current_mapping);

} else {

if (!current_mapping.ignore_contents) {

const line_ending_len: usize = if (is_crlf) 2 else 1;

result.writeSlice(source[pending_start.? .. index + line_ending_len]);

line_number += 1;

.non_preprocessor => switch (c) {

'\r', '\n' => {

const is_crlf = formsLineEndingPair(source, c, index + 1);

if (!current_mapping.ignore_contents) {

result.write(c);

if (is_crlf) result.write(source[index + 1]);

line_number += 1;

// If there have been no line mappings at all, then we're dealing with an empty file.

// In this case, we want to fake a line mapping just so that we return something

// that is useable in the same way that a non-empty mapping would be.

try handleLineEnd(allocator, line_number, &parse_result.mappings, &current_mapping);

}

 

if (next_index >= source.len) return false;

 

const next_ending = source[next_index];

}

 

pub fn handleLineEnd(allocator: Allocator, post_processed_line_number: usize, mapping: *SourceMappings, current_mapping: *CurrentMapping) !void {

const filename_offset = try mapping.files.put(allocator, current_mapping.filename.items);

 

 

current_mapping.line_num += 1;

current_mapping.pending = false;

}

 

pub const SourceMappings = struct {

files: StringTable = .{},

/// The default assumes that the first filename added is the root file.

/// The value should be set to the correct offset if that assumption does not hold.

root_filename_offset: u32 = 0,

 

start_line: usize,

filename_offset: u32,

};

 

pub fn deinit(self: *SourceMappings, allocator: Allocator) void {

self.files.deinit(allocator);

}

 

}

 

}

 

}

 

}

 

std.debug.assert(num_following_lines_to_collapse > 0);

 

 

}

 

/// Returns true if the line is from the main/root file (i.e. not a file that has been

/// `#include`d).

pub fn isRootFile(self: *SourceMappings, line_num: usize) bool {

}

};

 

defer mappings.deinit(allocator);

const filename_offset = try mappings.files.put(allocator, "test.rc");

 

 

 

}

 

/// Same thing as StringTable in Zig's src/Wasm.zig

std.debug.print("{}: {s}:{}-{}\n", .{ line_num, span.filename, span.start_line, span.end_line });

}

std.debug.print("\nactual mappings:\n", .{});

const filename = results.mappings.files.get(span.filename_offset);

}

std.debug.print("\n", .{});

return err;

}

 

fn expectEqualMappings(expected_spans: []const ExpectedSourceSpan, mappings: SourceMappings) !void {

for (expected_spans, 0..) |expected_span, i| {

const line_num = i + 1;

const filename = mappings.files.get(span.filename_offset);

try std.testing.expectEqual(expected_span.start_line, span.start_line);

try std.testing.expectEqual(expected_span.end_line, span.end_line);

defer result.mappings.deinit(std.testing.allocator);

try std.testing.expectEqualStrings("", result.result);

}

 

};

}

 

/// Used for generic colored errors/warnings/notes, more context-specific error messages

/// are handled elsewhere.

switch (msg_type) {

.err => {

try config.setColor(writer, .bold);

try writer.writeByte('\n');

try config.setColor(writer, .reset);

}

 

 

// The ensureUnusedCapacity call above guarantees this.

const notes_start = wip.reserveNotes(@intCast(other_list.len)) catch unreachable;

for (notes_start.., other_list) |note, message| {

}

}

 

};

const loc = std.zig.findLineColumn(source, span.main);

 

.msg = try eb.addString(msg),

.src_loc = try eb.addSourceLocation(.{

.src_path = try eb.addString(src_path),

}),

.notes_len = 0, // TODO rework this function to be recursive

}));

}

}

}

if (index == .none) return .none;

const other_sl = other.getSourceLocation(index);

 

const src_loc = try wip.addSourceLocation(.{

.src_path = try wip.addString(other.nullTerminatedString(other_sl.src_path)),

.line = other_sl.line,

.reference_trace_len = other_sl.reference_trace_len,

});

 

 

return src_loc;

}

}

}

};

 

const c_codegen = @import("codegen/c.zig");

const libtsan = @import("libtsan.zig");

const Zir = std.zig.Zir;

const Builtin = @import("Builtin.zig");

const LlvmObject = @import("codegen/llvm.zig").Object;

 

global_cache_directory: Directory,

libc_include_dir_list: []const []const u8,

libc_framework_dir_list: []const []const u8,

thread_pool: *ThreadPool,

 

/// Populated when we build the libc++ static library. A Job to build this is placed in the queue

options.libc_installation,

);

 

const sysroot = options.sysroot orelse libc_dirs.sysroot;

 

const include_compiler_rt = options.want_compiler_rt orelse

.self_exe_path = options.self_exe_path,

.libc_include_dir_list = libc_dirs.libc_include_dir_list,

.libc_framework_dir_list = libc_dirs.libc_framework_dir_list,

.thread_pool = options.thread_pool,

.clang_passthrough_mode = options.clang_passthrough_mode,

.clang_preprocessor_mode = options.clang_preprocessor_mode,

man.hash.add(comp.link_eh_frame_hdr);

man.hash.add(comp.skip_linker_dependencies);

man.hash.add(comp.include_compiler_rt);

man.hash.addListOfBytes(comp.force_undefined_symbols.keys());

man.hash.addListOfBytes(comp.framework_dirs);

try link.hashAddSystemLibs(man, comp.system_libs);

pub fn obtainWin32ResourceCacheManifest(comp: *const Compilation) Cache.Manifest {

var man = comp.cache_parent.obtain();

 

 

return man;

}

}

 

fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32_resource_prog_node: *std.Progress.Node) !void {

}

const self_exe_path = comp.self_exe_path orelse

 

const tracy_trace = trace(@src());

defer tracy_trace.end();

if (win32_resource.src == .manifest) {

_ = try man.addFile(src_path, null);

 

const res_basename = try std.fmt.allocPrint(arena, "{s}.res", .{src_basename});

 

const digest = if (try man.hit()) man.final() else blk: {

var o_dir = try comp.local_cache_directory.handle.makeOpenPath(o_sub_path, .{});

defer o_dir.close();

 

 

// In .rc files, a " within a quoted string is escaped as ""

const fmtRcEscape = struct {

// 1 is CREATEPROCESS_MANIFEST_RESOURCE_ID which is the default ID used for RT_MANIFEST resources

// 24 is RT_MANIFEST

const input = try std.fmt.allocPrint(arena, "1 24 \"{s}\"", .{fmtRcEscape(src_path)});

 

 

 

break :blk digest;

};

const rc_basename_noext = src_basename[0 .. src_basename.len - std.fs.path.extension(src_basename).len];

 

const digest = if (try man.hit()) man.final() else blk: {

var zig_cache_tmp_dir = try comp.local_cache_directory.handle.makeOpenPath("tmp", .{});

defer zig_cache_tmp_dir.close();

 

// so we need a temporary filename.

const out_res_path = try comp.tmpFilePath(arena, res_filename);

 

var argv = std.ArrayList([]const u8).init(comp.gpa);

defer argv.deinit();

 

});

// them being defined matches the behavior of how MSVC calls rc.exe which is the more

// relevant behavior in this case.

}

 

 

 

 

};

}

 

// Rename into place.

defer o_dir.close();

const tmp_basename = std.fs.path.basename(out_res_path);

try std.fs.rename(zig_cache_tmp_dir, tmp_basename, o_dir, res_filename);

break :blk digest;

};

 

};

}

 

pub fn tmpFilePath(comp: *Compilation, ally: Allocator, suffix: []const u8) error{OutOfMemory}![]const u8 {

const s = std.fs.path.sep_str;

const rand_int = std.crypto.random.int(u64);

try argv.append("-isystem");

try argv.append(c_headers_dir);

 

}

 

if (target.cpu.model.llvm_name) |llvm_name| {

return error.AnalysisFail;

}

 

pub const FileExt = enum {

c,

cpp,

 

} else if (mem.eql(u8, cmd, "translate-c")) {

return buildOutputType(gpa, arena, args, .translate_c);

} else if (mem.eql(u8, cmd, "rc")) {

} else if (mem.eql(u8, cmd, "fmt")) {

return jitCmd(gpa, arena, cmd_args, .{

.cmd_name = "fmt",

}

}

 

const usage_init =

\\Usage: zig init

\\

prepend_zig_exe_path: bool = false,

depend_on_aro: bool = false,

capture: ?*[]u8 = null,

};

 

fn jitCmd(

};

defer comp.destroy();

 

 

const exe_path = try global_cache_directory.join(arena, &.{comp.cache_use.whole.bin_sub_path.?});

child_argv.appendAssumeCapacity(exe_path);