#sleela 2.5 material; < os-generate.sleela -- the runnable OS SOURCE GENERATOR for lib/os. Unlike > < os-build.sleela (which PRINTS the generated artifacts to show the shape), > < this program WRITES the real Linux-level C/C++ source tree to disk through > < the os*/file bridge (osMakeDir / openFile / write / close), the same path the > < split SLOSCreator provider uses. Running it materialises a complete, buildable > < /os-out tree you can source, copy, commit, or download. > < > < It also closes the loop to the upstream OS parts: it drops the SLDistroSource > < reference (mearvk/Ubuntu.Determinant.Beta.Restricted, pinned) into the tree as > < provenance and writes a fetch-upstream.sh that performs the opt-in, pinned, > < shallow clone of the real distro next to the generated scaffolding. > < > < Build parameters (read from the environment, with Linux defaults): > < OS_NAME product name (default "Determinant") > < OS_VERSION version (default "1.0") > < OS_ARCH target arch (default "amd64") > < OS_OUT output root directory (default "/projects/sandbox/os-out") > < > < OS_NAME=Determinant OS_ARCH=arm64 ./impl/build/sleela run lib/operating-system/os-generate.sleela > < > < Requires #sleela 1.5 for the os* built-ins (declared 1.11 for field dispatch). > < ---- The upstream OS-parts reference (compact mirror of SLDistroSource) -- > class Upstream { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader, or catalog can read and (where appropriate) override this record. Values are faithful to the subject's real origin where publicly known. >> String metaVersion = "1.0.0"; int metaId = 10960; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-10"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 9; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } String url; String branch; String commit; String repo; void configure() { repo = "Ubuntu.Determinant.Beta.Restricted"; url = "https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git"; branch = "main"; commit = "4918080dcf0f52dc771aa1a30b0e0f63495f7a8d"; } String referenceSheet() { String s = "# Upstream OS-parts reference (pinned)\n"; s = s + "repo: mearvk/" + repo + "\n"; s = s + "url: " + url + "\n"; s = s + "branch: " + branch + "\n"; s = s + "commit: " + commit + "\n"; s = s + "parts: kernel->kernels installer->installer desktop->gnome-source" + " filesystem->file-systems userland->userland\n"; return s; } < The opt-in shallow fetch script written into the tree. > String fetchScript() { String s = "#!/bin/sh\n# fetch-upstream.sh -- opt-in, pinned, shallow clone of the real OS parts\n"; s = s + "# Downloads the Ubuntu distro NEXT TO this generated tree (upstream/).\n"; s = s + "set -eu\nDEST=\"$(dirname \"$0\")/upstream/" + repo + "\"\n"; s = s + "mkdir -p \"$(dirname \"$DEST\")\"\n"; s = s + "if [ -d \"$DEST/.git\" ]; then echo \"already fetched: $DEST\"; exit 0; fi\n"; s = s + "git -c http.postBuffer=524288000 -c http.version=HTTP/1.1 clone \\\n"; s = s + " --depth 1 --single-branch --branch " + branch + " \\\n"; s = s + " " + url + " \"$DEST\"\n"; s = s + "echo \"fetched " + repo + " (" + branch + ") into $DEST\"\n"; return s; } } < ---- A compact Linux OS model (OOD aggregate) --------------------------- > struct OsModel { String name; String version; String shape; String arch; String triple; String loader; String kernel; String kernelVer; String cmdline; String rootfs; String init; String desktop; } < ---- The generator: emits each artifact AND writes it to disk ----------- > class OsGenerator { < output root > String root; < "bytes path" index > String manifest; int fileCount; < field dispatch (1.11) > Upstream upstream; void configure(String outputRoot) { root = outputRoot; manifest = ""; fileCount = 0; upstream = new Upstream(); upstream.configure(); osMakeDir(root); } int makeDir(String rel) { return osMakeDir(root + rel); } < Write one file relative to root; records bytes in the manifest. > int writeFile(String rel, String contents) { int fd = openFile(root + rel, "w"); if (fd < 0) { return -1; } int n = write(fd, contents); close(fd); if (n >= 0) { String line = "" + n + " " + rel; if (manifest == "") { manifest = line; } else { manifest = manifest + "\n" + line; } fileCount = fileCount + 1; } return n; } String identity(OsModel m) { return m.name + " " + m.version + " (" + m.shape + ", " + m.arch + ")"; } OsModel linux(String name, String version, String arch, String kernelVer) { OsModel m = new OsModel(); m.name = name; m.version = version; m.shape = "Linux"; m.arch = arch; if (arch == "arm64") { m.triple = "aarch64-unknown-linux-gnu"; } else { m.triple = "x86_64-unknown-linux-gnu"; } m.loader = "GRUB"; m.kernel = "Linux"; m.kernelVer = kernelVer; m.cmdline = "ro quiet splash"; m.rootfs = "ext4"; m.init = "systemd"; m.desktop = "GNOME Shell"; return m; } < Resolve a requested Linux kernel selection to a concrete version (compact > < mirror of SLKernelCatalog.resolveLinux). "" / "default" -> the LTS default. > String resolveKernel(String sel) { if (sel == "" || sel == "default") { return "6.12.0"; } if (sel == "latest") { return "6.18.0"; } if (sel == "6.18") { return "6.18.0"; } if (sel == "6.12" || sel == "6.12 LTS") { return "6.12.0"; } if (sel == "6.6" || sel == "6.6 LTS") { return "6.6.0"; } if (sel == "6.1" || sel == "6.1 LTS") { return "6.1.0"; } if (sel == "5.15" || sel == "5.15 LTS") { return "5.15.0"; } < explicit x.y.z passthrough > return sel; } < The foreign-executable (cross-OS) policy header for the Linux shape: a > < Linux image can run Windows .exe via binfmt_misc + Wine, and cross-arch ELF > < via QEMU-user. Compact mirror of SLExecutableTranslator for the Linux host. > String execTranslateHeader(OsModel m) { String h = "/* exec_translate.h - foreign-executable policy for " + m.shape + " (generated by SLeeLa lib/os) */\n"; h = h + "#ifndef EXEC_TRANSLATE_H\n#define EXEC_TRANSLATE_H\n\n"; h = h + "#define OS_HOST_SHAPE \"" + m.shape + "\"\n"; h = h + "#define OS_HAS_BINFMT 1 /* Linux FS-level interpreter (binfmt_misc) */\n"; h = h + "#define OS_FOREIGN_EXE \"Wine (Win32 compatibility layer)\"\n"; h = h + "#define OS_FOREIGN_ARCH \"QEMU-user (cross-arch ELF)\"\n\n"; h = h + "/* binfmt_misc registration template: bind a foreign extension to an\n"; h = h + " interpreter so the filesystem runs it on exec(). Example (Windows PE):\n"; h = h + " echo ':winexe:E::exe::/usr/bin/wine:OC' > /proc/sys/fs/binfmt_misc/register */\n"; h = h + "#define OS_BINFMT_REGISTER \"/proc/sys/fs/binfmt_misc/register\"\n"; h = h + "\n#endif /* EXEC_TRANSLATE_H */\n"; return h; } < The foreign-executable compatibility loader for the Linux shape: load the > < OS components (binfmt_misc + Wine/Darling/QEMU + guest libraries) so this > < Linux OS runs Windows .exe and macOS executables. Compact mirror of > < SLCompatLoaderEmitter for the Linux host (runs Windows + macOS guests). > String compatLoaderC(OsModel m) { String c = "/* compat_loader.c - foreign-executable compatibility loader for " + m.name + " */\n"; c = c + "/* Host OS: Linux. Loads binfmt_misc interpreters + translation runtimes\n"; c = c + " + guest libraries so this OS can run other families' executables. */\n"; c = c + "extern int binfmt_register(const char *rule);\n"; c = c + "extern int runtime_load(const char *runtime);\n"; c = c + "extern int libs_provide(const char *libset);\n"; c = c + "extern int run_foreign(const char *runtime, const char *path);\n\n"; c = c + "int compat_load_all(void) {\n"; c = c + " /* Linux runs Windows via wine + binfmt_misc + win32-libs */\n"; c = c + " binfmt_register(\"exe -> wine\");\n"; c = c + " runtime_load(\"wine\");\n"; c = c + " libs_provide(\"win32-libs\");\n"; c = c + " /* Linux runs macOS via darling + binfmt_misc + darwin-libs */\n"; c = c + " binfmt_register(\"app -> darling\");\n"; c = c + " runtime_load(\"darling\");\n"; c = c + " libs_provide(\"darwin-libs\");\n"; c = c + " return 0;\n}\n\n"; c = c + "/* Run a foreign executable; empty runtime => binfmt routes it. */\n"; c = c + "int compat_run(const char *runtime, const char *path) {\n"; c = c + " if (runtime == 0 || runtime[0] == 0) return run_foreign(\"\", path);\n"; c = c + " return run_foreign(runtime, path);\n}\n"; return c; } String compatConf(OsModel m) { String s = "# compat.conf - foreign-executable routes for " + m.name + " (host Linux)\n"; s = s + "host = Linux\n"; s = s + "route = Linux runs Windows via wine + binfmt_misc + win32-libs\n"; s = s + "route = Linux runs macOS via darling + binfmt_misc + darwin-libs\n"; return s; } < The minimum-boot base-driver series table for the Linux shape, plugging > < into os/base_drivers.h. Compact mirror of SLBaseDriverEmitter for Linux. > String baseDriversTableC(OsModel m) { String c = "/* base_drivers_table.c - minimum-boot driver series for " + m.name + " */\n"; c = c + "/* Plugs into os/base_drivers.h; the kernel brings these up in class order. */\n"; c = c + "#include \"base_drivers.h\"\n\n"; c = c + "static const sleela_driver k_series[] = {\n"; c = c + " { SL_DRV_BUS, \"pci + acpi\", SL_PHASE_BOOT, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_STORAGE, \"ahci + nvme + virtio_blk\", SL_PHASE_BOOT, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_DISPLAY, \"efifb / drm fbdev\", SL_PHASE_BOOT, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_KEYBOARD, \"atkbd + usbhid\", SL_PHASE_BOOT, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_MOUSE, \"usbhid\", SL_PHASE_EARLY, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_USB, \"xhci_hcd\", SL_PHASE_EARLY, SL_ORIGIN_INTREE },\n"; c = c + " { SL_DRV_AUDIO, \"snd_hda_intel\", SL_PHASE_EARLY, SL_ORIGIN_INTREE },\n"; c = c + "};\n\n"; c = c + "const sleela_driver *sleela_base_drivers(void) { return k_series; }\n"; c = c + "size_t sleela_base_driver_count(void) { return sizeof(k_series)/sizeof(k_series[0]); }\n"; c = c + "const char *sleela_os_host_family(void) { return \"Linux\"; }\n"; return c; } < The resolved download URLs for the Linux build, by phase (compile|iso). > < Mirror of SLDownloadSet.downloadManifest for the Linux shape. > String downloadsConf(OsModel m) { String s = "# downloads.conf - related download URLs for " + m.name + " (resolved pre-build)\n"; s = s + "# format: \n"; s = s + "package-repo compile http://archive.ubuntu.com/ubuntu\n"; s = s + "kernel-src compile https://cdn.kernel.org/pub/linux/kernel\n"; s = s + "upstream compile https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git\n"; s = s + "firmware-src iso https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git\n"; s = s + "runtime-wine iso https://dl.winehq.org/wine-builds\n"; s = s + "runtime-qemu iso https://www.qemu.org/download\n"; return s; } < The support-URL table: for each component, the prioritized mirrors tried if > < the primary 404s (authoritative -> official-mirror -> college/edu -> archive). > < Compact mirror of SLSupportDownloader for the Linux build. > String supportUrlsConf(OsModel m) { String s = "# support-urls.conf - fallback mirrors if a primary URL 404s\n"; s = s + "# order by likelihood of a final/college reference: authoritative > official > college > archive\n"; s = s + "[package]\n"; s = s + "authoritative http://archive.ubuntu.com/ubuntu\n"; s = s + "official-mirror http://mirror.ubuntu.com/ubuntu\n"; s = s + "college https://mirrors.mit.edu/ubuntu\n"; s = s + "archive https://web.archive.org/web/2id_/http://archive.ubuntu.com/ubuntu\n"; s = s + "[kernel]\n"; s = s + "authoritative https://cdn.kernel.org/pub/linux/kernel\n"; s = s + "official-mirror https://mirrors.kernel.org/pub/linux/kernel\n"; s = s + "college https://mirror.math.princeton.edu/pub/kernel/linux/kernel\n"; s = s + "archive https://web.archive.org/web/2id_/https://cdn.kernel.org/pub/linux/kernel\n"; s = s + "[firmware]\n"; s = s + "authoritative https://git.kernel.org/.../linux-firmware.git\n"; s = s + "official-mirror https://kernel.googlesource.com/.../linux-firmware\n"; s = s + "college https://mirrors.edge.kernel.org/pub/linux/kernel/firmware\n"; s = s + "archive https://web.archive.org/web/2id_/.../linux-firmware.git\n"; return s; } < The resilient fetch script: each component tries its mirrors in priority > < order and falls through on 404/failure to the next. Mirror of > < SLDownloadSet.supportFetchScript (compile phase). > String fetchResilientSh(OsModel m) { String s = "#!/bin/sh\n# fetch-downloads-resilient.sh - 404-tolerant fetch with mirror fallback\n"; s = s + "# order: authoritative -> official-mirror -> college/edu -> archive\nset -eu\nmkdir -p downloads\n\n"; s = s + "fetch_package() {\n"; s = s + " curl -fsSL --retry 2 -o downloads/package.payload \"http://archive.ubuntu.com/ubuntu\" && return 0\n"; s = s + " curl -fsSL --retry 2 -o downloads/package.payload \"http://mirror.ubuntu.com/ubuntu\" && return 0\n"; s = s + " curl -fsSL --retry 2 -o downloads/package.payload \"https://mirrors.mit.edu/ubuntu\" && return 0\n"; s = s + " curl -fsSL --retry 2 -o downloads/package.payload \"https://web.archive.org/web/2id_/http://archive.ubuntu.com/ubuntu\" && return 0\n"; s = s + " echo 'all package mirrors failed' >&2; return 1\n}\n"; s = s + "fetch_kernel() {\n"; s = s + " git clone --depth 1 \"https://cdn.kernel.org/pub/linux/kernel\" downloads/kernel-src && return 0\n"; s = s + " git clone --depth 1 \"https://mirrors.kernel.org/pub/linux/kernel\" downloads/kernel-src && return 0\n"; s = s + " git clone --depth 1 \"https://mirror.math.princeton.edu/pub/kernel/linux/kernel\" downloads/kernel-src && return 0\n"; s = s + " echo 'all kernel mirrors failed' >&2; return 1\n}\n"; s = s + "fetch_upstream() {\n"; s = s + " git clone --depth 1 \"https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git\" downloads/upstream && return 0\n"; s = s + " git clone --depth 1 \"https://gitlab.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git\" downloads/upstream && return 0\n"; s = s + " echo 'all upstream mirrors failed' >&2; return 1\n}\n"; s = s + "fetch_package; fetch_kernel; fetch_upstream\n"; s = s + "echo 'resilient downloads complete'\n"; return s; } < The opt-in fetch script for the related downloads (compile-phase sources). > String fetchDownloadsSh(OsModel m) { String s = "#!/bin/sh\n# fetch-downloads.sh - retrieve the related downloads (generated by SLeeLa lib/os)\n"; s = s + "set -eu\nmkdir -p downloads\n"; s = s + "# compile-phase sources\n"; s = s + "git clone --depth 1 https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git downloads/upstream || true\n"; s = s + "git clone --depth 1 https://cdn.kernel.org/pub/linux/kernel downloads/kernel-src || true\n"; s = s + "curl -fsSL -o downloads/package-index \"http://archive.ubuntu.com/ubuntu/dists/stable/Release\" || true\n"; s = s + "# iso-phase payloads\n"; s = s + "git clone --depth 1 https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git downloads/firmware || true\n"; s = s + "echo \"downloads complete\"\n"; return s; } < The global settings header + the kernel command line settings file. > String osConf(OsModel m) { String s = "# os.conf - global OS settings (generated by SLeeLa lib/os)\n"; s = s + "name = " + m.name + "\nversion = " + m.version + "\n"; s = s + "shape = " + m.shape + "\narch = " + m.arch + "\n"; s = s + "kernel = " + m.kernel + " " + m.kernelVer + "\n"; s = s + "# per-layer settings: config/swap.conf, config/filesystems.txt,\n"; s = s + "# config/downloads.conf, kernel/base-drivers/base-drivers.conf,\n"; s = s + "# userspace/os-loader/services.conf, userspace/compat-loader/compat.conf\n"; return s; } String cmdlineConf(OsModel m) { String s = "# cmdline.conf - kernel command line (generated by SLeeLa lib/os)\n"; s = s + "cmdline = " + m.cmdline + "\n"; return s; } String baseDriversConf(OsModel m) { String s = "# base-drivers.conf - minimum-boot driver series for " + m.name + " (host Linux)\n"; s = s + "# format: \n"; s = s + "bus pci+acpi boot\nstorage ahci+nvme boot\ndisplay efifb boot\nkeyboard atkbd+usbhid boot\n"; s = s + "mouse usbhid early\nusb xhci_hcd early\naudio snd_hda_intel early\n"; s = s + "# driver source policy: unknown=permissive (taint), foreign=bridge-only\n"; s = s + "# cross-OS bridge: Linux + Windows network driver -> ndiswrapper; gpu -> none\n"; return s; } < Swap configuration for the Linux shape: a zstd-compressed swap at 1.0x RAM > < with a conservative swappiness. Mirror of SLSwapConfig.emitLinux (file kind > < here; a builder can switch to zram/zswap via SLSwapConfig). > String swapConf(OsModel m) { String s = "# swap.conf - paging configuration for " + m.name + " (generated by SLeeLa lib/os)\n"; s = s + "kind = file\n"; s = s + "size = 1.0x RAM\n"; s = s + "# vm.swappiness governs reclaim aggressiveness (0..100)\n"; s = s + "vm.swappiness = 60\n"; s = s + "# /etc/fstab entry:\n"; s = s + "/swapfile none swap sw 0 0\n"; return s; } < The filesystem (file-table) type note for the Linux shape: the chosen root > < filesystem plus the catalogue of still-used table types a builder can pick. > String filesystemsConf(OsModel m) { String s = "# filesystems.txt - file-table types for " + m.name + " (generated by SLeeLa lib/os)\n"; s = s + "root = ext4 # default Linux root (journaling)\n"; s = s + "esp = fat32 # EFI System Partition (FAT required)\n"; s = s + "# Still-used table types available via SLFilesystemCatalog:\n"; s = s + "# FAT : fat12 fat16 fat32 vfat exfat\n"; s = s + "# Windows: ntfs refs\n"; s = s + "# ext : ext2 ext3 ext4\n"; s = s + "# Linux : xfs btrfs f2fs jfs reiserfs\n"; s = s + "# cross : zfs\n"; s = s + "# Apple : apfs hfs+\n"; s = s + "# Unix : ufs\n"; s = s + "# optical: iso9660 udf\n"; s = s + "# pseudo : squashfs tmpfs swap overlayfs\n"; s = s + "# network: nfs smb cifs\n"; return s; } < The executable file-type table for Linux (compact mirror of > < SLExecutableTypes.emitExecTypesHeader for the Linux shape). > String execTypesHeader(OsModel m) { String h = "/* exec_types.h - executable file types for " + m.shape + " (generated by SLeeLa lib/os) */\n"; h = h + "#ifndef EXEC_TYPES_H\n#define EXEC_TYPES_H\n\n"; h = h + "#define OS_EXEC_SHAPE \"" + m.shape + "\"\n"; h = h + "#define OS_EXEC_USESBIT 1 /* POSIX exec bit (chmod +x) governs */\n\n"; h = h + "/* NULL-terminated table of executable extensions (\"\" = no-ext ELF binary). */\n"; h = h + "static const char *const os_exec_types[] = {\n"; h = h + " \"\", \".sh\", \".bin\", \".run\", \".AppImage\", \".elf\", \".so\", \".ko\",\n"; h = h + " 0\n};\n\n"; h = h + "/* True if `ext` (with dot, \"\" for none) names an executable file type. */\n"; h = h + "static int os_is_executable_ext(const char *ext) {\n"; h = h + " for (const char *const *p = os_exec_types; *p; ++p) {\n"; h = h + " const char *a = *p, *b = ext; while (*a && *a == *b) { ++a; ++b; }\n"; h = h + " if (*a == 0 && *b == 0) return 1;\n"; h = h + " }\n return 0;\n}\n\n"; h = h + "#endif /* EXEC_TYPES_H */\n"; return h; } < ---- the emitted Linux-level sources -------------------------------- > String configHeader(OsModel m) { String h = "/* os_config.h - generated by SLeeLa lib/os from " + identity(m) + " */\n"; h = h + "#ifndef OS_CONFIG_H\n#define OS_CONFIG_H\n\n"; h = h + "#define OS_NAME \"" + m.name + "\"\n"; h = h + "#define OS_VERSION \"" + m.version + "\"\n"; h = h + "#define OS_SHAPE \"" + m.shape + "\"\n"; h = h + "#define OS_ARCH \"" + m.arch + "\"\n"; h = h + "#define OS_TRIPLE \"" + m.triple + "\"\n"; h = h + "#define OS_LOADER \"" + m.loader + "\"\n"; h = h + "#define OS_KERNEL \"" + m.kernel + "\"\n"; h = h + "#define OS_KERNEL_VER \"" + m.kernelVer + "\"\n"; h = h + "#define OS_CMDLINE \"" + m.cmdline + "\"\n"; h = h + "#define OS_ROOTFS \"" + m.rootfs + "\"\n"; h = h + "#define OS_INIT \"" + m.init + "\"\n"; h = h + "#define OS_DESKTOP \"" + m.desktop + "\"\n"; h = h + "\n#endif /* OS_CONFIG_H */\n"; return h; } String bootUnit(OsModel m) { String c = "/* os_boot.c - early boot path, generated for " + identity(m) + " */\n"; c = c + "#include \"os_config.h\"\n"; c = c + "extern int firmware_handoff(const char *loader);\n"; c = c + "extern int kernel_start(const char *cmdline);\n"; c = c + "extern int mount_rootfs(const char *fs);\n"; c = c + "extern int start_init(const char *init);\n\n"; c = c + "int os_boot(void) {\n"; c = c + " if (firmware_handoff(OS_LOADER) != 0) return 1;\n"; c = c + " if (kernel_start(OS_CMDLINE) != 0) return 2;\n"; c = c + " if (mount_rootfs(OS_ROOTFS) != 0) return 3;\n"; c = c + " return start_init(OS_INIT);\n"; c = c + "}\n"; return c; } String osImage(OsModel m) { String s = "// os_image.cpp - composes the boot chain, generated for " + identity(m) + "\n"; s = s + "#include \nnamespace sleela_os {\n"; s = s + "class OsImage {\npublic:\n"; s = s + " std::string name = \"" + m.name + "\";\n"; s = s + " std::string loader = \"" + m.loader + "\";\n"; s = s + " std::string kernel = \"" + m.kernel + "\";\n"; s = s + " std::string rootfs = \"" + m.rootfs + "\";\n"; s = s + " std::string init = \"" + m.init + "\";\n"; s = s + " int assemble() {\n"; s = s + " if (!firmwareHandoff(loader)) return 1;\n"; s = s + " if (!kernelStart()) return 2;\n"; s = s + " if (!mountRootfs(rootfs)) return 3;\n"; s = s + " startInit(init);\n return 0;\n }\n"; s = s + "private:\n"; s = s + " bool firmwareHandoff(const std::string&);\n"; s = s + " bool kernelStart();\n"; s = s + " bool mountRootfs(const std::string&);\n"; s = s + " void startInit(const std::string&);\n"; s = s + "};\n} // namespace sleela_os\n"; return s; } String osLoaderC(OsModel m) { String c = "/* os_loader.c - PID 1 / service manager for " + m.name + " */\n"; c = c + "extern int start_manager(const char *manager);\n"; c = c + "extern int start_service(const char *unit);\n"; c = c + "extern int start_session(void);\n\n"; c = c + "int os_loader_main(void) {\n"; c = c + " if (start_manager(\"" + m.init + "\") != 0) return 1;\n"; c = c + " start_service(\"systemd-udevd\");\n"; c = c + " start_service(\"systemd-networkd\");\n"; c = c + " start_service(\"systemd-journald\");\n"; c = c + " start_session(); /* -> desktop (" + m.desktop + ") */\n"; c = c + " for (;;) { /* reap children; PID 1 never exits */ }\n"; c = c + "}\n"; return c; } String isoRecipe(OsModel m) { String iso = m.name + "-" + m.version + "-" + m.arch + ".iso"; String r = "#!/bin/sh\n# gen-iso.sh for " + identity(m) + "\nset -eu\n"; r = r + "STAGE=staging/rootfs\nOUT=" + iso + "\n"; r = r + "cc -c os/os_boot.c -o \"$STAGE/boot/os_boot.o\"\n"; r = r + "c++ -c os/os_image.cpp -o \"$STAGE/boot/os_image.o\"\n"; r = r + "install-loader --loader " + m.loader + " --esp \"$STAGE/boot/efi\"\n"; r = r + "xorriso -as mkisofs -V " + m.name + "-" + m.version + " -o \"$OUT\" -e boot/efi/EFI/BOOT/BOOTX64.EFI -no-emul-boot -J -R \"$STAGE\"\n"; return r; } String makefile(OsModel m) { String mk = "# Makefile - generated for " + identity(m) + "\n"; mk = mk + "CC ?= cc\nCXX ?= c++\n\n"; mk = mk + "all: os iso\n\n"; mk = mk + "os: build/os_boot.o build/os_image.o build/os_loader.o\n\n"; mk = mk + "build/%.o: os/%.c\n\t@mkdir -p build\n\t$(CC) -c $< -o $@\n\n"; mk = mk + "build/os_image.o: os/os_image.cpp\n\t@mkdir -p build\n\t$(CXX) -c $< -o $@\n\n"; mk = mk + "iso: os\n\tsh tools/gen-iso.sh\n\n"; mk = mk + "upstream:\n\tsh fetch-upstream.sh\n\n"; mk = mk + ".PHONY: all os iso upstream\n"; return mk; } String buildSh(OsModel m) { String s = "#!/bin/sh\n# build.sh - compile the generated " + m.shape + " OS sources\nset -eu\n"; s = s + "make all\n"; return s; } < ---- materialise the whole tree ------------------------------------- > void generate(OsModel m) { makeDir(""); makeDir("/os"); makeDir("/userspace"); makeDir("/userspace/os-loader"); makeDir("/tools"); makeDir("/upstream"); < The OS itself (real Linux-level C/C++). > writeFile("/os/os_config.h", configHeader(m)); writeFile("/os/os_boot.c", bootUnit(m)); writeFile("/os/os_image.cpp", osImage(m)); writeFile("/os/exec_types.h", execTypesHeader(m)); writeFile("/os/exec_translate.h", execTranslateHeader(m)); writeFile("/userspace/os-loader/os_loader.c", osLoaderC(m)); makeDir("/userspace/compat-loader"); writeFile("/userspace/compat-loader/compat_loader.c", compatLoaderC(m)); writeFile("/userspace/compat-loader/compat.conf", compatConf(m)); makeDir("/config"); writeFile("/config/os.conf", osConf(m)); writeFile("/config/cmdline.conf", cmdlineConf(m)); writeFile("/config/downloads.conf", downloadsConf(m)); writeFile("/config/support-urls.conf", supportUrlsConf(m)); writeFile("/fetch-downloads.sh", fetchDownloadsSh(m)); writeFile("/fetch-downloads-resilient.sh", fetchResilientSh(m)); writeFile("/config/swap.conf", swapConf(m)); writeFile("/config/filesystems.txt", filesystemsConf(m)); makeDir("/kernel"); makeDir("/kernel/base-drivers"); writeFile("/kernel/base-drivers/base_drivers_table.c", baseDriversTableC(m)); writeFile("/kernel/base-drivers/base-drivers.conf", baseDriversConf(m)); < Build tooling + ISO recipe. > writeFile("/tools/gen-iso.sh", isoRecipe(m)); writeFile("/Makefile", makefile(m)); writeFile("/build.sh", buildSh(m)); < Upstream provenance + the opt-in fetch script (closes the loop). > writeFile("/upstream/DISTRO.reference", upstream.referenceSheet()); writeFile("/fetch-upstream.sh", upstream.fetchScript()); < Self-describing manifest, written last. > String md = "# Generated OS source tree\n\n"; md = md + "Model: " + identity(m) + "\n\n"; md = md + "Upstream parts: see upstream/DISTRO.reference (fetch with: sh fetch-upstream.sh)\n\n"; md = md + "Files written: " + fileCount + "\n\n## Index (bytes path)\n\n" + manifest + "\n"; writeFile("/MANIFEST.md", md); } < Read a build parameter from the environment, or fall back to a default. > String param(String envName, String fallback) { String v = osGetEnv(envName); if (v == "") { return fallback; } return v; } void main() { String outRoot = param("OS_OUT", "/projects/sandbox/os-out"); configure(outRoot); OsModel os = linux(param("OS_NAME", "Determinant"), param("OS_VERSION", "1.0"), param("OS_ARCH", "amd64"), resolveKernel(param("OS_KERNEL_VER", "default"))); print("================================================================"); print(" SLeeLa OS generator -> " + identity(os)); print(" kernel: " + os.kernel + " " + os.kernelVer); print(" output root: " + outRoot); print("================================================================"); generate(os); print("wrote " + fileCount + " files to " + outRoot); print(""); print(manifest); print(""); print("next:"); print(" cd " + outRoot + " && sh build.sh # compile the generated OS sources"); print(" cd " + outRoot + " && sh fetch-upstream.sh # opt-in: download the real OS parts"); print("done"); } }