1 files changed, 0 insertions, 209 deletions
diff --git a/rust/src/externallibrary.rs b/rust/src/externallibrary.rs
deleted file mode 100644
index a5dcefc8..00000000
--- a/rust/src/externallibrary.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use core::{ffi, mem, ptr};
-
-use binaryninjacore_sys::*;
-
-use crate::project::ProjectFile;
-use crate::rc::{CoreArrayProvider, CoreArrayProviderInner};
-use crate::string::{BnStrCompatible, BnString};
-use crate::symbol::Symbol;
-
-/// An ExternalLibrary is an abstraction for a library that is optionally backed
-/// by a [ProjectFile].
-#[repr(transparent)]
-pub struct ExternalLibrary {
-    handle: ptr::NonNull<BNExternalLibrary>,
-}
-
-impl Drop for ExternalLibrary {
-    fn drop(&mut self) {
-        unsafe { BNFreeExternalLibrary(self.as_raw()) }
-    }
-}
-
-impl Clone for ExternalLibrary {
-    fn clone(&self) -> Self {
-        unsafe {
-            Self::from_raw(ptr::NonNull::new(BNNewExternalLibraryReference(self.as_raw())).unwrap())
-        }
-    }
-}
-
-impl ExternalLibrary {
-    pub(crate) unsafe fn from_raw(handle: ptr::NonNull<BNExternalLibrary>) -> Self {
-        Self { handle }
-    }
-
-    pub(crate) unsafe fn ref_from_raw(handle: &*mut BNExternalLibrary) -> &Self {
-        assert!(!handle.is_null());
-        mem::transmute(handle)
-    }
-
-    #[allow(clippy::mut_from_ref)]
-    pub(crate) unsafe fn as_raw(&self) -> &mut BNExternalLibrary {
-        &mut *self.handle.as_ptr()
-    }
-
-    /// Get the name of this external library
-    pub fn name(&self) -> BnString {
-        let result = unsafe { BNExternalLibraryGetName(self.as_raw()) };
-        assert!(!result.is_null());
-        unsafe { BnString::from_raw(result) }
-    }
-
-    /// Get the file backing this external library
-    pub fn backing_file(&self) -> Option<ProjectFile> {
-        let result = unsafe { BNExternalLibraryGetBackingFile(self.as_raw()) };
-        let handle = ptr::NonNull::new(result)?;
-        Some(unsafe { ProjectFile::from_raw(handle) })
-    }
-
-    /// Set the file backing this external library
-    pub fn set_backing_file(&self, file: Option<&ProjectFile>) {
-        let file_handle = file
-            .map(|x| unsafe {x.as_raw() as *mut _})
-            .unwrap_or(ptr::null_mut());
-        unsafe { BNExternalLibrarySetBackingFile(self.as_raw(), file_handle) }
-    }
-}
-
-impl CoreArrayProvider for ExternalLibrary {
-    type Raw = *mut BNExternalLibrary;
-    type Context = ();
-    type Wrapped<'a> = &'a Self;
-}
-
-unsafe impl CoreArrayProviderInner for ExternalLibrary {
-    unsafe fn free(raw: *mut Self::Raw, count: usize, _context: &Self::Context) {
-        BNFreeExternalLibraryList(raw, count)
-    }
-
-    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, _context: &'a Self::Context) -> Self::Wrapped<'a> {
-        Self::ref_from_raw(raw)
-    }
-}
-
-/// An ExternalLocation is an association from a source symbol in a binary view
-/// to a target symbol and/or address in an [ExternalLibrary].
-#[repr(transparent)]
-pub struct ExternalLocation {
-    handle: ptr::NonNull<BNExternalLocation>,
-}
-
-impl Drop for ExternalLocation {
-    fn drop(&mut self) {
-        unsafe { BNFreeExternalLocation(self.as_raw()) }
-    }
-}
-
-impl Clone for ExternalLocation {
-    fn clone(&self) -> Self {
-        unsafe {
-            Self::from_raw(
-                ptr::NonNull::new(BNNewExternalLocationReference(self.as_raw())).unwrap(),
-            )
-        }
-    }
-}
-
-impl ExternalLocation {
-    pub(crate) unsafe fn from_raw(handle: ptr::NonNull<BNExternalLocation>) -> Self {
-        Self { handle }
-    }
-
-    pub(crate) unsafe fn ref_from_raw(handle: &*mut BNExternalLocation) -> &Self {
-        assert!(!handle.is_null());
-        mem::transmute(handle)
-    }
-
-    #[allow(clippy::mut_from_ref)]
-    pub(crate) unsafe fn as_raw(&self) -> &mut BNExternalLocation {
-        &mut *self.handle.as_ptr()
-    }
-
-    /// Get the source symbol for this ExternalLocation
-    pub fn source_symbol(&self) -> Symbol {
-        let result = unsafe { BNExternalLocationGetSourceSymbol(self.as_raw()) };
-        assert!(!result.is_null());
-        unsafe { Symbol::from_raw(result) }
-    }
-
-    /// Get the ExternalLibrary that this ExternalLocation targets
-    pub fn library(&self) -> Option<ExternalLibrary> {
-        let result = unsafe { BNExternalLocationGetExternalLibrary(self.as_raw()) };
-        let handle = ptr::NonNull::new(result)?;
-        Some(unsafe { ExternalLibrary::from_raw(handle) })
-    }
-
-    /// Set the ExternalLibrary that this ExternalLocation targets
-    pub fn set_external_library(&self, lib: Option<&ExternalLibrary>) {
-        let lib_handle = lib
-            .map(|x| unsafe {x.as_raw() as *mut _})
-            .unwrap_or(ptr::null_mut());
-        unsafe { BNExternalLocationSetExternalLibrary(self.as_raw(), lib_handle) }
-    }
-
-    /// Check if this ExternalLocation has a target address
-    pub fn has_target_address(&self) -> bool {
-        unsafe { BNExternalLocationHasTargetAddress(self.as_raw()) }
-    }
-
-    /// Check if this ExternalLocation has a target symbol
-    pub fn has_target_symbol(&self) -> bool {
-        unsafe { BNExternalLocationHasTargetSymbol(self.as_raw()) }
-    }
-
-    /// Get the address pointed to by this ExternalLocation, if any
-    pub fn target_address(&self) -> Option<u64> {
-        self.has_target_address()
-            .then(|| unsafe { BNExternalLocationGetTargetAddress(self.as_raw()) })
-    }
-
-    /// Set the address pointed to by this ExternalLocation.
-    /// ExternalLocations must have a valid target address and/or symbol set.
-    pub fn set_target_address(&self, mut address: Option<u64>) -> bool {
-        let address_ptr = address
-            .as_mut()
-            .map(|x| x as *mut u64)
-            .unwrap_or(ptr::null_mut());
-        unsafe { BNExternalLocationSetTargetAddress(self.as_raw(), address_ptr) }
-    }
-
-    /// Get the symbol pointed to by this ExternalLocation, if any
-    pub fn target_symbol(&self) -> Option<BnString> {
-        self.has_target_symbol().then(|| unsafe {
-            let result = BNExternalLocationGetTargetSymbol(self.as_raw());
-            assert!(!result.is_null());
-            BnString::from_raw(result)
-        })
-    }
-
-    /// Set the symbol pointed to by this ExternalLocation.
-    /// ExternalLocations must have a valid target address and/or symbol set.
-    pub fn set_target_symbol<S: BnStrCompatible>(&self, symbol: Option<S>) -> bool {
-        let symbol = symbol
-            .map(|x| x.into_bytes_with_nul().as_ref().as_ptr() as *const ffi::c_char)
-            .unwrap_or(ptr::null_mut());
-        unsafe {
-            BNExternalLocationSetTargetSymbol(
-                self.as_raw(),
-                symbol,
-            )
-        }
-    }
-}
-
-impl CoreArrayProvider for ExternalLocation {
-    type Raw = *mut BNExternalLocation;
-    type Context = ();
-    type Wrapped<'a> = &'a Self;
-}
-
-unsafe impl CoreArrayProviderInner for ExternalLocation {
-    unsafe fn free(raw: *mut Self::Raw, count: usize, _context: &Self::Context) {
-        BNFreeExternalLocationList(raw, count)
-    }
-
-    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, _context: &'a Self::Context) -> Self::Wrapped<'a> {
-        Self::ref_from_raw(raw)
-    }
-}