This is a combination of 23 commits, the work of Ryan Snyder:

Initial fresh repo

Add support for recent calling convention API updates and folds the binaryninjacore-sys crate directly into this one.

Add support for auto function analysis suppression

Finish moving binaryninjacore-sys back into this crate

Update for Symbol/Segment core API changes

Update for Symbol API cleanup

api: advance submodule reference, support Token changes

arch/lifting: support for flags in custom architectures

arch/lifting: support default flag write behaviors, handle more ops

build: enable headless binary support on MacOS via evil hack

bv: add BinaryView wrapper support, remove wrong comment

api: update to latest binja dev branch support

deps: bump dep versions

rust: bump to 2018 edition

api: bump to avoid cargo submodule brokenness

build: improve binaryninja path detection; enable linux linkhack

bv: stub for bv load settings

arch: fix flag related crash, minor llil update

api: update for recent changes

macos: disable linkhack briefly

1 files changed, 174 insertions, 0 deletions

diff --git a/rust/src/filemetadata.rs b/rust/src/filemetadata.rs
new file mode 100644
index 00000000..bb09a03f
--- /dev/null
+++ b/rust/src/filemetadata.rs
@@ -0,0 +1,174 @@
+use binaryninjacore_sys::{BNFileMetadata,
+                          BNCreateFileMetadata,
+                          BNNewFileReference,
+                          BNFreeFileMetadata,
+                          BNCloseFile,
+                          //BNSetFileMetadataNavigationHandler,
+                          BNIsFileModified,
+                          BNIsAnalysisChanged,
+                          BNMarkFileModified,
+                          BNMarkFileSaved,
+                          BNIsBackedByDatabase,
+                          BNGetFilename,
+                          BNSetFilename,
+                          BNBeginUndoActions,
+                          BNCommitUndoActions,
+                          BNUndo,
+                          BNRedo,
+                          BNGetCurrentView,
+                          BNGetCurrentOffset,
+                          BNNavigate,
+                          BNGetFileViewOfType};
+
+use crate::binaryview::BinaryView;
+
+use crate::rc::*;
+use crate::string::*;
+
+#[derive(PartialEq, Eq, Hash)]
+pub struct FileMetadata {
+    pub(crate) handle: *mut BNFileMetadata,
+}
+
+unsafe impl Send for FileMetadata {}
+unsafe impl Sync for FileMetadata {}
+
+impl FileMetadata {
+    pub(crate) fn from_raw(handle: *mut BNFileMetadata) -> Self {
+        Self { handle }
+    }
+
+    pub fn new() -> Ref<Self> {
+        unsafe { 
+            Ref::new(
+                Self {
+                    handle: BNCreateFileMetadata(),
+                }
+            )
+        }
+    }
+
+    pub fn with_filename<S: BnStrCompatible>(name: S) -> Ref<Self> {
+        let ret = FileMetadata::new();
+        ret.set_filename(name);
+        ret
+    }
+
+    pub fn close(&self) {
+        unsafe { BNCloseFile(self.handle); }
+    }
+
+    pub fn filename(&self) -> BnString {
+        unsafe {
+            let raw = BNGetFilename(self.handle);
+            BnString::from_raw(raw)
+        }
+    }
+
+    pub fn set_filename<S: BnStrCompatible>(&self, name: S) {
+        let name = name.as_bytes_with_nul();
+
+        unsafe { BNSetFilename(self.handle, name.as_ref().as_ptr() as *mut _); }
+    }
+
+    pub fn is_modified(&self) -> bool {
+        unsafe { BNIsFileModified(self.handle) }
+    }
+
+    pub fn mark_modified(&self) {
+        unsafe { BNMarkFileModified(self.handle); }
+    }
+
+    pub fn is_analysis_changed(&self) -> bool {
+        unsafe { BNIsAnalysisChanged(self.handle) }
+    }
+
+    pub fn mark_saved(&self) {
+        unsafe { BNMarkFileSaved(self.handle); }
+    }
+
+    pub fn is_database_backed(&self) -> bool {
+        unsafe { BNIsBackedByDatabase(self.handle) }
+    }
+
+    pub fn begin_undo_actions(&self) {
+        unsafe { BNBeginUndoActions(self.handle); }
+    }
+
+    pub fn commit_undo_actions(&self) {
+        unsafe { BNCommitUndoActions(self.handle); }
+    }
+
+    pub fn undo(&self) {
+        unsafe { BNUndo(self.handle); }
+    }
+
+    pub fn redo(&self) {
+        unsafe { BNRedo(self.handle); }
+    }
+
+    pub fn current_view(&self) -> BnString {
+        unsafe {
+            BnString::from_raw(BNGetCurrentView(self.handle))
+        }
+    }
+
+    pub fn current_offset(&self) -> u64 {
+        unsafe { BNGetCurrentOffset(self.handle) }
+    }
+
+    pub fn navigate_to<S: BnStrCompatible>(&self, view: S, offset: u64) -> Result<(), ()> {
+        let view = view.as_bytes_with_nul();
+
+        unsafe {
+            if BNNavigate(self.handle, view.as_ref().as_ptr() as *const _, offset) {
+                Ok(())
+            } else {
+                Err(())
+            }
+        }
+    }
+
+    pub fn get_view_of_type<S: BnStrCompatible>(&self, view: S) -> Result<Ref<BinaryView>, ()> {
+        let view = view.as_bytes_with_nul();
+
+        unsafe {
+            let res = BNGetFileViewOfType(self.handle, view.as_ref().as_ptr() as *const _);
+
+            if res.is_null() {
+                Err(())
+            } else {
+                Ok(Ref::new(BinaryView::from_raw(res)))
+            }
+        }
+    }
+}
+
+impl ToOwned for FileMetadata {
+    type Owned = Ref<Self>;
+
+    fn to_owned(&self) -> Self::Owned {
+        unsafe { RefCountable::inc_ref(self) }
+    }
+}
+
+unsafe impl RefCountable for FileMetadata {
+    unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
+        Ref::new(Self {
+            handle: BNNewFileReference(handle.handle),
+        })
+    }
+
+    unsafe fn dec_ref(handle: &Self) {
+        BNFreeFileMetadata(handle.handle);
+    }
+}
+
+
+/*
+BNCreateDatabase,
+BNCreateDatabaseWithProgress,
+BNOpenExistingDatabase,
+BNOpenExistingDatabaseWithProgress,
+*/
+