123use jrsonnet_evaluator::{4 create_error, create_error_result, Error, EvaluationState, ImportResolver, Result,5};6use std::{7 any::Any,8 cell::RefCell,9 collections::HashMap,10 ffi::{c_void, CStr, CString},11 fs::File,12 io::Read,13 os::raw::{c_char, c_int},14 path::PathBuf,15 ptr::null_mut,16 rc::Rc,17};1819pub type JsonnetImportCallback = unsafe extern "C" fn(20 ctx: *mut c_void,21 base: *const c_char,22 rel: *const c_char,23 found_here: *mut *const c_char,24 success: &mut c_int,25) -> *const c_char;262728pub struct CallbackImportResolver {29 cb: JsonnetImportCallback,30 ctx: *mut c_void,3132 out: RefCell<HashMap<PathBuf, Rc<str>>>,33}34impl ImportResolver for CallbackImportResolver {35 fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {36 let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();37 let rel = CString::new(path.to_str().unwrap()).unwrap().into_raw();38 let found_here: *mut c_char = null_mut();39 let mut success: i32 = 0;40 let result_ptr = unsafe {41 (self.cb)(42 self.ctx,43 base,44 rel,45 &mut (found_here as *const _),46 &mut success,47 )48 } as *mut i8;49 50 unsafe {51 CString::from_raw(base);52 CString::from_raw(rel);53 }54 let result_raw = unsafe { CStr::from_ptr(result_ptr) };55 let result_str = result_raw.to_str().unwrap();56 assert!(success == 0 || success == 1);57 if success == 0 {58 let result = result_str.to_owned();59 let err = Err(create_error(Error::ImportCallbackError(result)));60 unsafe { CString::from_raw(result_ptr) };61 return err;62 }6364 let found_here_raw = unsafe { CStr::from_ptr(found_here) };65 let found_here_buf = PathBuf::from(found_here_raw.to_str().unwrap());66 unsafe {67 CString::from_raw(found_here);68 }6970 let mut out = self.out.borrow_mut();71 if !out.contains_key(&found_here_buf) {72 out.insert(found_here_buf.clone(), result_str.into());73 unsafe { CString::from_raw(result_ptr) };74 }7576 Ok(Rc::new(found_here_buf))77 }78 fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>> {79 Ok(self.out.borrow().get(resolved).unwrap().clone())80 }81 unsafe fn as_any(&self) -> &dyn Any {82 self83 }84}858687#[no_mangle]88pub unsafe extern "C" fn jsonnet_import_callback(89 vm: &EvaluationState,90 cb: JsonnetImportCallback,91 ctx: *mut c_void,92) {93 vm.set_import_resolver(Box::new(CallbackImportResolver {94 cb,95 ctx,96 out: RefCell::new(HashMap::new()),97 }))98}99100101#[derive(Default)]102pub struct NativeImportResolver {103 library_paths: RefCell<Vec<PathBuf>>,104}105impl NativeImportResolver {106 fn add_jpath(&self, path: PathBuf) {107 self.library_paths.borrow_mut().push(path);108 }109}110impl ImportResolver for NativeImportResolver {111 fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {112 let mut new_path = from.clone();113 new_path.push(path);114 if new_path.exists() {115 Ok(Rc::new(new_path))116 } else {117 for library_path in self.library_paths.borrow().iter() {118 let mut cloned = library_path.clone();119 cloned.push(path);120 if cloned.exists() {121 return Ok(Rc::new(cloned));122 }123 }124 create_error_result(Error::ImportFileNotFound(from.clone(), path.clone()))125 }126 }127 fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {128 let mut file =129 File::open(id).map_err(|_e| create_error(Error::ResolvedFileNotFound(id.clone())))?;130 let mut out = String::new();131 file.read_to_string(&mut out)132 .map_err(|_e| create_error(Error::ImportBadFileUtf8(id.clone())))?;133 Ok(out.into())134 }135 unsafe fn as_any(&self) -> &dyn Any {136 self137 }138}139140141142143#[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}