`a94a1150b4f0`

2 files changed

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

68pub extern "C" fn jsonnet_make() -> Box<EvaluationState> {68pub extern "C" fn jsonnet_make() -> Box<EvaluationState> {
69	let state = EvaluationState::default();69	let state = EvaluationState::default();
70	state.with_stdlib();70	state.with_stdlib();
71	state.set_import_resolver(Box::new(NativeImportResolver::default()));71	state.settings_mut().import_resolver = Box::new(NativeImportResolver::default());
72	Box::new(state)72	Box::new(state)
73}73}
7474
75#[no_mangle]75#[no_mangle]
76pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {76pub extern "C" fn jsonnet_max_stack(vm: &EvaluationState, v: c_uint) {
77	vm.set_max_stack(v as usize);77	vm.settings_mut().max_stack = v as usize;
78}78}
7979
80// jrsonnet currently have no GC, so these functions is no-op80// jrsonnet currently have no GC, so these functions is no-op
273pub unsafe extern "C" fn jsonnet_jpath_add(vm: &EvaluationState, v: *const c_char) {273pub unsafe extern "C" fn jsonnet_jpath_add(vm: &EvaluationState, v: *const c_char) {
274	let cstr = CStr::from_ptr(v);274	let cstr = CStr::from_ptr(v);
275	let path = PathBuf::from(cstr.to_str().unwrap());275	let path = PathBuf::from(cstr.to_str().unwrap());
276	let any_resolver = vm.import_resolver();276	let any_resolver = &vm.settings().import_resolver;
277	let resolver = any_resolver277	let resolver = any_resolver
278		.as_any()278		.as_any()
279		.downcast_ref::<NativeImportResolver>()279		.downcast_ref::<NativeImportResolver>()

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

51	}51	}
52}52}
5353
54struct EvaluationSettings {54pub struct EvaluationSettings {
55	/// Limits recursion by limiting stack frames
55	max_stack_frames: usize,56	pub max_stack: usize,
57	/// Limit amount of stack trace items preserved
56	max_stack_trace_size: usize,58	pub max_trace: usize,
59	/// Used for std.extVar
57	ext_vars: HashMap<Rc<str>, Val>,60	pub ext_vars: HashMap<Rc<str>, Val>,
61	/// Global variables are inserted in default context
58	globals: HashMap<Rc<str>, Val>,62	pub globals: HashMap<Rc<str>, Val>,
63	/// Used to resolve file locations/contents
59	import_resolver: Box<dyn ImportResolver>,64	pub import_resolver: Box<dyn ImportResolver>,
60}65}
61impl Default for EvaluationSettings {66impl Default for EvaluationSettings {
62	fn default() -> Self {67	fn default() -> Self {
63		EvaluationSettings {68		EvaluationSettings {
64			max_stack_frames: 200,69			max_stack: 200,
65			max_stack_trace_size: 20,70			max_trace: 20,
66			globals: Default::default(),71			globals: Default::default(),
67			ext_vars: Default::default(),72			ext_vars: Default::default(),
68			import_resolver: Box::new(DummyImportResolver),73			import_resolver: Box::new(DummyImportResolver),
80	str_files: HashMap<Rc<PathBuf>, Rc<str>>,85	str_files: HashMap<Rc<PathBuf>, Rc<str>>,
81}86}
8287
83pub struct FileData(Rc<str>, LocExpr, Option<Val>);88pub struct FileData {
89	source_code: Rc<str>,
90	parsed: LocExpr,
91	evaluated: Option<Val>,
92}
84#[derive(Default)]93#[derive(Default)]
85pub struct EvaluationStateInternals {94pub struct EvaluationStateInternals {
95	/// Internal state
86	data: RefCell<EvaluationData>,96	data: RefCell<EvaluationData>,
97	/// Settings, safe to change at runtime
87	settings: RefCell<EvaluationSettings>,98	settings: RefCell<EvaluationSettings>,
88}99}
89100
123	fn data_mut(&self) -> RefMut<EvaluationData> {134	fn data_mut(&self) -> RefMut<EvaluationData> {
124		self.0.data.borrow_mut()135		self.0.data.borrow_mut()
125	}136	}
126	fn settings(&self) -> Ref<EvaluationSettings> {137	pub fn settings(&self) -> Ref<EvaluationSettings> {
127		self.0.settings.borrow()138		self.0.settings.borrow()
128	}139	}
129	fn settings_mut(&self) -> RefMut<EvaluationSettings> {140	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {
130		self.0.settings.borrow_mut()141		self.0.settings.borrow_mut()
131	}142	}
132
133	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {
134		self.settings_mut().import_resolver = resolver;
135	}
136	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {
137		Ref::map(self.settings(), |s|&*s.import_resolver)
138	}
139143
140	pub fn evaluate_file_to_json(144	pub fn evaluate_file_to_json(&self, path: &PathBuf) -> std::result::Result<Rc<str>, LocError> {
141		&self,
148		path: &PathBuf,150		path: &PathBuf,
149		snippet: &str,151		snippet: &str,
150	) -> std::result::Result<Rc<str>, LocError> {152	) -> std::result::Result<Rc<str>, LocError> {
151		self.parse_evaluate_raw_with_source(Rc::new(path.clone()), snippet).and_then(|v|v.into_json(4))153		self.parse_evaluate_raw(Rc::new(path.clone()), snippet)
154			.and_then(|v| v.into_json(4))
152	}155	}
153156
157	/// Parses and adds file to loaded
154	pub fn add_file(158	pub fn add_file(&self, path: Rc<PathBuf>, source_code: Rc<str>) -> Result<()> {
155		&self,
156		name: Rc<PathBuf>,
157		code: Rc<str>,
158	) -> std::result::Result<(), ParseError> {
159		self.data_mut().files.insert(159		self.add_parsed_file(
160			name.clone(),160			path.clone(),
161			FileData(
162				code.clone(),161			source_code.clone(),
163				parse(162			parse(
164					&code,163				&source_code,
165					&ParserSettings {164				&ParserSettings {
166						file_name: name,165					file_name: path.clone(),
167						loc_data: true,166					loc_data: true,
168					},167				},
169				)?,168			)
170				None,169			.map_err(|error| {
171			),170				create_error(Error::ImportSyntaxError {
171					error,
172					path,
173					source_code,
174				})
175			})?,
172		);176		)?;
173177
174		Ok(())178		Ok(())
175	}179	}
180
181	/// Adds file by source code and parsed expr
176	pub fn add_parsed_file(182	pub fn add_parsed_file(
177		&self,183		&self,
178		name: Rc<PathBuf>,184		name: Rc<PathBuf>,
179		code: Rc<str>,185		source_code: Rc<str>,
180		parsed: LocExpr,186		parsed: LocExpr,
181	) -> std::result::Result<(), ()> {187	) -> Result<()> {
182		self.data_mut()188		self.data_mut().files.insert(
183			.files
184			.insert(name, FileData(code, parsed, None));189			name,
190			FileData {
191				source_code,
192				parsed,
193				evaluated: None,
194			},
195		);
185196
186		Ok(())197		Ok(())
187	}198	}
188	pub fn get_source(&self, name: &PathBuf) -> Option<Rc<str>> {199	pub fn get_source(&self, name: &PathBuf) -> Option<Rc<str>> {
189		let ro_map = &self.data().files;200		let ro_map = &self.data().files;
190		ro_map.get(name).map(|value| value.0.clone())201		ro_map.get(name).map(|value| value.source_code.clone())
191	}202	}
192	pub fn map_source_locations(&self, file: &PathBuf, locs: &[usize]) -> Vec<CodeLocation> {203	pub fn map_source_locations(&self, file: &PathBuf, locs: &[usize]) -> Vec<CodeLocation> {
193		offset_to_location(&self.get_source(file).unwrap(), locs)204		offset_to_location(&self.get_source(file).unwrap(), locs)
200				let value = ro_map211				let value = ro_map
201					.get(name)212					.get(name)
202					.unwrap_or_else(|| panic!("file not added: {:?}", name));213					.unwrap_or_else(|| panic!("file not added: {:?}", name));
203				if value.2.is_some() {214				if value.evaluated.is_some() {
204					return Ok(value.2.clone().unwrap());215					return Ok(value.evaluated.clone().unwrap());
205				}216				}
206				value.1.clone()217				value.parsed.clone()
207			};218			};
208			let value = evaluate(self.create_default_context()?, &expr)?;219			let value = evaluate(self.create_default_context()?, &expr)?;
209			{220			{
212					.files224					.files
213					.get_mut(name)225					.get_mut(name)
214					.unwrap()226					.unwrap()
215					.2227					.evaluated
216					.replace(value.clone());228					.replace(value.clone());
217			}229			}
218			Ok(value)230			Ok(value)
219		})231		})
220	}232	}
233	pub fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
234		Ok(self.settings().import_resolver.resolve_file(from, path)?)
235	}
236	pub fn load_file_contents(&self, path: &PathBuf) -> Result<Rc<str>> {
237		Ok(self.settings().import_resolver.load_file_contents(path)?)
238	}
221	pub(crate) fn import_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Val> {239	pub(crate) fn import_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Val> {
222		let file_path = self.settings().import_resolver.resolve_file(from, path)?;240		let file_path = self.resolve_file(from, path)?;
223		{241		{
224			let files = &self.data().files;242			let files = &self.data().files;
225			if files.contains_key(&file_path) {243			if files.contains_key(&file_path) {
226				return self.evaluate_file(&file_path);244				return self.evaluate_file(&file_path);
227			}245			}
228		}246		}
229		let contents = self.settings().import_resolver.load_file_contents(&file_path)?;247		let contents = self.load_file_contents(&file_path)?;
230		self.add_file(file_path.clone(), contents).map_err(|e| {248		self.add_file(file_path.clone(), contents)?;
231			create_error(Error::ImportSyntaxError(e))
232		})?;
233		self.evaluate_file(&file_path)249		self.evaluate_file(&file_path)
234	}250	}
235	pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<str>> {251	pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<str>> {
236		let path = self.settings().import_resolver.resolve_file(from, path)?;252		let path = self.resolve_file(from, path)?;
237		if !self.data().str_files.contains_key(&path) {253		if !self.data().str_files.contains_key(&path) {
238			let file_str = self.settings().import_resolver.load_file_contents(&path)?;254			let file_str = self.load_file_contents(&path)?;
239			self.data_mut()255			self.data_mut().str_files.insert(path.clone(), file_str);
240				.str_files
241				.insert(path.clone(), file_str);
242		}256		}
243		Ok(self.data().str_files.get(&path).cloned().unwrap())257		Ok(self.data().str_files.get(&path).cloned().unwrap())
244	}258	}
245259
260	/// Parses and evaluates snippet
246	pub fn parse_evaluate_raw_with_source(&self, source: Rc<PathBuf>, code: &str) -> Result<Val> {261	pub fn parse_evaluate_raw(&self, source: Rc<PathBuf>, code: &str) -> Result<Val> {
247		let parsed = parse(262		let parsed = parse(
248			&code,263			&code,
249			&ParserSettings {264			&ParserSettings {
254		.unwrap();269		.unwrap();
255		self.evaluate_raw(parsed)270		self.evaluate_raw(parsed)
256	}271	}
257	pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {272	/// Evaluates parsed expression
258		self.parse_evaluate_raw_with_source(Rc::new(PathBuf::from("raw.jsonnet")), code)
259	}
260
261	pub fn evaluate_raw(&self, code: LocExpr) -> Result<Val> {273	pub fn evaluate_raw(&self, code: LocExpr) -> Result<Val> {
262		self.run_in_state(|| evaluate(self.create_default_context()?, &code))274		self.run_in_state(|| evaluate(self.create_default_context()?, &code))
279		self291		self
280	}292	}
281293
294	/// Creates context with all passed global variables
282	pub fn create_default_context(&self) -> Result<Context> {295	pub fn create_default_context(&self) -> Result<Context> {
283		let globals = &self.settings().globals;296		let globals = &self.settings().globals;
284		let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();297		let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();
301		{314		{
302			let mut data = self.data_mut();315			let mut data = self.data_mut();
303			let stack_depth = &mut data.stack_depth;316			let stack_depth = &mut data.stack_depth;
304			if *stack_depth > self.settings().max_stack_frames {317			if *stack_depth > self.settings().max_stack {
305				// Error creation uses data, so i drop guard here318				// Error creation uses data, so i drop guard here
306				drop(data);319				drop(data);
307				return Err(self.error(Error::StackOverflow));320				return Err(self.error(Error::StackOverflow));