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

--- /dev/null
+++ b/bindings/c/.gitignore
@@ -0,0 +1 @@
+libjsonnet_test_file

--- /dev/null
+++ b/bindings/jsonnet/src/interop.rs
@@ -0,0 +1,36 @@
+//! Jrsonnet specific additional binding helpers
+
+use crate::import::jsonnet_import_callback;
+use jrsonnet_evaluator::EvaluationState;
+use std::{
+	ffi::c_void,
+	os::raw::{c_char, c_int},
+};
+
+extern "C" {
+	pub fn _jrsonnet_static_import_callback(
+		ctx: *mut c_void,
+		base: *const c_char,
+		rel: *const c_char,
+		found_here: *mut *const c_char,
+		success: &mut c_int,
+	) -> *const c_char;
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(
+	vm: &EvaluationState,
+	ctx: *mut c_void,
+) {
+	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)
+}
+
+#[no_mangle]
+pub extern "C" fn jrsonnet_set_trace_format(vm: &EvaluationState, format: u8) {
+	use jrsonnet_evaluator::trace::JSFormat;
+	match format {
+		1 => vm.set_trace_format(Box::new(JSFormat)),
+		_ => panic!("unknown trace format"),
+	}
+}

--- /dev/null
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -0,0 +1,45 @@
+//! Extract values from VM
+
+use jrsonnet_evaluator::{EvaluationState, Val};
+
+use std::{
+	ffi::CString,
+	os::raw::{c_char, c_double, c_int},
+};
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {
+	match v.unwrap_if_lazy().unwrap() {
+		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
+		_ => std::ptr::null_mut(),
+	}
+}
+#[no_mangle]
+pub extern "C" fn jsonnet_json_extract_number(
+	_vm: &EvaluationState,
+	v: &Val,
+	out: &mut c_double,
+) -> c_int {
+	match v.unwrap_if_lazy().unwrap() {
+		Val::Num(n) => {
+			*out = n;
+			1
+		}
+		_ => 0,
+	}
+}
+#[no_mangle]
+pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {
+	match v.unwrap_if_lazy().unwrap() {
+		Val::Bool(false) => 0,
+		Val::Bool(true) => 1,
+		_ => 2,
+	}
+}
+#[no_mangle]
+pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {
+	match v.unwrap_if_lazy().unwrap() {
+		Val::Null => 1,
+		_ => 0,
+	}
+}

--- /dev/null
+++ b/bindings/jsonnet/src/val_make.rs
@@ -0,0 +1,47 @@
+//! Create values in VM
+
+use jrsonnet_evaluator::{EvaluationState, ObjValue, Val};
+use std::{
+	ffi::CStr,
+	os::raw::{c_char, c_double, c_int},
+	rc::Rc,
+};
+
+/// # Safety
+///
+/// This function is safe, if received v is a pointer to normal C string
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_json_make_string(
+	_vm: &EvaluationState,
+	v: *const c_char,
+) -> *mut Val {
+	let cstr = CStr::from_ptr(v);
+	let str = cstr.to_str().unwrap();
+	Box::into_raw(Box::new(Val::Str(str.into())))
+}
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_make_number(_vm: &EvaluationState, v: c_double) -> *mut Val {
+	Box::into_raw(Box::new(Val::Num(v)))
+}
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_make_bool(_vm: &EvaluationState, v: c_int) -> *mut Val {
+	assert!(v == 0 || v == 1);
+	Box::into_raw(Box::new(Val::Bool(v == 1)))
+}
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_make_null(_vm: &EvaluationState) -> *mut Val {
+	Box::into_raw(Box::new(Val::Null))
+}
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {
+	Box::into_raw(Box::new(Val::Arr(Rc::new(Vec::new()))))
+}
+
+#[no_mangle]
+pub extern "C" fn jsonnet_json_make_object(_vm: &EvaluationState) -> *mut Val {
+	Box::into_raw(Box::new(Val::Obj(ObjValue::new_empty())))
+}

--- /dev/null
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -0,0 +1,55 @@
+//! Modify VM values
+//! Only tested with variables, which haven't altered by code before appearing here
+//! In jrsonnet every value is immutable, and this code is probally broken
+
+use jrsonnet_evaluator::{EvaluationState, LazyBinding, LazyVal, ObjMember, ObjValue, Val};
+use jrsonnet_parser::Visibility;
+use std::{collections::HashMap, ffi::CStr, os::raw::c_char, rc::Rc};
+
+/// # Safety
+///
+/// Received arr value should be correct pointer to array allocated by make_array
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_json_array_append(
+	_vm: &EvaluationState,
+	arr: *mut Val,
+	val: &Val,
+) {
+	match *Box::from_raw(arr) {
+		Val::Arr(old) => {
+			let mut new = Rc::try_unwrap(old).expect("arr with no refs");
+			new.push(val.clone());
+			*arr = Val::Arr(Rc::new(new));
+		}
+		_ => panic!("should receive array"),
+	}
+}
+
+/// # Safety
+///
+/// This function is safe if passed name is ok
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_json_object_append(
+	_vm: &EvaluationState,
+	obj: &mut Val,
+	name: *const c_char,
+	val: &Val,
+) {
+	match obj {
+		Val::Obj(old) => {
+			let mut new = HashMap::new();
+			new.insert(
+				CStr::from_ptr(name).to_str().unwrap().into(),
+				ObjMember {
+					add: false,
+					visibility: Visibility::Normal,
+					invoke: LazyBinding::Bound(LazyVal::new_resolved(val.clone())),
+					location: None,
+				},
+			);
+			let new_obj = ObjValue::new(Some(old.clone()), Rc::new(new));
+			*obj = Val::Obj(new_obj);
+		}
+		_ => panic!("should receive object"),
+	}
+}

--- /dev/null
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -0,0 +1,64 @@
+//! Manipulate external variables and top level arguments
+
+use jrsonnet_evaluator::EvaluationState;
+use std::{ffi::CStr, os::raw::c_char};
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_ext_var(
+	vm: &EvaluationState,
+	name: *const c_char,
+	value: *const c_char,
+) {
+	let name = CStr::from_ptr(name);
+	let value = CStr::from_ptr(value);
+	vm.add_ext_str(
+		name.to_str().unwrap().into(),
+		value.to_str().unwrap().into(),
+	)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_ext_code(
+	vm: &EvaluationState,
+	name: *const c_char,
+	value: *const c_char,
+) {
+	let name = CStr::from_ptr(name);
+	let value = CStr::from_ptr(value);
+	vm.add_ext_code(
+		name.to_str().unwrap().into(),
+		value.to_str().unwrap().into(),
+	)
+	.unwrap()
+}
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_tla_var(
+	vm: &EvaluationState,
+	name: *const c_char,
+	value: *const c_char,
+) {
+	let name = CStr::from_ptr(name);
+	let value = CStr::from_ptr(value);
+	vm.add_tla_str(
+		name.to_str().unwrap().into(),
+		value.to_str().unwrap().into(),
+	)
+}
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn jsonnet_tla_code(
+	vm: &EvaluationState,
+	name: *const c_char,
+	value: *const c_char,
+) {
+	let name = CStr::from_ptr(name);
+	let value = CStr::from_ptr(value);
+	vm.add_tla_code(
+		name.to_str().unwrap().into(),
+		value.to_str().unwrap().into(),
+	)
+	.unwrap()
+}