<< lib/operating-system/SLExecutableTranslator.sleela SLeeLa Standard Library Definition. Definition: Defines SLExecutableTranslator — the policy and mechanism for running a FOREIGN executable type on a host OS, so a builder can declare any file type runnable on a given OS even when the host would not natively execute it (the canonical example: a Linux host running a Windows .exe). Native executables run directly (see SLExecutableTypes); a foreign type needs a TRANSLATION layer, of which there are two kinds: 1. FS-level interpreter — the kernel's binfmt_misc facility: register a magic/extension -> interpreter mapping so the filesystem itself hands the file to an interpreter when it is exec()'d (Linux). 2. OS container / compat layer — a user-space translator that houses the execution: Wine (Win32 on Linux/macOS), QEMU-user (cross-architecture ELF), Rosetta 2 (x86-64 on Apple Silicon), WSL (ELF on Windows). This object answers "can host H run foreign type T, and how?", names the translator, and emits the registration (a binfmt_misc line, or the container invocation) so a builder can wire the capability into the generated OS. It is both a design object (consulted by the OS generator) and a host object (register()/run() cross the os* bridge where the facility exists). Family: operating-system. Design + host roles; register()/run() cross the osRun bridge (requires #sleela 1.5). Honesty: naming a translator does not install it; where the interpreter/container is absent the foreign type stays unrunnable and the methods report that rather than faking success. >> #sleela 2.5 material; class SLExecutableTranslator { < ---- 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 = 10891; 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; } < the host OS running the file: "Linux" / "Windows" / "macOS" > String host; void configure(String hostShape) { if (hostShape == "Windows") { host = "Windows"; return; } if (hostShape == "macOS") { host = "macOS"; return; } host = "Linux"; } void configureForHost() { configure(osPlatform()); } String hostName() { return host; } < ---- The foreign "world" a file type belongs to --------------------- > < worldOf(ext): the executable world an extension/type comes from, so the > < translator can pick the right layer. "" = a bare (no-ext) binary, treated > < as native to whatever host it sits on. > String worldOf(String ext) { if (ext == ".exe" || ext == ".com" || ext == ".bat" || ext == ".cmd" || ext == ".ps1" || ext == ".msi" || ext == ".vbs" || ext == ".scr") { return "Windows"; } if (ext == ".app" || ext == ".command" || ext == ".dylib") { return "macOS"; } if (ext == ".sh" || ext == ".elf" || ext == ".so" || ext == ".run" || ext == ".AppImage" || ext == ".ko") { return "Linux"; } return "native"; } < isForeign(ext): does running this type on the host require translation? > boolean isForeign(String ext) { String w = worldOf(ext); if (w == "native") { return false; } return w != host; } < ---- Which translator applies, and how ------------------------------ > < translatorFor(ext): the name of the layer that runs this foreign type on > < the host, or "" when the type is native (no translation needed). The names > < are the real-world facilities a builder would install. > String translatorFor(String ext) { if (!isForeign(ext)) { return ""; } String w = worldOf(ext); if (host == "Linux") { if (w == "Windows") { return "Wine (Win32 compatibility layer)"; } if (w == "macOS") { return "Darling (macOS compatibility layer)"; } return "QEMU-user (cross-arch ELF)"; } if (host == "macOS") { if (w == "Windows") { return "Wine / CrossOver"; } if (w == "Linux") { return "Docker/Lima (Linux VM) or QEMU-user"; } return "Rosetta 2 (x86-64 translation)"; } < Windows host. > if (w == "Linux") { return "WSL2 (Windows Subsystem for Linux)"; } return "a VM / QEMU (no native compat layer)"; } < kind(ext): the TRANSLATION KIND for the host+type: "native" (runs direct), > < "binfmt" (an FS-level interpreter can be registered), or "container" > < (a user-space compat layer / VM houses the execution). > String kind(String ext) { if (!isForeign(ext)) { return "native"; } < Only Linux exposes binfmt_misc, and it is the FS-level route for Windows > < PE and cross-arch ELF (binding Wine / QEMU as the interpreter). > if (host == "Linux") { return "binfmt"; } return "container"; } < Does the host provide a filesystem-level interpreter facility at all? > boolean hasFsInterpreter() { return host == "Linux"; } < ---- Registration: make a foreign type runnable --------------------- > < binfmtLine(ext, interpreter): the binfmt_misc registration string that > < binds a foreign type to an interpreter at the filesystem level. Written to > < /proc/sys/fs/binfmt_misc/register (or a systemd-binfmt .conf) on Linux. > < Form: ":name:extension|magic:::interpreter:flags". > String binfmtLine(String ext, String interpreter) { String tag = ext; < Strip the leading dot for the registration name. > String nm = "foreign"; return ":" + nm + ":E::" + stripDot(ext) + "::" + interpreter + ":OC"; } String stripDot(String ext) { if (ext == ".exe") { return "exe"; } if (ext == ".com") { return "com"; } if (ext == ".bat") { return "bat"; } if (ext == ".msi") { return "msi"; } if (ext == ".app") { return "app"; } if (ext == ".elf") { return "elf"; } return "bin"; } < The host command that registers a foreign type so the FS/compat layer runs > < it. On Linux this appends a binfmt_misc rule; elsewhere it is advisory text > < naming the container to install (there is no FS-level register there). > String registerCommand(String ext, String interpreter) { if (host == "Linux") { return "echo '" + binfmtLine(ext, interpreter) + "' > /proc/sys/fs/binfmt_misc/register"; } return "# install " + translatorFor(ext) + " to run " + ext + " on " + host; } < runCommand(path, ext, interpreter): how the host actually launches a > < foreign file. With a registered FS interpreter it runs directly; otherwise > < it is invoked through the named container/compat layer. > String runCommand(String path, String ext, String interpreter) { < native: direct > if (!isForeign(ext)) { return path; } < FS interpreter handles it > if (kind(ext) == "binfmt") { return path; } < container/compat prefix > return interpreter + " " + path; } < ---- Host actions (cross the os* bridge) ---------------------------- > < register(ext, interpreter): on Linux, attempt the binfmt_misc registration > < (requires the facility mounted and privilege); returns the exit code (0 ok). > < On other hosts there is no FS-level register, so it reports -1 (the builder > < must install the named container). Never fakes success. > int register(String ext, String interpreter) { if (host != "Linux") { return -1; } < facility absent > if (osExists("/proc/sys/fs/binfmt_misc") != 1) { return -2; } return osRun(registerCommand(ext, interpreter) + " 2>/dev/null"); } < runnableNow(ext, interpreterPath): best-effort check that the host can run > < this foreign type right now — the interpreter/container binary is present. > boolean runnableNow(String ext, String interpreterPath) { if (!isForeign(ext)) { return true; } return osExists(interpreterPath) == 1; } < ---- Generated C/C++ note ------------------------------------------- > < A short header documenting the host's foreign-exec policy for the generated > < OS, so the working C/CPP set records which translators the image expects. > String emitTranslatorHeader() { String h = "/* exec_translate.h - foreign-executable policy for " + host + " (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 \"" + host + "\"\n"; h = h + "#define OS_HAS_BINFMT " + bit(hasFsInterpreter()) + "\n"; h = h + "/* Foreign type -> translator (host-specific). Empty interpreter means native. */\n"; h = h + "#define OS_FOREIGN_EXE \"" + translatorFor(".exe") + "\"\n"; h = h + "#define OS_FOREIGN_ELF \"" + translatorFor(".elf") + "\"\n"; h = h + "#define OS_FOREIGN_APP \"" + translatorFor(".app") + "\"\n"; h = h + "\n#endif /* EXEC_TRANSLATE_H */\n"; return h; } String bit(boolean b) { if (b) { return "1"; } return "0"; } }