git.delta.rocks / jrsonnet / refs/commits / c6e9f5b704f3

--- a/bindings/c/libjsonnet_test_file.c
+++ b/bindings/c/libjsonnet_test_file.c
@@ -1,16 +1,3 @@
-/*
-Copyright 2015 Google Inc. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
 #include <stdlib.h>
 #include <stdio.h>
 

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -27,11 +27,17 @@
 
 [lib]
 name = "jsonnet"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "staticlib"]
 
 [features]
+default = ["interop-common", "interop-wasm", "interop-threading"]
 # Export additional functions for native integration, i.e ability to set custom trace format
-interop = []
+interop-common = []
+# Provide ability to statically override callbacks from WASM (by using imports)
+interop-wasm = []
+# Provide ability to move jsonnet vm state between threads
+interop-threading = []
+
 experimental = ["exp-preserve-order", "exp-destruct"]
 exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]
 exp-destruct = ["jrsonnet-evaluator/exp-destruct"]

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -15,7 +15,7 @@
 use jrsonnet_evaluator::{
 	bail,
 	error::{ErrorKind::*, Result},
-	FileImportResolver, ImportResolver,
+	ImportResolver,
 };
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
@@ -106,6 +106,10 @@
 	fn as_any(&self) -> &dyn Any {
 		self
 	}
+
+	fn as_any_mut(&mut self) -> &mut dyn Any {
+		self
+	}
 }
 
 /// # Safety
@@ -117,7 +121,7 @@
 	cb: JsonnetImportCallback,
 	ctx: *mut c_void,
 ) {
-	vm.state.set_import_resolver(CallbackImportResolver {
+	vm.replace_import_resolver(CallbackImportResolver {
 		cb,
 		ctx,
 		out: RefCell::new(HashMap::new()),
@@ -131,10 +135,5 @@
 pub unsafe extern "C" fn jsonnet_jpath_add(vm: &VM, path: *const c_char) {
 	let cstr = unsafe { CStr::from_ptr(path) };
 	let path = PathBuf::from(cstr.to_str().unwrap());
-	let any_resolver = vm.state.import_resolver();
-	let resolver = any_resolver
-		.as_any()
-		.downcast_ref::<FileImportResolver>()
-		.expect("jpaths are not compatible with callback imports!");
-	resolver.add_jpath(path);
+	vm.add_jpath(path);
 }

1//! Jrsonnet specific additional binding helpers1//! Jrsonnet specific additional binding helpers
22
3use std::{3use crate::VM;
4	ffi::c_void,4
5#[cfg(feature = "interop-wasm")]
6pub mod wasm {
5	os::raw::{c_char, c_int},7	use std::ffi::{c_char, c_int, c_void};
6};
78
8use jrsonnet_evaluator::Val;9	use jrsonnet_evaluator::Val;
910
10use crate::{import::jsonnet_import_callback, native::jsonnet_native_callback};11	use crate::VM;
1112
12extern "C" {13	extern "C" {
14
13	pub fn _jrsonnet_static_import_callback(15		pub fn _jrsonnet_static_import_callback(
14		ctx: *mut c_void,16			ctx: *mut c_void,
15		base: *const c_char,17			base: *const c_char,
16		rel: *const c_char,18			rel: *const c_char,
17		found_here: *mut *const c_char,19			found_here: *mut *const c_char,
18		success: &mut c_int,20			buf: *mut *mut c_char,
21			buflen: *mut usize,
19	) -> *const c_char;22		) -> c_int;
2023
21	#[allow(improper_ctypes)]24		#[allow(improper_ctypes)]
22	pub fn _jrsonnet_static_native_callback(25		pub fn _jrsonnet_static_native_callback(
26	) -> *mut Val;29		) -> *mut Val;
27}30	}
2831
29/// # Safety
30#[no_mangle]32	#[no_mangle]
33	#[cfg(feature = "interop-wasm")]
34	// ctx arg is passed as-is to callback
35	#[allow(clippy::not_unsafe_ptr_arg_deref)]
31pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(vm: &VM, ctx: *mut c_void) {36	pub extern "C" fn jrsonnet_apply_static_import_callback(vm: &VM, ctx: *mut c_void) {
32	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)37		unsafe { crate::import::jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx) }
33}38	}
3439
35/// # Safety40	/// # Safety
41	///
42	/// `name` and `raw_params` should be correctly initialized
36#[no_mangle]43	#[no_mangle]
44	#[cfg(feature = "interop-wasm")]
37pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(45	pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(
38	vm: &VM,46		vm: &VM,
39	name: *const c_char,47		name: *const c_char,
40	ctx: *mut c_void,48		ctx: *mut c_void,
41	raw_params: *const *const c_char,49		raw_params: *const *const c_char,
42) {50	) {
51		unsafe {
43	jsonnet_native_callback(vm, name, _jrsonnet_static_native_callback, ctx, raw_params)52			crate::native::jsonnet_native_callback(
53				vm,
54				name,
55				_jrsonnet_static_native_callback,
56				ctx,
57				raw_params,
58			);
59		}
44}60	}
61}
62
63#[cfg(feature = "interop-common")]
64mod common {
65	use jrsonnet_evaluator::trace::{CompactFormat, ExplainingFormat, JsFormat, PathResolver};
66
67	use crate::VM;
4568
46#[no_mangle]69	#[no_mangle]
47pub extern "C" fn jrsonnet_set_trace_format(vm: &VM, format: u8) {70	pub extern "C" fn jrsonnet_set_trace_format(vm: &mut VM, format: u8) {
48	use jrsonnet_evaluator::trace::JsFormat;
49	match format {71		match format {
72			0 => {
73				vm.trace_format = Box::new(CompactFormat {
74					max_trace: 20,
75					resolver: PathResolver::new_cwd_fallback(),
76					padding: 4,
77				});
78			}
50		1 => vm.set_trace_format(Box::new(JsFormat)),79			1 => vm.trace_format = Box::new(JsFormat { max_trace: 20 }),
80			2 => {
81				vm.trace_format = Box::new(ExplainingFormat {
82					resolver: PathResolver::new_cwd_fallback(),
83					max_trace: 20,
84				});
85			}
51		_ => panic!("unknown trace format"),86			_ => panic!("unknown trace format"),
52	}87		}
53}88	}
89}
90
91#[cfg(feature = "interop-threading")]
92mod threading {
93	use std::{ffi::c_int, thread::ThreadId};
94
95	pub struct ThreadCTX {
96		interner: *mut jrsonnet_interner::interop::PoolState,
97		gc: *mut jrsonnet_gcmodule::interop::GcState,
98	}
99
100	/// Golang jrsonnet bindings require Jsonnet VM to be movable.
101	/// Jrsonnet uses `thread_local` in some places, thus making VM
102	/// immovable by default. By using `jrsonnet_exit_thread` and
103	/// `jrsonnet_reenter_thread`, you can move `thread_local` state to
104	/// where it is more convinient to use it.
105	///
106	/// # Safety
107	///
108	/// Current thread GC will be broken after this call, need to call
109	/// `jrsonet_enter_thread` before doing anything.
110	#[no_mangle]
111	pub unsafe extern "C" fn jrsonnet_exit_thread() -> *mut ThreadCTX {
112		Box::into_raw(Box::new(ThreadCTX {
113			interner: jrsonnet_interner::interop::exit_thread(),
114			gc: unsafe { jrsonnet_gcmodule::interop::exit_thread() },
115		}))
116	}
117
118	#[no_mangle]
119	pub extern "C" fn jrsonnet_reenter_thread(mut ctx: Box<ThreadCTX>) {
120		use std::ptr::null_mut;
121		assert!(
122			!ctx.interner.is_null() && !ctx.gc.is_null(),
123			"reused context?"
124		);
125		unsafe { jrsonnet_interner::interop::reenter_thread(ctx.interner) }
126		unsafe { jrsonnet_gcmodule::interop::reenter_thread(ctx.gc) }
127		// Just in case
128		ctx.interner = null_mut();
129		ctx.gc = null_mut();
130	}
131
132	// ThreadId is compatible with u64, and there is unstable cast
133	// method... But until it is stabilized, lets erase its type by
134	// boxing.
135	pub enum JrThreadId {}
136
137	#[no_mangle]
138	pub extern "C" fn jrsonnet_thread_id() -> *mut JrThreadId {
139		Box::into_raw(Box::new(std::thread::current().id())).cast()
140	}
141
142	#[no_mangle]
143	pub extern "C" fn jrsonnet_thread_id_compare(
144		a: *const JrThreadId,
145		b: *const JrThreadId,
146	) -> c_int {
147		let a: &ThreadId = unsafe { *a.cast() };
148		let b: &ThreadId = unsafe { *b.cast() };
149		i32::from(*a == *b)
150	}
151
152	#[no_mangle]
153	pub unsafe extern "C" fn jrsonnet_thread_id_free(id: *mut JrThreadId) {
154		let _id: Box<ThreadId> = unsafe { Box::from_raw(id.cast()) };
155	}
156}
54157

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -1,6 +1,5 @@
 #![allow(clippy::box_default)]
 
-#[cfg(feature = "interop")]
 pub mod interop;
 
 pub mod import;
@@ -12,22 +11,27 @@
 
 use std::{
 	alloc::Layout,
+	any::Any,
 	borrow::Cow,
+	cell::RefCell,
 	ffi::{CStr, CString, OsStr},
 	os::raw::{c_char, c_double, c_int, c_uint},
-	path::Path,
+	path::{Path, PathBuf},
 };
 
 use jrsonnet_evaluator::{
 	apply_tla, bail,
 	function::TlaArg,
-	gc::GcHashMap,
+	gc::{GcHashMap, TraceBox},
 	manifest::{JsonFormat, ManifestFormat, ToStringFormat},
 	stack::set_stack_depth_limit,
 	tb,
 	trace::{CompactFormat, PathResolver, TraceFormat},
-	FileImportResolver, IStr, Result, State, Val,
+	FileImportResolver, IStr, ImportResolver, Result, State, Val,
 };
+use jrsonnet_gcmodule::Trace;
+use jrsonnet_parser::SourcePath;
+use jrsonnet_stdlib::ContextInitializer;
 
 /// WASM stub
 #[cfg(target_arch = "wasm32")]
@@ -72,22 +76,84 @@
 	}
 }
 
+#[derive(Trace)]
+struct VMImportResolver {
+	#[trace(tracking(force))]
+	inner: RefCell<TraceBox<dyn ImportResolver>>,
+}
+impl VMImportResolver {
+	fn new(value: impl ImportResolver) -> Self {
+		Self {
+			inner: RefCell::new(tb!(value)),
+		}
+	}
+}
+impl ImportResolver for VMImportResolver {
+	fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>> {
+		self.inner.borrow().load_file_contents(resolved)
+	}
+
+	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
+		self.inner.borrow().resolve_from(from, path)
+	}
+
+	fn resolve_from_default(&self, path: &str) -> Result<SourcePath> {
+		self.inner.borrow().resolve_from_default(path)
+	}
+
+	fn resolve(&self, path: &Path) -> Result<SourcePath> {
+		self.inner.borrow().resolve(path)
+	}
+
+	fn as_any(&self) -> &dyn Any {
+		self
+	}
+	fn as_any_mut(&mut self) -> &mut dyn Any {
+		self
+	}
+}
+
 pub struct VM {
 	state: State,
 	manifest_format: Box<dyn ManifestFormat>,
 	trace_format: Box<dyn TraceFormat>,
 	tla_args: GcHashMap<IStr, TlaArg>,
 }
+impl VM {
+	fn replace_import_resolver(&self, resolver: impl ImportResolver) {
+		*self
+			.state
+			.import_resolver()
+			.as_any()
+			.downcast_ref::<VMImportResolver>()
+			.expect("valid resolver ty")
+			.inner
+			.borrow_mut() = tb!(resolver);
+	}
+	fn add_jpath(&self, path: PathBuf) {
+		self.state
+			.import_resolver()
+			.as_any()
+			.downcast_ref::<VMImportResolver>()
+			.expect("valid resolver ty")
+			.inner
+			.borrow_mut()
+			.as_any_mut()
+			.downcast_mut::<FileImportResolver>()
+			.expect("jpaths are not compatible with callback imports!")
+			.add_jpath(path);
+	}
+}
 
 /// Creates a new Jsonnet virtual machine.
 #[no_mangle]
 #[allow(clippy::box_default)]
 pub extern "C" fn jsonnet_make() -> *mut VM {
-	let state = State::default();
-	state.settings_mut().import_resolver = tb!(FileImportResolver::default());
-	state.settings_mut().context_initializer = tb!(jrsonnet_stdlib::ContextInitializer::new(
-		PathResolver::new_cwd_fallback(),
-	));
+	let mut state = State::builder();
+	state
+		.import_resolver(VMImportResolver::new(FileImportResolver::default()))
+		.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let state = state.build();
 	Box::into_raw(Box::new(VM {
 		state,
 		manifest_format: Box::new(JsonFormat::default()),