git.delta.rocks / jrsonnet / refs/commits / 6bf55d21bf51

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, bail,23	function::TlaArg,24	gc::GcHashMap,25	manifest::{JsonFormat, ManifestFormat, ToStringFormat},26	stack::set_stack_depth_limit,27	tb,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 unsafe {150			std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap())151		};152	}153	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D154	// OR (Alternative way of fixing this TODO)155	// TODO: Standard allocator uses malloc, and it doesn't uses allocation size,156	// TODO: so it should work in normal cases. Maybe force allocator for this library?157	let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();158	if sz == 0 {159		unsafe { std::alloc::dealloc(buf, old_layout) };160		return std::ptr::null_mut();161	}162	unsafe { std::alloc::realloc(buf, old_layout, sz) }163}164165/// Clean up a JSON subtree.166///167/// This is useful if you want to abort with an error mid-way through building a complex value.168#[no_mangle]169#[allow(clippy::boxed_local)]170pub extern "C" fn jsonnet_json_destroy(_vm: &VM, v: Box<Val>) {171	drop(v);172}173174/// Set the number of lines of stack trace to display (0 for all of them).175#[no_mangle]176pub extern "C" fn jsonnet_max_trace(vm: &mut VM, v: c_uint) {177	if let Some(format) = vm.trace_format.as_any_mut().downcast_mut::<CompactFormat>() {178		format.max_trace = v as usize179	} else {180		panic!("max_trace is not supported by current tracing format")181	}182}183184/// Evaluate a file containing Jsonnet code, return a JSON string.185///186/// The returned string should be cleaned up with jsonnet_realloc.187///188/// # Safety189///190/// `filename` should be a NUL-terminated string191#[no_mangle]192pub unsafe extern "C" fn jsonnet_evaluate_file(193	vm: &VM,194	filename: *const c_char,195	error: &mut c_int,196) -> *const c_char {197	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };198	match vm199		.state200		.import(filename)201		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))202		.and_then(|val| val.manifest(&vm.manifest_format))203	{204		Ok(v) => {205			*error = 0;206			CString::new(&*v as &str).unwrap().into_raw()207		}208		Err(e) => {209			*error = 1;210			let mut out = String::new();211			vm.trace_format.write_trace(&mut out, &e).unwrap();212			CString::new(&out as &str).unwrap().into_raw()213		}214	}215}216217/// Evaluate a string containing Jsonnet code, return a JSON string.218///219/// The returned string should be cleaned up with jsonnet_realloc.220///221/// # Safety222///223/// `filename`, `snippet` should be a NUL-terminated strings224#[no_mangle]225pub unsafe extern "C" fn jsonnet_evaluate_snippet(226	vm: &VM,227	filename: *const c_char,228	snippet: *const c_char,229	error: &mut c_int,230) -> *const c_char {231	let filename = unsafe { CStr::from_ptr(filename) };232	let snippet = unsafe { CStr::from_ptr(snippet) };233	match vm234		.state235		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())236		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))237		.and_then(|val| val.manifest(&vm.manifest_format))238	{239		Ok(v) => {240			*error = 0;241			CString::new(&*v as &str).unwrap().into_raw()242		}243		Err(e) => {244			*error = 1;245			let mut out = String::new();246			vm.trace_format.write_trace(&mut out, &e).unwrap();247			CString::new(&out as &str).unwrap().into_raw()248		}249	}250}251252fn val_to_multi(val: Val, format: &dyn ManifestFormat) -> Result<Vec<(IStr, IStr)>> {253	let Val::Obj(val) = val else {254		bail!("expected object as multi output")255	};256	let mut out = Vec::new();257	for (k, v) in val.iter(258		#[cfg(feature = "exp-preserve-order")]259		false,260	) {261		out.push((k, v?.manifest(format)?.into()));262	}263	Ok(out)264}265266fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {267	let mut out = Vec::new();268	for (i, (k, v)) in multi.iter().enumerate() {269		if i != 0 {270			out.push(0);271		}272		out.extend_from_slice(k.as_bytes());273		out.push(0);274		out.extend_from_slice(v.as_bytes());275	}276	out.push(0);277	out.push(0);278	let v = out.as_ptr();279	std::mem::forget(out);280	v.cast::<c_char>()281}282283/// # Safety284#[no_mangle]285pub unsafe extern "C" fn jsonnet_evaluate_file_multi(286	vm: &VM,287	filename: *const c_char,288	error: &mut c_int,289) -> *const c_char {290	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };291	match vm292		.state293		.import(filename)294		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))295		.and_then(|val| val_to_multi(val, &vm.manifest_format))296	{297		Ok(v) => {298			*error = 0;299			multi_to_raw(v)300		}301		Err(e) => {302			*error = 1;303			let mut out = String::new();304			vm.trace_format.write_trace(&mut out, &e).unwrap();305			CString::new(&out as &str).unwrap().into_raw()306		}307	}308}309310/// # Safety311#[no_mangle]312pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(313	vm: &VM,314	filename: *const c_char,315	snippet: *const c_char,316	error: &mut c_int,317) -> *const c_char {318	let filename = unsafe { CStr::from_ptr(filename) };319	let snippet = unsafe { CStr::from_ptr(snippet) };320	match vm321		.state322		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())323		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))324		.and_then(|val| val_to_multi(val, &vm.manifest_format))325	{326		Ok(v) => {327			*error = 0;328			multi_to_raw(v)329		}330		Err(e) => {331			*error = 1;332			let mut out = String::new();333			vm.trace_format.write_trace(&mut out, &e).unwrap();334			CString::new(&out as &str).unwrap().into_raw()335		}336	}337}338339fn val_to_stream(val: Val, format: &dyn ManifestFormat) -> Result<Vec<IStr>> {340	let Val::Arr(val) = val else {341		bail!("expected array as stream output")342	};343	let mut out = Vec::new();344	for item in val.iter() {345		out.push(item?.manifest(format)?.into());346	}347	Ok(out)348}349350fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {351	let mut out = Vec::new();352	for (i, v) in multi.iter().enumerate() {353		if i != 0 {354			out.push(0);355		}356		out.extend_from_slice(v.as_bytes());357	}358	out.push(0);359	out.push(0);360	let v = out.as_ptr();361	std::mem::forget(out);362	v as *const c_char363}364365/// # Safety366#[no_mangle]367pub unsafe extern "C" fn jsonnet_evaluate_file_stream(368	vm: &VM,369	filename: *const c_char,370	error: &mut c_int,371) -> *const c_char {372	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };373	match vm374		.state375		.import(filename)376		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))377		.and_then(|val| val_to_stream(val, &vm.manifest_format))378	{379		Ok(v) => {380			*error = 0;381			stream_to_raw(v)382		}383		Err(e) => {384			*error = 1;385			let mut out = String::new();386			vm.trace_format.write_trace(&mut out, &e).unwrap();387			CString::new(&out as &str).unwrap().into_raw()388		}389	}390}391392/// # Safety393#[no_mangle]394pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(395	vm: &VM,396	filename: *const c_char,397	snippet: *const c_char,398	error: &mut c_int,399) -> *const c_char {400	let filename = unsafe { CStr::from_ptr(filename) };401	let snippet = unsafe { CStr::from_ptr(snippet) };402	match vm403		.state404		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())405		.and_then(|val| apply_tla(vm.state.clone(), &vm.tla_args, val))406		.and_then(|val| val_to_stream(val, &vm.manifest_format))407	{408		Ok(v) => {409			*error = 0;410			stream_to_raw(v)411		}412		Err(e) => {413			*error = 1;414			let mut out = String::new();415			vm.trace_format.write_trace(&mut out, &e).unwrap();416			CString::new(&out as &str).unwrap().into_raw()417		}418	}419}