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

161	})161	})
162}162}
163163
164fn multi_to_raw(multi: Vec<(Rc<str>, Rc<str>)>) -> *const c_char {
165	let mut out = Vec::new();
166	for (i, (k, v)) in multi.iter().enumerate() {
167		if i != 0 {
168			out.push(0);
169		}
170		out.extend_from_slice(k.as_bytes());
171		out.push(0);
172		out.extend_from_slice(v.as_bytes());
173	}
174	out.push(0);
175	out.push(0);
176	let v = out.as_ptr();
177	std::mem::forget(out);
178	v as *const c_char
179}
180
181/// # Safety
164#[no_mangle]182#[no_mangle]
165pub extern "C" fn jsonnet_evaluate_file_multi() {183pub unsafe extern "C" fn jsonnet_evaluate_file_multi(
184	vm: &EvaluationState,
185	filename: *const c_char,
186	error: &mut c_int,
187) -> *const c_char {
188	vm.run_in_state(|| {
189		let filename = CStr::from_ptr(filename);
190		match vm
191			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
192			.and_then(|v| vm.with_tla(v))
193			.and_then(|v| vm.manifest_multi(v))
194		{
195			Ok(v) => {
196				*error = 0;
197				multi_to_raw(v)
198			}
199			Err(e) => {
200				*error = 1;
201				let out = vm.stringify_err(&e);
166	todo!()202				CString::new(&out as &str).unwrap().into_raw()
203			}
167}204		}
205	})
206}
207
208/// # Safety
168#[no_mangle]209#[no_mangle]
169pub extern "C" fn jsonnet_evaluate_snippet_multi() {210pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(
211	vm: &EvaluationState,
212	filename: *const c_char,
213	snippet: *const c_char,
214	error: &mut c_int,
215) -> *const c_char {
216	vm.run_in_state(|| {
217		let filename = CStr::from_ptr(filename);
218		let snippet = CStr::from_ptr(snippet);
219		match vm
220			.evaluate_snippet_raw(
221				Rc::new(PathBuf::from(filename.to_str().unwrap())),
222				snippet.to_str().unwrap().into(),
223			)
224			.and_then(|v| vm.with_tla(v))
225			.and_then(|v| vm.manifest_multi(v))
226		{
227			Ok(v) => {
228				*error = 0;
229				multi_to_raw(v)
230			}
231			Err(e) => {
232				*error = 1;
233				let out = vm.stringify_err(&e);
170	todo!()234				CString::new(&out as &str).unwrap().into_raw()
235			}
171}236		}
237	})
238}
239
240fn stream_to_raw(multi: Vec<Rc<str>>) -> *const c_char {
241	let mut out = Vec::new();
242	for (i, v) in multi.iter().enumerate() {
243		if i != 0 {
244			out.push(0);
245		}
246		out.extend_from_slice(v.as_bytes());
247	}
248	out.push(0);
249	out.push(0);
250	let v = out.as_ptr();
251	std::mem::forget(out);
252	v as *const c_char
253}
254
255/// # Safety
172#[no_mangle]256#[no_mangle]
173pub extern "C" fn jsonnet_evaluate_file_stream() {257pub unsafe extern "C" fn jsonnet_evaluate_file_stream(
258	vm: &EvaluationState,
259	filename: *const c_char,
260	error: &mut c_int,
261) -> *const c_char {
262	vm.run_in_state(|| {
263		let filename = CStr::from_ptr(filename);
264		match vm
265			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
266			.and_then(|v| vm.with_tla(v))
267			.and_then(|v| vm.manifest_stream(v))
268		{
269			Ok(v) => {
270				*error = 0;
271				stream_to_raw(v)
272			}
273			Err(e) => {
274				*error = 1;
275				let out = vm.stringify_err(&e);
174	todo!()276				CString::new(&out as &str).unwrap().into_raw()
277			}
175}278		}
279	})
280}
281
282/// # Safety
176#[no_mangle]283#[no_mangle]
177pub extern "C" fn jsonnet_evaluate_snippet_stream() {284pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(
285	vm: &EvaluationState,
286	filename: *const c_char,
287	snippet: *const c_char,
288	error: &mut c_int,
289) -> *const c_char {
290	vm.run_in_state(|| {
291		let filename = CStr::from_ptr(filename);
292		let snippet = CStr::from_ptr(snippet);
293		match vm
294			.evaluate_snippet_raw(
295				Rc::new(PathBuf::from(filename.to_str().unwrap())),
296				snippet.to_str().unwrap().into(),
297			)
298			.and_then(|v| vm.with_tla(v))
299			.and_then(|v| vm.manifest_stream(v))
300		{
301			Ok(v) => {
302				*error = 0;
303				stream_to_raw(v)
304			}
305			Err(e) => {
306				*error = 1;
307				let out = vm.stringify_err(&e);
178	todo!()308				CString::new(&out as &str).unwrap().into_raw()
309			}
179}310		}
311	})
312}
180313

--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -470,7 +470,7 @@
 	let mut tmp_out = String::new();
 
 	match code.convtype {
-		ConvTypeV::String => tmp_out.push_str(&value.clone().into_string()?),
+		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),
 		ConvTypeV::Decimal => {
 			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;
 			render_decimal(

--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -95,8 +95,8 @@
 		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),
 		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),
 
-		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_string()?).into()),
-		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_string()?, s).into()),
+		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().to_string()?).into()),
+		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),
 
 		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
 		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
@@ -975,9 +975,9 @@
 			if assertion_result {
 				evaluate(context, returned)?
 			} else if let Some(msg) = msg {
-				throw!(AssertionFailed(evaluate(context, msg)?));
+				throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));
 			} else {
-				throw!(AssertionFailed(Val::Null));
+				throw!(AssertionFailed(Val::Null.to_string()?));
 			}
 		}
 		ErrorStmt(e) => push(

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -321,6 +321,12 @@
 	pub fn manifest(&self, val: Val) -> Result<Rc<str>> {
 		self.run_in_state(|| val.manifest(&self.manifest_format()))
 	}
+	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(Rc<str>, Rc<str>)>> {
+		self.run_in_state(|| val.manifest_multi(&self.manifest_format()))
+	}
+	pub fn manifest_stream(&self, val: Val) -> Result<Vec<Rc<str>>> {
+		self.run_in_state(|| val.manifest_stream(&self.manifest_format()))
+	}
 
 	/// If passed value is function - call with set TLA
 	pub fn with_tla(&self, val: Val) -> Result<Val> {

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -213,7 +213,7 @@
 		})
 	}
 
-	pub fn into_string(self) -> Result<Rc<str>> {
+	pub fn to_string(&self) -> Result<Rc<str>> {
 		Ok(match self.unwrap_if_lazy()? {
 			Val::Bool(true) => "true".into(),
 			Val::Bool(false) => "false".into(),
@@ -230,6 +230,36 @@
 		})
 	}
 
+	/// Expects value to be object, outputs (key, manifested value) pairs
+	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {
+		let obj = match self {
+			Val::Obj(obj) => obj,
+			_ => throw!(MultiManifestOutputIsNotAObject),
+		};
+		let keys = obj.visible_fields();
+		let mut out = Vec::with_capacity(keys.len());
+		for key in keys {
+			let value = obj
+				.get(key.clone())?
+				.expect("item in object")
+				.manifest(ty)?;
+			out.push((key, value));
+		}
+		Ok(out)
+	}
+
+	/// Expects value to be array, outputs manifested values
+	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {
+		let arr = match self {
+			Val::Arr(a) => a,
+			_ => throw!(StreamManifestOutputIsNotAArray),
+		};
+		let mut out = Vec::with_capacity(arr.len());
+		for i in arr.iter() {
+			out.push(i.manifest(ty)?);
+		}
+		Ok(out)
+	}
 
 	pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {
 		Ok(match ty {