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

8787
88[[package]]88[[package]]
89name = "clap"89name = "clap"
90version = "3.1.18"90version = "3.2.8"
91source = "registry+https://github.com/rust-lang/crates.io-index"91source = "registry+https://github.com/rust-lang/crates.io-index"
92checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b"92checksum = "190814073e85d238f31ff738fcb0bf6910cedeb73376c87cd69291028966fd83"
93dependencies = [93dependencies = [
94 "atty",94 "atty",
95 "bitflags",95 "bitflags",
96 "clap_derive",96 "clap_derive",
97 "clap_lex",97 "clap_lex",
98 "indexmap",98 "indexmap",
99 "lazy_static",99 "once_cell",
100 "strsim",100 "strsim",
101 "termcolor",101 "termcolor",
102 "textwrap",102 "textwrap",
103]103]
104104
105[[package]]105[[package]]
106name = "clap_complete"106name = "clap_complete"
107version = "3.1.4"107version = "3.2.3"
108source = "registry+https://github.com/rust-lang/crates.io-index"108source = "registry+https://github.com/rust-lang/crates.io-index"
109checksum = "da92e6facd8d73c22745a5d3cbb59bdf8e46e3235c923e516527d8e81eec14a4"109checksum = "ead064480dfc4880a10764488415a97fdd36a4cf1bb022d372f02e8faf8386e1"
110dependencies = [110dependencies = [
111 "clap",111 "clap",
112]112]
113113
114[[package]]114[[package]]
115name = "clap_derive"115name = "clap_derive"
116version = "3.1.18"116version = "3.2.7"
117source = "registry+https://github.com/rust-lang/crates.io-index"117source = "registry+https://github.com/rust-lang/crates.io-index"
118checksum = "25320346e922cffe59c0bbc5410c8d8784509efb321488971081313cb1e1a33c"118checksum = "759bf187376e1afa7b85b959e6a664a3e7a95203415dba952ad19139e798f902"
119dependencies = [119dependencies = [
120 "heck",120 "heck",
121 "proc-macro-error",121 "proc-macro-error",
126126
127[[package]]127[[package]]
128name = "clap_lex"128name = "clap_lex"
129version = "0.2.0"129version = "0.2.4"
130source = "registry+https://github.com/rust-lang/crates.io-index"130source = "registry+https://github.com/rust-lang/crates.io-index"
131checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213"131checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
132dependencies = [132dependencies = [
133 "os_str_bytes",133 "os_str_bytes",
134]134]
221 "jrsonnet-evaluator",221 "jrsonnet-evaluator",
222 "jrsonnet-gcmodule",222 "jrsonnet-gcmodule",
223 "jrsonnet-parser",223 "jrsonnet-parser",
224 "jrsonnet-stdlib",
224]225]
225226
226[[package]]227[[package]]
229dependencies = [230dependencies = [
230 "annotate-snippets",231 "annotate-snippets",
231 "anyhow",232 "anyhow",
232 "base64",
233 "bincode",233 "bincode",
234 "hashbrown 0.12.1",234 "hashbrown 0.12.1",
235 "jrsonnet-gcmodule",235 "jrsonnet-gcmodule",
236 "jrsonnet-interner",236 "jrsonnet-interner",
237 "jrsonnet-macros",237 "jrsonnet-macros",
238 "jrsonnet-parser",238 "jrsonnet-parser",
239 "jrsonnet-stdlib",
240 "jrsonnet-types",239 "jrsonnet-types",
241 "md5",
242 "pathdiff",240 "pathdiff",
243 "rustc-hash",241 "rustc-hash",
244 "serde",242 "serde",
245 "serde_json",243 "serde_json",
246 "serde_yaml_with_quirks",
247 "static_assertions",244 "static_assertions",
248 "strsim",245 "strsim",
249 "thiserror",246 "thiserror",
278 "jrsonnet-gcmodule",275 "jrsonnet-gcmodule",
279 "rustc-hash",276 "rustc-hash",
280 "serde",277 "serde",
278 "structdump",
281]279]
282280
283[[package]]281[[package]]
295dependencies = [293dependencies = [
296 "jrsonnet-gcmodule",294 "jrsonnet-gcmodule",
297 "jrsonnet-interner",295 "jrsonnet-interner",
298 "jrsonnet-stdlib",
299 "peg",296 "peg",
300 "serde",297 "serde",
301 "static_assertions",298 "static_assertions",
299 "structdump",
302]300]
303301
304[[package]]302[[package]]
305name = "jrsonnet-stdlib"303name = "jrsonnet-stdlib"
306version = "0.4.2"304version = "0.4.2"
305dependencies = [
306 "base64",
307 "bincode",
308 "jrsonnet-evaluator",
309 "jrsonnet-gcmodule",
310 "jrsonnet-macros",
311 "jrsonnet-parser",
312 "md5",
313 "serde",
314 "serde_json",
315 "serde_yaml_with_quirks",
316 "structdump",
317]
307318
308[[package]]319[[package]]
309name = "jrsonnet-types"320name = "jrsonnet-types"
313 "peg",324 "peg",
314]325]
315
316[[package]]
317name = "jsonnet"
318version = "0.4.2"
319dependencies = [
320 "jrsonnet-evaluator",
321 "jrsonnet-gcmodule",
322 "jrsonnet-parser",
323]
324
325[[package]]
326name = "lazy_static"
327version = "1.4.0"
328source = "registry+https://github.com/rust-lang/crates.io-index"
329checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
330326
331[[package]]327[[package]]
332name = "libc"328name = "libc"
333version = "0.2.126"329version = "0.2.126"
334source = "registry+https://github.com/rust-lang/crates.io-index"330source = "registry+https://github.com/rust-lang/crates.io-index"
335checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"331checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
332
333[[package]]
334name = "libjsonnet"
335version = "0.4.2"
336dependencies = [
337 "jrsonnet-evaluator",
338 "jrsonnet-gcmodule",
339 "jrsonnet-parser",
340 "jrsonnet-stdlib",
341]
336342
337[[package]]343[[package]]
338name = "linked-hash-map"344name = "linked-hash-map"
339version = "0.5.4"345version = "0.5.6"
340source = "registry+https://github.com/rust-lang/crates.io-index"346source = "registry+https://github.com/rust-lang/crates.io-index"
341checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"347checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
342348
343[[package]]349[[package]]
344name = "lock_api"350name = "lock_api"
511517
512[[package]]518[[package]]
513name = "serde"519name = "serde"
514version = "1.0.137"520version = "1.0.142"
515source = "registry+https://github.com/rust-lang/crates.io-index"521source = "registry+https://github.com/rust-lang/crates.io-index"
516checksum = "61ea8d54c77f8315140a05f4c7237403bf38b72704d031543aa1d16abbf517d1"522checksum = "e590c437916fb6b221e1d00df6e3294f3fccd70ca7e92541c475d6ed6ef5fee2"
517dependencies = [523dependencies = [
518 "serde_derive",524 "serde_derive",
519]525]
520526
521[[package]]527[[package]]
522name = "serde_derive"528name = "serde_derive"
523version = "1.0.137"529version = "1.0.142"
524source = "registry+https://github.com/rust-lang/crates.io-index"530source = "registry+https://github.com/rust-lang/crates.io-index"
525checksum = "1f26faba0c3959972377d3b2d306ee9f71faee9714294e41bb777f83f88578be"531checksum = "34b5b8d809babe02f538c2cfec6f2c1ed10804c0e5a6a041a049a4f5588ccc2e"
526dependencies = [532dependencies = [
527 "proc-macro2",533 "proc-macro2",
528 "quote",534 "quote",
531537
532[[package]]538[[package]]
533name = "serde_json"539name = "serde_json"
534version = "1.0.81"540version = "1.0.82"
535source = "registry+https://github.com/rust-lang/crates.io-index"541source = "registry+https://github.com/rust-lang/crates.io-index"
536checksum = "9b7ce2b32a1aed03c558dc61a5cd328f15aff2dbc17daad8fb8af04d2100e15c"542checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7"
537dependencies = [543dependencies = [
538 "indexmap",544 "indexmap",
539 "itoa",545 "itoa",
571source = "registry+https://github.com/rust-lang/crates.io-index"577source = "registry+https://github.com/rust-lang/crates.io-index"
572checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"578checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
579
580[[package]]
581name = "structdump"
582version = "0.2.0"
583source = "registry+https://github.com/rust-lang/crates.io-index"
584checksum = "b0570327507bf281d8a6e6b0d4c082b12cb6bcee27efce755aa5efacd44076c1"
585dependencies = [
586 "proc-macro2",
587 "quote",
588 "structdump-derive",
589]
590
591[[package]]
592name = "structdump-derive"
593version = "0.2.0"
594source = "registry+https://github.com/rust-lang/crates.io-index"
595checksum = "29cc0b59cfa11f1bceda09a9a7e37e6a6c3138575fd24ade8aa9af6d09aedf28"
596dependencies = [
597 "proc-macro2",
598 "quote",
599 "syn",
600]
573601
574[[package]]602[[package]]
575name = "syn"603name = "syn"
591 "winapi-util",619 "winapi-util",
592]620]
621
622[[package]]
623name = "tests"
624version = "0.1.0"
625dependencies = [
626 "jrsonnet-evaluator",
627 "jrsonnet-gcmodule",
628 "jrsonnet-stdlib",
629 "serde",
630]
593631
594[[package]]632[[package]]
595name = "textwrap"633name = "textwrap"

1[workspace]1[workspace]
2members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet"]2members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet", "tests"]
33
4[profile.test]4[profile.test]
5opt-level = 15opt-level = 1

1[package]1[package]
2name = "jsonnet"2name = "libjsonnet"
3description = "Rust implementation of libjsonnet.so"3description = "Rust implementation of libjsonnet.so"
4version = "0.4.2"4version = "0.4.2"
5authors = ["Yaroslav Bolyukin <iam@lach.pw>"]5authors = ["Yaroslav Bolyukin <iam@lach.pw>"]
10[dependencies]10[dependencies]
11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2" }11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2" }
12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.4.2" }12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.4.2" }
13jrsonnet-stdlib = { path = "../../crates/jrsonnet-stdlib", version = "0.4.2" }
13jrsonnet-gcmodule = { version = "0.3.4" }14jrsonnet-gcmodule = { version = "0.3.4" }
1415
15[lib]16[lib]
17name = "jsonnet"
16crate-type = ["cdylib"]18crate-type = ["cdylib"]
1719
18[features]20[features]
21# Export additional functions for native integration, i.e ability to set custom trace format
19interop = []22interop = []
20experimental = ["exp-preserve-order", "exp-destruct"]23experimental = ["exp-preserve-order", "exp-destruct"]
21exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]24exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]

4	any::Any,4	any::Any,
5	cell::RefCell,5	cell::RefCell,
6	collections::HashMap,6	collections::HashMap,
7	env::current_dir,
7	ffi::{c_void, CStr, CString},8	ffi::{c_void, CStr, CString},
8	fs::File,
9	io::Read,
10	os::raw::{c_char, c_int},9	os::raw::{c_char, c_int},
11	path::{Path, PathBuf},10	path::PathBuf,
12	ptr::null_mut,11	ptr::null_mut,
13};12};
1413
15use jrsonnet_evaluator::{14use jrsonnet_evaluator::{
16	error::{Error::*, Result},15	error::{Error::*, Result},
17	throw, ImportResolver, State,16	throw, FileImportResolver, ImportResolver, State,
18};17};
18use jrsonnet_parser::{SourceDirectory, SourceFile, SourcePath};
1919
20pub type JsonnetImportCallback = unsafe extern "C" fn(20pub type JsonnetImportCallback = unsafe extern "C" fn(
21	ctx: *mut c_void,21	ctx: *mut c_void,
29pub struct CallbackImportResolver {29pub struct CallbackImportResolver {
30	cb: JsonnetImportCallback,30	cb: JsonnetImportCallback,
31	ctx: *mut c_void,31	ctx: *mut c_void,
32	out: RefCell<HashMap<PathBuf, Vec<u8>>>,32	out: RefCell<HashMap<SourcePath, Vec<u8>>>,
33}33}
34impl ImportResolver for CallbackImportResolver {34impl ImportResolver for CallbackImportResolver {
35	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {35	fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {
36		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();36		let base = if let Some(p) = from.downcast_ref::<SourceFile>() {
37			let mut o = p.path().to_owned();
38			o.pop();
39			o
40		} else if let Some(d) = from.downcast_ref::<SourceDirectory>() {
41			d.path().to_owned()
42		} else if from.is_default() {
43			current_dir().map_err(|e| ImportIo(e.to_string()))?
44		} else {
45			unreachable!("can't resolve this path");
46		};
47		let base = unsafe { crate::unparse_path(&base) };
37		let rel = CString::new(path).unwrap().into_raw();48		let rel = CString::new(path).unwrap();
38		let found_here: *mut c_char = null_mut();49		let found_here: *mut c_char = null_mut();
39		let mut success: i32 = 0;50		let mut success: i32 = 0;
40		let result_ptr = unsafe {51		let result_ptr = unsafe {
41			(self.cb)(52			(self.cb)(
42				self.ctx,53				self.ctx,
43				base,54				base.as_ptr(),
44				rel,55				rel.as_ptr(),
45				&mut (found_here as *const _),56				&mut (found_here as *const _),
46				&mut success,57				&mut success,
47			)58			)
48		};59		};
49		// Release memory occipied by arguments passed
50		unsafe {
51			let _ = CString::from_raw(base);
52			let _ = CString::from_raw(rel);
53		}
54		let result_raw = unsafe { CStr::from_ptr(result_ptr) };60		let result_raw = unsafe { CStr::from_ptr(result_ptr) };
55		let result_str = result_raw.to_str().unwrap();61		let result_str = result_raw.to_str().unwrap();
56		assert!(success == 0 || success == 1);62		assert!(success == 0 || success == 1);
61		}67		}
6268
63		let found_here_raw = unsafe { CStr::from_ptr(found_here) };69		let found_here_raw = unsafe { CStr::from_ptr(found_here) };
64		let found_here_buf = PathBuf::from(found_here_raw.to_str().unwrap());70		let found_here_buf = SourcePath::new(SourceFile::new(PathBuf::from(
71			found_here_raw.to_str().unwrap(),
72		)));
65		unsafe {73		unsafe {
66			let _ = CString::from_raw(found_here);74			let _ = CString::from_raw(found_here);
67		}75		}
7482
75		Ok(found_here_buf)83		Ok(found_here_buf)
76	}84	}
77	fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>> {85	fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>> {
78		Ok(self.out.borrow().get(resolved).unwrap().clone())86		Ok(self.out.borrow().get(resolved).unwrap().clone())
79	}87	}
8088
81	unsafe fn as_any(&self) -> &dyn Any {89	fn as_any(&self) -> &dyn Any {
82		self90		self
83	}91	}
84}92}
8593
86/// # Safety94/// # Safety
95///
96/// It should be safe to call `cb` using valid values with passed `ctx`
87#[no_mangle]97#[no_mangle]
88pub unsafe extern "C" fn jsonnet_import_callback(98pub unsafe extern "C" fn jsonnet_import_callback(
89	vm: &State,99	vm: &State,
97	}))107	}))
98}108}
99
100/// Standard FS import resolver
101#[derive(Default)]
102pub struct NativeImportResolver {
103	library_paths: RefCell<Vec<PathBuf>>,
104}
105impl NativeImportResolver {
106	fn add_jpath(&self, path: PathBuf) {
107		self.library_paths.borrow_mut().push(path);
108	}
109}
110impl ImportResolver for NativeImportResolver {
111	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
112		let mut new_path = from.to_owned();
113		new_path.push(path);
114		if new_path.exists() {
115			Ok(new_path)
116		} else {
117			for library_path in self.library_paths.borrow().iter() {
118				let mut cloned = library_path.clone();
119				cloned.push(path);
120				if cloned.exists() {
121					return Ok(cloned);
122				}
123			}
124			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))
125		}
126	}
127	fn load_file_contents(&self, id: &Path) -> Result<Vec<u8>> {
128		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.to_owned()))?;
129		let mut out = Vec::new();
130		file.read_to_end(&mut out)
131			.map_err(|e| ImportIo(e.to_string()))?;
132		Ok(out)
133	}
134	unsafe fn as_any(&self) -> &dyn Any {
135		self
136	}
137}
138109
139/// # Safety110/// # Safety
140///111///
141/// This function is safe, if received v is a pointer to normal C string112/// `path` should be a NUL-terminated string
142#[no_mangle]113#[no_mangle]
143pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, v: *const c_char) {114pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, path: *const c_char) {
144	let cstr = CStr::from_ptr(v);115	let cstr = CStr::from_ptr(path);
145	let path = PathBuf::from(cstr.to_str().unwrap());116	let path = PathBuf::from(cstr.to_str().unwrap());
146	let any_resolver = &vm.settings().import_resolver;117	let any_resolver = vm.import_resolver();
147	let resolver = any_resolver118	let resolver = any_resolver
148		.as_any()119		.as_any()
149		.downcast_ref::<NativeImportResolver>()120		.downcast_ref::<FileImportResolver>()
150		.expect("jpaths are not compatible with callback imports!");121		.expect("jpaths are not compatible with callback imports!");
151	resolver.add_jpath(path);122	resolver.add_jpath(path);
152}123}

1010
11use std::{11use std::{
12	alloc::Layout,12	alloc::Layout,
13	borrow::Cow,
13	ffi::{CStr, CString},14	ffi::{CStr, CString, OsStr},
14	os::raw::{c_char, c_double, c_int, c_uint},15	os::raw::{c_char, c_double, c_int, c_uint},
15	path::PathBuf,16	path::Path,
16};17};
1718
18use import::NativeImportResolver;
19use jrsonnet_evaluator::{IStr, ManifestFormat, State, Val};19use jrsonnet_evaluator::{
20	trace::PathResolver, FileImportResolver, IStr, ManifestFormat, State, Val,
21};
2022
21/// WASM stub23/// WASM stub
22#[cfg(target_arch = "wasm32")]24#[cfg(target_arch = "wasm32")]
23#[no_mangle]25#[no_mangle]
24pub extern "C" fn _start() {}26pub extern "C" fn _start() {}
2527
28/// Return the version string of the Jsonnet interpreter.
29/// Conforms to [semantic versioning](http://semver.org/).
30/// If this does not match `LIB_JSONNET_VERSION`
31/// then there is a mismatch between header and compiled library.
26#[no_mangle]32#[no_mangle]
27pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {33pub extern "C" fn jsonnet_version() -> &'static [u8; 8] {
28	b"v0.16.0\0"34	b"v0.16.0\0"
29}35}
3036
37unsafe fn parse_path(input: &CStr) -> Cow<Path> {
38	#[cfg(target_family = "unix")]
39	{
40		use std::os::unix::ffi::OsStrExt;
41		let str = OsStr::from_bytes(input.to_bytes());
42		Cow::Borrowed(Path::new(str))
43	}
44	#[cfg(not(target_family = "unix"))]
45	{
46		let string = input.to_str().expect("bad utf-8");
47		Cow::Borrowed(string.as_ref())
48	}
49}
50
51unsafe fn unparse_path(input: &Path) -> Cow<CStr> {
52	#[cfg(target_family = "unix")]
53	{
54		use std::os::unix::ffi::OsStrExt;
55		let str = CString::new(input.as_os_str().as_bytes()).expect("input has zero byte in it");
56		Cow::Owned(str)
57	}
58	#[cfg(not(target_family = "unix"))]
59	{
60		let str = input.as_os_str().to_str().expect("bad utf-8");
61		let cstr = CString::new(str).expect("input has NUL inside");
62		Cow::Owned(cstr)
63	}
64}
65
66/// Creates a new Jsonnet virtual machine.
31#[no_mangle]67#[no_mangle]
68#[allow(clippy::box_default)]
32pub extern "C" fn jsonnet_make() -> *mut State {69pub extern "C" fn jsonnet_make() -> *mut State {
33	let state = State::default();70	let state = State::default();
34	state.with_stdlib();71	state.settings_mut().import_resolver = Box::new(FileImportResolver::default());
35	state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());72	state.settings_mut().context_initializer = Box::new(jrsonnet_stdlib::ContextInitializer::new(
73		state.clone(),
74		PathResolver::new_cwd_fallback(),
75	));
36	Box::into_raw(Box::new(state))76	Box::into_raw(Box::new(state))
37}77}
3878
39/// # Safety79/// Complement of [`jsonnet_vm_make`].
40#[no_mangle]80#[no_mangle]
41#[allow(clippy::boxed_local)]81#[allow(clippy::boxed_local)]
42pub unsafe extern "C" fn jsonnet_destroy(vm: *mut State) {82pub extern "C" fn jsonnet_destroy(vm: Box<State>) {
43	Box::from_raw(vm);83	drop(vm);
44}84}
4585
86/// Set the maximum stack depth.
46#[no_mangle]87#[no_mangle]
47pub extern "C" fn jsonnet_max_stack(vm: &State, v: c_uint) {88pub extern "C" fn jsonnet_max_stack(vm: &State, v: c_uint) {
48	vm.settings_mut().max_stack = v as usize;89	vm.settings_mut().max_stack = v as usize;
49}90}
5091
51// jrsonnet currently have no GC, so these functions is no-op92/// Set the number of objects required before a garbage collection cycle is allowed.
93///
94/// No-op for now
52#[no_mangle]95#[no_mangle]
53pub extern "C" fn jsonnet_gc_min_objects(_vm: &State, _v: c_uint) {}96pub extern "C" fn jsonnet_gc_min_objects(_vm: &State, _v: c_uint) {}
97
98/// Run the garbage collector after this amount of growth in the number of objects
99///
100/// No-op for now
54#[no_mangle]101#[no_mangle]
55pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &State, _v: c_double) {}102pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &State, _v: c_double) {}
56103
104/// Expect a string as output and don't JSON encode it.
57#[no_mangle]105#[no_mangle]
58pub extern "C" fn jsonnet_string_output(vm: &State, v: c_int) {106pub extern "C" fn jsonnet_string_output(vm: &State, v: c_int) {
59	match v {107	match v {
67	}115	}
68}116}
69117
118/// Allocate, resize, or free a buffer.  This will abort if the memory cannot be allocated. It will
119/// only return NULL if sz was zero.
120///
70/// # Safety121/// # Safety
122///
123/// `buf` should be either previosly allocated by this library, or NULL
71///124///
72/// This function is most definitely broken, but it works somehow, see TODO inside125/// This function is most definitely broken, but it works somehow, see TODO inside
73#[no_mangle]126#[no_mangle]
74pub unsafe extern "C" fn jsonnet_realloc(_vm: &State, buf: *mut u8, sz: usize) -> *mut u8 {127pub unsafe extern "C" fn jsonnet_realloc(_vm: &State, buf: *mut u8, sz: usize) -> *mut u8 {
75	if buf.is_null() {128	if buf.is_null() {
76		assert!(sz != 0);129		if sz == 0 {
130			return std::ptr::null_mut();
131		}
77		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());132		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());
78	}133	}
79	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D134	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D
88	std::alloc::realloc(buf, old_layout, sz)143	std::alloc::realloc(buf, old_layout, sz)
89}144}
90145
146/// Clean up a JSON subtree.
91/// # Safety147///
148/// This is useful if you want to abort with an error mid-way through building a complex value.
92#[no_mangle]149#[no_mangle]
93#[allow(clippy::boxed_local)]150#[allow(clippy::boxed_local)]
94pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &State, v: *mut Val) {151pub extern "C" fn jsonnet_json_destroy(_vm: &State, v: Box<Val>) {
95	Box::from_raw(v);152	drop(v);
96}153}
97154
155/// Set the number of lines of stack trace to display (0 for all of them).
98#[no_mangle]156#[no_mangle]
99pub extern "C" fn jsonnet_max_trace(vm: &State, v: c_uint) {157pub extern "C" fn jsonnet_max_trace(vm: &State, v: c_uint) {
100	vm.set_max_trace(v as usize)158	vm.set_max_trace(v as usize)
101}159}
102160
161/// Evaluate a file containing Jsonnet code, return a JSON string.
162///
163/// The returned string should be cleaned up with jsonnet_realloc.
164///
103/// # Safety165/// # Safety
104///166///
105/// This function is safe, if received v is a pointer to normal C string167/// `filename` should be a NUL-terminated string
106#[no_mangle]168#[no_mangle]
107pub unsafe extern "C" fn jsonnet_evaluate_file(169pub unsafe extern "C" fn jsonnet_evaluate_file(
108	vm: &State,170	vm: &State,
109	filename: *const c_char,171	filename: *const c_char,
110	error: &mut c_int,172	error: &mut c_int,
111) -> *const c_char {173) -> *const c_char {
112	let filename = CStr::from_ptr(filename);174	let filename = parse_path(CStr::from_ptr(filename));
113	match vm175	match vm
114		.import(PathBuf::from(filename.to_str().unwrap()))176		.import(&filename)
115		.and_then(|v| vm.with_tla(v))177		.and_then(|v| vm.with_tla(v))
116		.and_then(|v| vm.manifest(v))178		.and_then(|v| vm.manifest(v))
117	{179	{
127	}189	}
128}190}
129191
192/// Evaluate a string containing Jsonnet code, return a JSON string.
193///
194/// The returned string should be cleaned up with jsonnet_realloc.
195///
130/// # Safety196/// # Safety
131///197///
132/// This function is safe, if received v is a pointer to normal C string198/// `filename`, `snippet` should be a NUL-terminated strings
133#[no_mangle]199#[no_mangle]
134pub unsafe extern "C" fn jsonnet_evaluate_snippet(200pub unsafe extern "C" fn jsonnet_evaluate_snippet(
135	vm: &State,201	vm: &State,
141	let snippet = CStr::from_ptr(snippet);207	let snippet = CStr::from_ptr(snippet);
142	match vm208	match vm
143		.evaluate_snippet(209		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
144			filename.to_str().unwrap().into(),
145			snippet.to_str().unwrap().into(),
146		)
147		.and_then(|v| vm.with_tla(v))210		.and_then(|v| vm.with_tla(v))
148		.and_then(|v| vm.manifest(v))211		.and_then(|v| vm.manifest(v))
183	filename: *const c_char,246	filename: *const c_char,
184	error: &mut c_int,247	error: &mut c_int,
185) -> *const c_char {248) -> *const c_char {
186	let filename = CStr::from_ptr(filename);249	let filename = parse_path(CStr::from_ptr(filename));
187	match vm250	match vm
188		.import(PathBuf::from(filename.to_str().unwrap()))251		.import(&filename)
189		.and_then(|v| vm.with_tla(v))252		.and_then(|v| vm.with_tla(v))
190		.and_then(|v| vm.manifest_multi(v))253		.and_then(|v| vm.manifest_multi(v))
191	{254	{
213	let snippet = CStr::from_ptr(snippet);276	let snippet = CStr::from_ptr(snippet);
214	match vm277	match vm
215		.evaluate_snippet(278		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
216			filename.to_str().unwrap().into(),
217			snippet.to_str().unwrap().into(),
218		)
219		.and_then(|v| vm.with_tla(v))279		.and_then(|v| vm.with_tla(v))
220		.and_then(|v| vm.manifest_multi(v))280		.and_then(|v| vm.manifest_multi(v))
253	filename: *const c_char,313	filename: *const c_char,
254	error: &mut c_int,314	error: &mut c_int,
255) -> *const c_char {315) -> *const c_char {
256	let filename = CStr::from_ptr(filename);316	let filename = parse_path(CStr::from_ptr(filename));
257	match vm317	match vm
258		.import(PathBuf::from(filename.to_str().unwrap()))318		.import(&filename)
259		.and_then(|v| vm.with_tla(v))319		.and_then(|v| vm.with_tla(v))
260		.and_then(|v| vm.manifest_stream(v))320		.and_then(|v| vm.manifest_stream(v))
261	{321	{
266		Err(e) => {326		Err(e) => {
267			*error = 1;327			*error = 1;
268			let out = vm.stringify_err(&e);328			let out = vm.stringify_err(&e);
269			CString::new(&out as &str).unwrap().into_raw()329			CString::new(&out as &str)
330				.expect("there should be no \\0 in the error string")
331				.into_raw()
270		}332		}
271	}333	}
283	let snippet = CStr::from_ptr(snippet);345	let snippet = CStr::from_ptr(snippet);
284	match vm346	match vm
285		.evaluate_snippet(347		.evaluate_snippet(
286			filename.to_str().unwrap().into(),348			filename.to_str().expect("filename is not utf-8"),
287			snippet.to_str().unwrap().into(),349			snippet.to_str().expect("snippet is not utf-8"),
288		)350		)
289		.and_then(|v| vm.with_tla(v))351		.and_then(|v| vm.with_tla(v))
290		.and_then(|v| vm.manifest_stream(v))352		.and_then(|v| vm.manifest_stream(v))
296		Err(e) => {358		Err(e) => {
297			*error = 1;359			*error = 1;
298			let out = vm.stringify_err(&e);360			let out = vm.stringify_err(&e);
299			CString::new(&out as &str).unwrap().into_raw()361			CString::new(&out as &str)
362				.expect("there should be no \\0 in the error string")
363				.into_raw()
300		}364		}
301	}365	}