Mos Build is now a namespace not a type

Having a separate type for Mos Application building seemed wrong as the
associated functions are just a wrapper around the std.Build, not
something separate.

* Rename MosBuild.zig to mos_build.zig for the same reason.

Author: coderarjob

src/apps/zapps/CMakeLists.txt

@@ -1,11 +1,15 @@
 find_package(Zig 0.15.1 EXACT REQUIRED)
 
+set(ZIG_COMMON_SOURCE_FILES
+    ${CMAKE_CURRENT_LIST_DIR}/build.zig
+    ${CMAKE_CURRENT_LIST_DIR}/mos_build.zig
+)
+
 add_zig_build(
     NAME hello
     OUTPUTS hello
     SOURCES
-        ${CMAKE_CURRENT_LIST_DIR}/build.zig
-        ${CMAKE_CURRENT_LIST_DIR}/MosBuild.zig
+        ${ZIG_COMMON_SOURCE_FILES}
         ${CMAKE_CURRENT_LIST_DIR}/hello.zig
     DEPENDS
         cm

src/apps/zapps/MosBuild.zig

@@ -1,8 +1,13 @@
 const std = @import("std");
-const MosBuild = @import("MosBuild.zig");
+const mos = @import("mos_build.zig");
 
 pub fn build(b: *std.Build) !void {
-    const mos_build = try MosBuild.init(b);
-    const hello_install = mos_build.addExecutable("hello", "./hello.zig");
-    b.getInstallStep().dependOn(hello_install);
+    const optimize = b.standardOptimizeOption(.{});
+    const exe = mos.addExecutable(b, "hello", .{
+        .optimize = optimize,
+        .root_src_file = "./hello.zig",
+        .options = try mos.addDefaultOptions(b),
+        .target = b.resolveTargetQuery(mos.i686_target_query),
+    });
+    b.getInstallStep().dependOn(exe);
 }

src/apps/zapps/build.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+const Build = std.Build;
+const Step = Build.Step;
+const Target = std.Target;
+
+const BuildOptions = struct {
+    linker_script_rel_path: []const u8,
+    libcm_rel_path: []const u8,
+    crta_rel_path: []const u8,
+    include_rel_path: []const u8,
+    entry_point: []const u8,
+};
+
+pub const i686_target_query = Target.Query{
+    .abi = .none,
+    .cpu_arch = .x86,
+    .cpu_model = .{
+        .explicit = &.{
+            .name = "i686",
+            .llvm_name = "",
+            .features = .empty,
+        },
+    },
+    .os_tag = .freestanding,
+};
+
+const ExecutableOptions = struct {
+    options: BuildOptions,
+    root_src_file: []const u8,
+    target: Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+};
+
+pub fn addDefaultOptions(b: *Build) !BuildOptions {
+    const linker_script_path = b.option(
+        []const u8,
+        "LinkerScriptPath",
+        "Absolute path to linker script",
+    ) orelse ""; // Must provide 'LinkerScriptPath'
+    const libcm_path = b.option(
+        []const u8,
+        "LibCMPath",
+        "Absolute path to libcm library",
+    ) orelse ""; // Must provide 'LibCMPath'
+    const crt_path = b.option(
+        []const u8,
+        "CRTPath",
+        "Absolute path to crt.o",
+    ) orelse ""; // Must provide 'CRTPath'
+    const include_path = b.option(
+        []const u8,
+        "CInludePath",
+        "Absolute path to C include root dir",
+    ) orelse ""; // Must provide 'CInludePath'
+    const entry_point = b.option(
+        []const u8,
+        "EntryPoint",
+        "Entry point of user application",
+    ) orelse ""; // Must provide 'EntryPoint'
+
+    return .{
+        .crta_rel_path = try std.fs.path.relative(b.allocator, ".", crt_path),
+        .include_rel_path = try std.fs.path.relative(b.allocator, ".", include_path),
+        .libcm_rel_path = try std.fs.path.relative(b.allocator, ".", libcm_path),
+        .linker_script_rel_path = try std.fs.path.relative(b.allocator, ".", linker_script_path),
+        .entry_point = entry_point,
+    };
+}
+
+pub fn addExecutable(b: *Build, comptime name: []const u8, options: ExecutableOptions) *Step {
+    const exe = elf_compilation(b, name, &options);
+    const exe_install = b.addInstallArtifact(exe, .{});
+
+    const flatten_output_file = name ++ ".flt";
+    const objcopy_run = b.addSystemCommand(&.{ "objcopy", "-O", "binary" });
+    objcopy_run.addArg(b.getInstallPath(.bin, exe.name));
+    const flatten_output_path = objcopy_run.addOutputFileArg(flatten_output_file);
+
+    const flatten_install = b.addInstallFileWithDir(flatten_output_path, .bin, flatten_output_file);
+
+    objcopy_run.step.dependOn(&exe_install.step);
+    return &flatten_install.step;
+}
+
+fn elf_compilation(b: *Build, comptime name: []const u8, options: *const ExecutableOptions) *Step.Compile {
+    const exe = b.addExecutable(.{
+        .name = name,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(options.root_src_file),
+            .target = options.target,
+            .optimize = options.optimize,
+            .omit_frame_pointer = false,
+            .red_zone = false,
+            .unwind_tables = .none,
+            .stack_protector = false,
+            .single_threaded = true,
+            .pic = false,
+        }),
+    });
+
+    exe.root_module.addLibraryPath(b.path(options.options.libcm_rel_path));
+    exe.root_module.linkSystemLibrary("cm", .{});
+    exe.addObjectFile(b.path(options.options.crta_rel_path));
+    exe.addIncludePath(b.path(options.options.include_rel_path));
+
+    exe.linker_script = b.path(options.options.linker_script_rel_path);
+    exe.link_gc_sections = true;
+    exe.link_eh_frame_hdr = false;
+    exe.entry = .{ .symbol_name = options.options.entry_point };
+
+    return exe;
+}