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

1515
16use jrsonnet_evaluator::{16use jrsonnet_evaluator::{
17	error::{Error::*, Result},17	error::{Error::*, Result},
18	throw, EvaluationState, ImportResolver,18	throw, ImportResolver, State,
19};19};
2020
21pub type JsonnetImportCallback = unsafe extern "C" fn(21pub type JsonnetImportCallback = unsafe extern "C" fn(
87/// # Safety87/// # Safety
88#[no_mangle]88#[no_mangle]
89pub unsafe extern "C" fn jsonnet_import_callback(89pub unsafe extern "C" fn jsonnet_import_callback(
90	vm: &EvaluationState,90	vm: &State,
91	cb: JsonnetImportCallback,91	cb: JsonnetImportCallback,
92	ctx: *mut c_void,92	ctx: *mut c_void,
93) {93) {
141///141///
142/// This function is safe, if received v is a pointer to normal C string142/// This function is safe, if received v is a pointer to normal C string
143#[no_mangle]143#[no_mangle]
144pub unsafe extern "C" fn jsonnet_jpath_add(vm: &EvaluationState, v: *const c_char) {144pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, v: *const c_char) {
145	let cstr = CStr::from_ptr(v);145	let cstr = CStr::from_ptr(v);
146	let path = PathBuf::from(cstr.to_str().unwrap());146	let path = PathBuf::from(cstr.to_str().unwrap());
147	let any_resolver = &vm.settings().import_resolver;147	let any_resolver = &vm.settings().import_resolver;

5	os::raw::{c_char, c_int},5	os::raw::{c_char, c_int},
6};6};
77
8use jrsonnet_evaluator::{EvaluationState, Val};8use jrsonnet_evaluator::{State, Val};
99
10use crate::{import::jsonnet_import_callback, native::jsonnet_native_callback};10use crate::{import::jsonnet_import_callback, native::jsonnet_native_callback};
1111
2828
29/// # Safety29/// # Safety
30#[no_mangle]30#[no_mangle]
31pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(31pub unsafe extern "C" fn jrsonnet_apply_static_import_callback(vm: &State, ctx: *mut c_void) {
32	vm: &EvaluationState,
33	ctx: *mut c_void,
34) {
35	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)32	jsonnet_import_callback(vm, _jrsonnet_static_import_callback, ctx)
38/// # Safety35/// # Safety
39#[no_mangle]36#[no_mangle]
40pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(37pub unsafe extern "C" fn jrsonnet_apply_static_native_callback(
41	vm: &EvaluationState,38	vm: &State,
42	name: *const c_char,39	name: *const c_char,
43	ctx: *mut c_void,40	ctx: *mut c_void,
44	raw_params: *const *const c_char,41	raw_params: *const *const c_char,
47}44}
4845
49#[no_mangle]46#[no_mangle]
50pub extern "C" fn jrsonnet_set_trace_format(vm: &EvaluationState, format: u8) {47pub extern "C" fn jrsonnet_set_trace_format(vm: &State, format: u8) {
51	use jrsonnet_evaluator::trace::JsFormat;48	use jrsonnet_evaluator::trace::JsFormat;
52	match format {49	match format {
53		1 => vm.set_trace_format(Box::new(JsFormat)),50		1 => vm.set_trace_format(Box::new(JsFormat)),

16};16};
1717
18use import::NativeImportResolver;18use import::NativeImportResolver;
19use jrsonnet_evaluator::{EvaluationState, IStr, ManifestFormat, Val};19use jrsonnet_evaluator::{IStr, ManifestFormat, State, Val};
2020
21/// WASM stub21/// WASM stub
22#[cfg(target_arch = "wasm32")]22#[cfg(target_arch = "wasm32")]
29}29}
3030
31#[no_mangle]31#[no_mangle]
32pub extern "C" fn jsonnet_make() -> *mut EvaluationState {32pub extern "C" fn jsonnet_make() -> *mut State {
33	let state = EvaluationState::default();33	let state = State::default();
34	state.with_stdlib();34	state.with_stdlib();
35	state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());35	state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());
36	Box::into_raw(Box::new(state))36	Box::into_raw(Box::new(state))
39/// # Safety39/// # Safety
40#[no_mangle]40#[no_mangle]
41#[allow(clippy::boxed_local)]41#[allow(clippy::boxed_local)]
42pub unsafe extern "C" fn jsonnet_destroy(vm: *mut EvaluationState) {42pub unsafe extern "C" fn jsonnet_destroy(vm: *mut State) {
43	Box::from_raw(vm);43	Box::from_raw(vm);
44}44}
4545
46#[no_mangle]46#[no_mangle]
47pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {47pub extern "C" fn jsonnet_max_stack(vm: &State, v: c_uint) {
48	vm.settings_mut().max_stack = v as usize;48	vm.settings_mut().max_stack = v as usize;
49}49}
5050
51// jrsonnet currently have no GC, so these functions is no-op51// jrsonnet currently have no GC, so these functions is no-op
52#[no_mangle]52#[no_mangle]
53pub extern "C" fn jsonnet_gc_min_objects(_vm: &EvaluationState, _v: c_uint) {}53pub extern "C" fn jsonnet_gc_min_objects(_vm: &State, _v: c_uint) {}
54#[no_mangle]54#[no_mangle]
55pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &EvaluationState, _v: c_double) {}55pub extern "C" fn jsonnet_gc_growth_trigger(_vm: &State, _v: c_double) {}
5656
57#[no_mangle]57#[no_mangle]
58pub extern "C" fn jsonnet_string_output(vm: &EvaluationState, v: c_int) {58pub extern "C" fn jsonnet_string_output(vm: &State, v: c_int) {
59	match v {59	match v {
60		1 => vm.set_manifest_format(ManifestFormat::String),60		1 => vm.set_manifest_format(ManifestFormat::String),
61		0 => vm.set_manifest_format(ManifestFormat::Json {61		0 => vm.set_manifest_format(ManifestFormat::Json {
71///71///
72/// This function is most definitely broken, but it works somehow, see TODO inside72/// This function is most definitely broken, but it works somehow, see TODO inside
73#[no_mangle]73#[no_mangle]
74pub unsafe extern "C" fn jsonnet_realloc(74pub unsafe extern "C" fn jsonnet_realloc(_vm: &State, buf: *mut u8, sz: usize) -> *mut u8 {
75	_vm: &EvaluationState,
76	buf: *mut u8,
77	sz: usize,
78) -> *mut u8 {
95/// # Safety91/// # Safety
96#[no_mangle]92#[no_mangle]
97#[allow(clippy::boxed_local)]93#[allow(clippy::boxed_local)]
98pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &EvaluationState, v: *mut Val) {94pub unsafe extern "C" fn jsonnet_json_destroy(_vm: &State, v: *mut Val) {
99	Box::from_raw(v);95	Box::from_raw(v);
100}96}
10197
102#[no_mangle]98#[no_mangle]
103pub extern "C" fn jsonnet_max_trace(vm: &EvaluationState, v: c_uint) {99pub extern "C" fn jsonnet_max_trace(vm: &State, v: c_uint) {
104	vm.set_max_trace(v as usize)100	vm.set_max_trace(v as usize)
105}101}
106102
109/// This function is safe, if received v is a pointer to normal C string105/// This function is safe, if received v is a pointer to normal C string
110#[no_mangle]106#[no_mangle]
111pub unsafe extern "C" fn jsonnet_evaluate_file(107pub unsafe extern "C" fn jsonnet_evaluate_file(
112	vm: &EvaluationState,108	vm: &State,
113	filename: *const c_char,109	filename: *const c_char,
114	error: &mut c_int,110	error: &mut c_int,
115) -> *const c_char {111) -> *const c_char {
116	vm.run_in_state(|| {
117		let filename = CStr::from_ptr(filename);112	let filename = CStr::from_ptr(filename);
118		match vm113	match vm
119			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))114		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
130				CString::new(&out as &str).unwrap().into_raw()125			CString::new(&out as &str).unwrap().into_raw()
131			}126		}
132		}127	}
133	})
134}128}
135129
136/// # Safety130/// # Safety
137///131///
138/// This function is safe, if received v is a pointer to normal C string132/// This function is safe, if received v is a pointer to normal C string
139#[no_mangle]133#[no_mangle]
140pub unsafe extern "C" fn jsonnet_evaluate_snippet(134pub unsafe extern "C" fn jsonnet_evaluate_snippet(
141	vm: &EvaluationState,135	vm: &State,
142	filename: *const c_char,136	filename: *const c_char,
143	snippet: *const c_char,137	snippet: *const c_char,
144	error: &mut c_int,138	error: &mut c_int,
145) -> *const c_char {139) -> *const c_char {
146	vm.run_in_state(|| {
147		let filename = CStr::from_ptr(filename);140	let filename = CStr::from_ptr(filename);
148		let snippet = CStr::from_ptr(snippet);141	let snippet = CStr::from_ptr(snippet);
149		match vm142	match vm
164				CString::new(&out as &str).unwrap().into_raw()157			CString::new(&out as &str).unwrap().into_raw()
165			}158		}
166		}159	}
167	})
168}160}
169161
170fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {162fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {
187/// # Safety179/// # Safety
188#[no_mangle]180#[no_mangle]
189pub unsafe extern "C" fn jsonnet_evaluate_file_multi(181pub unsafe extern "C" fn jsonnet_evaluate_file_multi(
190	vm: &EvaluationState,182	vm: &State,
191	filename: *const c_char,183	filename: *const c_char,
192	error: &mut c_int,184	error: &mut c_int,
193) -> *const c_char {185) -> *const c_char {
194	vm.run_in_state(|| {
195		let filename = CStr::from_ptr(filename);186	let filename = CStr::from_ptr(filename);
196		match vm187	match vm
197			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))188		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
208				CString::new(&out as &str).unwrap().into_raw()199			CString::new(&out as &str).unwrap().into_raw()
209			}200		}
210		}201	}
211	})
212}202}
213203
214/// # Safety204/// # Safety
215#[no_mangle]205#[no_mangle]
216pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(206pub unsafe extern "C" fn jsonnet_evaluate_snippet_multi(
217	vm: &EvaluationState,207	vm: &State,
218	filename: *const c_char,208	filename: *const c_char,
219	snippet: *const c_char,209	snippet: *const c_char,
220	error: &mut c_int,210	error: &mut c_int,
221) -> *const c_char {211) -> *const c_char {
222	vm.run_in_state(|| {
223		let filename = CStr::from_ptr(filename);212	let filename = CStr::from_ptr(filename);
224		let snippet = CStr::from_ptr(snippet);213	let snippet = CStr::from_ptr(snippet);
225		match vm214	match vm
240				CString::new(&out as &str).unwrap().into_raw()229			CString::new(&out as &str).unwrap().into_raw()
241			}230		}
242		}231	}
243	})
244}232}
245233
246fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {234fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {
261/// # Safety249/// # Safety
262#[no_mangle]250#[no_mangle]
263pub unsafe extern "C" fn jsonnet_evaluate_file_stream(251pub unsafe extern "C" fn jsonnet_evaluate_file_stream(
264	vm: &EvaluationState,252	vm: &State,
265	filename: *const c_char,253	filename: *const c_char,
266	error: &mut c_int,254	error: &mut c_int,
267) -> *const c_char {255) -> *const c_char {
268	vm.run_in_state(|| {
269		let filename = CStr::from_ptr(filename);256	let filename = CStr::from_ptr(filename);
270		match vm257	match vm
271			.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))258		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))
282				CString::new(&out as &str).unwrap().into_raw()269			CString::new(&out as &str).unwrap().into_raw()
283			}270		}
284		}271	}
285	})
286}272}
287273
288/// # Safety274/// # Safety
289#[no_mangle]275#[no_mangle]
290pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(276pub unsafe extern "C" fn jsonnet_evaluate_snippet_stream(
291	vm: &EvaluationState,277	vm: &State,
292	filename: *const c_char,278	filename: *const c_char,
293	snippet: *const c_char,279	snippet: *const c_char,
294	error: &mut c_int,280	error: &mut c_int,
295) -> *const c_char {281) -> *const c_char {
296	vm.run_in_state(|| {
297		let filename = CStr::from_ptr(filename);282	let filename = CStr::from_ptr(filename);
298		let snippet = CStr::from_ptr(snippet);283	let snippet = CStr::from_ptr(snippet);
299		match vm284	match vm
314				CString::new(&out as &str).unwrap().into_raw()299			CString::new(&out as &str).unwrap().into_raw()
315			}300		}
316		}301	}
317	})
318}302}
319303

1use std::{1use std::{
2	convert::TryFrom,
3	ffi::{c_void, CStr},2	ffi::{c_void, CStr},
4	os::raw::{c_char, c_int},3	os::raw::{c_char, c_int},
5	path::Path,4	path::Path,
12	function::BuiltinParam,11	function::BuiltinParam,
13	gc::TraceBox,12	gc::TraceBox,
14	native::{NativeCallback, NativeCallbackHandler},13	native::{NativeCallback, NativeCallbackHandler},
15	EvaluationState, IStr, Val,14	typed::Typed,
15	IStr, State, Val,
16};16};
1717
18type JsonnetNativeCallback = unsafe extern "C" fn(18type JsonnetNativeCallback = unsafe extern "C" fn(
29	cb: JsonnetNativeCallback,29	cb: JsonnetNativeCallback,
30}30}
31impl NativeCallbackHandler for JsonnetNativeCallbackHandler {31impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
32	fn call(&self, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {32	fn call(&self, s: State, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {
33		let mut n_args = Vec::new();33		let mut n_args = Vec::new();
34		for a in args {34		for a in args {
35			n_args.push(Some(Box::new(a.clone())));35			n_args.push(Some(Box::new(a.clone())));
47		if success == 1 {47		if success == 1 {
48			Ok(v)48			Ok(v)
49		} else {49		} else {
50			let e = IStr::try_from(v).expect("error msg");50			let e = IStr::from_untyped(v, s).expect("error msg");
51			Err(Error::RuntimeError(e).into())51			Err(Error::RuntimeError(e).into())
52		}52		}
53	}53	}
56/// # Safety56/// # Safety
57#[no_mangle]57#[no_mangle]
58pub unsafe extern "C" fn jsonnet_native_callback(58pub unsafe extern "C" fn jsonnet_native_callback(
59	vm: &EvaluationState,59	vm: &State,
60	name: *const c_char,60	name: *const c_char,
61	cb: JsonnetNativeCallback,61	cb: JsonnetNativeCallback,
62	ctx: *const c_void,62	ctx: *const c_void,

5	os::raw::{c_char, c_double, c_int},5	os::raw::{c_char, c_double, c_int},
6};6};
77
8use jrsonnet_evaluator::{EvaluationState, Val};8use jrsonnet_evaluator::{State, Val};
99
10#[no_mangle]10#[no_mangle]
11pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {11pub extern "C" fn jsonnet_json_extract_string(_vm: &State, v: &Val) -> *mut c_char {
12	match v {12	match v {
13		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),13		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
14		_ => std::ptr::null_mut(),14		_ => std::ptr::null_mut(),
15	}15	}
16}16}
17#[no_mangle]17#[no_mangle]
18pub extern "C" fn jsonnet_json_extract_number(18pub extern "C" fn jsonnet_json_extract_number(_vm: &State, v: &Val, out: &mut c_double) -> c_int {
19	_vm: &EvaluationState,
20	v: &Val,
21	out: &mut c_double,
22) -> c_int {
29	}25	}
30}26}
31#[no_mangle]27#[no_mangle]
32pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {28pub extern "C" fn jsonnet_json_extract_bool(_vm: &State, v: &Val) -> c_int {
33	match v {29	match v {
34		Val::Bool(false) => 0,30		Val::Bool(false) => 0,
35		Val::Bool(true) => 1,31		Val::Bool(true) => 1,
36		_ => 2,32		_ => 2,
37	}33	}
38}34}
39#[no_mangle]35#[no_mangle]
40pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {36pub extern "C" fn jsonnet_json_extract_null(_vm: &State, v: &Val) -> c_int {
41	match v {37	match v {
42		Val::Null => 1,38		Val::Null => 1,
43		_ => 0,39		_ => 0,

6};6};
77
8use gcmodule::Cc;8use gcmodule::Cc;
9use jrsonnet_evaluator::{val::ArrValue, EvaluationState, ObjValue, Val};9use jrsonnet_evaluator::{val::ArrValue, ObjValue, State, Val};
1010
11/// # Safety11/// # Safety
12///12///
13/// This function is safe, if received v is a pointer to normal C string13/// This function is safe, if received v is a pointer to normal C string
14#[no_mangle]14#[no_mangle]
15pub unsafe extern "C" fn jsonnet_json_make_string(15pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &State, v: *const c_char) -> *mut Val {
16	_vm: &EvaluationState,
17	v: *const c_char,
18) -> *mut Val {
19	let cstr = CStr::from_ptr(v);16	let cstr = CStr::from_ptr(v);
22}19}
2320
24#[no_mangle]21#[no_mangle]
25pub extern "C" fn jsonnet_json_make_number(_vm: &EvaluationState, v: c_double) -> *mut Val {22pub extern "C" fn jsonnet_json_make_number(_vm: &State, v: c_double) -> *mut Val {
26	Box::into_raw(Box::new(Val::Num(v)))23	Box::into_raw(Box::new(Val::Num(v)))
27}24}
2825
29#[no_mangle]26#[no_mangle]
30pub extern "C" fn jsonnet_json_make_bool(_vm: &EvaluationState, v: c_int) -> *mut Val {27pub extern "C" fn jsonnet_json_make_bool(_vm: &State, v: c_int) -> *mut Val {
31	assert!(v == 0 || v == 1);28	assert!(v == 0 || v == 1);
32	Box::into_raw(Box::new(Val::Bool(v == 1)))29	Box::into_raw(Box::new(Val::Bool(v == 1)))
33}30}
3431
35#[no_mangle]32#[no_mangle]
36pub extern "C" fn jsonnet_json_make_null(_vm: &EvaluationState) -> *mut Val {33pub extern "C" fn jsonnet_json_make_null(_vm: &State) -> *mut Val {
37	Box::into_raw(Box::new(Val::Null))34	Box::into_raw(Box::new(Val::Null))
38}35}
3936
40#[no_mangle]37#[no_mangle]
41pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {38pub extern "C" fn jsonnet_json_make_array(_vm: &State) -> *mut Val {
42	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Cc::new(Vec::new())))))39	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Cc::new(Vec::new())))))
43}40}
4441
45#[no_mangle]42#[no_mangle]
46pub extern "C" fn jsonnet_json_make_object(_vm: &EvaluationState) -> *mut Val {43pub extern "C" fn jsonnet_json_make_object(_vm: &State) -> *mut Val {
47	Box::into_raw(Box::new(Val::Obj(ObjValue::new_empty())))44	Box::into_raw(Box::new(Val::Obj(ObjValue::new_empty())))
48}45}
4946

5use std::{ffi::CStr, os::raw::c_char};5use std::{ffi::CStr, os::raw::c_char};
66
7use gcmodule::Cc;7use gcmodule::Cc;
8use jrsonnet_evaluator::{val::ArrValue, EvaluationState, LazyVal, Val};8use jrsonnet_evaluator::{val::ArrValue, LazyVal, State, Val};
99
10/// # Safety10/// # Safety
11///11///
12/// Received arr value should be correct pointer to array allocated by make_array12/// Received arr value should be correct pointer to array allocated by make_array
13#[no_mangle]13#[no_mangle]
14pub unsafe extern "C" fn jsonnet_json_array_append(14pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &State, arr: &mut Val, val: &Val) {
15	_vm: &EvaluationState,
16	arr: &mut Val,
17	val: &Val,
18) {
34/// This function is safe if passed name is ok30/// This function is safe if passed name is ok
35#[no_mangle]31#[no_mangle]
36pub unsafe extern "C" fn jsonnet_json_object_append(32pub unsafe extern "C" fn jsonnet_json_object_append(
37	_vm: &EvaluationState,33	_vm: &State,
38	obj: &mut Val,34	obj: &mut Val,
39	name: *const c_char,35	name: *const c_char,
40	val: &Val,36	val: &Val,

22
3use std::{ffi::CStr, os::raw::c_char};3use std::{ffi::CStr, os::raw::c_char};
44
5use jrsonnet_evaluator::EvaluationState;5use jrsonnet_evaluator::State;
66
7/// # Safety7/// # Safety
8#[no_mangle]8#[no_mangle]
9pub unsafe extern "C" fn jsonnet_ext_var(9pub unsafe extern "C" fn jsonnet_ext_var(vm: &State, name: *const c_char, value: *const c_char) {
10	vm: &EvaluationState,
11	name: *const c_char,
12	value: *const c_char,
13) {
2117
22/// # Safety18/// # Safety
23#[no_mangle]19#[no_mangle]
24pub unsafe extern "C" fn jsonnet_ext_code(20pub unsafe extern "C" fn jsonnet_ext_code(vm: &State, name: *const c_char, value: *const c_char) {
25	vm: &EvaluationState,
26	name: *const c_char,
27	value: *const c_char,
28) {
36}28}
37/// # Safety29/// # Safety
38#[no_mangle]30#[no_mangle]
39pub unsafe extern "C" fn jsonnet_tla_var(31pub unsafe extern "C" fn jsonnet_tla_var(vm: &State, name: *const c_char, value: *const c_char) {
40	vm: &EvaluationState,
41	name: *const c_char,
42	value: *const c_char,
43) {
50}38}
51/// # Safety39/// # Safety
52#[no_mangle]40#[no_mangle]
53pub unsafe extern "C" fn jsonnet_tla_code(41pub unsafe extern "C" fn jsonnet_tla_code(vm: &State, name: *const c_char, value: *const c_char) {
54	vm: &EvaluationState,
55	name: *const c_char,
56	value: *const c_char,
57) {

7use clap::{AppSettings, IntoApp, Parser};7use clap::{AppSettings, IntoApp, Parser};
8use clap_complete::Shell;8use clap_complete::Shell;
9use jrsonnet_cli::{ConfigureState, GcOpts, GeneralOpts, InputOpts, ManifestOpts, OutputOpts};9use jrsonnet_cli::{ConfigureState, GcOpts, GeneralOpts, InputOpts, ManifestOpts, OutputOpts};
10use jrsonnet_evaluator::{error::LocError, EvaluationState};10use jrsonnet_evaluator::{error::LocError, State};
1111
12#[cfg(feature = "mimalloc")]12#[cfg(feature = "mimalloc")]
13#[global_allocator]13#[global_allocator]
102102
103fn main_catch(opts: Opts) -> bool {103fn main_catch(opts: Opts) -> bool {
104	let _printer = opts.gc.stats_printer();104	let _printer = opts.gc.stats_printer();
105	let state = EvaluationState::default();105	let s = State::default();
106	if let Err(e) = main_real(&state, opts) {106	if let Err(e) = main_real(&s, opts) {
107		if let Error::Evaluation(e) = e {107		if let Error::Evaluation(e) = e {
108			eprintln!("{}", state.stringify_err(&e));108			eprintln!("{}", s.stringify_err(&e));
109		} else {109		} else {
110			eprintln!("{}", e);110			eprintln!("{}", e);
111		}111		}
114	true114	true
115}115}
116116
117fn main_real(state: &EvaluationState, opts: Opts) -> Result<(), Error> {117fn main_real(s: &State, opts: Opts) -> Result<(), Error> {
118	opts.gc.configure_global();118	opts.gc.configure_global();
119	opts.general.configure(state)?;119	opts.general.configure(s)?;
120	opts.manifest.configure(state)?;120	opts.manifest.configure(s)?;
121121
122	let val = if opts.input.exec {122	let val = if opts.input.exec {
123		state.evaluate_snippet_raw(123		s.evaluate_snippet_raw(
124			PathBuf::from("<cmdline>").into(),124			PathBuf::from("<cmdline>").into(),
125			(&opts.input.input as &str).into(),125			(&opts.input.input as &str).into(),
126		)?126		)?
127	} else if opts.input.input == "-" {127	} else if opts.input.input == "-" {
128		let mut input = Vec::new();128		let mut input = Vec::new();
129		std::io::stdin().read_to_end(&mut input)?;129		std::io::stdin().read_to_end(&mut input)?;
130		let input_str = std::str::from_utf8(&input)?.into();130		let input_str = std::str::from_utf8(&input)?.into();
131		state.evaluate_snippet_raw(PathBuf::from("<stdin>").into(), input_str)?131		s.evaluate_snippet_raw(PathBuf::from("<stdin>").into(), input_str)?
132	} else {132	} else {
133		state.evaluate_file_raw(&PathBuf::from(opts.input.input))?133		s.evaluate_file_raw(&PathBuf::from(opts.input.input))?
134	};134	};
135135
136	let val = state.with_tla(val)?;136	let val = s.with_tla(val)?;
137137
138	if let Some(multi) = opts.output.multi {138	if let Some(multi) = opts.output.multi {
139		if opts.output.create_output_dirs {139		if opts.output.create_output_dirs {
140			let mut dir = multi.clone();140			let mut dir = multi.clone();
141			dir.pop();141			dir.pop();
142			create_dir_all(dir)?;142			create_dir_all(dir)?;
143		}143		}
144		for (file, data) in state.manifest_multi(val)?.iter() {144		for (file, data) in s.manifest_multi(val)?.iter() {
145			let mut path = multi.clone();145			let mut path = multi.clone();
146			path.push(file as &str);146			path.push(file as &str);
147			if opts.output.create_output_dirs {147			if opts.output.create_output_dirs {
160			create_dir_all(dir)?;160			create_dir_all(dir)?;
161		}161		}
162		let mut file = File::create(path)?;162		let mut file = File::create(path)?;
163		writeln!(file, "{}", state.manifest(val)?)?;163		writeln!(file, "{}", s.manifest(val)?)?;
164	} else {164	} else {
165		let output = state.manifest(val)?;165		let output = s.manifest(val)?;
166		if !output.is_empty() {166		if !output.is_empty() {
167			println!("{}", output);167			println!("{}", output);
168		}168		}

1use std::{fs::read_to_string, str::FromStr};1use std::{fs::read_to_string, str::FromStr};
22
3use clap::Parser;3use clap::Parser;
4use jrsonnet_evaluator::{error::Result, EvaluationState};4use jrsonnet_evaluator::{error::Result, State};
55
6use crate::ConfigureState;6use crate::ConfigureState;
77
100	ext_code_file: Vec<ExtFile>,100	ext_code_file: Vec<ExtFile>,
101}101}
102impl ConfigureState for ExtVarOpts {102impl ConfigureState for ExtVarOpts {
103	fn configure(&self, state: &EvaluationState) -> Result<()> {103	fn configure(&self, s: &State) -> Result<()> {
104		for ext in self.ext_str.iter() {104		for ext in self.ext_str.iter() {
105			state.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());105			s.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
106		}106		}
107		for ext in self.ext_str_file.iter() {107		for ext in self.ext_str_file.iter() {
108			state.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());108			s.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
109		}109		}
110		for ext in self.ext_code.iter() {110		for ext in self.ext_code.iter() {
111			state.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;111			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
112		}112		}
113		for ext in self.ext_code_file.iter() {113		for ext in self.ext_code_file.iter() {
114			state.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;114			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;
115		}115		}
116		Ok(())116		Ok(())
117	}117	}