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

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -1,3 +1,10 @@
+# NOTE: This library may panic, and it is only safe to panic in FFI contexts when library is built in panic="abort" mode,
+# which is set for release builds of this library.
+# FIXME: Move this warning somewhere else, or remove panics from this library (It is not always possible, in some cases
+# there is nothing to report the error, in those cases use `abort()`)
+# NOTE: This library assumes the allocator is libc malloc or alternative, which does track allocation size for user,
+# see TODO in `jsonnet_realloc`.
+
 [package]
 name = "libjsonnet"
 description = "Rust implementation of libjsonnet.so"

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -129,7 +129,7 @@
 /// `path` should be a NUL-terminated string
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_jpath_add(vm: &VM, path: *const c_char) {
-	let cstr = CStr::from_ptr(path);
+	let cstr = unsafe { CStr::from_ptr(path) };
 	let path = PathBuf::from(cstr.to_str().unwrap());
 	let any_resolver = vm.state.import_resolver();
 	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())

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -17,7 +17,7 @@
 /// failure, which will appear in Jsonnet as an error. The `argv` pointer is an array whose size
 /// matches the array of parameters supplied when the native callback was originally registered.
 ///
-/// - `ctx` User pointer, given in jsonnet_native_callback.
+/// - `ctx` User pointer, given in `jsonnet_native_callback`.
 /// - `argv` Array of arguments from Jsonnet code.
 /// - `param` success Set this byref param to 1 to indicate success and 0 for failure.
 /// Returns the content of the imported file, or an error message.
@@ -69,17 +69,19 @@
 	ctx: *const c_void,
 	mut raw_params: *const *const c_char,
 ) {
-	let name = CStr::from_ptr(name).to_str().expect("name is not utf-8");
+	let name = unsafe { CStr::from_ptr(name).to_str().expect("name is not utf-8") };
 	let mut params = Vec::new();
 	loop {
-		if (*raw_params).is_null() {
+		if (unsafe { *raw_params }).is_null() {
 			break;
 		}
-		let param = CStr::from_ptr(*raw_params)
-			.to_str()
-			.expect("param name is not utf-8");
+		let param = unsafe {
+			CStr::from_ptr(*raw_params)
+				.to_str()
+				.expect("param name is not utf-8")
+		};
 		params.push(param.into());
-		raw_params = raw_params.offset(1);
+		raw_params = unsafe { raw_params.offset(1) };
 	}
 
 	let any_resolver = vm.state.context_initializer();
@@ -91,5 +93,5 @@
 			name,
 			#[allow(deprecated)]
 			NativeCallback::new(params, JsonnetNativeCallbackHandler { ctx, cb }),
-		)
+		);
 }

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -16,7 +16,7 @@
 /// `v` should be a NUL-terminated string
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &VM, val: *const c_char) -> *mut Val {
-	let val = CStr::from_ptr(val);
+	let val = unsafe { CStr::from_ptr(val) };
 	let val = val.to_str().expect("string is not utf-8");
 	Box::into_raw(Box::new(Val::string(val)))
 }

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -47,7 +47,7 @@
 ) {
 	match obj {
 		Val::Obj(old) => old
-			.extend_field(CStr::from_ptr(name).to_str().unwrap().into())
+			.extend_field(unsafe { CStr::from_ptr(name).to_str().unwrap().into() })
 			.value(val.clone()),
 		_ => panic!("should receive object"),
 	}

--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -16,8 +16,8 @@
 /// `name`, `code` should be a NUL-terminated strings
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_ext_var(vm: &VM, name: *const c_char, value: *const c_char) {
-	let name = CStr::from_ptr(name);
-	let value = CStr::from_ptr(value);
+	let name = unsafe { CStr::from_ptr(name) };
+	let value = unsafe { CStr::from_ptr(value) };
 
 	let any_initializer = vm.state.context_initializer();
 	any_initializer
@@ -39,8 +39,8 @@
 /// `name`, `code` should be a NUL-terminated strings
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_ext_code(vm: &VM, name: *const c_char, code: *const c_char) {
-	let name = CStr::from_ptr(name);
-	let code = CStr::from_ptr(code);
+	let name = unsafe { CStr::from_ptr(name) };
+	let code = unsafe { CStr::from_ptr(code) };
 
 	let any_initializer = vm.state.context_initializer();
 	any_initializer
@@ -63,8 +63,8 @@
 /// `name`, `value` should be a NUL-terminated strings
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_tla_var(vm: &mut VM, name: *const c_char, value: *const c_char) {
-	let name = CStr::from_ptr(name);
-	let value = CStr::from_ptr(value);
+	let name = unsafe { CStr::from_ptr(name) };
+	let value = unsafe { CStr::from_ptr(value) };
 	vm.tla_args.insert(
 		name.to_str().expect("name is not utf-8").into(),
 		TlaArg::String(value.to_str().expect("value is not utf-8").into()),
@@ -80,8 +80,8 @@
 /// `name`, `code` should be a NUL-terminated strings
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_tla_code(vm: &mut VM, name: *const c_char, code: *const c_char) {
-	let name = CStr::from_ptr(name);
-	let code = CStr::from_ptr(code);
+	let name = unsafe { CStr::from_ptr(name) };
+	let code = unsafe { CStr::from_ptr(code) };
 
 	let name: IStr = name.to_str().expect("name is not utf-8").into();
 	let code: IStr = code.to_str().expect("code is not utf-8").into();

--- a/cmds/jrsonnet-fmt/src/main.rs
+++ b/cmds/jrsonnet-fmt/src/main.rs
@@ -328,6 +328,10 @@
 			format_comments(&ele.inline_trivia, CommentLocation::ItemInline, out);
 			p!(out, if("between args", multi_line, nl));
 		}
+		if end_comments.should_start_with_newline {
+			p!(out, nl);
+		}
+		format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
 		p!(out, if("end args", multi_line, <i info(end)) str(")"));
 	}
 }

--- a/crates/jrsonnet-rowan-parser/src/parser.rs
+++ b/crates/jrsonnet-rowan-parser/src/parser.rs
@@ -1,6 +1,5 @@
 use std::{cell::Cell, fmt, rc::Rc};
 
-use miette::{LabeledSpan, SourceOffset, SourceSpan};
 use rowan::{GreenNode, TextRange};
 
 use crate::{
@@ -51,28 +50,6 @@
 pub struct LocatedSyntaxError {
 	pub error: SyntaxError,
 	pub range: TextRange,
-}
-
-impl From<LocatedSyntaxError> for LabeledSpan {
-	fn from(val: LocatedSyntaxError) -> Self {
-		let span = SourceSpan::new(
-			SourceOffset::from(usize::from(val.range.start())),
-			usize::from(val.range.end() - val.range.start()),
-		);
-		dbg!(&val);
-		match val.error {
-			SyntaxError::Unexpected { expected, found } => LabeledSpan::new_with_span(
-				Some(format!("expected {expected}, found {found:?}")),
-				span,
-			),
-			SyntaxError::Missing { expected } => {
-				LabeledSpan::new_with_span(Some(format!("missing {expected}")), span)
-			}
-			SyntaxError::Custom { error } | SyntaxError::Hint { error } => {
-				LabeledSpan::new_with_span(Some(error), span)
-			}
-		}
-	}
 }
 
 impl Parser {