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

1//! Import resolution manipulation utilities23use jrsonnet_evaluator::{4	error::{Error::*, Result},5	throw, EvaluationState, ImportResolver,6};7use jrsonnet_interner::IStr;8use std::{9	any::Any,10	cell::RefCell,11	collections::HashMap,12	ffi::{c_void, CStr, CString},13	fs::File,14	io::Read,15	os::raw::{c_char, c_int},16	path::PathBuf,17	ptr::null_mut,18	rc::Rc,19};2021pub type JsonnetImportCallback = unsafe extern "C" fn(22	ctx: *mut c_void,23	base: *const c_char,24	rel: *const c_char,25	found_here: *mut *const c_char,26	success: &mut c_int,27) -> *const c_char;2829/// Resolves imports using callback30pub struct CallbackImportResolver {31	cb: JsonnetImportCallback,32	ctx: *mut c_void,3334	out: RefCell<HashMap<PathBuf, IStr>>,35}36impl ImportResolver for CallbackImportResolver {37	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {38		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();39		let rel = CString::new(path.to_str().unwrap()).unwrap().into_raw();40		let found_here: *mut c_char = null_mut();41		let mut success: i32 = 0;42		let result_ptr = unsafe {43			(self.cb)(44				self.ctx,45				base,46				rel,47				&mut (found_here as *const _),48				&mut success,49			)50		} as *mut i8;51		// Release memory occipied by arguments passed52		unsafe {53			CString::from_raw(base);54			CString::from_raw(rel);55		}56		let result_raw = unsafe { CStr::from_ptr(result_ptr) };57		let result_str = result_raw.to_str().unwrap();58		assert!(success == 0 || success == 1);59		if success == 0 {60			unsafe { CString::from_raw(result_ptr) };61			let result = result_str.to_owned();62			throw!(ImportCallbackError(result));63		}6465		let found_here_raw = unsafe { CStr::from_ptr(found_here) };66		let found_here_buf = PathBuf::from(found_here_raw.to_str().unwrap());67		unsafe {68			CString::from_raw(found_here);69		}7071		let mut out = self.out.borrow_mut();72		if !out.contains_key(&found_here_buf) {73			out.insert(found_here_buf.clone(), result_str.into());74			unsafe { CString::from_raw(result_ptr) };75		}7677		Ok(Rc::new(found_here_buf))78	}79	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr> {80		Ok(self.out.borrow().get(resolved).unwrap().clone())81	}82	unsafe fn as_any(&self) -> &dyn Any {83		self84	}85}8687/// # Safety88#[no_mangle]89pub unsafe extern "C" fn jsonnet_import_callback(90	vm: &EvaluationState,91	cb: JsonnetImportCallback,92	ctx: *mut c_void,93) {94	vm.set_import_resolver(Box::new(CallbackImportResolver {95		cb,96		ctx,97		out: RefCell::new(HashMap::new()),98	}))99}100101/// Standard FS import resolver102#[derive(Default)]103pub struct NativeImportResolver {104	library_paths: RefCell<Vec<PathBuf>>,105}106impl NativeImportResolver {107	fn add_jpath(&self, path: PathBuf) {108		self.library_paths.borrow_mut().push(path);109	}110}111impl ImportResolver for NativeImportResolver {112	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {113		let mut new_path = from.clone();114		new_path.push(path);115		if new_path.exists() {116			Ok(Rc::new(new_path))117		} else {118			for library_path in self.library_paths.borrow().iter() {119				let mut cloned = library_path.clone();120				cloned.push(path);121				if cloned.exists() {122					return Ok(Rc::new(cloned));123				}124			}125			throw!(ImportFileNotFound(from.clone(), path.clone()))126		}127	}128	fn load_file_contents(&self, id: &PathBuf) -> Result<IStr> {129		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;130		let mut out = String::new();131		file.read_to_string(&mut out)132			.map_err(|_e| ImportBadFileUtf8(id.clone()))?;133		Ok(out.into())134	}135	unsafe fn as_any(&self) -> &dyn Any {136		self137	}138}139140/// # Safety141///142/// This function is safe, if received v is a pointer to normal C string143#[no_mangle]144pub unsafe extern "C" fn jsonnet_jpath_add(vm: &EvaluationState, v: *const c_char) {145	let cstr = CStr::from_ptr(v);146	let path = PathBuf::from(cstr.to_str().unwrap());147	let any_resolver = &vm.settings().import_resolver;148	let resolver = any_resolver149		.as_any()150		.downcast_ref::<NativeImportResolver>()151		.expect("jpaths are not compatible with callback imports!");152	resolver.add_jpath(path);153}