git.delta.rocks / jrsonnet / refs/commits / 96da6f397b93

10	os::raw::{c_char, c_int},10	os::raw::{c_char, c_int},
11	path::{Path, PathBuf},11	path::{Path, PathBuf},
12	ptr::null_mut,12	ptr::null_mut,
13	rc::Rc,
14};13};
1514
16use jrsonnet_evaluator::{15use jrsonnet_evaluator::{
33	out: RefCell<HashMap<PathBuf, Vec<u8>>>,32	out: RefCell<HashMap<PathBuf, Vec<u8>>>,
34}33}
35impl ImportResolver for CallbackImportResolver {34impl ImportResolver for CallbackImportResolver {
36	fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {35	fn resolve_file(&self, from: &Path, path: &Path) -> Result<PathBuf> {
37		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();36		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();
38		let rel = CString::new(path.to_str().unwrap()).unwrap().into_raw();37		let rel = CString::new(path.to_str().unwrap()).unwrap().into_raw();
39		let found_here: *mut c_char = null_mut();38		let found_here: *mut c_char = null_mut();
73			unsafe { CString::from_raw(result_ptr) };72			unsafe { CString::from_raw(result_ptr) };
74		}73		}
7574
76		Ok(found_here_buf.into())75		Ok(found_here_buf)
77	}76	}
78	fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>> {77	fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>> {
79		Ok(self.out.borrow().get(resolved).unwrap().clone())78		Ok(self.out.borrow().get(resolved).unwrap().clone())
109	}108	}
110}109}
111impl ImportResolver for NativeImportResolver {110impl ImportResolver for NativeImportResolver {
112	fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {111	fn resolve_file(&self, from: &Path, path: &Path) -> Result<PathBuf> {
113		let mut new_path = from.to_owned();112		let mut new_path = from.to_owned();
114		new_path.push(path);113		new_path.push(path);
115		if new_path.exists() {114		if new_path.exists() {

111) -> *const c_char {111) -> *const c_char {
112	let filename = CStr::from_ptr(filename);112	let filename = CStr::from_ptr(filename);
113	match vm113	match vm
114		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))114		.import(PathBuf::from(filename.to_str().unwrap()))
115		.and_then(|v| vm.with_tla(v))115		.and_then(|v| vm.with_tla(v))
116		.and_then(|v| vm.manifest(v))116		.and_then(|v| vm.manifest(v))
117	{117	{
140	let filename = CStr::from_ptr(filename);140	let filename = CStr::from_ptr(filename);
141	let snippet = CStr::from_ptr(snippet);141	let snippet = CStr::from_ptr(snippet);
142	match vm142	match vm
143		.evaluate_snippet_raw(143		.evaluate_snippet(
144			PathBuf::from(filename.to_str().unwrap()).into(),144			filename.to_str().unwrap().into(),
145			snippet.to_str().unwrap().into(),145			snippet.to_str().unwrap().into(),
146		)146		)
147		.and_then(|v| vm.with_tla(v))147		.and_then(|v| vm.with_tla(v))
185) -> *const c_char {185) -> *const c_char {
186	let filename = CStr::from_ptr(filename);186	let filename = CStr::from_ptr(filename);
187	match vm187	match vm
188		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))188		.import(PathBuf::from(filename.to_str().unwrap()))
189		.and_then(|v| vm.with_tla(v))189		.and_then(|v| vm.with_tla(v))
190		.and_then(|v| vm.manifest_multi(v))190		.and_then(|v| vm.manifest_multi(v))
191	{191	{
212	let filename = CStr::from_ptr(filename);212	let filename = CStr::from_ptr(filename);
213	let snippet = CStr::from_ptr(snippet);213	let snippet = CStr::from_ptr(snippet);
214	match vm214	match vm
215		.evaluate_snippet_raw(215		.evaluate_snippet(
216			PathBuf::from(filename.to_str().unwrap()).into(),216			filename.to_str().unwrap().into(),
217			snippet.to_str().unwrap().into(),217			snippet.to_str().unwrap().into(),
218		)218		)
219		.and_then(|v| vm.with_tla(v))219		.and_then(|v| vm.with_tla(v))
255) -> *const c_char {255) -> *const c_char {
256	let filename = CStr::from_ptr(filename);256	let filename = CStr::from_ptr(filename);
257	match vm257	match vm
258		.evaluate_file_raw_nocwd(&PathBuf::from(filename.to_str().unwrap()))258		.import(PathBuf::from(filename.to_str().unwrap()))
259		.and_then(|v| vm.with_tla(v))259		.and_then(|v| vm.with_tla(v))
260		.and_then(|v| vm.manifest_stream(v))260		.and_then(|v| vm.manifest_stream(v))
261	{261	{
282	let filename = CStr::from_ptr(filename);282	let filename = CStr::from_ptr(filename);
283	let snippet = CStr::from_ptr(snippet);283	let snippet = CStr::from_ptr(snippet);
284	match vm284	match vm
285		.evaluate_snippet_raw(285		.evaluate_snippet(
286			PathBuf::from(filename.to_str().unwrap()).into(),286			filename.to_str().unwrap().into(),
287			snippet.to_str().unwrap().into(),287			snippet.to_str().unwrap().into(),
288		)288		)
289		.and_then(|v| vm.with_tla(v))289		.and_then(|v| vm.with_tla(v))

1use std::{1use std::{
2	ffi::{c_void, CStr},2	ffi::{c_void, CStr},
3	os::raw::{c_char, c_int},3	os::raw::{c_char, c_int},
4	path::Path,
5	rc::Rc,
6};4};
75
8use gcmodule::Cc;6use gcmodule::Cc;
28	cb: JsonnetNativeCallback,26	cb: JsonnetNativeCallback,
29}27}
30impl NativeCallbackHandler for JsonnetNativeCallbackHandler {28impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
31	fn call(&self, s: State, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {29	fn call(&self, s: State, args: &[Val]) -> Result<Val, LocError> {
32		let mut n_args = Vec::new();30		let mut n_args = Vec::new();
33		for a in args {31		for a in args {
34			n_args.push(Some(Box::new(a.clone())));32			n_args.push(Some(Box::new(a.clone())));

120	opts.manifest.configure(s)?;120	opts.manifest.configure(s)?;
121121
122	let val = if opts.input.exec {122	let val = if opts.input.exec {
123		s.evaluate_snippet_raw(123		s.evaluate_snippet("<cmdline>".to_owned(), (&opts.input.input as &str).into())?
124			PathBuf::from("<cmdline>").into(),
125			(&opts.input.input as &str).into(),
126		)?
127	} else if opts.input.input == "-" {124	} else if opts.input.input == "-" {
128		let mut input = Vec::new();125		let mut input = Vec::new();
129		std::io::stdin().read_to_end(&mut input)?;126		std::io::stdin().read_to_end(&mut input)?;
130		let input_str = std::str::from_utf8(&input)?.into();127		let input_str = std::str::from_utf8(&input)?.into();
131		s.evaluate_snippet_raw(PathBuf::from("<stdin>").into(), input_str)?128		s.evaluate_snippet("<stdin>".to_owned(), input_str)?
132	} else {129	} else {
133		s.evaluate_file_raw(&PathBuf::from(opts.input.input))?130		s.import(s.resolve_file(&PathBuf::new(), &opts.input.input)?)?
134	};131	};
135132
136	let val = s.with_tla(val)?;133	let val = s.with_tla(val)?;

108			s.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			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;111			s.add_ext_code(&ext.name as &str, (&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			s.add_ext_code((&ext.name as &str).into(), (&ext.value as &str).into())?;114			s.add_ext_code(&ext.name as &str, (&ext.value as &str).into())?;
115		}115		}
116		Ok(())116		Ok(())
117	}117	}

55			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into())55			s.add_tla_str((&tla.name as &str).into(), (&tla.value as &str).into())
56		}56		}
57		for tla in self.tla_code.iter() {57		for tla in self.tla_code.iter() {
58			s.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;58			s.add_tla_code((&tla.name as &str).into(), &tla.value as &str)?;
59		}59		}
60		for tla in self.tla_code_file.iter() {60		for tla in self.tla_code_file.iter() {
61			s.add_tla_code((&tla.name as &str).into(), (&tla.value as &str).into())?;61			s.add_tla_code((&tla.name as &str).into(), &tla.value as &str)?;
62		}62		}
63		Ok(())63		Ok(())
64	}64	}

28jrsonnet-types = { path = "../jrsonnet-types", version = "0.4.2" }28jrsonnet-types = { path = "../jrsonnet-types", version = "0.4.2" }
29jrsonnet-macros = { path = "../jrsonnet-macros", version = "0.4.2" }29jrsonnet-macros = { path = "../jrsonnet-macros", version = "0.4.2" }
30pathdiff = "0.2.1"30pathdiff = "0.2.1"
31hashbrown = "0.12.1"
32static_assertions = "1.1.0"
3133
32md5 = "0.7.0"34md5 = "0.7.0"
33base64 = "0.13.0"35base64 = "0.13.0"

1use std::{1use std::{borrow::Cow, env, fs::File, io::Write, path::Path};
2	env,
3	fs::File,
4	io::Write,
5	path::{Path, PathBuf},
6};
72
8use bincode::serialize;3use bincode::serialize;
9use jrsonnet_parser::{parse, ParserSettings};4use jrsonnet_parser::{parse, ParserSettings, Source};
10use jrsonnet_stdlib::STDLIB_STR;5use jrsonnet_stdlib::STDLIB_STR;
116
12fn main() {7fn main() {
13	let parsed = parse(8	let parsed = parse(
14		STDLIB_STR,9		STDLIB_STR,
15		&ParserSettings {10		&ParserSettings {
16			file_name: PathBuf::from("std.jsonnet").into(),11			file_name: Source::new_virtual(Cow::Borrowed("<std>")),
17		},12		},
18	)13	)
19	.expect("parse");14	.expect("parse");

1use std::{1use std::{fmt::Debug, path::PathBuf};
2	fmt::Debug,
3	path::{Path, PathBuf},
4	rc::Rc,
5};
62
7use gcmodule::Trace;3use gcmodule::Trace;
8use jrsonnet_interner::IStr;4use jrsonnet_interner::IStr;
9use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};5use jrsonnet_parser::{BinaryOpType, ExprLocation, Source, UnaryOpType};
10use jrsonnet_types::ValType;6use jrsonnet_types::ValType;
11use thiserror::Error;7use thiserror::Error;
128
85	StandaloneSuper,81	StandaloneSuper,
8682
87	#[error("can't resolve {1} from {0}")]83	#[error("can't resolve {1} from {0}")]
88	ImportFileNotFound(PathBuf, PathBuf),84	ImportFileNotFound(PathBuf, String),
89	#[error("resolved file not found: {0}")]85	#[error("resolved file not found: {0}")]
90	ResolvedFileNotFound(PathBuf),86	ResolvedFileNotFound(PathBuf),
91	#[error("imported file is not valid utf-8: {0:?}")]87	#[error("imported file is not valid utf-8: {0:?}")]
94	ImportIo(String),90	ImportIo(String),
95	#[error("tried to import {1} from {0}, but imports is not supported")]91	#[error("tried to import {1} from {0}, but imports is not supported")]
96	ImportNotSupported(PathBuf, PathBuf),92	ImportNotSupported(PathBuf, PathBuf),
93	#[error("can't import from virtual file")]
94	CantImportFromVirtualFile,
97	#[error(95	#[error(
98		"syntax error: expected {}, got {:?}",96		"syntax error: expected {}, got {:?}",
99		.error.expected,97		.error.expected,
100		.source_code.chars().nth(error.location.offset)98		.source_code.chars().nth(error.location.offset)
101		.map_or_else(|| "EOF".into(), |c| c.to_string())99		.map_or_else(|| "EOF".into(), |c| c.to_string())
102	)]100	)]
103	ImportSyntaxError {101	ImportSyntaxError {
104		#[skip_trace]
105		path: Rc<Path>,102		path: Source,
106		source_code: IStr,103		source_code: IStr,
107		#[skip_trace]104		#[skip_trace]
108		error: Box<jrsonnet_parser::ParseError>,105		error: Box<jrsonnet_parser::ParseError>,

452						Ok(Some(v)) => Ok(v),452						Ok(Some(v)) => Ok(v),
453						Ok(None) => throw!(NoSuchField(key.clone())),453						Ok(None) => throw!(NoSuchField(key.clone())),
454						Err(e) if matches!(e.error(), MagicThisFileUsed) => {454						Err(e) if matches!(e.error(), MagicThisFileUsed) => {
455							Ok(Val::Str(loc.0.to_string_lossy().into()))455							Ok(Val::Str(loc.0.full_path().into()))
456						}456						}
457						Err(e) => Err(e),457						Err(e) => Err(e),
458					},458					},
617617
618			std_slice(indexable.into_indexable()?, start, end, step)?618			std_slice(indexable.into_indexable()?, start, end, step)?
619		}619		}
620		Import(path) => {620		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {
621			let tmp = loc.clone().0;621			let tmp = loc.clone().0;
622			let mut import_location = tmp.to_path_buf();622			let import_location = tmp
623				.path()
624				.map(|p| {
625					let mut p = p.to_owned();
626					p.pop();
627					p
628				})
629				.unwrap_or_default();
623			import_location.pop();630			let path = s.resolve_file(&import_location, path as &str)?;
631			match i {
624			s.push(632				Import(_) => s.push(
625				CallLocation::new(loc),633				CallLocation::new(loc),
626				|| format!("import {:?}", path),634					|| format!("import {:?}", path.clone()),
627				|| s.import_file(&import_location, path),635					|| s.import(path.clone()),
628			)?636				)?,
637				ImportStr(_) => Val::Str(s.import_str(path)?),
638				ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_bin(path)?)),
639				_ => unreachable!(),
640		}
629		}641		}
630		ImportStr(path) => {
631			let tmp = loc.clone().0;
632			let mut import_location = tmp.to_path_buf();
633			import_location.pop();
634			Val::Str(s.import_file_str(&import_location, path)?)
635		}
636		ImportBin(path) => {
637			let tmp = loc.clone().0;
638			let mut import_location = tmp.to_path_buf();
639			import_location.pop();
640			let bytes = s.import_file_bin(&import_location, path)?;
641			Val::Arr(ArrValue::Bytes(bytes))
642		}
643	})642	})
644}643}
645644

47	}47	}
48}48}
4949
50#[derive(Clone)]
50pub enum TlaArg {51pub enum TlaArg {
51	String(IStr),52	String(IStr),
52	Code(LocExpr),53	Code(LocExpr),

1use std::{borrow::Cow, path::Path, rc::Rc};1use std::borrow::Cow;
22
3use gcmodule::Trace;3use gcmodule::Trace;
44
51		&self.params51		&self.params
52	}52	}
5353
54	fn call(&self, s: State, ctx: Context, loc: CallLocation, args: &dyn ArgsLike) -> Result<Val> {54	fn call(&self, s: State, ctx: Context, _loc: CallLocation, args: &dyn ArgsLike) -> Result<Val> {
55		let args = parse_builtin_call(s.clone(), ctx, &self.params, args, true)?;55		let args = parse_builtin_call(s.clone(), ctx, &self.params, args, true)?;
56		let mut out_args = Vec::with_capacity(self.params.len());56		let mut out_args = Vec::with_capacity(self.params.len());
57		for p in &self.params {57		for p in &self.params {
58			out_args.push(args[&p.name].evaluate(s.clone())?);58			out_args.push(args[&p.name].evaluate(s.clone())?);
59		}59		}
60		self.handler.call(s, loc.0.map(|l| l.0.clone()), &out_args)60		self.handler.call(s, &out_args)
61	}61	}
62}62}
6363
64pub trait NativeCallbackHandler: Trace {64pub trait NativeCallbackHandler: Trace {
65	fn call(&self, s: State, from: Option<Rc<Path>>, args: &[Val]) -> Result<Val>;65	fn call(&self, s: State, args: &[Val]) -> Result<Val>;
66}66}
6767

1/// Macros to help deal with Gc1/// Macros to help deal with Gc
2use std::{2use std::{
3	borrow::{Borrow, BorrowMut},3	borrow::{Borrow, BorrowMut},
4	collections::{HashMap, HashSet},4	collections::HashSet,
5	hash::BuildHasherDefault,5	hash::BuildHasherDefault,
6	ops::{Deref, DerefMut},6	ops::{Deref, DerefMut},
7};7};
88
9use gcmodule::{Trace, Tracer};9use gcmodule::{Trace, Tracer};
10use hashbrown::HashMap;
10use rustc_hash::{FxHashMap, FxHashSet};11use rustc_hash::{FxHashSet, FxHasher};
1112
12/// Replacement for box, which assumes that the underlying type is [`Trace`]13/// Replacement for box, which assumes that the underlying type is [`Trace`]
13/// Used in places, where `Cc<dyn Trait>` should be used instead, but it can't, because `CoerceUnsiced` is not stable14/// Used in places, where `Cc<dyn Trait>` should be used instead, but it can't, because `CoerceUnsiced` is not stable
115	}116	}
116}117}
117118
118#[derive(Clone)]
119pub struct GcHashMap<K, V>(pub FxHashMap<K, V>);119pub struct GcHashMap<K, V>(pub HashMap<K, V, BuildHasherDefault<FxHasher>>);
120impl<K, V> GcHashMap<K, V> {120impl<K, V> GcHashMap<K, V> {
121	pub fn new() -> Self {121	pub fn new() -> Self {
122		Self(HashMap::default())122		Self(HashMap::default())
123	}123	}
124	pub fn with_capacity(capacity: usize) -> Self {124	pub fn with_capacity(capacity: usize) -> Self {
125		Self(FxHashMap::with_capacity_and_hasher(125		Self(HashMap::with_capacity_and_hasher(
126			capacity,126			capacity,
127			BuildHasherDefault::default(),127			BuildHasherDefault::default(),
128		))128		))
141	}141	}
142}142}
143impl<K, V> Deref for GcHashMap<K, V> {143impl<K, V> Deref for GcHashMap<K, V> {
144	type Target = FxHashMap<K, V>;144	type Target = HashMap<K, V, BuildHasherDefault<FxHasher>>;
145145
146	fn deref(&self) -> &Self::Target {146	fn deref(&self) -> &Self::Target {
147		&self.0147		&self.0

1use std::{1use std::{
2	any::Any,2	any::Any,
3	convert::TryFrom,
4	fs,3	fs,
5	io::Read,4	io::Read,
6	path::{Path, PathBuf},5	path::{Path, PathBuf},
7	rc::Rc,
8};6};
97
10use fs::File;8use fs::File;
11use jrsonnet_interner::IStr;
129
13use crate::{10use crate::{
14	error::{Error::*, Result},11	error::{Error::*, Result},
20	/// Resolves real file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond17	/// Resolves real file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond
21	/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`18	/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`
22	/// where `${vendor}` is a library path.19	/// where `${vendor}` is a library path.
23	fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>>;20	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf>;
2421
25	fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>>;22	fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>>;
26
27	/// Reads file from filesystem, should be used only with path received from `resolve_file`
28	fn load_file_str(&self, resolved: &Path) -> Result<IStr> {
29		Ok(IStr::try_from(&self.load_file_contents(resolved)? as &[u8])
30			.map_err(|_| ImportBadFileUtf8(resolved.to_path_buf()))?)
31	}
32
33	/// Reads file from filesystem, should be used only with path received from `resolve_file`
34	fn load_file_bin(&self, resolved: &Path) -> Result<Rc<[u8]>> {
35		Ok(self.load_file_contents(resolved)?.into())
36	}
3723
38	/// # Safety24	/// # Safety
39	///25	///
46/// Dummy resolver, can't resolve/load any file32/// Dummy resolver, can't resolve/load any file
47pub struct DummyImportResolver;33pub struct DummyImportResolver;
48impl ImportResolver for DummyImportResolver {34impl ImportResolver for DummyImportResolver {
49	fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {35	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
50		throw!(ImportNotSupported(from.into(), path.into()))36		throw!(ImportNotSupported(from.into(), path.into()))
51	}37	}
5238
73	pub library_paths: Vec<PathBuf>,59	pub library_paths: Vec<PathBuf>,
74}60}
75impl ImportResolver for FileImportResolver {61impl ImportResolver for FileImportResolver {
76	fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {62	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
77		let mut direct = from.to_path_buf();63		let mut direct = from.to_path_buf();
78		direct.push(path);64		direct.push(path);
79		if direct.exists() {65		if direct.exists() {
80			Ok(direct.into())66			Ok(direct.canonicalize().map_err(|e| ImportIo(e.to_string()))?)
81		} else {67		} else {
82			for library_path in &self.library_paths {68			for library_path in &self.library_paths {
83				let mut cloned = library_path.clone();69				let mut cloned = library_path.clone();
84				cloned.push(path);70				cloned.push(path);
85				if cloned.exists() {71				if cloned.exists() {
86					return Ok(cloned.into());72					return Ok(cloned.canonicalize().map_err(|e| ImportIo(e.to_string()))?);
87				}73				}
88			}74			}
89			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))75			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))

38pub mod val;38pub mod val;
3939
40use std::{40use std::{
41	borrow::Cow,
41	cell::{Ref, RefCell, RefMut},42	cell::{Ref, RefCell, RefMut},
42	collections::HashMap,43	collections::HashMap,
43	fmt::{self, Debug},44	fmt::{self, Debug},
52use function::{builtin::Builtin, CallLocation, TlaArg};53use function::{builtin::Builtin, CallLocation, TlaArg};
53use gc::{GcHashMap, TraceBox};54use gc::{GcHashMap, TraceBox};
54use gcmodule::{Cc, Trace, Weak};55use gcmodule::{Cc, Trace, Weak};
56use hashbrown::hash_map::RawEntryMut;
55pub use import::*;57pub use import::*;
58use jrsonnet_interner::IBytes;
56pub use jrsonnet_interner::IStr;59pub use jrsonnet_interner::IStr;
57pub use jrsonnet_parser as parser;60pub use jrsonnet_parser as parser;
58use jrsonnet_parser::*;61use jrsonnet_parser::*;
96	/// Limits amount of stack trace items preserved99	/// Limits amount of stack trace items preserved
97	pub max_trace: usize,100	pub max_trace: usize,
98	/// Used for s`td.extVar`101	/// Used for s`td.extVar`
99	pub ext_vars: HashMap<IStr, Val>,102	pub ext_vars: HashMap<IStr, TlaArg>,
100	/// Used for ext.native103	/// Used for ext.native
101	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,104	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,
102	/// TLA vars105	/// TLA vars
141	stack_generation: usize,144	stack_generation: usize,
142145
143	breakpoints: Breakpoints,146	breakpoints: Breakpoints,
147
144	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces148	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces
145	files: GcHashMap<Rc<Path>, FileData>,149	files: GcHashMap<PathBuf, FileData>,
146	str_files: GcHashMap<Rc<Path>, IStr>,150	/// Contains tla arguments and others, which aren't needed to be obtained by name
147	bin_files: GcHashMap<Rc<Path>, Rc<[u8]>>,151	volatile_files: GcHashMap<String, String>,
148}152}
153struct FileData {
154	string: Option<IStr>,
155	bytes: Option<IBytes>,
156	parsed: Option<LocExpr>,
157	evaluated: Option<Val>,
149158
150pub struct FileData {
151	source_code: IStr,
152	parsed: LocExpr,
153	evaluated: Option<Val>,159	evaluating: bool,
154}160}
161impl FileData {
162	fn new_string(data: IStr) -> Self {
163		Self {
164			string: Some(data),
165			bytes: None,
166			parsed: None,
167			evaluated: None,
168			evaluating: false,
169		}
170	}
171	fn new_bytes(data: IBytes) -> Self {
172		Self {
173			string: None,
174			bytes: Some(data),
175			parsed: None,
176			evaluated: None,
177			evaluating: false,
178		}
179	}
180}
155181
156#[allow(clippy::type_complexity)]182#[allow(clippy::type_complexity)]
157pub struct Breakpoint {183pub struct Breakpoint {
198pub struct State(Rc<EvaluationStateInternals>);224pub struct State(Rc<EvaluationStateInternals>);
199225
200impl State {226impl State {
201	/// Parses and adds file as loaded227	pub fn import_str(&self, path: PathBuf) -> Result<IStr> {
202	pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {
203		let parsed = parse(228		let mut data = self.data_mut();
204			&source_code,
205			&ParserSettings {
206				file_name: path.clone(),
207			},229		let mut file = data.files.raw_entry_mut().from_key(&path);
208		)
209		.map_err(|error| ImportSyntaxError {
210			error: Box::new(error),
211			path: path.clone(),
212			source_code: source_code.clone(),
213		})?;
214		self.add_parsed_file(path, source_code, parsed.clone())?;
215230
216		Ok(parsed)231		let file = match file {
232			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
233			RawEntryMut::Vacant(v) => {
234				let data = self.settings().import_resolver.load_file_contents(&path)?;
235				v.insert(
236					path.clone(),
237					FileData::new_string(
238						std::str::from_utf8(&data)
239							.map_err(|_| ImportBadFileUtf8(path.clone()))?
240							.into(),
241					),
242				)
243				.1
244			}
245		};
246		if let Some(str) = &file.string {
247			return Ok(str.clone());
248		}
249		if file.string.is_none() {
250			file.string = Some(
251				file.bytes
252					.as_ref()
253					.expect("either string or bytes should be set")
254					.clone()
255					.cast_str()
256					.ok_or_else(|| ImportBadFileUtf8(path.clone()))?,
257			);
258		}
259		Ok(file.string.as_ref().expect("just set").clone())
217	}260	}
261	pub fn import_bin(&self, path: PathBuf) -> Result<IBytes> {
262		let mut data = self.data_mut();
263		let mut file = data.files.raw_entry_mut().from_key(&path);
218264
219	pub fn reset_evaluation_state(&self, name: &Path) {265		let file = match file {
266			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
267			RawEntryMut::Vacant(v) => {
268				let data = self.settings().import_resolver.load_file_contents(&path)?;
269				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))
270					.1
271			}
272		};
273		if let Some(str) = &file.bytes {
220		self.data_mut()274			return Ok(str.clone());
221			.files275		}
276		if file.bytes.is_none() {
222			.get_mut(name)277			file.bytes = Some(
278				file.string
279					.as_ref()
223			.expect("file not found")280					.expect("either string or bytes should be set")
224			.evaluated281					.clone()
225			.take();282					.cast_bytes(),
283			);
284		}
285		Ok(file.bytes.as_ref().expect("just set").clone())
226	}286	}
287	pub fn import(&self, path: PathBuf) -> Result<Val> {
288		let mut data = self.data_mut();
289		let mut file = data.files.raw_entry_mut().from_key(&path);
227290
228	/// Adds file by source code and parsed expr291		let file = match file {
292			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
293			RawEntryMut::Vacant(v) => {
229	pub fn add_parsed_file(294				let data = self.settings().import_resolver.load_file_contents(&path)?;
230		&self,295				v.insert(
296					path.clone(),
231		name: Rc<Path>,297					FileData::new_string(
298						std::str::from_utf8(&data)
299							.map_err(|_| ImportBadFileUtf8(path.clone()))?
300							.into(),
232		source_code: IStr,301					),
302				)
303				.1
304			}
305		};
306		if let Some(val) = &file.evaluated {
307			return Ok(val.clone());
308		}
309		if file.string.is_none() {
310			file.string = Some(
311				std::str::from_utf8(
312					file.bytes
313						.as_ref()
314						.expect("either string or bytes should be set"),
233		parsed: LocExpr,315				)
316				.map_err(|_| ImportBadFileUtf8(path.clone()))?
317				.into(),
234	) -> Result<()> {318			);
319		}
320		let code = file.string.as_ref().expect("just set");
235		self.data_mut().files.insert(321		let file_name = Source::new(path.clone()).expect("resolver should return correct name");
322		if file.parsed.is_none() {
236			name,323			file.parsed = Some(
324				jrsonnet_parser::parse(
325					code,
237			FileData {326					&ParserSettings {
238				source_code,327						file_name: file_name.clone(),
239				parsed,328					},
240				evaluated: None,329				)
330				.map_err(|e| ImportSyntaxError {
331					path: file_name,
241			},332					source_code: code.clone(),
333					error: Box::new(e),
334				})?,
242		);335			);
336		}
337		let parsed = file.parsed.as_ref().expect("just set").clone();
338		if file.evaluating {
339			throw!(InfiniteRecursionDetected)
340		}
341		file.evaluating = true;
342		// Dropping file here, as it borrows data, which may be used in evaluation
343		drop(data);
344		let res = evaluate(self.clone(), self.create_default_context(), &parsed);
243345
244		Ok(())346		let mut data = self.data_mut();
347		let mut file = data.files.raw_entry_mut().from_key(&path);
348
349		let file = match file {
350			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
351			RawEntryMut::Vacant(_) => unreachable!("this file was just here!"),
352		};
353		file.evaluating = false;
354		match res {
355			Ok(v) => {
356				file.evaluated = Some(v.clone());
357				Ok(v)
358			}
359			Err(e) => Err(e),
360		}
245	}361	}
362
246	pub fn get_source(&self, name: &Path) -> Option<IStr> {363	pub fn get_source(&self, name: Source) -> Option<String> {
247		let ro_map = &self.data().files;364		let data = self.data();
365		match name.repr() {
366			Ok(real) => data
367				.files
248		ro_map.get(name).map(|value| value.source_code.clone())368				.get(real)
369				.and_then(|f| f.string.as_ref())
370				.map(ToString::to_string),
371			Err(e) => data.volatile_files.get(e).map(ToOwned::to_owned),
372		}
249	}373	}
250	pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {374	pub fn map_source_locations(&self, file: Source, locs: &[u32]) -> Vec<CodeLocation> {
251		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)375		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)
252	}376	}
253	pub fn map_from_source_location(377	pub fn map_from_source_location(
254		&self,378		&self,
255		file: &Path,379		file: Source,
256		line: usize,380		line: usize,
257		column: usize,381		column: usize,
258	) -> Option<usize> {382	) -> Option<usize> {
262			column,386			column,
263		)387		)
264	}388	}
265	pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {
266		let file_path = self.resolve_file(from, path)?;
267		{
268			let data = self.data();
269			let files = &data.files;
270			if files.contains_key(&file_path as &Path) {
271				drop(data);
272				return self.evaluate_loaded_file_raw(&file_path);
273			}
274		}
275		let contents = self.load_file_str(&file_path)?;
276		self.add_file(file_path.clone(), contents)?;
277		self.evaluate_loaded_file_raw(&file_path)
278	}
279	pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {
280		let path = self.resolve_file(from, path)?;
281		if !self.data().str_files.contains_key(&path) {
282			let file_str = self.load_file_str(&path)?;
283			self.data_mut().str_files.insert(path.clone(), file_str);
284		}
285		Ok(self.data().str_files.get(&path).cloned().unwrap())
286	}
287	pub(crate) fn import_file_bin(&self, from: &Path, path: &Path) -> Result<Rc<[u8]>> {
288		let path = self.resolve_file(from, path)?;
289		if !self.data().bin_files.contains_key(&path) {
290			let file_bin = self.load_file_bin(&path)?;
291			self.data_mut().bin_files.insert(path.clone(), file_bin);
292		}
293		Ok(self.data().bin_files.get(&path).cloned().unwrap())
294	}
295
296	fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {
297		let expr: LocExpr = {
298			let ro_map = &self.data().files;
299			let value = ro_map
300				.get(name)
301				.unwrap_or_else(|| panic!("file not added: {:?}", name));
302			if let Some(ref evaluated) = value.evaluated {
303				return Ok(evaluated.clone());
304			}
305			value.parsed.clone()
306		};
307		let value = evaluate(self.clone(), self.create_default_context(), &expr)?;
308		{
309			self.data_mut()
310				.files
311				.get_mut(name)
312				.unwrap()
313				.evaluated
314				.replace(value.clone());
315		}
316		Ok(value)
317	}
318
319	/// Adds standard library global variable (std) to this evaluator389	/// Adds standard library global variable (std) to this evaluator
320	pub fn with_stdlib(&self) -> &Self {390	pub fn with_stdlib(&self) -> &Self {
321		use jrsonnet_stdlib::STDLIB_STR;391		let val = evaluate(
322		let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();
323
324		self.add_parsed_file(392			self.clone(),
325			std_path.clone(),
326			STDLIB_STR.to_owned().into(),393			self.create_default_context(),
327			stdlib::get_parsed_stdlib(),394			&stdlib::get_parsed_stdlib(),
328		)395		)
329		.expect("stdlib is correct");396		.expect("std should not fail");
330		let val = self
331			.evaluate_loaded_file_raw(&std_path)
332			.expect("stdlib is correct");
333		self.settings_mut().globals.insert("std".into(), val);397		self.settings_mut().globals.insert("std".into(), val);
334		self398		self
335	}399	}
506570
507/// Raw methods evaluate passed values but don't perform TLA execution571/// Raw methods evaluate passed values but don't perform TLA execution
508impl State {572impl State {
509	pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {
510		self.import_file(&std::env::current_dir().expect("cwd"), name)
511	}
512	pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {
513		self.import_file(&PathBuf::from("."), name)
514	}
515	/// Parses and evaluates the given snippet573	/// Parses and evaluates the given snippet
516	pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {574	pub fn evaluate_snippet(&self, name: String, code: String) -> Result<Val> {
517		let parsed = parse(575		let source = Source::new_virtual(Cow::Owned(name.clone()));
576		let parsed = jrsonnet_parser::parse(
518			&code,577			&code,
519			&ParserSettings {578			&ParserSettings {
520				file_name: source.clone(),579				file_name: source.clone(),
521			},580			},
522		)581		)
523		.map_err(|e| ImportSyntaxError {582		.map_err(|e| ImportSyntaxError {
524			path: source.clone(),583			path: source,
525			source_code: code.clone(),584			source_code: code.clone().into(),
526			error: Box::new(e),585			error: Box::new(e),
527		})?;586		})?;
528		self.add_parsed_file(source, code, parsed.clone())?;587		self.data_mut().volatile_files.insert(name, code);
529		self.evaluate_expr_raw(parsed)588		evaluate(self.clone(), self.create_default_context(), &parsed)
530	}589	}
531	/// Evaluates the parsed expression
532	pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {
533		evaluate(self.clone(), self.create_default_context(), &code)
534	}
535}590}
536591
537/// Settings utilities592/// Settings utilities
538impl State {593impl State {
539	pub fn add_ext_var(&self, name: IStr, value: Val) {594	pub fn add_ext_var(&self, name: IStr, value: Val) {
540		self.settings_mut().ext_vars.insert(name, value);595		self.settings_mut()
596			.ext_vars
597			.insert(name, TlaArg::Val(value));
541	}598	}
542	pub fn add_ext_str(&self, name: IStr, value: IStr) {599	pub fn add_ext_str(&self, name: IStr, value: IStr) {
543		self.add_ext_var(name, Val::Str(value));600		self.settings_mut()
601			.ext_vars
602			.insert(name, TlaArg::String(value));
544	}603	}
545	pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {604	pub fn add_ext_code(&self, name: &str, code: String) -> Result<()> {
546		let value =605		let source_name = format!("<extvar:{}>", name);
547			self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;606		let source = Source::new_virtual(Cow::Owned(source_name.clone()));
607		let parsed = jrsonnet_parser::parse(
608			&code,
609			&ParserSettings {
610				file_name: source.clone(),
611			},
612		)
613		.map_err(|e| ImportSyntaxError {
614			path: source,
615			source_code: code.clone().into(),
616			error: Box::new(e),
617		})?;
548		self.add_ext_var(name, value);618		self.data_mut().volatile_files.insert(source_name, code);
619		self.settings_mut()
620			.ext_vars
621			.insert(name.into(), TlaArg::Code(parsed));
549		Ok(())622		Ok(())
550	}623	}
551624
559			.tla_vars632			.tla_vars
560			.insert(name, TlaArg::String(value));633			.insert(name, TlaArg::String(value));
561	}634	}
562	pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {635	pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {
563		let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;636		let source_name = format!("<top-level-arg:{}>", name);
637		let source = Source::new_virtual(Cow::Owned(source_name.clone()));
638		let parsed = jrsonnet_parser::parse(
639			code,
640			&ParserSettings {
641				file_name: source.clone(),
642			},
643		)
644		.map_err(|e| ImportSyntaxError {
645			path: source,
646			source_code: code.into(),
647			error: Box::new(e),
648		})?;
649		self.data_mut()
650			.volatile_files
651			.insert(source_name, code.to_owned());
564		self.settings_mut()652		self.settings_mut()
565			.tla_vars653			.tla_vars
566			.insert(name, TlaArg::Code(parsed));654			.insert(name, TlaArg::Code(parsed));
567		Ok(())655		Ok(())
568	}656	}
569657
570	pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {658	pub fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
571		self.settings().import_resolver.resolve_file(from, path)659		self.settings()
572	}660			.import_resolver
573	pub fn load_file_str(&self, path: &Path) -> Result<IStr> {
574		self.settings().import_resolver.load_file_str(path)
575	}661			.resolve_file(from, path.as_ref())
576	pub fn load_file_bin(&self, path: &Path) -> Result<Rc<[u8]>> {
577		self.settings().import_resolver.load_file_bin(path)
578	}662	}
579663
580	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {664	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {