falsepattern/zig-glfw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Revert "all: build: fix sdkPath for relative @src.file / fix autocompletion with ZLS / IDEs (#661)"

Browse source 
This reverts commit 711e644a061cf8e21c35308873fe0f0e698ac490.

Lue suggested reverting #661 because ZLS worked around the issue of @src
being relative in that environment: https://github.com/zigtools/zls/pull/898

This is not a perfect solution (what zls did seems to be a workaround), but
is good enough for us until Zig gets an official package manager.
This commit is contained in:
Stephen Gutekanst 2023-01-10 01:43:50 -07:00 • committed by Stephen Gutekanst
parent c1b4a83c0f
commit 20fc0272f0
2 changed files with 26 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -59,7 +59,7 @@ const glfw = @import("libs/mach-glfw/build.zig");
pub fn build(b: *Builder) !void { pub fn build(b: *Builder) !void {
... ...
exe.addPackage(glfw.pkg(b)); exe.addPackage(glfw.pkg);
try glfw.link(b, exe, .{}); try glfw.link(b, exe, .{});
} }
``` ```

99
build.zig
View file

@ -14,7 +14,7 @@ pub fn build(b: *Builder) !void {
} }
pub fn testStep(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) !*std.build.RunStep { pub fn testStep(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) !*std.build.RunStep {
const main_tests = b.addTestExe("glfw-tests", sdkPath(b, "/src/main.zig")); const main_tests = b.addTestExe("glfw-tests", sdkPath("/src/main.zig"));
main_tests.setBuildMode(mode); main_tests.setBuildMode(mode);
main_tests.setTarget(target); main_tests.setTarget(target);
try link(b, main_tests, .{}); try link(b, main_tests, .{});
@ -23,7 +23,7 @@ pub fn testStep(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget
} }
fn testStepShared(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) !*std.build.RunStep { fn testStepShared(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) !*std.build.RunStep {
const main_tests = b.addTestExe("glfw-tests-shared", sdkPath(b, "/src/main.zig")); const main_tests = b.addTestExe("glfw-tests-shared", sdkPath("/src/main.zig"));
main_tests.setBuildMode(mode); main_tests.setBuildMode(mode);
main_tests.setTarget(target); main_tests.setTarget(target);
try link(b, main_tests, .{ .shared = true }); try link(b, main_tests, .{ .shared = true });
@ -64,19 +64,10 @@ pub const Options = struct {
install_libs: bool = false, install_libs: bool = false,
}; };
var cached_pkg: ?std.build.Pkg = null; pub const pkg = std.build.Pkg{
.name = "glfw",
pub fn pkg(b: *Builder) std.build.Pkg { .source = .{ .path = sdkPath("/src/main.zig") },
if (cached_pkg == null) { };
cached_pkg = .{
.name = "glfw",
.source = .{ .path = sdkPath(b, "/src/main.zig") },
.dependencies = &.{},
};
}
return cached_pkg.?;
}
pub const LinkError = error{FailedToLinkGPU} || BuildError; pub const LinkError = error{FailedToLinkGPU} || BuildError;
pub fn link(b: *Builder, step: *std.build.LibExeObjStep, options: Options) LinkError!void { pub fn link(b: *Builder, step: *std.build.LibExeObjStep, options: Options) LinkError!void {
@ -117,21 +108,21 @@ fn buildLibrary(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget
} }
fn addGLFWIncludes(step: *std.build.LibExeObjStep) void { fn addGLFWIncludes(step: *std.build.LibExeObjStep) void {
step.addIncludePath(sdkPath(step.builder, "/upstream/glfw/include")); step.addIncludePath(sdkPath("/upstream/glfw/include"));
step.addIncludePath(sdkPath(step.builder, "/upstream/vulkan_headers/include")); step.addIncludePath(sdkPath("/upstream/vulkan_headers/include"));
} }
fn addGLFWSources(b: *Builder, lib: *std.build.LibExeObjStep, options: Options) std.mem.Allocator.Error!void { fn addGLFWSources(b: *Builder, lib: *std.build.LibExeObjStep, options: Options) std.mem.Allocator.Error!void {
const include_glfw_src = try std.mem.concat(b.allocator, u8, &.{ "-I", sdkPath(b, "/upstream/glfw/src") }); const include_glfw_src = comptime "-I" ++ sdkPath("/upstream/glfw/src");
switch (lib.target_info.target.os.tag) { switch (lib.target_info.target.os.tag) {
.windows => lib.addCSourceFiles(&.{ .windows => lib.addCSourceFiles(&.{
sdkPath(b, "/src/sources_all.c"), sdkPath("/src/sources_all.c"),
sdkPath(b, "/src/sources_windows.c"), sdkPath("/src/sources_windows.c"),
}, &.{ "-D_GLFW_WIN32", include_glfw_src }), }, &.{ "-D_GLFW_WIN32", include_glfw_src }),
.macos => lib.addCSourceFiles(&.{ .macos => lib.addCSourceFiles(&.{
sdkPath(b, "/src/sources_all.c"), sdkPath("/src/sources_all.c"),
sdkPath(b, "/src/sources_macos.m"), sdkPath("/src/sources_macos.m"),
sdkPath(b, "/src/sources_macos.c"), sdkPath("/src/sources_macos.c"),
}, &.{ "-D_GLFW_COCOA", include_glfw_src }), }, &.{ "-D_GLFW_COCOA", include_glfw_src }),
else => { else => {
// TODO(future): for now, Linux can't be built with musl: // TODO(future): for now, Linux can't be built with musl:
@ -142,17 +133,17 @@ fn addGLFWSources(b: *Builder, lib: *std.build.LibExeObjStep, options: Options)
// ``` // ```
var sources = std.ArrayList([]const u8).init(b.allocator); var sources = std.ArrayList([]const u8).init(b.allocator);
var flags = std.ArrayList([]const u8).init(b.allocator); var flags = std.ArrayList([]const u8).init(b.allocator);
try sources.append(sdkPath(b, "/src/sources_all.c")); try sources.append(sdkPath("/src/sources_all.c"));
try sources.append(sdkPath(b, "/src/sources_linux.c")); try sources.append(sdkPath("/src/sources_linux.c"));
if (options.x11) { if (options.x11) {
try sources.append(sdkPath(b, "/src/sources_linux_x11.c")); try sources.append(sdkPath("/src/sources_linux_x11.c"));
try flags.append("-D_GLFW_X11"); try flags.append("-D_GLFW_X11");
} }
if (options.wayland) { if (options.wayland) {
try sources.append(sdkPath(b, "/src/sources_linux_wayland.c")); try sources.append(sdkPath("/src/sources_linux_wayland.c"));
try flags.append("-D_GLFW_WAYLAND"); try flags.append("-D_GLFW_WAYLAND");
} }
try flags.append(include_glfw_src); try flags.append(comptime "-I" ++ sdkPath("/upstream/glfw/src"));
// TODO(upstream): glfw can't compile on clang15 without this flag // TODO(upstream): glfw can't compile on clang15 without this flag
try flags.append("-Wno-implicit-function-declaration"); try flags.append("-Wno-implicit-function-declaration");
@ -206,57 +197,17 @@ fn ensureDependencySubmodule(allocator: std.mem.Allocator, path: []const u8) !vo
if (std.mem.eql(u8, no_ensure_submodules, "true")) return; if (std.mem.eql(u8, no_ensure_submodules, "true")) return;
} else |_| {} } else |_| {}
var child = std.ChildProcess.init(&.{ "git", "submodule", "update", "--init", path }, allocator); var child = std.ChildProcess.init(&.{ "git", "submodule", "update", "--init", path }, allocator);
child.cwd = sdkPathAllocator(allocator, "/"); child.cwd = sdkPath("/");
child.stderr = std.io.getStdErr(); child.stderr = std.io.getStdErr();
child.stdout = std.io.getStdOut(); child.stdout = std.io.getStdOut();
_ = try child.spawnAndWait(); _ = try child.spawnAndWait();
} }
const unresolved_dir = (struct { fn sdkPath(comptime suffix: []const u8) []const u8 {
inline fn unresolvedDir() []const u8 {
return comptime std.fs.path.dirname(@src().file) orelse ".";
}
}).unresolvedDir();
fn thisDir(allocator: std.mem.Allocator) []const u8 {
if (comptime unresolved_dir[0] == '/') {
return unresolved_dir;
}
const cached_dir = &(struct {
var cached_dir: ?[]const u8 = null;
}).cached_dir;
if (cached_dir.* == null) {
cached_dir.* = std.fs.cwd().realpathAlloc(allocator, unresolved_dir) catch unreachable;
}
return cached_dir.*.?;
}
inline fn sdkPath(b: *Builder, comptime suffix: []const u8) []const u8 {
return sdkPathAllocator(b.allocator, suffix);
}
inline fn sdkPathAllocator(allocator: std.mem.Allocator, comptime suffix: []const u8) []const u8 {
return sdkPathInternal(allocator, suffix.len, suffix[0..suffix.len].*);
}
fn sdkPathInternal(allocator: std.mem.Allocator, comptime len: usize, comptime suffix: [len]u8) []const u8 {
if (suffix[0] != '/') @compileError("suffix must be an absolute path"); if (suffix[0] != '/') @compileError("suffix must be an absolute path");
return comptime blk: {
if (comptime unresolved_dir[0] == '/') { const root_dir = std.fs.path.dirname(@src().file) orelse ".";
return unresolved_dir ++ @as([]const u8, &suffix); break :blk root_dir ++ suffix;
} };
const cached_dir = &(struct {
var cached_dir: ?[]const u8 = null;
}).cached_dir;
if (cached_dir.* == null) {
cached_dir.* = std.fs.path.resolve(allocator, &.{ thisDir(allocator), suffix[1..] }) catch unreachable;
}
return cached_dir.*.?;
} }