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

1# NOTE: This library may panic, and it is only safe to panic in FFI contexts when library is built in panic="abort" mode,
2# which is set for release builds of this library.
3# FIXME: Move this warning somewhere else, or remove panics from this library (It is not always possible, in some cases
4# there is nothing to report the error, in those cases use `abort()`)
5# NOTE: This library assumes the allocator is libc malloc or alternative, which does track allocation size for user,
6# see TODO in `jsonnet_realloc`.
7
1[package]8[package]
2name = "libjsonnet"9name = "libjsonnet"

129/// `path` should be a NUL-terminated string129/// `path` should be a NUL-terminated string
130#[no_mangle]130#[no_mangle]
131pub unsafe extern "C" fn jsonnet_jpath_add(vm: &VM, path: *const c_char) {131pub unsafe extern "C" fn jsonnet_jpath_add(vm: &VM, path: *const c_char) {
132	let cstr = CStr::from_ptr(path);132	let cstr = unsafe { CStr::from_ptr(path) };
133	let path = PathBuf::from(cstr.to_str().unwrap());133	let path = PathBuf::from(cstr.to_str().unwrap());
134	let any_resolver = vm.state.import_resolver();134	let any_resolver = vm.state.import_resolver();
135	let resolver = any_resolver135	let resolver = any_resolver

146		if sz == 0 {146		if sz == 0 {
147			return std::ptr::null_mut();147			return std::ptr::null_mut();
148		}148		}
149		return std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap());149		return unsafe {
150			std::alloc::alloc(Layout::from_size_align(sz, std::mem::align_of::<u8>()).unwrap())
151		};
150	}152	}
151	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D153	// TODO: Somehow store size of allocation, because its real size is probally not 16 :D
152	// OR (Alternative way of fixing this TODO)154	// OR (Alternative way of fixing this TODO)
153	// TODO: Standard allocator uses malloc, and it doesn't uses allocation size,155	// 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?156	// 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();157	let old_layout = Layout::from_size_align(16, std::mem::align_of::<u8>()).unwrap();
156	if sz == 0 {158	if sz == 0 {
157		std::alloc::dealloc(buf, old_layout);159		unsafe { std::alloc::dealloc(buf, old_layout) };
158		return std::ptr::null_mut();160		return std::ptr::null_mut();
159	}161	}
160	std::alloc::realloc(buf, old_layout, sz)162	unsafe { std::alloc::realloc(buf, old_layout, sz) }
161}163}
162164
163/// Clean up a JSON subtree.165/// Clean up a JSON subtree.
192	filename: *const c_char,194	filename: *const c_char,
193	error: &mut c_int,195	error: &mut c_int,
194) -> *const c_char {196) -> *const c_char {
195	let filename = parse_path(CStr::from_ptr(filename));197	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };
196	match vm198	match vm
197		.state199		.state
198		.import(filename)200		.import(filename)
226	snippet: *const c_char,228	snippet: *const c_char,
227	error: &mut c_int,229	error: &mut c_int,
228) -> *const c_char {230) -> *const c_char {
229	let filename = CStr::from_ptr(filename);231	let filename = unsafe { CStr::from_ptr(filename) };
230	let snippet = CStr::from_ptr(snippet);232	let snippet = unsafe { CStr::from_ptr(snippet) };
231	match vm233	match vm
232		.state234		.state
233		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())235		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
275	out.push(0);277	out.push(0);
276	let v = out.as_ptr();278	let v = out.as_ptr();
277	std::mem::forget(out);279	std::mem::forget(out);
278	v as *const c_char280	v.cast::<c_char>()
279}281}
280282
281/// # Safety283/// # Safety
285	filename: *const c_char,287	filename: *const c_char,
286	error: &mut c_int,288	error: &mut c_int,
287) -> *const c_char {289) -> *const c_char {
288	let filename = parse_path(CStr::from_ptr(filename));290	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };
289	match vm291	match vm
290		.state292		.state
291		.import(filename)293		.import(filename)
313	snippet: *const c_char,315	snippet: *const c_char,
314	error: &mut c_int,316	error: &mut c_int,
315) -> *const c_char {317) -> *const c_char {
316	let filename = CStr::from_ptr(filename);318	let filename = unsafe { CStr::from_ptr(filename) };
317	let snippet = CStr::from_ptr(snippet);319	let snippet = unsafe { CStr::from_ptr(snippet) };
318	match vm320	match vm
319		.state321		.state
320		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())322		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())
367	filename: *const c_char,369	filename: *const c_char,
368	error: &mut c_int,370	error: &mut c_int,
369) -> *const c_char {371) -> *const c_char {
370	let filename = parse_path(CStr::from_ptr(filename));372	let filename = unsafe { parse_path(CStr::from_ptr(filename)) };
371	match vm373	match vm
372		.state374		.state
373		.import(filename)375		.import(filename)
395	snippet: *const c_char,397	snippet: *const c_char,
396	error: &mut c_int,398	error: &mut c_int,
397) -> *const c_char {399) -> *const c_char {
398	let filename = CStr::from_ptr(filename);400	let filename = unsafe { CStr::from_ptr(filename) };
399	let snippet = CStr::from_ptr(snippet);401	let snippet = unsafe { CStr::from_ptr(snippet) };
400	match vm402	match vm
401		.state403		.state
402		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())404		.evaluate_snippet(filename.to_str().unwrap(), snippet.to_str().unwrap())

17/// failure, which will appear in Jsonnet as an error. The `argv` pointer is an array whose size17/// failure, which will appear in Jsonnet as an error. The `argv` pointer is an array whose size
18/// matches the array of parameters supplied when the native callback was originally registered.18/// matches the array of parameters supplied when the native callback was originally registered.
19///19///
20/// - `ctx` User pointer, given in jsonnet_native_callback.20/// - `ctx` User pointer, given in `jsonnet_native_callback`.
21/// - `argv` Array of arguments from Jsonnet code.21/// - `argv` Array of arguments from Jsonnet code.
22/// - `param` success Set this byref param to 1 to indicate success and 0 for failure.22/// - `param` success Set this byref param to 1 to indicate success and 0 for failure.
23/// Returns the content of the imported file, or an error message.23/// Returns the content of the imported file, or an error message.
69	ctx: *const c_void,69	ctx: *const c_void,
70	mut raw_params: *const *const c_char,70	mut raw_params: *const *const c_char,
71) {71) {
72	let name = CStr::from_ptr(name).to_str().expect("name is not utf-8");72	let name = unsafe { CStr::from_ptr(name).to_str().expect("name is not utf-8") };
73	let mut params = Vec::new();73	let mut params = Vec::new();
74	loop {74	loop {
75		if (*raw_params).is_null() {75		if (unsafe { *raw_params }).is_null() {
76			break;76			break;
77		}77		}
78		let param = CStr::from_ptr(*raw_params)78		let param = unsafe {
79			CStr::from_ptr(*raw_params)
79			.to_str()80				.to_str()
80			.expect("param name is not utf-8");81				.expect("param name is not utf-8")
82		};
81		params.push(param.into());83		params.push(param.into());
82		raw_params = raw_params.offset(1);84		raw_params = unsafe { raw_params.offset(1) };
83	}85	}
8486
85	let any_resolver = vm.state.context_initializer();87	let any_resolver = vm.state.context_initializer();
91			name,93			name,
92			#[allow(deprecated)]94			#[allow(deprecated)]
93			NativeCallback::new(params, JsonnetNativeCallbackHandler { ctx, cb }),95			NativeCallback::new(params, JsonnetNativeCallbackHandler { ctx, cb }),
94		)96		);
95}97}
9698

16/// `v` should be a NUL-terminated string16/// `v` should be a NUL-terminated string
17#[no_mangle]17#[no_mangle]
18pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {18pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {
19	let val = CStr::from_ptr(val);19	let val = unsafe { CStr::from_ptr(val) };
20	let val = val.to_str().expect("string is not utf-8");20	let val = val.to_str().expect("string is not utf-8");
21	Box::into_raw(Box::new(Val::string(val)))21	Box::into_raw(Box::new(Val::string(val)))
22}22}

47) {47) {
48	match obj {48	match obj {
49		Val::Obj(old) => old49		Val::Obj(old) => old
50			.extend_field(CStr::from_ptr(name).to_str().unwrap().into())50			.extend_field(unsafe { CStr::from_ptr(name).to_str().unwrap().into() })
51			.value(val.clone()),51			.value(val.clone()),
52		_ => panic!("should receive object"),52		_ => panic!("should receive object"),
53	}53	}

16/// `name`, `code` should be a NUL-terminated strings16/// `name`, `code` should be a NUL-terminated strings
17#[no_mangle]17#[no_mangle]
18pub unsafe extern "C" fn jsonnet_ext_var(vm: &VM, name: *const c_char, value: *const c_char) {18pub unsafe extern "C" fn jsonnet_ext_var(vm: &VM, name: *const c_char, value: *const c_char) {
19	let name = CStr::from_ptr(name);19	let name = unsafe { CStr::from_ptr(name) };
20	let value = CStr::from_ptr(value);20	let value = unsafe { CStr::from_ptr(value) };
2121
22	let any_initializer = vm.state.context_initializer();22	let any_initializer = vm.state.context_initializer();
23	any_initializer23	any_initializer
39/// `name`, `code` should be a NUL-terminated strings39/// `name`, `code` should be a NUL-terminated strings
40#[no_mangle]40#[no_mangle]
41pub unsafe extern "C" fn jsonnet_ext_code(vm: &VM, name: *const c_char, code: *const c_char) {41pub unsafe extern "C" fn jsonnet_ext_code(vm: &VM, name: *const c_char, code: *const c_char) {
42	let name = CStr::from_ptr(name);42	let name = unsafe { CStr::from_ptr(name) };
43	let code = CStr::from_ptr(code);43	let code = unsafe { CStr::from_ptr(code) };
4444
45	let any_initializer = vm.state.context_initializer();45	let any_initializer = vm.state.context_initializer();
46	any_initializer46	any_initializer
63/// `name`, `value` should be a NUL-terminated strings63/// `name`, `value` should be a NUL-terminated strings
64#[no_mangle]64#[no_mangle]
65pub unsafe extern "C" fn jsonnet_tla_var(vm: &mut VM, name: *const c_char, value: *const c_char) {65pub unsafe extern "C" fn jsonnet_tla_var(vm: &mut VM, name: *const c_char, value: *const c_char) {
66	let name = CStr::from_ptr(name);66	let name = unsafe { CStr::from_ptr(name) };
67	let value = CStr::from_ptr(value);67	let value = unsafe { CStr::from_ptr(value) };
68	vm.tla_args.insert(68	vm.tla_args.insert(
69		name.to_str().expect("name is not utf-8").into(),69		name.to_str().expect("name is not utf-8").into(),
70		TlaArg::String(value.to_str().expect("value is not utf-8").into()),70		TlaArg::String(value.to_str().expect("value is not utf-8").into()),
80/// `name`, `code` should be a NUL-terminated strings80/// `name`, `code` should be a NUL-terminated strings
81#[no_mangle]81#[no_mangle]
82pub unsafe extern "C" fn jsonnet_tla_code(vm: &mut VM, name: *const c_char, code: *const c_char) {82pub unsafe extern "C" fn jsonnet_tla_code(vm: &mut VM, name: *const c_char, code: *const c_char) {
83	let name = CStr::from_ptr(name);83	let name = unsafe { CStr::from_ptr(name) };
84	let code = CStr::from_ptr(code);84	let code = unsafe { CStr::from_ptr(code) };
8585
86	let name: IStr = name.to_str().expect("name is not utf-8").into();86	let name: IStr = name.to_str().expect("name is not utf-8").into();
87	let code: IStr = code.to_str().expect("code is not utf-8").into();87	let code: IStr = code.to_str().expect("code is not utf-8").into();

328			format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);328			format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);
329			p!(out, if("between args", multi_line, nl));329			p!(out, if("between args", multi_line, nl));
330		}330		}
331		if end_comments.should_start_with_newline {
332			p!(out, nl);
333		}
334		format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
331		p!(out, if("end args", multi_line, <i info(end)) str(")"));335		p!(out, if("end args", multi_line, <i info(end)) str(")"));
332	}336	}
333}337}

1use std::{cell::Cell, fmt, rc::Rc};1use std::{cell::Cell, fmt, rc::Rc};
22
3use miette::{LabeledSpan, SourceOffset, SourceSpan};
4use rowan::{GreenNode, TextRange};3use rowan::{GreenNode, TextRange};
54
6use crate::{5use crate::{
53	pub range: TextRange,52	pub range: TextRange,
54}53}
55
56impl From<LocatedSyntaxError> for LabeledSpan {
57	fn from(val: LocatedSyntaxError) -> Self {
58		let span = SourceSpan::new(
59			SourceOffset::from(usize::from(val.range.start())),
60			usize::from(val.range.end() - val.range.start()),
61		);
62		dbg!(&val);
63		match val.error {
64			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(
65				Some(format!("expected {expected}, found {found:?}")),
66				span,
67			),
68			SyntaxError::Missing { expected } => {
69				LabeledSpan::new_with_span(Some(format!("missing {expected}")), span)
70			}
71			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {
72				LabeledSpan::new_with_span(Some(error), span)
73			}
74		}
75	}
76}
7754
78impl Parser {55impl Parser {
79	pub fn new(kinds: Vec<SyntaxKind>) -> Self {56	pub fn new(kinds: Vec<SyntaxKind>) -> Self {