`6e40dd49aa72`

5 files changed

modifiedbindings/jsonnet/src/lib.rsdiff before after both

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

modifiedcrates/jrsonnet-evaluator/src/builtin/format.rsdiff before after both

470	let mut tmp_out = String::new();470	let mut tmp_out = String::new();
471471
472	match code.convtype {472	match code.convtype {
473		ConvTypeV::String => tmp_out.push_str(&value.clone().into_string()?),473		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),
474		ConvTypeV::Decimal => {474		ConvTypeV::Decimal => {
475			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;475			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;
476			render_decimal(476			render_decimal(

modifiedcrates/jrsonnet-evaluator/src/evaluate.rsdiff before after both

95		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),95		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),
96		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),96		(Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),
9797
98		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_string()?).into()),98		(Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().to_string()?).into()),
99		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_string()?, s).into()),99		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),
100100
101		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),101		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
102		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),102		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
975			if assertion_result {975			if assertion_result {
976				evaluate(context, returned)?976				evaluate(context, returned)?
977			} else if let Some(msg) = msg {977			} else if let Some(msg) = msg {
978				throw!(AssertionFailed(evaluate(context, msg)?));978				throw!(AssertionFailed(evaluate(context, msg)?.to_string()?));
979			} else {979			} else {
980				throw!(AssertionFailed(Val::Null));980				throw!(AssertionFailed(Val::Null.to_string()?));
981			}981			}
982		}982		}
983		ErrorStmt(e) => push(983		ErrorStmt(e) => push(

modifiedcrates/jrsonnet-evaluator/src/lib.rsdiff before after both

321	pub fn manifest(&self, val: Val) -> Result<Rc<str>> {321	pub fn manifest(&self, val: Val) -> Result<Rc<str>> {
322		self.run_in_state(|| val.manifest(&self.manifest_format()))322		self.run_in_state(|| val.manifest(&self.manifest_format()))
323	}323	}
324	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(Rc<str>, Rc<str>)>> {
325		self.run_in_state(|| val.manifest_multi(&self.manifest_format()))
326	}
327	pub fn manifest_stream(&self, val: Val) -> Result<Vec<Rc<str>>> {
328		self.run_in_state(|| val.manifest_stream(&self.manifest_format()))
329	}
324330
325	/// If passed value is function - call with set TLA331	/// If passed value is function - call with set TLA
326	pub fn with_tla(&self, val: Val) -> Result<Val> {332	pub fn with_tla(&self, val: Val) -> Result<Val> {

modifiedcrates/jrsonnet-evaluator/src/val.rsdiff before after both

213		})213		})
214	}214	}
215215
216	pub fn into_string(self) -> Result<Rc<str>> {216	pub fn to_string(&self) -> Result<Rc<str>> {
217		Ok(match self.unwrap_if_lazy()? {217		Ok(match self.unwrap_if_lazy()? {
218			Val::Bool(true) => "true".into(),218			Val::Bool(true) => "true".into(),
219			Val::Bool(false) => "false".into(),219			Val::Bool(false) => "false".into(),
230		})230		})
231	}231	}
232232
233	/// Expects value to be object, outputs (key, manifested value) pairs
234	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {
235		let obj = match self {
236			Val::Obj(obj) => obj,
237			_ => throw!(MultiManifestOutputIsNotAObject),
238		};
239		let keys = obj.visible_fields();
240		let mut out = Vec::with_capacity(keys.len());
241		for key in keys {
242			let value = obj
243				.get(key.clone())?
244				.expect("item in object")
245				.manifest(ty)?;
246			out.push((key, value));
247		}
248		Ok(out)
249	}
250
251	/// Expects value to be array, outputs manifested values
252	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {
253		let arr = match self {
254			Val::Arr(a) => a,
255			_ => throw!(StreamManifestOutputIsNotAArray),
256		};
257		let mut out = Vec::with_capacity(arr.len());
258		for i in arr.iter() {
259			out.push(i.manifest(ty)?);
260		}
261		Ok(out)
262	}
233263
234	pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {264	pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {
235		Ok(match ty {265		Ok(match ty {