git.delta.rocks / jrsonnet / refs/commits / 2b4e36fe5944

1#[cfg(feature = "interop")]2pub mod interop;34pub mod import;5pub mod native;6pub mod val_extract;7pub mod val_make;8pub mod val_modify;9pub mod vars_tlas;1011use std::{12	alloc::Layout,13	borrow::Cow,14	ffi::{CStr, CString, OsStr},15	os::raw::{c_char, c_double, c_int, c_uint},16	path::Path,17};1819use jrsonnet_evaluator::{20	apply_tla,21	function::TlaArg,22	gc::GcHashMap,23	stack::set_stack_depth_limit,24	stdlib::manifest::{JsonFormat, ToStringFormat},25	tb, throw,26	trace::{CompactFormat, PathResolver, TraceFormat},27	FileImportResolver, IStr, ManifestFormat, Result, State, Val,28};2930/// WASM stub31#[cfg(target_arch = "wasm32")]32#[no_mangle]33pub extern "C" fn _start() {}3435/// Return the version string of the Jsonnet interpreter.36/// Conforms to [semantic versioning](http://semver.org/).37/// If this does not match `LIB_JSONNET_VERSION`38/// then there is a mismatch between header and compiled library.39#[no_mangle]40pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {41	b"v0.16.0\0"42}4344unsafe fn parse_path(input: &CStr) -> Cow<Path> {45	#[cfg(target_family = "unix")]46	{47		use std::os::unix::ffi::OsStrExt;48		let str = OsStr::from_bytes(input.to_bytes());49		Cow::Borrowed(Path::new(str))50	}51	#[cfg(not(target_family = "unix"))]52	{53		let string = input.to_str().expect("bad utf-8");54		Cow::Borrowed(string.as_ref())55	}56}5758unsafe fn unparse_path(input: &Path) -> Cow<CStr> {59	#[cfg(target_family = "unix")]60	{61		use std::os::unix::ffi::OsStrExt;62		let str = CString::new(input.as_os_str().as_bytes()).expect("input has zero byte in it");63		Cow::Owned(str)64	}65	#[cfg(not(target_family = "unix"))]66	{67		let str = input.as_os_str().to_str().expect("bad utf-8");68		let cstr = CString::new(str).expect("input has NUL inside");69		Cow::Owned(cstr)70	}71}7273pub struct VM {74	state: State,75	manifest_format: Box<dyn ManifestFormat>,76	trace_format: Box<dyn TraceFormat>,77	tla_args: GcHashMap<IStr, TlaArg>,78}7980/// Creates a new Jsonnet virtual machine.81#[no_mangle]82#[allow(clippy::box_default)]83pub extern "C" fn jsonnet_make() -> *mut VM {84	let state = State::default();85	state.settings_mut().import_resolver = tb!(FileImportResolver::default());86	state.settings_mut().context_initializer = tb!(jrsonnet_stdlib::ContextInitializer::new(87		state.clone(),88		PathResolver::new_cwd_fallback(),89	));90	Box::into_raw(Box::new(VM {91		state,92		manifest_format: Box::new(JsonFormat::default()),93		trace_format: Box::new(CompactFormat::default()),94		tla_args: GcHashMap::new(),95	}))96}9798/// Complement of [`jsonnet_vm_make`].99#[no_mangle]100#[allow(clippy::boxed_local)]101pub extern "C" fn jsonnet_destroy(vm: Box<VM>) {102	drop(vm);103}104105/// Set the maximum stack depth.106#[no_mangle]107pub extern "C" fn jsonnet_max_stack(_vm: &VM, v: c_uint) {108	set_stack_depth_limit(v as usize)109}110111/// Set the number of objects required before a garbage collection cycle is allowed.112///113/// No-op for now114#[no_mangle]115pub extern "C" fn jsonnet_gc_min_objects(_vm: &VM, _v: c_uint) {}116117/// Run the garbage collector after this amount of growth in the number of objects118///119/// No-op for now120#[no_mangle]121pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &VM, _v: c_double) {}122123/// Expect a string as output and don't JSON encode it.124#[no_mangle]125pub extern "C" fn jsonnet_string_output(vm: &mut VM, v: c_int) {126	vm.manifest_format = match v {127		0 => Box::new(JsonFormat::default()),128		1 => Box::new(ToStringFormat),129		_ => panic!("incorrect output format"),130	};131}132133/// Allocate, resize, or free a buffer.  This will abort if the memory cannot be allocated. It will134/// only return NULL if sz was zero.135///136/// # Safety137///138/// `buf` should be either previosly allocated by this library, or NULL139///140/// This function is most definitely broken, but it works somehow, see TODO inside141#[no_mangle]142pub unsafe extern "C" fn jsonnet_realloc(_vm: &VM, buf: *mut u8, sz: usize) -> *mut u8 {143	if buf.is_null() {144		if sz == 0 {145			return std::ptr::null_mut();146		}147		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());148	}149	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D150	// OR (Alternative way of fixing this TODO)151	// TODO: Standard allocator uses malloc, and it doesn't uses allocation size,152	// TODO: so it should work in normal cases. Maybe force allocator for this library?153	let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();154	if sz == 0 {155		std::alloc::dealloc(buf, old_layout);156		return std::ptr::null_mut();157	}158	std::alloc::realloc(buf, old_layout, sz)159}160161/// Clean up a JSON subtree.162///163/// This is useful if you want to abort with an error mid-way through building a complex value.164#[no_mangle]165#[allow(clippy::boxed_local)]166pub extern "C" fn jsonnet_json_destroy(_vm: &VM, v: Box<Val>) {167	drop(v);168}169170/// Set the number of lines of stack trace to display (0 for all of them).171#[no_mangle]172pub extern "C" fn jsonnet_max_trace(vm: &mut VM, v: c_uint) {173	if let Some(format) = vm.trace_format.as_any_mut().downcast_mut::<CompactFormat>() {174		format.max_trace = v as usize175	} else {176		panic!("max_trace is not supported by current tracing format")177	}178}179180/// Evaluate a file containing Jsonnet code, return a JSON string.181///182/// The returned string should be cleaned up with jsonnet_realloc.183///184/// # Safety185///186/// `filename` should be a NUL-terminated string187#[no_mangle]188pub unsafe extern "C" fn jsonnet_evaluate_file(189	vm: &VM,190	filename: *const c_char,191	error: &mut c_int,192) -> *const c_char {193	let filename = parse_path(CStr::from_ptr(filename));194	match vm195		.state196		.import(&filename)197		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))198		.and_then(|val| val.manifest(&vm.manifest_format))199	{200		Ok(v) => {201			*error = 0;202			CString::new(&*v as &str).unwrap().into_raw()203		}204		Err(e) => {205			*error = 1;206			let mut out = String::new();207			vm.trace_format.write_trace(&mut out, &e).unwrap();208			CString::new(&out as &str).unwrap().into_raw()209		}210	}211}212213/// Evaluate a string containing Jsonnet code, return a JSON string.214///215/// The returned string should be cleaned up with jsonnet_realloc.216///217/// # Safety218///219/// `filename`, `snippet` should be a NUL-terminated strings220#[no_mangle]221pub unsafe extern "C" fn jsonnet_evaluate_snippet(222	vm: &VM,223	filename: *const c_char,224	snippet: *const c_char,225	error: &mut c_int,226) -> *const c_char {227	let filename = CStr::from_ptr(filename);228	let snippet = CStr::from_ptr(snippet);229	match vm230		.state231		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())232		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))233		.and_then(|val| val.manifest(&vm.manifest_format))234	{235		Ok(v) => {236			*error = 0;237			CString::new(&*v as &str).unwrap().into_raw()238		}239		Err(e) => {240			*error = 1;241			let mut out = String::new();242			vm.trace_format.write_trace(&mut out, &e).unwrap();243			CString::new(&out as &str).unwrap().into_raw()244		}245	}246}247248fn val_to_multi(val: Val, format: &dyn ManifestFormat) -> Result<Vec<(IStr, IStr)>> {249	let Val::Obj(val) = val else {250		throw!("expected object as multi output")251	};252	let mut out = Vec::new();253	for (k, v) in val.iter(254		#[cfg(feature = "exp-preserve-order")]255		false,256	) {257		out.push((k, v?.manifest(format)?.into()));258	}259	Ok(out)260}261262fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {263	let mut out = Vec::new();264	for (i, (k, v)) in multi.iter().enumerate() {265		if i != 0 {266			out.push(0);267		}268		out.extend_from_slice(k.as_bytes());269		out.push(0);270		out.extend_from_slice(v.as_bytes());271	}272	out.push(0);273	out.push(0);274	let v = out.as_ptr();275	std::mem::forget(out);276	v as *const c_char277}278279/// # Safety280#[no_mangle]281pub unsafe extern "C" fn jsonnet_evaluate_file_multi(282	vm: &VM,283	filename: *const c_char,284	error: &mut c_int,285) -> *const c_char {286	let filename = parse_path(CStr::from_ptr(filename));287	match vm288		.state289		.import(&filename)290		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))291		.and_then(|val| val_to_multi(val, &vm.manifest_format))292	{293		Ok(v) => {294			*error = 0;295			multi_to_raw(v)296		}297		Err(e) => {298			*error = 1;299			let mut out = String::new();300			vm.trace_format.write_trace(&mut out, &e).unwrap();301			CString::new(&out as &str).unwrap().into_raw()302		}303	}304}305306/// # Safety307#[no_mangle]308pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(309	vm: &VM,310	filename: *const c_char,311	snippet: *const c_char,312	error: &mut c_int,313) -> *const c_char {314	let filename = CStr::from_ptr(filename);315	let snippet = CStr::from_ptr(snippet);316	match vm317		.state318		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())319		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))320		.and_then(|val| val_to_multi(val, &vm.manifest_format))321	{322		Ok(v) => {323			*error = 0;324			multi_to_raw(v)325		}326		Err(e) => {327			*error = 1;328			let mut out = String::new();329			vm.trace_format.write_trace(&mut out, &e).unwrap();330			CString::new(&out as &str).unwrap().into_raw()331		}332	}333}334335fn val_to_stream(val: Val, format: &dyn ManifestFormat) -> Result<Vec<IStr>> {336	let Val::Arr(val) = val else {337		throw!("expected array as stream output")338	};339	let mut out = Vec::new();340	for item in val.iter() {341		out.push(item?.manifest(format)?.into());342	}343	Ok(out)344}345346fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {347	let mut out = Vec::new();348	for (i, v) in multi.iter().enumerate() {349		if i != 0 {350			out.push(0);351		}352		out.extend_from_slice(v.as_bytes());353	}354	out.push(0);355	out.push(0);356	let v = out.as_ptr();357	std::mem::forget(out);358	v as *const c_char359}360361/// # Safety362#[no_mangle]363pub unsafe extern "C" fn jsonnet_evaluate_file_stream(364	vm: &VM,365	filename: *const c_char,366	error: &mut c_int,367) -> *const c_char {368	let filename = parse_path(CStr::from_ptr(filename));369	match vm370		.state371		.import(filename)372		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))373		.and_then(|val| val_to_stream(val, &vm.manifest_format))374	{375		Ok(v) => {376			*error = 0;377			stream_to_raw(v)378		}379		Err(e) => {380			*error = 1;381			let mut out = String::new();382			vm.trace_format.write_trace(&mut out, &e).unwrap();383			CString::new(&out as &str).unwrap().into_raw()384		}385	}386}387388/// # Safety389#[no_mangle]390pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(391	vm: &VM,392	filename: *const c_char,393	snippet: *const c_char,394	error: &mut c_int,395) -> *const c_char {396	let filename = CStr::from_ptr(filename);397	let snippet = CStr::from_ptr(snippet);398	match vm399		.state400		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())401		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))402		.and_then(|val| val_to_stream(val, &vm.manifest_format))403	{404		Ok(v) => {405			*error = 0;406			stream_to_raw(v)407		}408		Err(e) => {409			*error = 1;410			let mut out = String::new();411			vm.trace_format.write_trace(&mut out, &e).unwrap();412			CString::new(&out as &str).unwrap().into_raw()413		}414	}415}