difftreelog
feat native callbacks
in: master
10 files changed
bindings/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;
bindings/jsonnet/src/lib.rsdiffbeforeafterboth1pub mod import;2pub mod interop;3pub mod val_extract;4pub mod val_make;5pub mod val_modify;6pub mod vars_tlas;78use import::NativeImportResolver;9use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Val};10use std::{11 alloc::Layout,12 ffi::{CStr, CString},13 os::raw::{c_char, c_double, c_int, c_uint},14 path::PathBuf,15 rc::Rc,16};1718/// WASM stub19#[cfg(target_arch = "wasm32")]20#[no_mangle]21pub extern "C" fn _start() {}2223#[no_mangle]24pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {25 b"v0.16.0\0"26}2728#[no_mangle]29pub extern "C" fn jsonnet_make() -> *mut EvaluationState {30 let state = EvaluationState::default();31 state.with_stdlib();32 state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());33 Box::into_raw(Box::new(state))34}3536/// # Safety37#[no_mangle]38#[allow(clippy::boxed_local)]39pub unsafe extern "C" fn jsonnet_destroy(vm: *mut EvaluationState) {40 Box::from_raw(vm);41}4243#[no_mangle]44pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {45 vm.settings_mut().max_stack = v as usize;46}4748// jrsonnet currently have no GC, so these functions is no-op49#[no_mangle]50pub extern "C" fn jsonnet_gc_min_objects(_vm: &EvaluationState, _v: c_uint) {}51#[no_mangle]52pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &EvaluationState, _v: c_double) {}5354#[no_mangle]55pub extern "C" fn jsonnet_string_output(vm: &EvaluationState, v: c_int) {56 match v {57 1 => vm.set_manifest_format(ManifestFormat::String),58 0 => vm.set_manifest_format(ManifestFormat::Json(4)),59 _ => panic!("incorrect output format"),60 }61}6263/// # Safety64///65/// This function is most definitely broken, but it works somehow, see TODO inside66#[no_mangle]67pub unsafe extern "C" fn jsonnet_realloc(68 _vm: &EvaluationState,69 buf: *mut u8,70 sz: usize,71) -> *mut u8 {72 if buf.is_null() {73 assert!(sz != 0);74 return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());75 }76 // TODO: Somehow store size of allocation, because its real size is probally not 16 :D77 // OR (Alternative way of fixing this TODO)78 // TODO: Standard allocator uses malloc, and it doesn't uses allocation size,79 // TODO: so it should work in normal cases. Maybe force allocator for this library?80 let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();81 if sz == 0 {82 std::alloc::dealloc(buf, old_layout);83 return std::ptr::null_mut();84 }85 std::alloc::realloc(buf, old_layout, sz)86}8788/// # Safety89#[no_mangle]90#[allow(clippy::boxed_local)]91pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &EvaluationState, v: *mut Val) {92 Box::from_raw(v);93}9495#[no_mangle]96pub extern "C" fn jsonnet_native_callback() {97 todo!()98}99100#[no_mangle]101pub extern "C" fn jsonnet_max_trace(vm: &EvaluationState, v: c_uint) {102 vm.set_max_trace(v as usize)103}104105/// # Safety106///107/// This function is safe, if received v is a pointer to normal C string108#[no_mangle]109pub unsafe extern "C" fn jsonnet_evaluate_file(110 vm: &EvaluationState,111 filename: *const c_char,112 error: &mut c_int,113) -> *const c_char {114 vm.run_in_state(|| {115 let filename = CStr::from_ptr(filename);116 match vm117 .evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))118 .and_then(|v| vm.with_tla(v))119 .and_then(|v| vm.manifest(v))120 {121 Ok(v) => {122 *error = 0;123 CString::new(&*v as &str).unwrap().into_raw()124 }125 Err(e) => {126 *error = 1;127 let out = vm.stringify_err(&e);128 CString::new(&out as &str).unwrap().into_raw()129 }130 }131 })132}133134/// # Safety135///136/// This function is safe, if received v is a pointer to normal C string137#[no_mangle]138pub unsafe extern "C" fn jsonnet_evaluate_snippet(139 vm: &EvaluationState,140 filename: *const c_char,141 snippet: *const c_char,142 error: &mut c_int,143) -> *const c_char {144 vm.run_in_state(|| {145 let filename = CStr::from_ptr(filename);146 let snippet = CStr::from_ptr(snippet);147 match vm148 .evaluate_snippet_raw(149 Rc::new(PathBuf::from(filename.to_str().unwrap())),150 snippet.to_str().unwrap().into(),151 )152 .and_then(|v| vm.with_tla(v))153 .and_then(|v| vm.manifest(v))154 {155 Ok(v) => {156 *error = 0;157 CString::new(&*v as &str).unwrap().into_raw()158 }159 Err(e) => {160 *error = 1;161 let out = vm.stringify_err(&e);162 CString::new(&out as &str).unwrap().into_raw()163 }164 }165 })166}167168#[no_mangle]169pub extern "C" fn jsonnet_evaluate_file_multi() {170 todo!()171}172#[no_mangle]173pub extern "C" fn jsonnet_evaluate_snippet_multi() {174 todo!()175}176#[no_mangle]177pub extern "C" fn jsonnet_evaluate_file_stream() {178 todo!()179}180#[no_mangle]181pub extern "C" fn jsonnet_evaluate_snippet_stream() {182 todo!()183}1pub mod import;2pub mod interop;3pub mod native;4pub mod val_extract;5pub mod val_make;6pub mod val_modify;7pub mod vars_tlas;89use import::NativeImportResolver;10use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Val};11use std::{12 alloc::Layout,13 ffi::{CStr, CString},14 os::raw::{c_char, c_double, c_int, c_uint},15 path::PathBuf,16 rc::Rc,17};1819/// WASM stub20#[cfg(target_arch = "wasm32")]21#[no_mangle]22pub extern "C" fn _start() {}2324#[no_mangle]25pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {26 b"v0.16.0\0"27}2829#[no_mangle]30pub extern "C" fn jsonnet_make() -> *mut EvaluationState {31 let state = EvaluationState::default();32 state.with_stdlib();33 state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());34 Box::into_raw(Box::new(state))35}3637/// # Safety38#[no_mangle]39#[allow(clippy::boxed_local)]40pub unsafe extern "C" fn jsonnet_destroy(vm: *mut EvaluationState) {41 Box::from_raw(vm);42}4344#[no_mangle]45pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {46 vm.settings_mut().max_stack = v as usize;47}4849// jrsonnet currently have no GC, so these functions is no-op50#[no_mangle]51pub extern "C" fn jsonnet_gc_min_objects(_vm: &EvaluationState, _v: c_uint) {}52#[no_mangle]53pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &EvaluationState, _v: c_double) {}5455#[no_mangle]56pub extern "C" fn jsonnet_string_output(vm: &EvaluationState, v: c_int) {57 match v {58 1 => vm.set_manifest_format(ManifestFormat::String),59 0 => vm.set_manifest_format(ManifestFormat::Json(4)),60 _ => panic!("incorrect output format"),61 }62}6364/// # Safety65///66/// This function is most definitely broken, but it works somehow, see TODO inside67#[no_mangle]68pub unsafe extern "C" fn jsonnet_realloc(69 _vm: &EvaluationState,70 buf: *mut u8,71 sz: usize,72) -> *mut u8 {73 if buf.is_null() {74 assert!(sz != 0);75 return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());76 }77 // TODO: Somehow store size of allocation, because its real size is probally not 16 :D78 // OR (Alternative way of fixing this TODO)79 // TODO: Standard allocator uses malloc, and it doesn't uses allocation size,80 // TODO: so it should work in normal cases. Maybe force allocator for this library?81 let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();82 if sz == 0 {83 std::alloc::dealloc(buf, old_layout);84 return std::ptr::null_mut();85 }86 std::alloc::realloc(buf, old_layout, sz)87}8889/// # Safety90#[no_mangle]91#[allow(clippy::boxed_local)]92pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &EvaluationState, v: *mut Val) {93 Box::from_raw(v);94}9596#[no_mangle]97pub extern "C" fn jsonnet_max_trace(vm: &EvaluationState, v: c_uint) {98 vm.set_max_trace(v as usize)99}100101/// # Safety102///103/// This function is safe, if received v is a pointer to normal C string104#[no_mangle]105pub unsafe extern "C" fn jsonnet_evaluate_file(106 vm: &EvaluationState,107 filename: *const c_char,108 error: &mut c_int,109) -> *const c_char {110 vm.run_in_state(|| {111 let filename = CStr::from_ptr(filename);112 match vm113 .evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))114 .and_then(|v| vm.with_tla(v))115 .and_then(|v| vm.manifest(v))116 {117 Ok(v) => {118 *error = 0;119 CString::new(&*v as &str).unwrap().into_raw()120 }121 Err(e) => {122 *error = 1;123 let out = vm.stringify_err(&e);124 CString::new(&out as &str).unwrap().into_raw()125 }126 }127 })128}129130/// # Safety131///132/// This function is safe, if received v is a pointer to normal C string133#[no_mangle]134pub unsafe extern "C" fn jsonnet_evaluate_snippet(135 vm: &EvaluationState,136 filename: *const c_char,137 snippet: *const c_char,138 error: &mut c_int,139) -> *const c_char {140 vm.run_in_state(|| {141 let filename = CStr::from_ptr(filename);142 let snippet = CStr::from_ptr(snippet);143 match vm144 .evaluate_snippet_raw(145 Rc::new(PathBuf::from(filename.to_str().unwrap())),146 snippet.to_str().unwrap().into(),147 )148 .and_then(|v| vm.with_tla(v))149 .and_then(|v| vm.manifest(v))150 {151 Ok(v) => {152 *error = 0;153 CString::new(&*v as &str).unwrap().into_raw()154 }155 Err(e) => {156 *error = 1;157 let out = vm.stringify_err(&e);158 CString::new(&out as &str).unwrap().into_raw()159 }160 }161 })162}163164#[no_mangle]165pub extern "C" fn jsonnet_evaluate_file_multi() {166 todo!()167}168#[no_mangle]169pub extern "C" fn jsonnet_evaluate_snippet_multi() {170 todo!()171}172#[no_mangle]173pub extern "C" fn jsonnet_evaluate_file_stream() {174 todo!()175}176#[no_mangle]177pub extern "C" fn jsonnet_evaluate_snippet_stream() {178 todo!()179}bindings/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())
+ }
+ })),
+ )
+}
crates/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!(),
crates/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),
crates/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 {
crates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth--- 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()))
}
})
crates/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(())
+ }
}
crates/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()
+ }
+}
crates/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