From 020afa68e92fbbb228362ed8a089344f6f60d0b9 Mon Sep 17 00:00:00 2001 From: Lach Date: Sun, 23 Aug 2020 00:23:19 +0000 Subject: [PATCH] feat: native callbacks --- --- 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; --- 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] --- /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()) + } + })), + ) +} --- 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!(), --- a/crates/jrsonnet-evaluator/src/error.rs +++ b/crates/jrsonnet-evaluator/src/error.rs @@ -33,6 +33,7 @@ FunctionParameterNotBoundInCall(Rc), UndefinedExternalVariable(Rc), + UndefinedExternalFunction(Rc), FieldMustBeStringGot(ValType), --- 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 { --- a/crates/jrsonnet-evaluator/src/integrations/serde.rs +++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs @@ -40,7 +40,7 @@ } Value::Object(out) } - Val::Func(_) | Val::Intristic(_, _) => { + Val::Func(_) | Val::Intristic(_, _) | Val::NativeExt(_, _) => { throw!(RuntimeError("tried to manifest function".into())) } }) --- 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, Val>, + /// Used for ext.native + pub ext_natives: HashMap, Rc>, /// TLA vars pub tla_vars: HashMap, 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, cb: Rc) { + 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(()) + } } --- /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 Result>, +} +impl NativeCallback { + pub fn new(params: ParamsDesc, handler: impl Fn(&[Val]) -> Result + 'static) -> Self { + Self { + params, + handler: Box::new(handler), + } + } + pub fn call(&self, args: &[Val]) -> Result { + (self.handler)(args) + } +} +impl Debug for NativeCallback { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("NativeCallback").finish() + } +} --- 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, Rc), + NativeExt(Rc, Rc), } 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 -- gitstuff