feat(build): build.zig MVP: build and run functionaltests on linux

NEW BUILD SYSTEM!

This is a MVP implementation which supports building the "nvim" binary,
including cross-compilation for some targets.
As an example, you can build a aarch64-macos binary from
an x86-64-linux-gnu host, or vice versa

Add CI target for build.zig currently for functionaltests on linux
x86_64 only

Follow up items:

-  praxis for version and dependency bumping
-  windows 💀
-  full integration of libintl and gettext (or a desicion not to)
-  update help and API metadata files
-  installation into a $PREFIX
-  more tests and linters

deps/iconv_apple/build.zig

@@ -0,0 +1,90 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const upstream = b.dependency("libiconv", .{});
+    const lib = b.addStaticLibrary(.{
+        .name = "iconv",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.addIncludePath(b.path("include/"));
+    lib.addIncludePath(upstream.path(""));
+    lib.addIncludePath(upstream.path("citrus/"));
+    lib.addIncludePath(upstream.path("libcharset/"));
+    lib.addIncludePath(upstream.path("libiconv_modules/UTF8/"));
+    // zig any-macos-any headers already includes iconv, it just cannot link without a SDK
+    // lib.installHeader(upstream.path("iconv.h"), "iconv.h");
+
+    lib.linkLibC();
+
+    lib.addCSourceFiles(.{ .root = upstream.path(""), .files = &.{
+        "citrus/bsd_iconv.c",
+        "citrus/citrus_bcs.c",
+        "citrus/citrus_bcs_strtol.c",
+        "citrus/citrus_bcs_strtoul.c",
+        "citrus/citrus_csmapper.c",
+        "citrus/citrus_db.c",
+        "citrus/citrus_db_factory.c",
+        "citrus/citrus_db_hash.c",
+        "citrus/citrus_esdb.c",
+        "citrus/citrus_hash.c",
+        "citrus/citrus_iconv.c",
+        "citrus/citrus_lookup.c",
+        "citrus/citrus_lookup_factory.c",
+        "citrus/citrus_mapper.c",
+        "citrus/citrus_memstream.c",
+        "citrus/citrus_mmap.c",
+        "citrus/citrus_module.c",
+        "citrus/citrus_none.c",
+        "citrus/citrus_pivot_factory.c",
+        "citrus/citrus_prop.c",
+        "citrus/citrus_stdenc.c",
+        "citrus/__iconv.c",
+        "citrus/iconv.c",
+        "citrus/iconv_canonicalize.c",
+        "citrus/iconv_close.c",
+        "citrus/iconv_compat.c",
+        "citrus/iconvctl.c",
+        "citrus/__iconv_free_list.c",
+        "citrus/__iconv_get_list.c",
+        "citrus/iconvlist.c",
+        "citrus/iconv_open.c",
+        "citrus/iconv_open_into.c",
+        "citrus/iconv_set_relocation_prefix.c",
+        "libcharset/libcharset.c",
+        "libiconv_modules/BIG5/citrus_big5.c",
+        "libiconv_modules/DECHanyu/citrus_dechanyu.c",
+        "libiconv_modules/DECKanji/citrus_deckanji.c",
+        "libiconv_modules/EUC/citrus_euc.c",
+        "libiconv_modules/EUCTW/citrus_euctw.c",
+        "libiconv_modules/GBK2K/citrus_gbk2k.c",
+        "libiconv_modules/HZ/citrus_hz.c",
+        "libiconv_modules/iconv_none/citrus_iconv_none.c",
+        "libiconv_modules/iconv_std/citrus_iconv_std.c",
+        "libiconv_modules/ISO2022/citrus_iso2022.c",
+        "libiconv_modules/JOHAB/citrus_johab.c",
+        "libiconv_modules/mapper_646/citrus_mapper_646.c",
+        "libiconv_modules/mapper_none/citrus_mapper_none.c",
+        "libiconv_modules/mapper_serial/citrus_mapper_serial.c",
+        "libiconv_modules/mapper_std/citrus_mapper_std.c",
+        "libiconv_modules/mapper_zone/citrus_mapper_zone.c",
+        "libiconv_modules/MSKanji/citrus_mskanji.c",
+        "libiconv_modules/UES/citrus_ues.c",
+        "libiconv_modules/UTF1632/citrus_utf1632.c",
+        "libiconv_modules/UTF7/citrus_utf7.c",
+        "libiconv_modules/UTF8/citrus_utf8.c",
+        "libiconv_modules/UTF8MAC/citrus_utf8mac.c",
+        "libiconv_modules/VIQR/citrus_viqr.c",
+        "libiconv_modules/ZW/citrus_zw.c",
+    }, .flags = &.{
+        "-D_PATH_I18NMODULE=\"/usr/lib/i18n\"",
+        "-D_PATH_ESDB=\"/usr/share/i18n/esdb\"",
+        "-D_PATH_CSMAPPER=\"/usr/share/i18n/csmapper\"",
+    } });
+
+    b.installArtifact(lib);
+}

deps/iconv_apple/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = "libiconv",
+    .version = "107.0.0",
+    .paths = .{""},
+
+    .dependencies = .{
+        .libiconv = .{
+            .url = "git+https://github.com/apple-oss-distributions/libiconv?ref=libiconv-107#a3f3b2c76dbf8ba11881debc6bcb4e309958d252",
+            .hash = "12202adcca76e9822f506b5acd2f0a3e285c152e2f48683341fd719d9f1df3a1296b",
+        },
+    },
+}

deps/iconv_apple/include/os/variant_private.h

@@ -0,0 +1 @@
+#define os_variant_has_internal_content(sys) false

deps/libuv/build.zig

@@ -0,0 +1,125 @@
+const std = @import("std");
+
+// Based on mitchellh/zig-libuv, with changes.
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const upstream = b.dependency("libuv", .{});
+    const lib = b.addStaticLibrary(.{
+        .name = "uv",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.addIncludePath(upstream.path("include"));
+    lib.addIncludePath(upstream.path("src"));
+
+    lib.installHeadersDirectory(upstream.path("include"), ".", .{});
+
+    if (target.result.os.tag == .windows) {
+        lib.linkSystemLibrary("psapi");
+        lib.linkSystemLibrary("user32");
+        lib.linkSystemLibrary("advapi32");
+        lib.linkSystemLibrary("iphlpapi");
+        lib.linkSystemLibrary("userenv");
+        lib.linkSystemLibrary("ws2_32");
+    }
+    if (target.result.os.tag == .linux) {
+        lib.linkSystemLibrary("pthread");
+    }
+    lib.linkLibC();
+
+    if (target.result.os.tag != .windows) {
+        lib.root_module.addCMacro("FILE_OFFSET_BITS", "64");
+        lib.root_module.addCMacro("_LARGEFILE_SOURCE", "");
+    }
+
+    if (target.result.os.tag == .linux) {
+        lib.root_module.addCMacro("_GNU_SOURCE", "");
+        lib.root_module.addCMacro("_POSIX_C_SOURCE", "200112");
+    }
+
+    if (target.result.os.tag.isDarwin()) {
+        lib.root_module.addCMacro("_DARWIN_UNLIMITED_SELECT", "1");
+        lib.root_module.addCMacro("_DARWIN_USE_64_BIT_INODE", "1");
+    }
+
+    const root = upstream.path("");
+
+    // C files common to all platforms
+    lib.addCSourceFiles(.{ .root = root, .files = &.{
+        "src/fs-poll.c",
+        "src/idna.c",
+        "src/inet.c",
+        "src/random.c",
+        "src/strscpy.c",
+        "src/strtok.c",
+        "src/threadpool.c",
+        "src/timer.c",
+        "src/uv-common.c",
+        "src/uv-data-getter-setters.c",
+        "src/version.c",
+    } });
+
+    if (target.result.os.tag != .windows) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/async.c",
+            "src/unix/core.c",
+            "src/unix/dl.c",
+            "src/unix/fs.c",
+            "src/unix/getaddrinfo.c",
+            "src/unix/getnameinfo.c",
+            "src/unix/loop-watcher.c",
+            "src/unix/loop.c",
+            "src/unix/pipe.c",
+            "src/unix/poll.c",
+            "src/unix/process.c",
+            "src/unix/random-devurandom.c",
+            "src/unix/signal.c",
+            "src/unix/stream.c",
+            "src/unix/tcp.c",
+            "src/unix/thread.c",
+            "src/unix/tty.c",
+            "src/unix/udp.c",
+        } });
+    }
+
+    if (target.result.os.tag == .linux or target.result.os.tag.isDarwin()) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/proctitle.c",
+        } });
+    }
+
+    if (target.result.os.tag == .linux) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/linux.c",
+            "src/unix/procfs-exepath.c",
+            "src/unix/random-getrandom.c",
+            "src/unix/random-sysctl-linux.c",
+        } });
+    }
+
+    if (target.result.os.tag.isBSD()) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/bsd-ifaddrs.c",
+            "src/unix/kqueue.c",
+        } });
+    }
+
+    if (target.result.os.tag.isDarwin() or target.result.os.tag == .openbsd) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/random-getentropy.c",
+        } });
+    }
+
+    if (target.result.os.tag.isDarwin()) {
+        lib.addCSourceFiles(.{ .root = root, .files = &.{
+            "src/unix/darwin-proctitle.c",
+            "src/unix/darwin.c",
+            "src/unix/fsevents.c",
+        } });
+    }
+
+    b.installArtifact(lib);
+}

deps/libuv/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = "libuv",
+    .version = "1.51.0",
+    .paths = .{""},
+
+    .dependencies = .{
+        .libuv = .{
+            .url = "git+https://github.com/libuv/libuv?ref=v1.51.0#76fb3b73da3f8ddaeeb87d23fda04b9bda219f5e",
+            .hash = "N-V-__8AAExNRADXPh6GLMmWlqC2EVkp6hzH9wPuzjh_eSkE",
+        },
+    },
+}

deps/unibilium/build.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const upstream = b.dependency("unibilium", .{});
+    const lib = b.addStaticLibrary(.{
+        .name = "unibilium",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.addIncludePath(upstream.path(""));
+
+    lib.installHeader(upstream.path("unibilium.h"), "unibilium.h");
+
+    lib.linkLibC();
+
+    lib.addCSourceFiles(.{ .root = upstream.path(""), .files = &.{
+        "unibilium.c",
+        "uninames.c",
+        "uniutil.c",
+    }, .flags = &.{"-DTERMINFO_DIRS=\"/etc/terminfo:/usr/share/terminfo\""} });
+
+    b.installArtifact(lib);
+}

deps/unibilium/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = "unibilium",
+    .version = "2.1.2",
+    .paths = .{""},
+
+    .dependencies = .{
+        .unibilium = .{
+            .url = "git+https://github.com/neovim/unibilium?ref=v2.1.2#bfcb0350129dd76893bc90399cf37c45812268a2",
+            .hash = "1220a082fc7bdf2a6d9c19576c49bb4e33923ba54622a7340af611e9deb46f851f9a",
+        },
+    },
+}

deps/utf8proc/build.zig

@@ -0,0 +1,24 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const upstream = b.dependency("utf8proc", .{});
+    const lib = b.addStaticLibrary(.{
+        .name = "utf8proc",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    lib.addIncludePath(upstream.path(""));
+    lib.installHeader(upstream.path("utf8proc.h"), "utf8proc.h");
+
+    lib.linkLibC();
+
+    lib.addCSourceFiles(.{ .root = upstream.path(""), .files = &.{
+        "utf8proc.c",
+    } });
+
+    b.installArtifact(lib);
+}

deps/utf8proc/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = "utf8proc",
+    .version = "2.10.0",
+    .paths = .{""},
+
+    .dependencies = .{
+        .utf8proc = .{
+            .url = "git+https://github.com/JuliaStrings/utf8proc?ref=v2.10.0#a1b99daa2a3393884220264c927a48ba1251a9c6",
+            .hash = "1220d80ce0bde71b8acae76b9686fa785aa0cdf165f0d6e93a853d57bfbed129a5e7",
+        },
+    },
+}