git.delta.rocks / jrsonnet / refs/commits / 020afa68e92f

difftreelog

feat native callbacks

Lach2020-08-23parent: #1feb056.patch.diff
in: master

10 files changed

modifiedbindings/jsonnet/src/interop.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/interop.rs
+++ b/bindings/jsonnet/src/interop.rs
@@ -1,7 +1,7 @@
 //! Jrsonnet specific additional binding helpers
 
-use crate::import::jsonnet_import_callback;
-use jrsonnet_evaluator::EvaluationState;
+use crate::{import::jsonnet_import_callback, native::jsonnet_native_callback};
+use jrsonnet_evaluator::{EvaluationState, Val};
 use std::{
 	ffi::c_void,
 	os::raw::{c_char, c_int},
@@ -15,6 +15,13 @@
 		found_here: *mut *const c_char,
 		success: &mut c_int,
 	) -> *const c_char;
+
+	#[allow(improper_ctypes)]
+	pub fn _jrsonnet_static_native_callback(
+		ctx: *const c_void,
+		argv: *const *const Val,
+		success: *mut c_int,
+	) -> *mut Val;
 }
 
 /// # Safety
@@ -26,6 +33,17 @@
 	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)
 }
 
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(
+	vm: &EvaluationState,
+	name: *const c_char,
+	ctx: *mut c_void,
+	raw_params: *const *const c_char,
+) {
+	jsonnet_native_callback(vm, name, _jrsonnet_static_native_callback, ctx, raw_params)
+}
+
 #[no_mangle]
 pub extern "C" fn jrsonnet_set_trace_format(vm: &EvaluationState, format: u8) {
 	use jrsonnet_evaluator::trace::JSFormat;
modifiedbindings/jsonnet/src/lib.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod import;
 pub mod interop;
+pub mod native;
 pub mod val_extract;
 pub mod val_make;
 pub mod val_modify;
@@ -90,11 +91,6 @@
 #[allow(clippy::boxed_local)]
 pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &EvaluationState, v: *mut Val) {
 	Box::from_raw(v);
-}
-
-#[no_mangle]
-pub extern "C" fn jsonnet_native_callback() {
-	todo!()
 }
 
 #[no_mangle]
addedbindings/jsonnet/src/native.rsdiffbeforeafterboth
--- /dev/null
+++ b/bindings/jsonnet/src/native.rs
@@ -0,0 +1,55 @@
+use jrsonnet_evaluator::{error::Error, native::NativeCallback, EvaluationState, Val};
+use jrsonnet_parser::{Param, ParamsDesc};
+use std::{
+	ffi::{c_void, CStr},
+	os::raw::{c_char, c_int},
+	rc::Rc,
+};
+
+type JsonnetNativeCallback = unsafe extern "C" fn(
+	ctx: *const c_void,
+	argv: *const *const Val,
+	success: *mut c_int,
+) -> *mut Val;
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_native_callback(
+	vm: &EvaluationState,
+	name: *const c_char,
+	cb: JsonnetNativeCallback,
+	ctx: *const c_void,
+	mut raw_params: *const *const c_char,
+) {
+	let name = CStr::from_ptr(name).to_str().expect("utf8 name").into();
+	let mut params = Vec::new();
+	loop {
+		if (*raw_params).is_null() {
+			break;
+		}
+		let param = CStr::from_ptr(*raw_params).to_str().expect("not utf8");
+		params.push(Param(param.into(), None));
+		raw_params = raw_params.offset(1);
+	}
+	let params = ParamsDesc(Rc::new(params));
+
+	vm.add_native(
+		name,
+		Rc::new(NativeCallback::new(params, move |args| {
+			let mut n_args = Vec::new();
+			for a in args {
+				n_args.push(Some(Box::new(a.clone())));
+			}
+			n_args.push(None);
+			let mut success = 1;
+			let v = cb(ctx, &n_args as *const _ as *const *const Val, &mut success);
+			let v = *Box::from_raw(v);
+			if success == 1 {
+				Ok(v)
+			} else {
+				let e = v.try_cast_str("native error").expect("error msg");
+				Err(Error::RuntimeError(e).into())
+			}
+		})),
+	)
+}
modifiedcrates/jrsonnet-evaluator/src/builtin/manifest.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -117,7 +117,7 @@
 			}
 			buf.push('}');
 		}
-		Val::Func(_) | Val::Intristic(_, _) => {
+		Val::Func(_) | Val::Intristic(_, _) | Val::NativeExt(_, _) => {
 			throw!(RuntimeError("tried to manifest function".into()))
 		}
 		Val::Lazy(_) => unreachable!(),
modifiedcrates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -33,6 +33,7 @@
 	FunctionParameterNotBoundInCall(Rc<str>),
 
 	UndefinedExternalVariable(Rc<str>),
+	UndefinedExternalFunction(Rc<str>),
 
 	FieldMustBeStringGot(ValType),
modifiedcrates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -5,9 +5,9 @@
 	},
 	context_creator, equals,
 	error::Error::*,
-	future_wrapper, lazy_val, parse_args, primitive_equals, push, throw, with_state, Context,
-	ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError, ObjMember, ObjValue, Result, Val,
-	ValType,
+	future_wrapper, lazy_val, parse_args, parse_function_call, primitive_equals, push, throw,
+	with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError, ObjMember,
+	ObjValue, Result, Val, ValType,
 };
 use closure::closure;
 use jrsonnet_parser::{
@@ -549,13 +549,20 @@
 					], {
 						Ok(Val::Num(x.powf(n)))
 					})?,
-					("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [
+					("std", "extVar") => parse_args!(context, "std.extVar", args, 1, [
 						0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
 					], {
 						Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(
 							|| UndefinedExternalVariable(x),
 						)?)
 					})?,
+					("std", "native") => parse_args!(context, "std.native", args, 1, [
+						0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
+					], {
+						Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::NativeExt(x.clone(), v)).ok_or_else(
+							|| UndefinedExternalFunction(x),
+						)?)
+					})?,
 					("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [
 						0, func: [Val::Func]!!Val::Func, vec![ValType::Func];
 						1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];
@@ -780,6 +787,18 @@
 				})
 			},
 		)?,
+		Val::NativeExt(n, f) => push(
+			loc,
+			|| format!("native <{}> call", n),
+			|| {
+				let args = parse_function_call(context, None, &f.params, args, true)?;
+				let mut out_args = Vec::with_capacity(f.params.len());
+				for p in f.params.0.iter() {
+					out_args.push(args.binding(p.0.clone())?.evaluate()?);
+				}
+				Ok(f.call(&out_args)?)
+			},
+		)?,
 		Val::Func(f) => {
 			let body = || f.evaluate(context, args, tailstrict);
 			if tailstrict {
modifiedcrates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth
40				}40				}
41				Value::Object(out)41				Value::Object(out)
42			}42			}
43			Val::Func(_) | Val::Intristic(_, _) => {43			Val::Func(_) | Val::Intristic(_, _) | Val::NativeExt(_, _) => {
44				throw!(RuntimeError("tried to manifest function".into()))44				throw!(RuntimeError("tried to manifest function".into()))
45			}45			}
46		})46		})
modifiedcrates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -10,6 +10,7 @@
 mod import;
 mod integrations;
 mod map;
+pub mod native;
 mod obj;
 pub mod trace;
 mod val;
@@ -21,6 +22,7 @@
 pub use function::parse_function_call;
 pub use import::*;
 use jrsonnet_parser::*;
+use native::NativeCallback;
 pub use obj::*;
 use std::{
 	cell::{Ref, RefCell, RefMut},
@@ -60,6 +62,8 @@
 	pub max_trace: usize,
 	/// Used for std.extVar
 	pub ext_vars: HashMap<Rc<str>, Val>,
+	/// Used for ext.native
+	pub ext_natives: HashMap<Rc<str>, Rc<NativeCallback>>,
 	/// TLA vars
 	pub tla_vars: HashMap<Rc<str>, Val>,
 	/// Global variables are inserted in default context
@@ -78,6 +82,7 @@
 			max_trace: 20,
 			globals: Default::default(),
 			ext_vars: Default::default(),
+			ext_natives: Default::default(),
 			tla_vars: Default::default(),
 			import_resolver: Box::new(DummyImportResolver),
 			manifest_format: ManifestFormat::Json(4),
@@ -415,6 +420,10 @@
 		self.settings_mut().import_resolver = resolver;
 	}
 
+	pub fn add_native(&self, name: Rc<str>, cb: Rc<NativeCallback>) {
+		self.settings_mut().ext_natives.insert(name, cb);
+	}
+
 	pub fn manifest_format(&self) -> ManifestFormat {
 		self.settings().manifest_format.clone()
 	}
@@ -850,4 +859,30 @@
 		);
 		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")
 	}
+
+	#[test]
+	fn native_ext() -> crate::error::Result<()> {
+		use super::native::NativeCallback;
+		let evaluator = EvaluationState::default();
+
+		evaluator.with_stdlib();
+		evaluator.settings_mut().ext_natives.insert(
+			"native_add".into(),
+			Rc::new(NativeCallback::new(
+				ParamsDesc(Rc::new(vec![
+					Param("a".into(), None),
+					Param("b".into(), None),
+				])),
+				|args| match (&args[0], &args[1]) {
+					(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),
+					(_, _) => todo!(),
+				},
+			)),
+		);
+		evaluator.evaluate_snippet_raw(
+			Rc::new(PathBuf::from("test.jsonnet")),
+			"std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),
+		)?;
+		Ok(())
+	}
 }
addedcrates/jrsonnet-evaluator/src/native.rsdiffbeforeafterboth
--- /dev/null
+++ b/crates/jrsonnet-evaluator/src/native.rs
@@ -0,0 +1,24 @@
+use crate::{error::Result, Val};
+use jrsonnet_parser::ParamsDesc;
+use std::fmt::Debug;
+
+pub struct NativeCallback {
+	pub params: ParamsDesc,
+	handler: Box<dyn Fn(&[Val]) -> Result<Val>>,
+}
+impl NativeCallback {
+	pub fn new(params: ParamsDesc, handler: impl Fn(&[Val]) -> Result<Val> + 'static) -> Self {
+		Self {
+			params,
+			handler: Box::new(handler),
+		}
+	}
+	pub fn call(&self, args: &[Val]) -> Result<Val> {
+		(self.handler)(args)
+	}
+}
+impl Debug for NativeCallback {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("NativeCallback").finish()
+	}
+}
modifiedcrates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -3,6 +3,7 @@
 	error::Error::*,
 	evaluate,
 	function::{parse_function_call, parse_function_call_map, place_args},
+	native::NativeCallback,
 	throw, with_state, Context, ObjValue, Result,
 };
 use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};
@@ -152,6 +153,7 @@
 
 	// Library functions implemented in native
 	Intristic(Rc<str>, Rc<str>),
+	NativeExt(Rc<str>, Rc<NativeCallback>),
 }
 macro_rules! matches_unwrap {
 	($e: expr, $p: pat, $r: expr) => {
@@ -204,10 +206,9 @@
 			Val::Num(..) => ValType::Num,
 			Val::Arr(..) => ValType::Arr,
 			Val::Obj(..) => ValType::Obj,
-			Val::Func(..) => ValType::Func,
 			Val::Bool(_) => ValType::Bool,
 			Val::Null => ValType::Null,
-			Val::Intristic(_, _) => ValType::Func,
+			Val::Func(..) | Val::Intristic(_, _) | Val::NativeExt(_, _) => ValType::Func,
 			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
 		})
 	}
@@ -343,7 +344,7 @@
 }
 
 fn is_function_like(val: &Val) -> bool {
-	matches!(val, Val::Func(_) | Val::Intristic(_, _))
+	matches!(val, Val::Func(_) | Val::Intristic(_, _) | Val::NativeExt(_, _))
 }
 
 /// Implements std.primitiveEquals builtin