1 files changed, 0 insertions, 437 deletions
diff --git a/rust/src/linearview.rs b/rust/src/linearview.rs
deleted file mode 100644
index b90d2784..00000000
--- a/rust/src/linearview.rs
+++ /dev/null
@@ -1,437 +0,0 @@
-// Copyright 2022-2024 Vector 35 Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! APIs for accessing Binary Ninja's linear view
-
-use binaryninjacore_sys::*;
-
-use crate::binaryview::BinaryView;
-use crate::disassembly::{DisassemblySettings, DisassemblyTextLine};
-use crate::function::Function;
-
-use crate::rc::*;
-use std::ops::Deref;
-
-use std::mem;
-
-pub struct LinearViewObject {
-    pub(crate) handle: *mut BNLinearViewObject,
-}
-
-impl LinearViewObject {
-    pub(crate) unsafe fn from_raw(handle: *mut BNLinearViewObject) -> Ref<Self> {
-        debug_assert!(!handle.is_null());
-
-        Ref::new(Self { handle })
-    }
-
-    pub fn data_only(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewDataOnly(view.handle, settings.handle);
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn disassembly(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewDisassembly(view.handle, settings.handle);
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn lifted_il(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewLiftedIL(view.handle, settings.handle);
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn mlil(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewMediumLevelIL(view.handle, settings.handle);
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn mlil_ssa(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewMediumLevelILSSAForm(
-                view.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn hlil(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewHighLevelIL(view.handle, settings.handle);
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn hlil_ssa(view: &BinaryView, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewHighLevelILSSAForm(
-                view.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn language_representation(
-        view: &BinaryView,
-        settings: &DisassemblySettings,
-        language: &str,
-    ) -> Ref<Self> {
-        unsafe {
-            let language = std::ffi::CString::new(language).unwrap();
-            let handle = binaryninjacore_sys::BNCreateLinearViewLanguageRepresentation(
-                view.handle,
-                settings.handle,
-                language.as_ptr(),
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_disassembly(
-        function: &Function,
-        settings: &DisassemblySettings,
-    ) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionDisassembly(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_lifted_il(
-        function: &Function,
-        settings: &DisassemblySettings,
-    ) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionLiftedIL(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_mlil(function: &Function, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionMediumLevelIL(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_mlil_ssa(
-        function: &Function,
-        settings: &DisassemblySettings,
-    ) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_hlil(function: &Function, settings: &DisassemblySettings) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionHighLevelIL(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_hlil_ssa(
-        function: &Function,
-        settings: &DisassemblySettings,
-    ) -> Ref<Self> {
-        unsafe {
-            let handle = binaryninjacore_sys::BNCreateLinearViewSingleFunctionHighLevelILSSAForm(
-                function.handle,
-                settings.handle,
-            );
-
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn single_function_language_representation(
-        function: &Function,
-        settings: &DisassemblySettings,
-        language: &str,
-    ) -> Ref<Self> {
-        unsafe {
-            let language = std::ffi::CString::new(language).unwrap();
-            let handle =
-                binaryninjacore_sys::BNCreateLinearViewSingleFunctionLanguageRepresentation(
-                    function.handle,
-                    settings.handle,
-                    language.as_ptr(),
-                );
-
-            Self::from_raw(handle)
-        }
-    }
-}
-
-unsafe impl RefCountable for LinearViewObject {
-    unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
-        Ref::new(Self {
-            handle: BNNewLinearViewObjectReference(handle.handle),
-        })
-    }
-
-    unsafe fn dec_ref(handle: &Self) {
-        BNFreeLinearViewObject(handle.handle);
-    }
-}
-
-impl ToOwned for LinearViewObject {
-    type Owned = Ref<Self>;
-
-    fn to_owned(&self) -> Self::Owned {
-        unsafe { RefCountable::inc_ref(self) }
-    }
-}
-
-unsafe impl Send for LinearViewObject {}
-unsafe impl Sync for LinearViewObject {}
-
-#[derive(Eq)]
-pub struct LinearViewCursor {
-    pub(crate) handle: *mut binaryninjacore_sys::BNLinearViewCursor,
-}
-
-impl LinearViewCursor {
-    pub(crate) unsafe fn from_raw(handle: *mut BNLinearViewCursor) -> Ref<Self> {
-        debug_assert!(!handle.is_null());
-
-        Ref::new(Self { handle })
-    }
-
-    pub fn new(root: &LinearViewObject) -> Ref<Self> {
-        unsafe {
-            let handle = BNCreateLinearViewCursor(root.handle);
-            Self::from_raw(handle)
-        }
-    }
-
-    /// Gets the current [LinearViewObject] associated with this cursor.
-    pub fn current_object(&self) -> Ref<LinearViewObject> {
-        unsafe {
-            let handle = BNGetLinearViewCursorCurrentObject(self.handle);
-            LinearViewObject::from_raw(handle)
-        }
-    }
-
-    // FIXME: can we implement clone without shadowing ToOwned?
-    pub fn duplicate(&self) -> Ref<Self> {
-        unsafe {
-            let handle = BNDuplicateLinearViewCursor(self.handle);
-            Self::from_raw(handle)
-        }
-    }
-
-    pub fn before_begin(&self) -> bool {
-        unsafe { BNIsLinearViewCursorBeforeBegin(self.handle) }
-    }
-
-    pub fn after_end(&self) -> bool {
-        unsafe { BNIsLinearViewCursorAfterEnd(self.handle) }
-    }
-
-    pub fn valid(&self) -> bool {
-        !(self.before_begin() || self.after_end())
-    }
-
-    pub fn seek_to_start(&self) {
-        unsafe { BNSeekLinearViewCursorToBegin(self.handle) }
-    }
-
-    pub fn seek_to_end(&self) {
-        unsafe { BNSeekLinearViewCursorToEnd(self.handle) }
-    }
-
-    pub fn seek_to_address(&self, address: u64) {
-        unsafe { BNSeekLinearViewCursorToAddress(self.handle, address) }
-    }
-
-    pub fn ordering_index(&self) -> std::ops::Range<u64> {
-        unsafe {
-            let range = BNGetLinearViewCursorOrderingIndex(self.handle);
-            range.start..range.end
-        }
-    }
-
-    pub fn ordering_index_total(&self) -> u64 {
-        unsafe { BNGetLinearViewCursorOrderingIndexTotal(self.handle) }
-    }
-
-    pub fn seek_to_ordering_index(&self, idx: u64) {
-        unsafe { BNSeekLinearViewCursorToAddress(self.handle, idx) }
-    }
-
-    pub fn previous(&self) -> bool {
-        unsafe { BNLinearViewCursorPrevious(self.handle) }
-    }
-
-    pub fn next(&self) -> bool {
-        unsafe { BNLinearViewCursorNext(self.handle) }
-    }
-
-    pub fn lines(&self) -> Array<LinearDisassemblyLine> {
-        let mut count: usize = 0;
-        unsafe {
-            let handles = BNGetLinearViewCursorLines(self.handle, &mut count);
-            Array::new(handles, count, ())
-        }
-    }
-}
-
-impl PartialEq for LinearViewCursor {
-    fn eq(&self, other: &Self) -> bool {
-        unsafe { BNCompareLinearViewCursors(self.handle, other.handle) == 0 }
-    }
-}
-
-impl PartialOrd for LinearViewCursor {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for LinearViewCursor {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        match unsafe { BNCompareLinearViewCursors(self.handle, other.handle) } {
-            i if i < 0 => std::cmp::Ordering::Less,
-            i if i > 0 => std::cmp::Ordering::Greater,
-            _ => std::cmp::Ordering::Equal,
-        }
-    }
-}
-
-unsafe impl RefCountable for LinearViewCursor {
-    unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
-        Ref::new(Self {
-            handle: BNNewLinearViewCursorReference(handle.handle),
-        })
-    }
-
-    unsafe fn dec_ref(handle: &Self) {
-        BNFreeLinearViewCursor(handle.handle);
-    }
-}
-
-impl ToOwned for LinearViewCursor {
-    type Owned = Ref<Self>;
-
-    fn to_owned(&self) -> Self::Owned {
-        unsafe { RefCountable::inc_ref(self) }
-    }
-}
-
-unsafe impl Send for LinearViewCursor {}
-unsafe impl Sync for LinearViewCursor {}
-
-pub type LinearDisassemblyLineType = BNLinearDisassemblyLineType;
-
-pub struct LinearDisassemblyLine {
-    t: LinearDisassemblyLineType,
-
-    // These will be cleaned up by BNFreeLinearDisassemblyLines, so we
-    // don't drop them in the relevant deconstructors.
-    function: mem::ManuallyDrop<Ref<Function>>,
-    contents: mem::ManuallyDrop<DisassemblyTextLine>,
-}
-
-impl LinearDisassemblyLine {
-    pub(crate) unsafe fn from_raw(raw: &BNLinearDisassemblyLine) -> Self {
-        let linetype = raw.type_;
-        let function = mem::ManuallyDrop::new(Function::from_raw(raw.function));
-        let contents = mem::ManuallyDrop::new(DisassemblyTextLine(raw.contents));
-        Self {
-            t: linetype,
-            function,
-            contents,
-        }
-    }
-
-    pub fn function(&self) -> &Function {
-        self.function.as_ref()
-    }
-
-    pub fn line_type(&self) -> LinearDisassemblyLineType {
-        self.t
-    }
-}
-
-impl Deref for LinearDisassemblyLine {
-    type Target = DisassemblyTextLine;
-    fn deref(&self) -> &Self::Target {
-        self.contents.deref()
-    }
-}
-
-impl std::fmt::Display for LinearDisassemblyLine {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.deref())
-    }
-}
-
-impl CoreArrayProvider for LinearDisassemblyLine {
-    type Raw = BNLinearDisassemblyLine;
-    type Context = ();
-    type Wrapped<'a> = Guard<'a, LinearDisassemblyLine>;
-}
-
-unsafe impl CoreArrayProviderInner for LinearDisassemblyLine {
-    unsafe fn free(raw: *mut BNLinearDisassemblyLine, count: usize, _context: &()) {
-        BNFreeLinearDisassemblyLines(raw, count);
-    }
-    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, _context: &'a Self::Context) -> Self::Wrapped<'a> {
-        Guard::new(LinearDisassemblyLine::from_raw(raw), _context)
-    }
-}