mirror of
https://github.com/ziglang/zig.git
synced 2025-12-10 16:23:07 +00:00
03a23418ff
* implement --debug-cc and --debug-link
* implement C source files having extra flags
- TODO a way to pass them on the CLI
* introduce the Directory abstraction which contains both an open file
descriptor and a file path name. The former is preferred but the
latter is needed when communicating paths over a command line (e.g.
to Clang or LLD).
* use the cache hash to choose an artifact directory
- TODO: use separate cache hash instances for the zig module and
each C object
* Module: introduce the crt_files table for keeping track of built libc
artifacts for linking.
* Add the ability to build 4/6 of the glibc static CRT lib files.
* The zig-cache directory is now passed as a parameter to Module.
* Implement the CLI logic of -femit-bin and -femit-h
- TODO: respect -fno-emit-bin
- TODO: the emit .h feature
* Add the -fvalgrind, -fstack-check, and --single-threaded CLI options.
* Implement the logic for auto detecting whether to enable PIC,
sanitize-C, stack-check, valgrind, and single-threaded.
* Properly add PIC args (or not) to clang argv.
* Implement renaming clang-compiled object files into their proper
place within the cache artifact directory.
- TODO: std lib needs a proper higher level abstraction for
std.os.renameat.
* Package is cleaned up to use the "Unmanaged" StringHashMap and use the
new Directory abstraction.
* Clean up zig lib directory detection to make proper use of directory
handles.
* Linker code invokes LLD.
- TODO properly deal with the stdout and stderr that we get from it
and expose diagnostics from the Module API that match the expected
error message format.
* Delete the bitrotted LLVM C ABI bindings. We'll resurrect just the
functions we need as we introduce dependencies on them. So far it
only has ZigLLDLink in it.
* Remove dead timer code.
* `zig env` now prints the path to the zig executable as well.
84 lines
3.0 KiB
Zig
84 lines
3.0 KiB
Zig
const std = @import("std");
|
|
const mem = std.mem;
|
|
const fs = std.fs;
|
|
const CacheHash = std.cache_hash.CacheHash;
|
|
const Module = @import("Module.zig");
|
|
|
|
/// Returns the sub_path that worked, or `null` if none did.
|
|
/// The path of the returned Directory is relative to `base`.
|
|
/// The handle of the returned Directory is open.
|
|
fn testZigInstallPrefix(base_dir: fs.Dir) ?Module.Directory {
|
|
const test_index_file = "std" ++ fs.path.sep_str ++ "std.zig";
|
|
|
|
zig_dir: {
|
|
// Try lib/zig/std/std.zig
|
|
const lib_zig = "lib" ++ fs.path.sep_str ++ "zig";
|
|
var test_zig_dir = base_dir.openDir(lib_zig, .{}) catch break :zig_dir;
|
|
const file = test_zig_dir.openFile(test_index_file, .{}) catch {
|
|
test_zig_dir.close();
|
|
break :zig_dir;
|
|
};
|
|
file.close();
|
|
return Module.Directory{ .handle = test_zig_dir, .path = lib_zig };
|
|
}
|
|
|
|
// Try lib/std/std.zig
|
|
var test_zig_dir = base_dir.openDir("lib", .{}) catch return null;
|
|
const file = test_zig_dir.openFile(test_index_file, .{}) catch {
|
|
test_zig_dir.close();
|
|
return null;
|
|
};
|
|
file.close();
|
|
return Module.Directory{ .handle = test_zig_dir, .path = "lib" };
|
|
}
|
|
|
|
/// Both the directory handle and the path are newly allocated resources which the caller now owns.
|
|
pub fn findZigLibDir(gpa: *mem.Allocator) !Module.Directory {
|
|
const self_exe_path = try fs.selfExePathAlloc(gpa);
|
|
defer gpa.free(self_exe_path);
|
|
|
|
return findZigLibDirFromSelfExe(gpa, self_exe_path);
|
|
}
|
|
|
|
/// Both the directory handle and the path are newly allocated resources which the caller now owns.
|
|
pub fn findZigLibDirFromSelfExe(
|
|
allocator: *mem.Allocator,
|
|
self_exe_path: []const u8,
|
|
) error{ OutOfMemory, FileNotFound }!Module.Directory {
|
|
const cwd = fs.cwd();
|
|
var cur_path: []const u8 = self_exe_path;
|
|
while (fs.path.dirname(cur_path)) |dirname| : (cur_path = dirname) {
|
|
var base_dir = cwd.openDir(dirname, .{}) catch continue;
|
|
defer base_dir.close();
|
|
|
|
const sub_directory = testZigInstallPrefix(base_dir) orelse continue;
|
|
return Module.Directory{
|
|
.handle = sub_directory.handle,
|
|
.path = try fs.path.join(allocator, &[_][]const u8{ dirname, sub_directory.path.? }),
|
|
};
|
|
}
|
|
return error.FileNotFound;
|
|
}
|
|
|
|
/// Caller owns returned memory.
|
|
pub fn resolveGlobalCacheDir(allocator: *mem.Allocator) ![]u8 {
|
|
const appname = "zig";
|
|
|
|
if (std.Target.current.os.tag != .windows) {
|
|
if (std.os.getenv("XDG_CACHE_HOME")) |cache_root| {
|
|
return fs.path.join(allocator, &[_][]const u8{ cache_root, appname });
|
|
} else if (std.os.getenv("HOME")) |home| {
|
|
return fs.path.join(allocator, &[_][]const u8{ home, ".cache", appname });
|
|
}
|
|
}
|
|
|
|
return fs.getAppDataDir(allocator, appname);
|
|
}
|
|
|
|
pub fn openGlobalCacheDir() !fs.Dir {
|
|
var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
|
|
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
|
const path_name = try resolveGlobalCacheDir(&fba.allocator);
|
|
return fs.cwd().makeOpenPath(path_name, .{});
|
|
}
|