123use 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;282930pub 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 52 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}868788#[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}100101102#[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}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}