git.delta.rocks / jrsonnet / refs/commits / 83c939e4fa0b

1#![allow(clippy::box_default)]23#[cfg(feature = "interop")]4pub mod interop;56pub mod import;7pub mod native;8pub mod val_extract;9pub mod val_make;10pub mod val_modify;11pub mod vars_tlas;1213use std::{14	alloc::Layout,15	borrow::Cow,16	ffi::{CStr, CString, OsStr},17	os::raw::{c_char, c_double, c_int, c_uint},18	path::Path,19};2021use jrsonnet_evaluator::{22	apply_tla,23	function::TlaArg,24	gc::GcHashMap,25	manifest::{JsonFormat, ManifestFormat, ToStringFormat},26	stack::set_stack_depth_limit,27	tb, throw,28	trace::{CompactFormat, PathResolver, TraceFormat},29	FileImportResolver, IStr, Result, State, Val,30};3132/// WASM stub33#[cfg(target_arch = "wasm32")]34#[no_mangle]35pub extern "C" fn _start() {}3637/// Return the version string of the Jsonnet interpreter.38/// Conforms to [semantic versioning](http://semver.org/).39/// If this does not match `LIB_JSONNET_VERSION`40/// then there is a mismatch between header and compiled library.41#[no_mangle]42pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {43	b"v0.19.1\0"44}4546unsafe fn parse_path(input: &CStr) -> Cow<Path> {47	#[cfg(target_family = "unix")]48	{49		use std::os::unix::ffi::OsStrExt;50		let str = OsStr::from_bytes(input.to_bytes());51		Cow::Borrowed(Path::new(str))52	}53	#[cfg(not(target_family = "unix"))]54	{55		let string = input.to_str().expect("bad utf-8");56		Cow::Borrowed(string.as_ref())57	}58}5960unsafe fn unparse_path(input: &Path) -> Cow<CStr> {61	#[cfg(target_family = "unix")]62	{63		use std::os::unix::ffi::OsStrExt;64		let str = CString::new(input.as_os_str().as_bytes()).expect("input has zero byte in it");65		Cow::Owned(str)66	}67	#[cfg(not(target_family = "unix"))]68	{69		let str = input.as_os_str().to_str().expect("bad utf-8");70		let cstr = CString::new(str).expect("input has NUL inside");71		Cow::Owned(cstr)72	}73}7475pub struct VM {76	state: State,77	manifest_format: Box<dyn ManifestFormat>,78	trace_format: Box<dyn TraceFormat>,79	tla_args: GcHashMap<IStr, TlaArg>,80}8182/// Creates a new Jsonnet virtual machine.83#[no_mangle]84#[allow(clippy::box_default)]85pub extern "C" fn jsonnet_make() -> *mut VM {86	let state = State::default();87	state.settings_mut().import_resolver = tb!(FileImportResolver::default());88	state.settings_mut().context_initializer = tb!(jrsonnet_stdlib::ContextInitializer::new(89		state.clone(),90		PathResolver::new_cwd_fallback(),91	));92	Box::into_raw(Box::new(VM {93		state,94		manifest_format: Box::new(JsonFormat::default()),95		trace_format: Box::new(CompactFormat::default()),96		tla_args: GcHashMap::new(),97	}))98}99100/// Complement of [`jsonnet_vm_make`].101#[no_mangle]102#[allow(clippy::boxed_local)]103pub extern "C" fn jsonnet_destroy(vm: Box<VM>) {104	drop(vm);105}106107/// Set the maximum stack depth.108#[no_mangle]109pub extern "C" fn jsonnet_max_stack(_vm: &VM, v: c_uint) {110	set_stack_depth_limit(v as usize)111}112113/// Set the number of objects required before a garbage collection cycle is allowed.114///115/// No-op for now116#[no_mangle]117pub extern "C" fn jsonnet_gc_min_objects(_vm: &VM, _v: c_uint) {}118119/// Run the garbage collector after this amount of growth in the number of objects120///121/// No-op for now122#[no_mangle]123pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &VM, _v: c_double) {}124125/// Expect a string as output and don't JSON encode it.126#[no_mangle]127pub extern "C" fn jsonnet_string_output(vm: &mut VM, v: c_int) {128	vm.manifest_format = match v {129		0 => Box::new(JsonFormat::default()),130		1 => Box::new(ToStringFormat),131		_ => panic!("incorrect output format"),132	};133}134135/// Allocate, resize, or free a buffer.  This will abort if the memory cannot be allocated. It will136/// only return NULL if sz was zero.137///138/// # Safety139///140/// `buf` should be either previosly allocated by this library, or NULL141///142/// This function is most definitely broken, but it works somehow, see TODO inside143#[no_mangle]144pub unsafe extern "C" fn jsonnet_realloc(_vm: &VM, buf: *mut u8, sz: usize) -> *mut u8 {145	if buf.is_null() {146		if sz == 0 {147			return std::ptr::null_mut();148		}149		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());150	}151	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D152	// OR (Alternative way of fixing this TODO)153	// TODO: Standard allocator uses malloc, and it doesn't uses allocation size,154	// TODO: so it should work in normal cases. Maybe force allocator for this library?155	let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();156	if sz == 0 {157		std::alloc::dealloc(buf, old_layout);158		return std::ptr::null_mut();159	}160	std::alloc::realloc(buf, old_layout, sz)161}162163/// Clean up a JSON subtree.164///165/// This is useful if you want to abort with an error mid-way through building a complex value.166#[no_mangle]167#[allow(clippy::boxed_local)]168pub extern "C" fn jsonnet_json_destroy(_vm: &VM, v: Box<Val>) {169	drop(v);170}171172/// Set the number of lines of stack trace to display (0 for all of them).173#[no_mangle]174pub extern "C" fn jsonnet_max_trace(vm: &mut VM, v: c_uint) {175	if let Some(format) = vm.trace_format.as_any_mut().downcast_mut::<CompactFormat>() {176		format.max_trace = v as usize177	} else {178		panic!("max_trace is not supported by current tracing format")179	}180}181182/// Evaluate a file containing Jsonnet code, return a JSON string.183///184/// The returned string should be cleaned up with jsonnet_realloc.185///186/// # Safety187///188/// `filename` should be a NUL-terminated string189#[no_mangle]190pub unsafe extern "C" fn jsonnet_evaluate_file(191	vm: &VM,192	filename: *const c_char,193	error: &mut c_int,194) -> *const c_char {195	let filename = parse_path(CStr::from_ptr(filename));196	match vm197		.state198		.import(filename)199		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))200		.and_then(|val| val.manifest(&vm.manifest_format))201	{202		Ok(v) => {203			*error = 0;204			CString::new(&*v as &str).unwrap().into_raw()205		}206		Err(e) => {207			*error = 1;208			let mut out = String::new();209			vm.trace_format.write_trace(&mut out, &e).unwrap();210			CString::new(&out as &str).unwrap().into_raw()211		}212	}213}214215/// Evaluate a string containing Jsonnet code, return a JSON string.216///217/// The returned string should be cleaned up with jsonnet_realloc.218///219/// # Safety220///221/// `filename`, `snippet` should be a NUL-terminated strings222#[no_mangle]223pub unsafe extern "C" fn jsonnet_evaluate_snippet(224	vm: &VM,225	filename: *const c_char,226	snippet: *const c_char,227	error: &mut c_int,228) -> *const c_char {229	let filename = CStr::from_ptr(filename);230	let snippet = CStr::from_ptr(snippet);231	match vm232		.state233		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())234		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))235		.and_then(|val| val.manifest(&vm.manifest_format))236	{237		Ok(v) => {238			*error = 0;239			CString::new(&*v as &str).unwrap().into_raw()240		}241		Err(e) => {242			*error = 1;243			let mut out = String::new();244			vm.trace_format.write_trace(&mut out, &e).unwrap();245			CString::new(&out as &str).unwrap().into_raw()246		}247	}248}249250fn val_to_multi(val: Val, format: &dyn ManifestFormat) -> Result<Vec<(IStr, IStr)>> {251	let Val::Obj(val) = val else {252		throw!("expected object as multi output")253	};254	let mut out = Vec::new();255	for (k, v) in val.iter(256		#[cfg(feature = "exp-preserve-order")]257		false,258	) {259		out.push((k, v?.manifest(format)?.into()));260	}261	Ok(out)262}263264fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {265	let mut out = Vec::new();266	for (i, (k, v)) in multi.iter().enumerate() {267		if i != 0 {268			out.push(0);269		}270		out.extend_from_slice(k.as_bytes());271		out.push(0);272		out.extend_from_slice(v.as_bytes());273	}274	out.push(0);275	out.push(0);276	let v = out.as_ptr();277	std::mem::forget(out);278	v as *const c_char279}280281/// # Safety282#[no_mangle]283pub unsafe extern "C" fn jsonnet_evaluate_file_multi(284	vm: &VM,285	filename: *const c_char,286	error: &mut c_int,287) -> *const c_char {288	let filename = parse_path(CStr::from_ptr(filename));289	match vm290		.state291		.import(filename)292		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))293		.and_then(|val| val_to_multi(val, &vm.manifest_format))294	{295		Ok(v) => {296			*error = 0;297			multi_to_raw(v)298		}299		Err(e) => {300			*error = 1;301			let mut out = String::new();302			vm.trace_format.write_trace(&mut out, &e).unwrap();303			CString::new(&out as &str).unwrap().into_raw()304		}305	}306}307308/// # Safety309#[no_mangle]310pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(311	vm: &VM,312	filename: *const c_char,313	snippet: *const c_char,314	error: &mut c_int,315) -> *const c_char {316	let filename = CStr::from_ptr(filename);317	let snippet = CStr::from_ptr(snippet);318	match vm319		.state320		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())321		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))322		.and_then(|val| val_to_multi(val, &vm.manifest_format))323	{324		Ok(v) => {325			*error = 0;326			multi_to_raw(v)327		}328		Err(e) => {329			*error = 1;330			let mut out = String::new();331			vm.trace_format.write_trace(&mut out, &e).unwrap();332			CString::new(&out as &str).unwrap().into_raw()333		}334	}335}336337fn val_to_stream(val: Val, format: &dyn ManifestFormat) -> Result<Vec<IStr>> {338	let Val::Arr(val) = val else {339		throw!("expected array as stream output")340	};341	let mut out = Vec::new();342	for item in val.iter() {343		out.push(item?.manifest(format)?.into());344	}345	Ok(out)346}347348fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {349	let mut out = Vec::new();350	for (i, v) in multi.iter().enumerate() {351		if i != 0 {352			out.push(0);353		}354		out.extend_from_slice(v.as_bytes());355	}356	out.push(0);357	out.push(0);358	let v = out.as_ptr();359	std::mem::forget(out);360	v as *const c_char361}362363/// # Safety364#[no_mangle]365pub unsafe extern "C" fn jsonnet_evaluate_file_stream(366	vm: &VM,367	filename: *const c_char,368	error: &mut c_int,369) -> *const c_char {370	let filename = parse_path(CStr::from_ptr(filename));371	match vm372		.state373		.import(filename)374		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))375		.and_then(|val| val_to_stream(val, &vm.manifest_format))376	{377		Ok(v) => {378			*error = 0;379			stream_to_raw(v)380		}381		Err(e) => {382			*error = 1;383			let mut out = String::new();384			vm.trace_format.write_trace(&mut out, &e).unwrap();385			CString::new(&out as &str).unwrap().into_raw()386		}387	}388}389390/// # Safety391#[no_mangle]392pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(393	vm: &VM,394	filename: *const c_char,395	snippet: *const c_char,396	error: &mut c_int,397) -> *const c_char {398	let filename = CStr::from_ptr(filename);399	let snippet = CStr::from_ptr(snippet);400	match vm401		.state402		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())403		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))404		.and_then(|val| val_to_stream(val, &vm.manifest_format))405	{406		Ok(v) => {407			*error = 0;408			stream_to_raw(v)409		}410		Err(e) => {411			*error = 1;412			let mut out = String::new();413			vm.trace_format.write_trace(&mut out, &e).unwrap();414			CString::new(&out as &str).unwrap().into_raw()415		}416	}417}