mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-18 23:39:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

more fixes related to previous commits Package/Module API

Browse Source
This commit is contained in:
Andrew Kelley 2023-10-07 14:38:03 -07:00
parent a232f7e8ec
commit 35d81c99c0
2 changed files with 24 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/Sema.zig
View File

@ -5732,6 +5732,8 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
const tracy = trace(@src());
defer tracy.end();
const mod = sema.mod;
const gpa = sema.gpa;
const pl_node = sema.code.instructions.items(.data)[inst].pl_node;
const src = pl_node.src();
const extra = sema.code.extraData(Zir.Inst.Block, pl_node.payload_index);
@ -5741,7 +5743,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
if (!@import("build_options").have_llvm)
return sema.fail(parent_block, src, "C import unavailable; Zig compiler built without LLVM extensions", .{});
var c_import_buf = std.ArrayList(u8).init(sema.gpa);
var c_import_buf = std.ArrayList(u8).init(gpa);
defer c_import_buf.deinit();
var comptime_reason: Block.ComptimeReason = .{ .c_import = .{
@ -5763,25 +5765,24 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
.runtime_loop = parent_block.runtime_loop,
.runtime_index = parent_block.runtime_index,
};
defer child_block.instructions.deinit(sema.gpa);
defer child_block.instructions.deinit(gpa);
// Ignore the result, all the relevant operations have written to c_import_buf already.
_ = try sema.analyzeBodyBreak(&child_block, body);
const mod = sema.mod;
var c_import_res = mod.comp.cImport(c_import_buf.items) catch |err|
return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
defer c_import_res.deinit(mod.comp.gpa);
defer c_import_res.deinit(gpa);
if (c_import_res.errors.errorMessageCount() != 0) {
const msg = msg: {
const msg = try sema.errMsg(&child_block, src, "C import failed", .{});
errdefer msg.destroy(sema.gpa);
errdefer msg.destroy(gpa);
if (!mod.comp.bin_file.options.link_libc)
try sema.errNote(&child_block, src, msg, "libc headers not available; compilation does not link against libc", .{});
const gop = try mod.cimport_errors.getOrPut(sema.gpa, sema.owner_decl_index);
const gop = try mod.cimport_errors.getOrPut(gpa, sema.owner_decl_index);
if (!gop.found_existing) {
gop.value_ptr.* = c_import_res.errors;
c_import_res.errors = std.zig.ErrorBundle.empty;
@ -5790,16 +5791,19 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
};
return sema.failWithOwnedErrorMsg(&child_block, msg);
}
const c_import_pkg = Package.create(
sema.gpa,
null,
c_import_res.out_zig_path,
) catch |err| switch (err) {
error.OutOfMemory => return error.OutOfMemory,
else => unreachable, // we pass null for root_src_dir_path
};
// All modules are intended to go into an arena with a lifetime >= the ZigUnit.
// After the other uses of `tmp_hack_arena` are eliminated, it should be
// renamed to something more appropriate such as simply `arena`.
const zu_arena = mod.tmp_hack_arena.allocator();
const c_import_mod = try Package.Module.create(zu_arena, .{
.root = .{
.root_dir = Compilation.Directory.cwd(),
.sub_path = std.fs.path.dirname(c_import_res.out_zig_path) orelse "",
},
.root_src_path = std.fs.path.basename(c_import_res.out_zig_path),
});
const result = mod.importPkg(c_import_pkg) catch |err|
const result = mod.importPkg(c_import_mod) catch |err|
return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
mod.astGenFile(result.file) catch |err|

13
src/codegen/llvm.zig
View File

@ -1836,14 +1836,11 @@ pub const Object = struct {
}
const dir_path_z = d: {
var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
const dir_path = file.pkg.root_src_directory.path orelse ".";
const resolved_dir_path = if (std.fs.path.isAbsolute(dir_path))
dir_path
else
std.os.realpath(dir_path, &buffer) catch dir_path; // If realpath fails, fallback to whatever dir_path was
break :d try std.fs.path.joinZ(gpa, &.{
resolved_dir_path, std.fs.path.dirname(file.sub_file_path) orelse "",
});
const sub_path = std.fs.path.dirname(file.sub_file_path) orelse "";
const dir_path = try file.mod.root.joinStringZ(gpa, sub_path);
if (std.fs.path.isAbsolute(dir_path)) break :d dir_path;
const abs = std.fs.realpath(dir_path, &buffer) catch break :d dir_path;
break :d try std.fs.path.joinZ(gpa, &.{ abs, sub_path });
};
defer gpa.free(dir_path_z);
const sub_file_path_z = try gpa.dupeZ(u8, std.fs.path.basename(file.sub_file_path));