8cca3b9dde
The JNI/runtime-class path (Decision 5, Runtime* family). Coordinated across the hook boundary so the BuildOptions accessor + its registered hook string stay in sync: - src/: RuntimeClassDecl.foreign_path→runtime_path, splitForeignPath→splitRuntimePath, foreignPathToJavaName→runtimePathToJavaName, jni_main_foreign_paths→ jni_main_runtime_paths, hookJniMainForeignPathAt→hookJniMainRuntimePathAt, and the hook string 'BuildOptions.jni_main_foreign_path_at'→'…runtime_path_at'. - library/: build.sx accessor jni_main_foreign_path_at→jni_main_runtime_path_at + bundle.sx call sites + the local var → runtime_path + a comment. - specs.md: the accessor name + <foreign_path_with_dots> doc refs. - Regenerated 37 .ir snapshots: every program importing build declares the renamed @BuildOptions.jni_main_runtime_path_at hook stub — symbol-name change only (verified the .ir diff is ONLY this rename; reverted orthogonal empty-file normalization). Suite green (646 corpus / 444 unit, 0 failed).
531 lines
22 KiB
Zig
531 lines
22 KiB
Zig
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const interp_mod = @import("interp.zig");
|
|
const Value = interp_mod.Value;
|
|
const Interpreter = interp_mod.Interpreter;
|
|
const inst = @import("inst.zig");
|
|
const FuncId = inst.FuncId;
|
|
|
|
// ── BuildConfig ─────────────────────────────────────────────────────────
|
|
// Mutable build configuration accumulated by #run blocks via #compiler methods.
|
|
|
|
/// `(src_dir, dest_in_bundle)` pair recorded by
|
|
/// `BuildOptions.add_asset_dir(src, dest)`. The sx bundler walks the
|
|
/// list and recursively copies each `src` directory into the bundle
|
|
/// at the relative `dest` path (e.g. `("assets", "assets")` copies
|
|
/// `./assets/` to `<bundle>/assets/`). Android's Week-7 APK path will
|
|
/// zip the same pairs into the unaligned APK.
|
|
pub const AssetDir = struct {
|
|
src: []const u8,
|
|
dest: []const u8,
|
|
};
|
|
|
|
pub const BuildConfig = struct {
|
|
link_flags: std.ArrayList([]const u8) = .empty,
|
|
frameworks: std.ArrayList([]const u8) = .empty,
|
|
asset_dirs: std.ArrayList(AssetDir) = .empty,
|
|
output_path: ?[]const u8 = null,
|
|
wasm_shell_path: ?[]const u8 = null,
|
|
|
|
/// Post-link callback registered via
|
|
/// `BuildOptions.set_post_link_callback(fn)`. When set, the
|
|
/// compiler re-enters the IR interpreter after `target.link()`
|
|
/// and invokes this function with no args. A `false` return is
|
|
/// treated as a build failure.
|
|
post_link_callback_fn: ?FuncId = null,
|
|
/// Alternative to `post_link_callback_fn`: the qualified name of
|
|
/// a module whose `bundle_main` function should be called
|
|
/// post-link.
|
|
post_link_module: ?[]const u8 = null,
|
|
|
|
/// Path of the freshly-linked binary, populated by `main.zig`
|
|
/// right before the post-link callback runs. The sx-side bundler
|
|
/// reads this via `binary_path()` to know what file to wrap.
|
|
binary_path: ?[]const u8 = null,
|
|
|
|
// Apple `.app` / Android `.apk` bundling parameters. Set either
|
|
// by the sx-side `BuildOptions.set_bundle_*` methods (preferred)
|
|
// or by main.zig from CLI flags (transitional fallback). The sx
|
|
// bundler reads them via the matching accessor methods.
|
|
bundle_path: ?[]const u8 = null,
|
|
bundle_id: ?[]const u8 = null,
|
|
codesign_identity: ?[]const u8 = null,
|
|
provisioning_profile: ?[]const u8 = null,
|
|
|
|
/// Target triple as supplied to `--target` (canonicalized).
|
|
/// Populated by main.zig before the post-link callback runs so the
|
|
/// sx bundler can switch on iOS vs. macOS vs. simulator.
|
|
target_triple: ?[]const u8 = null,
|
|
|
|
/// Frameworks the binary links against (`-framework` names) and
|
|
/// the search paths to look them up in (`-F` directories), forwarded
|
|
/// from the link step so the sx bundler can embed them into
|
|
/// `<bundle>/Frameworks/`.
|
|
target_frameworks: []const []const u8 = &.{},
|
|
target_framework_paths: []const []const u8 = &.{},
|
|
|
|
/// User-supplied `AndroidManifest.xml` override (`--manifest <path>`
|
|
/// or `BuildOptions.set_manifest_path("...")`). When null, the
|
|
/// Android bundler synthesizes a default manifest.
|
|
manifest_path: ?[]const u8 = null,
|
|
/// User-supplied debug keystore path (`--keystore <path>` or
|
|
/// `BuildOptions.set_keystore_path("...")`). When null, the Android
|
|
/// bundler uses `$HOME/.android/debug.keystore` (auto-generated on
|
|
/// first use via `keytool`).
|
|
keystore_path: ?[]const u8 = null,
|
|
|
|
/// `#jni_main #jni_class("path") { ... }` decls discovered during
|
|
/// lowering, paired with their pre-rendered Java source. The
|
|
/// Android bundler writes each entry to
|
|
/// `<stage>/java/<pkg>/<Class>.java`, compiles via `javac` + `d8`,
|
|
/// and bundles the resulting `classes.dex` into the APK. Slices
|
|
/// reference compiler-owned memory that outlives the post-link
|
|
/// callback.
|
|
jni_main_runtime_paths: []const []const u8 = &.{},
|
|
jni_main_java_sources: []const []const u8 = &.{},
|
|
|
|
pub fn deinit(self: *BuildConfig, alloc: Allocator) void {
|
|
self.link_flags.deinit(alloc);
|
|
self.frameworks.deinit(alloc);
|
|
self.asset_dirs.deinit(alloc);
|
|
}
|
|
};
|
|
|
|
// ── Hook system ─────────────────────────────────────────────────────────
|
|
|
|
pub const HookError = error{
|
|
CannotEvalComptime,
|
|
TypeError,
|
|
};
|
|
|
|
/// Hook function signature. Receives the interpreter (for heap/string access),
|
|
/// resolved argument values, and the mutable build config.
|
|
pub const HookFn = *const fn (
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value;
|
|
|
|
pub const Registry = struct {
|
|
hooks: std.StringHashMap(HookFn),
|
|
|
|
pub fn init(alloc: Allocator) Registry {
|
|
return .{ .hooks = std.StringHashMap(HookFn).init(alloc) };
|
|
}
|
|
|
|
pub fn deinit(self: *Registry) void {
|
|
self.hooks.deinit();
|
|
}
|
|
|
|
pub fn get(self: *const Registry, name: []const u8) ?HookFn {
|
|
return self.hooks.get(name);
|
|
}
|
|
|
|
/// Register all built-in compiler hooks.
|
|
pub fn registerDefaults(self: *Registry) void {
|
|
self.hooks.put("build_options", &hookBuildOptions) catch {};
|
|
self.hooks.put("BuildOptions.add_link_flag", &hookAddLinkFlag) catch {};
|
|
self.hooks.put("BuildOptions.add_framework", &hookAddFramework) catch {};
|
|
self.hooks.put("BuildOptions.add_asset_dir", &hookAddAssetDir) catch {};
|
|
self.hooks.put("BuildOptions.asset_dir_count", &hookAssetDirCount) catch {};
|
|
self.hooks.put("BuildOptions.asset_dir_src_at", &hookAssetDirSrcAt) catch {};
|
|
self.hooks.put("BuildOptions.asset_dir_dest_at", &hookAssetDirDestAt) catch {};
|
|
self.hooks.put("BuildOptions.set_output_path", &hookSetOutputPath) catch {};
|
|
self.hooks.put("BuildOptions.set_wasm_shell", &hookSetWasmShell) catch {};
|
|
self.hooks.put("BuildOptions.set_post_link_callback", &hookSetPostLinkCallback) catch {};
|
|
self.hooks.put("BuildOptions.set_post_link_module", &hookSetPostLinkModule) catch {};
|
|
self.hooks.put("BuildOptions.binary_path", &hookGetBinaryPath) catch {};
|
|
// Bundling setters
|
|
self.hooks.put("BuildOptions.set_bundle_path", &hookSetBundlePath) catch {};
|
|
self.hooks.put("BuildOptions.set_bundle_id", &hookSetBundleId) catch {};
|
|
self.hooks.put("BuildOptions.set_codesign_identity", &hookSetCodesignIdentity) catch {};
|
|
self.hooks.put("BuildOptions.set_provisioning_profile", &hookSetProvisioningProfile) catch {};
|
|
// Bundling accessors
|
|
self.hooks.put("BuildOptions.bundle_path", &hookGetBundlePath) catch {};
|
|
self.hooks.put("BuildOptions.bundle_id", &hookGetBundleId) catch {};
|
|
self.hooks.put("BuildOptions.codesign_identity", &hookGetCodesignIdentity) catch {};
|
|
self.hooks.put("BuildOptions.provisioning_profile", &hookGetProvisioningProfile) catch {};
|
|
// Target accessors — mirror TargetConfig.is{MacOS,IOS,IOSDevice,IOSSimulator,Android}()
|
|
self.hooks.put("BuildOptions.target_triple", &hookGetTargetTriple) catch {};
|
|
self.hooks.put("BuildOptions.is_macos", &hookIsMacOS) catch {};
|
|
self.hooks.put("BuildOptions.is_ios", &hookIsIOS) catch {};
|
|
self.hooks.put("BuildOptions.is_ios_device", &hookIsIOSDevice) catch {};
|
|
self.hooks.put("BuildOptions.is_ios_simulator", &hookIsIOSSimulator) catch {};
|
|
self.hooks.put("BuildOptions.is_android", &hookIsAndroid) catch {};
|
|
// Android-specific setters + accessors
|
|
self.hooks.put("BuildOptions.set_manifest_path", &hookSetManifestPath) catch {};
|
|
self.hooks.put("BuildOptions.manifest_path", &hookGetManifestPath) catch {};
|
|
self.hooks.put("BuildOptions.set_keystore_path", &hookSetKeystorePath) catch {};
|
|
self.hooks.put("BuildOptions.keystore_path", &hookGetKeystorePath) catch {};
|
|
// #jni_main class emissions, exposed by index so bundle.sx can iterate.
|
|
self.hooks.put("BuildOptions.jni_main_count", &hookJniMainCount) catch {};
|
|
self.hooks.put("BuildOptions.jni_main_runtime_path_at", &hookJniMainRuntimePathAt) catch {};
|
|
self.hooks.put("BuildOptions.jni_main_java_source_at", &hookJniMainJavaSourceAt) catch {};
|
|
// Framework list accessors (for `.app/Frameworks/` embedding)
|
|
self.hooks.put("BuildOptions.framework_count", &hookFrameworkCount) catch {};
|
|
self.hooks.put("BuildOptions.framework_at", &hookFrameworkAt) catch {};
|
|
self.hooks.put("BuildOptions.framework_path_count", &hookFrameworkPathCount) catch {};
|
|
self.hooks.put("BuildOptions.framework_path_at", &hookFrameworkPathAt) catch {};
|
|
}
|
|
};
|
|
|
|
// ── build_options() hook ────────────────────────────────────────────────
|
|
|
|
fn hookBuildOptions(
|
|
_: *const Interpreter,
|
|
_: []const Value,
|
|
_: *BuildConfig,
|
|
_: Allocator,
|
|
) HookError!Value {
|
|
// build_options() returns a sentinel value; the real work happens
|
|
// when methods like add_link_flag/set_output_path are called on it.
|
|
return .void_val;
|
|
}
|
|
|
|
// ── BuildOptions hooks ──────────────────────────────────────────────────
|
|
|
|
fn hookAddLinkFlag(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), flag_string]
|
|
if (args.len < 2) return .void_val;
|
|
const str_val = args[1];
|
|
if (str_val.asString(interp)) |s| {
|
|
bc.link_flags.append(alloc, alloc.dupe(u8, s) catch return error.CannotEvalComptime) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookAddFramework(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), framework_name]
|
|
if (args.len < 2) return .void_val;
|
|
const str_val = args[1];
|
|
if (str_val.asString(interp)) |s| {
|
|
bc.frameworks.append(alloc, alloc.dupe(u8, s) catch return error.CannotEvalComptime) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookAddAssetDir(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), src_path, dest_path_in_bundle]
|
|
if (args.len < 3) return .void_val;
|
|
const src = args[1].asString(interp) orelse return error.TypeError;
|
|
const dest = args[2].asString(interp) orelse return error.TypeError;
|
|
const src_dup = alloc.dupe(u8, src) catch return error.CannotEvalComptime;
|
|
const dest_dup = alloc.dupe(u8, dest) catch return error.CannotEvalComptime;
|
|
bc.asset_dirs.append(alloc, .{ .src = src_dup, .dest = dest_dup }) catch return error.CannotEvalComptime;
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookAssetDirCount(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .int = @intCast(bc.asset_dirs.items.len) };
|
|
}
|
|
|
|
fn hookAssetDirSrcAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx = args[1].asInt() orelse return error.TypeError;
|
|
if (idx < 0 or @as(usize, @intCast(idx)) >= bc.asset_dirs.items.len) return Value{ .string = "" };
|
|
return Value{ .string = bc.asset_dirs.items[@intCast(idx)].src };
|
|
}
|
|
|
|
fn hookAssetDirDestAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx = args[1].asInt() orelse return error.TypeError;
|
|
if (idx < 0 or @as(usize, @intCast(idx)) >= bc.asset_dirs.items.len) return Value{ .string = "" };
|
|
return Value{ .string = bc.asset_dirs.items[@intCast(idx)].dest };
|
|
}
|
|
|
|
fn hookSetOutputPath(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), path_string]
|
|
if (args.len < 2) return .void_val;
|
|
const str_val = args[1];
|
|
if (str_val.asString(interp)) |s| {
|
|
bc.output_path = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetWasmShell(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), path_string]
|
|
if (args.len < 2) return .void_val;
|
|
const str_val = args[1];
|
|
if (str_val.asString(interp)) |s| {
|
|
bc.wasm_shell_path = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetPostLinkCallback(
|
|
_: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
_: Allocator,
|
|
) HookError!Value {
|
|
// args: [self (BuildOptions value), fn_value]. We accept a function
|
|
// value (.func_ref) and stash the FuncId so `main.zig` can re-enter
|
|
// the interpreter after linking.
|
|
if (args.len < 2) return .void_val;
|
|
switch (args[1]) {
|
|
.func_ref => |id| bc.post_link_callback_fn = id,
|
|
else => return error.TypeError,
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetPostLinkModule(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.post_link_module = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
/// Read the linked-binary path that main.zig populated right before
|
|
/// invoking the post-link callback. Returns the fat-string aggregate
|
|
/// the interpreter normally hands out for sx `string` values.
|
|
fn hookGetBinaryPath(
|
|
interp: *const Interpreter,
|
|
_: []const Value,
|
|
bc: *BuildConfig,
|
|
_: Allocator,
|
|
) HookError!Value {
|
|
_ = interp;
|
|
const path = bc.binary_path orelse "";
|
|
return Value{ .string = path };
|
|
}
|
|
|
|
// ── Bundling setters & accessors ─────────────────────────────────────
|
|
// Same pattern as set_output_path: take a string arg, dupe into the
|
|
// long-lived allocator, store on BuildConfig. The companion accessor
|
|
// reads back the same field; empty string when unset.
|
|
|
|
fn hookSetBundlePath(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.bundle_path = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetBundleId(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.bundle_id = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetCodesignIdentity(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.codesign_identity = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookSetProvisioningProfile(
|
|
interp: *const Interpreter,
|
|
args: []const Value,
|
|
bc: *BuildConfig,
|
|
alloc: Allocator,
|
|
) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.provisioning_profile = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookGetBundlePath(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.bundle_path orelse "" };
|
|
}
|
|
|
|
fn hookGetBundleId(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.bundle_id orelse "" };
|
|
}
|
|
|
|
fn hookGetCodesignIdentity(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.codesign_identity orelse "" };
|
|
}
|
|
|
|
fn hookGetProvisioningProfile(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.provisioning_profile orelse "" };
|
|
}
|
|
|
|
// ── Target accessors ──────────────────────────────────────────────────
|
|
// These look at the target_triple that main.zig populates and answer
|
|
// the same questions TargetConfig's helpers do for Zig callers.
|
|
|
|
fn tripleContains(triple: ?[]const u8, needle: []const u8) bool {
|
|
const t = triple orelse return false;
|
|
return std.mem.indexOf(u8, t, needle) != null;
|
|
}
|
|
|
|
fn isIOSTriple(triple: ?[]const u8) bool {
|
|
return tripleContains(triple, "apple-ios");
|
|
}
|
|
|
|
fn hookGetTargetTriple(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.target_triple orelse "" };
|
|
}
|
|
|
|
fn hookIsMacOS(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (isIOSTriple(bc.target_triple)) return Value{ .boolean = false };
|
|
const t = bc.target_triple orelse "";
|
|
const is_mac = std.mem.indexOf(u8, t, "apple-macosx") != null or
|
|
std.mem.indexOf(u8, t, "apple-macos") != null or
|
|
std.mem.indexOf(u8, t, "apple-darwin") != null;
|
|
return Value{ .boolean = is_mac };
|
|
}
|
|
|
|
fn hookIsIOS(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .boolean = isIOSTriple(bc.target_triple) };
|
|
}
|
|
|
|
fn hookIsIOSDevice(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
const ios = isIOSTriple(bc.target_triple);
|
|
const sim = tripleContains(bc.target_triple, "simulator");
|
|
return Value{ .boolean = ios and !sim };
|
|
}
|
|
|
|
fn hookIsIOSSimulator(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
const ios = isIOSTriple(bc.target_triple);
|
|
const sim = tripleContains(bc.target_triple, "simulator");
|
|
return Value{ .boolean = ios and sim };
|
|
}
|
|
|
|
fn hookIsAndroid(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .boolean = tripleContains(bc.target_triple, "android") };
|
|
}
|
|
|
|
// ── Android-specific bundling setters + accessors ─────────────────────
|
|
|
|
fn hookSetManifestPath(interp: *const Interpreter, args: []const Value, bc: *BuildConfig, alloc: Allocator) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.manifest_path = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookGetManifestPath(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.manifest_path orelse "" };
|
|
}
|
|
|
|
fn hookSetKeystorePath(interp: *const Interpreter, args: []const Value, bc: *BuildConfig, alloc: Allocator) HookError!Value {
|
|
if (args.len < 2) return .void_val;
|
|
if (args[1].asString(interp)) |s| {
|
|
bc.keystore_path = alloc.dupe(u8, s) catch return error.CannotEvalComptime;
|
|
}
|
|
return .void_val;
|
|
}
|
|
|
|
fn hookGetKeystorePath(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .string = bc.keystore_path orelse "" };
|
|
}
|
|
|
|
// ── #jni_main emission accessors ──────────────────────────────────────
|
|
// The Android bundler walks these as `0..jni_main_count()` and reads
|
|
// each entry's `(runtime_path, java_source)` pair so it can write a
|
|
// `.java` file per decl, compile via javac, and produce classes.dex
|
|
// via d8 before zipping into the APK.
|
|
|
|
fn hookJniMainCount(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return Value{ .int = @intCast(bc.jni_main_runtime_paths.len) };
|
|
}
|
|
|
|
fn hookJniMainRuntimePathAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx = args[1].asInt() orelse return error.TypeError;
|
|
if (idx < 0 or @as(usize, @intCast(idx)) >= bc.jni_main_runtime_paths.len) return Value{ .string = "" };
|
|
return Value{ .string = bc.jni_main_runtime_paths[@intCast(idx)] };
|
|
}
|
|
|
|
fn hookJniMainJavaSourceAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx = args[1].asInt() orelse return error.TypeError;
|
|
if (idx < 0 or @as(usize, @intCast(idx)) >= bc.jni_main_java_sources.len) return Value{ .string = "" };
|
|
return Value{ .string = bc.jni_main_java_sources[@intCast(idx)] };
|
|
}
|
|
|
|
// ── Framework list accessors ──────────────────────────────────────────
|
|
// The Apple .app bundler in `library/modules/platform/bundle.sx` walks
|
|
// the framework list to recursively copy each `<Name>.framework`
|
|
// directory from the user's -F search paths into `<bundle>/Frameworks/`.
|
|
// Slice-of-string returns aren't natively expressible as a Value, so we
|
|
// expose count + indexed lookups instead.
|
|
|
|
fn intValue(n: i64) Value {
|
|
return Value{ .int = n };
|
|
}
|
|
|
|
fn hookFrameworkCount(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return intValue(@intCast(bc.target_frameworks.len));
|
|
}
|
|
|
|
fn hookFrameworkAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx_i64 = args[1].asInt() orelse return error.TypeError;
|
|
if (idx_i64 < 0 or @as(usize, @intCast(idx_i64)) >= bc.target_frameworks.len) {
|
|
return Value{ .string = "" };
|
|
}
|
|
return Value{ .string = bc.target_frameworks[@intCast(idx_i64)] };
|
|
}
|
|
|
|
fn hookFrameworkPathCount(_: *const Interpreter, _: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
return intValue(@intCast(bc.target_framework_paths.len));
|
|
}
|
|
|
|
fn hookFrameworkPathAt(_: *const Interpreter, args: []const Value, bc: *BuildConfig, _: Allocator) HookError!Value {
|
|
if (args.len < 2) return Value{ .string = "" };
|
|
const idx_i64 = args[1].asInt() orelse return error.TypeError;
|
|
if (idx_i64 < 0 or @as(usize, @intCast(idx_i64)) >= bc.target_framework_paths.len) {
|
|
return Value{ .string = "" };
|
|
}
|
|
return Value{ .string = bc.target_framework_paths[@intCast(idx_i64)] };
|
|
}
|