Skip to content

Update build.zig to compile on the latest stable Zig 0.15.2 #894

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
NWilson merged 3 commits into from
Apr 3, 2026
+108 −70
Merged

Update build.zig to compile on the latest stable Zig 0.15.2 #894

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
cbaa0c7
Update build.zig to compile on the latest stable Zig 0.15.2
bernardassan Mar 20, 2026
161bed5
Cleanup based on review from https://github.com/PCRE2Project/pcre2/pu…
bernardassan Mar 25, 2026
e9cde38
Add just a few additional flags for consistency across the zig modules
NWilson Apr 3, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
178 changes: 108 additions & 70 deletions build.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,77 +7,103 @@ pub const CodeUnitWidth = enum {
};

pub fn build(b: *std.Build) !void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const linkage = b.option(std.builtin.LinkMode, "linkage", "whether to statically or dynamically link the library") orelse @as(std.builtin.LinkMode, if (target.result.isGnuLibC()) .dynamic else .static);
const target = b.standardTargetOptions(.{});
const rt = target.result;

const linkage = b.option(std.builtin.LinkMode, "linkage", "whether to statically or dynamically link the library") orelse @as(std.builtin.LinkMode, if (rt.isGnuLibC()) .dynamic else .static);
const sanitize_c = b.option(std.zig.SanitizeC, "sanitize_c", "whether to build with undefined behaviour sanitizer enabled") orelse .off;
const codeUnitWidth = b.option(CodeUnitWidth, "code-unit-width", "Sets the code unit width") orelse .@"8";
const jit = b.option(bool, "support_jit", "Enable/disable JIT compiler support") orelse false;

const pcre2_header_dir = b.addWriteFiles();
const pcre2_header = pcre2_header_dir.addCopyFile(b.path("src/pcre2.h.generic"), "pcre2.h");
const pcre2_h_dir = b.addWriteFiles();
const pcre2_h = pcre2_h_dir.addCopyFile(b.path("src/pcre2.h.generic"), "pcre2.h");
b.addNamedLazyPath("pcre2.h", pcre2_h);

const is_unix = rt.os.tag != .windows;
const is_mingw = rt.isMinGW();
const is_musl = rt.isMuslLibC();
const is_glibc = rt.isGnuLibC();
const is_freebsd = rt.isFreeBSDLibC();

const config_header = b.addConfigHeader(
const cflags = &.{
"-fvisibility=hidden",
};

const config_h = b.addConfigHeader(
.{
.style = .{ .cmake = b.path("src/config-cmake.h.in") },
.style = .{
.cmake = b.path("src/config-cmake.h.in"),
},
.include_path = "config.h",
},
// These options should be kept in-sync with those in config-cmake.h.in, and
// should be the same set of options (no more needed). It is permitted to
// specify fewer options here than in config-cmake.h.in, if an option is
// disabled in all zig build configurations.
.{
.HAVE_ASSERT_H = true,
.HAVE_UNISTD_H = (target.result.os.tag != .windows),
.HAVE_WINDOWS_H = (target.result.os.tag == .windows),
.HAVE_DIRENT_H = is_unix or is_mingw,
.HAVE_SYS_STAT_H = true,
.HAVE_SYS_TYPES_H = true,
.HAVE_UNISTD_H = is_unix or is_mingw,
.HAVE_WINDOWS_H = rt.os.tag == .windows,

.HAVE_ATTRIBUTE_UNINITIALIZED = true,
.HAVE_MEMFD_CREATE = is_musl or is_glibc or is_freebsd,
.HAVE_SECURE_GETENV = is_musl or is_glibc or is_freebsd,

// all compilation is using the Zig bundled c compiler
.HAVE_BUILTIN_ASSUME = null,
.HAVE_BUILTIN_MUL_OVERFLOW = true,
.HAVE_BUILTIN_UNREACHABLE = true,
.HAVE_ATTRIBUTE_UNINITIALIZED = true,

.SUPPORT_PCRE2_8 = codeUnitWidth == CodeUnitWidth.@"8",
.SUPPORT_PCRE2_16 = codeUnitWidth == CodeUnitWidth.@"16",
.SUPPORT_PCRE2_32 = codeUnitWidth == CodeUnitWidth.@"32",
.SUPPORT_PCRE2_8 = codeUnitWidth == .@"8",
.SUPPORT_PCRE2_16 = codeUnitWidth == .@"16",
.SUPPORT_PCRE2_32 = codeUnitWidth == .@"32",
.SUPPORT_UNICODE = true,
.SUPPORT_JIT = jit,

.PCRE2_EXPORT = null,
// As for CMake builds, use visibilty attributes for both shared and static
// builds. Internal symbols should be hidden even in static builds, because
// the user could be statically linking PCRE2 into their own shared library.
.PCRE2_EXPORT = "__attribute__ ((visibility (\"default\")))",

.PCRE2_LINK_SIZE = 2,
.PCRE2_PARENS_NEST_LIMIT = 250,
.PCRE2_HEAP_LIMIT = 20000000,
.PCRE2_MAX_VARLOOKBEHIND = 255,
.PCRE2_MATCH_LIMIT = 10000000,
.PCRE2_MATCH_LIMIT_DEPTH = "MATCH_LIMIT",
.PCRE2_MAX_VARLOOKBEHIND = 255,
.NEWLINE_DEFAULT = 2,
.PCRE2_PARENS_NEST_LIMIT = 250,
.PCRE2GREP_BUFSIZE = 20480,
.PCRE2GREP_MAX_BUFSIZE = 1048576,
.NEWLINE_DEFAULT = 2,
},
);

// pcre2-8/16/32 library

const lib_mod = b.createModule(.{
.target = target,
.optimize = optimize,
.sanitize_c = sanitize_c,
.link_libc = true,
});

lib_mod.addCMacro("HAVE_CONFIG_H", "");
lib_mod.addCMacro("PCRE2_CODE_UNIT_WIDTH", @tagName(codeUnitWidth));
if (linkage == .static) {
lib_mod.addCMacro("PCRE2_STATIC", "");
switch (linkage) {
.static => lib_mod.addCMacro("PCRE2_STATIC", ""),
.dynamic => {},
}
lib_mod.addConfigHeader(config_h);
lib_mod.addIncludePath(pcre2_h_dir.getDirectory());
lib_mod.addIncludePath(b.path("src"));
Comment thread
bernardassan marked this conversation as resolved.

const lib = b.addLibrary(.{
.name = b.fmt("pcre2-{s}", .{@tagName(codeUnitWidth)}),
.root_module = lib_mod,
.linkage = linkage,
});

lib.addConfigHeader(config_header);
lib.addIncludePath(pcre2_header_dir.getDirectory());
lib.addIncludePath(b.path("src"));

lib.addCSourceFile(.{
lib_mod.addCSourceFile(.{
.file = b.addWriteFiles().addCopyFile(b.path("src/pcre2_chartables.c.dist"), "pcre2_chartables.c"),
.flags = cflags,
});

lib.addCSourceFiles(.{
lib_mod.addCSourceFiles(.{
.files = &.{
"src/pcre2_auto_possess.c",
"src/pcre2_chkdint.c",
Expand Down Expand Up @@ -110,83 +136,95 @@ pub fn build(b: *std.Build) !void {
"src/pcre2_valid_utf.c",
"src/pcre2_xclass.c",
},
.flags = cflags,
});

lib.installHeader(pcre2_header, "pcre2.h");
const lib = b.addLibrary(.{
.name = b.fmt("pcre2-{t}", .{codeUnitWidth}),
.root_module = lib_mod,
.linkage = linkage,
});

lib.installHeader(pcre2_h, "pcre2.h");
b.installArtifact(lib);

// pcre2test

const pcre2test_mod = b.createModule(.{
.target = target,
.optimize = optimize,
.sanitize_c = sanitize_c,
.link_libc = true,
});

pcre2test_mod.addCMacro("HAVE_CONFIG_H", "");
if (linkage == .static) {
pcre2test_mod.addCMacro("PCRE2_STATIC", "");
} else {
pcre2test_mod.addCMacro("PCRE2POSIX_SHARED", "");

// Note: On Windows, consumers linking against the static library should
// probably define PCRE2_STATIC themselves (e.g. via
// addCMacro("PCRE2_STATIC", "")).
// As far as I know, Zig's build system does not currently have a mechanism
// to propagate compile definitions to downstream consumers (like CMake's
// PUBLIC target_compile_definitions). On non-Windows targets this is a no-op.
switch (linkage) {
.static => pcre2test_mod.addCMacro("PCRE2_STATIC", ""),
.dynamic => pcre2test_mod.addCMacro("PCRE2POSIX_SHARED", ""),
}

const pcre2test = b.addExecutable(.{
.name = "pcre2test",
.root_module = pcre2test_mod,
});
pcre2test_mod.addConfigHeader(config_h);
pcre2test_mod.addIncludePath(pcre2_h_dir.getDirectory());
pcre2test_mod.addIncludePath(b.path("src"));

// pcre2-posix library
pcre2test_mod.addCSourceFile(.{
.file = b.path("src/pcre2test.c"),
.flags = cflags,
});

pcre2test_mod.linkLibrary(lib);
b.installArtifact(pcre2test);

// pcre2-posix library
if (codeUnitWidth == CodeUnitWidth.@"8") {
const posixLib_mod = b.createModule(.{
.target = target,
.optimize = optimize,
.sanitize_c = sanitize_c,
.link_libc = true,
});

posixLib_mod.addCMacro("HAVE_CONFIG_H", "");
posixLib_mod.addCMacro("PCRE2_CODE_UNIT_WIDTH", @tagName(codeUnitWidth));
if (linkage == .static) {
posixLib_mod.addCMacro("PCRE2_STATIC", "");
} else {
posixLib_mod.addCMacro("PCRE2POSIX_SHARED", "");
}

const posixLib = b.addLibrary(.{
.name = "pcre2-posix",
.root_module = posixLib_mod,
.linkage = linkage,
});
switch (linkage) {
.static => posixLib_mod.addCMacro("PCRE2_STATIC", ""),
.dynamic => posixLib_mod.addCMacro("PCRE2POSIX_SHARED", ""),
}

posixLib.addConfigHeader(config_header);
posixLib.addIncludePath(pcre2_header_dir.getDirectory());
posixLib.addIncludePath(b.path("src"));
posixLib_mod.addConfigHeader(config_h);
posixLib_mod.addIncludePath(pcre2_h_dir.getDirectory());
posixLib_mod.addIncludePath(b.path("src"));

posixLib.addCSourceFiles(.{
posixLib_mod.addCSourceFiles(.{
.files = &.{
"src/pcre2posix.c",
},
.flags = cflags,
});

posixLib_mod.linkLibrary(lib);

const posixLib = b.addLibrary(.{
.name = "pcre2-posix",
.root_module = posixLib_mod,
.linkage = linkage,
});

posixLib.linkLibrary(lib);
pcre2test_mod.linkLibrary(posixLib);

b.addNamedLazyPath("pcre2posix.h", b.path("src/pcre2posix.h"));
posixLib.installHeader(b.path("src/pcre2posix.h"), "pcre2posix.h");
Comment thread
bernardassan marked this conversation as resolved.
b.installArtifact(posixLib);

pcre2test.linkLibrary(posixLib);
}

// pcre2test (again)

pcre2test.addConfigHeader(config_header);
pcre2test.addIncludePath(pcre2_header_dir.getDirectory());
pcre2test.addIncludePath(b.path("src"));

pcre2test.addCSourceFile(.{
.file = b.path("src/pcre2test.c"),
});

pcre2test.linkLibrary(lib);

b.installArtifact(pcre2test);
}
Loading