Merge: C++ Api

Author: CouleeApps

binaryninjaapi.h

@@ -22394,6 +22394,67 @@ namespace BinaryNinja {
 		std::optional<DerivedString> RecognizeConstantData(
 			const HighLevelILInstruction& instr) override;
 	};
+
+	class DatabaseObject: public CoreRefCountObject<BNDatabaseObject, BNNewDatabaseObjectReference, BNFreeDatabaseObject>
+	{
+	public:
+		explicit DatabaseObject(BNDatabaseObject* database);
+		virtual ~DatabaseObject();
+
+		// TODO: User subclassing
+		int GetType() const;
+		std::string GetId() const;
+		std::string GetDescription() const;
+		Ref<DatabaseObject> GetParent() const;
+		std::unordered_map<std::string, Ref<DatabaseObject>> GetChildren();
+		std::vector<std::string> GetDependencies() const;
+	};
+
+	class DiffState:
+		public CoreRefCountObject<BNDiffState, BNNewDiffStateReference, BNFreeDiffState>
+	{
+	public:
+		explicit DiffState(BNDiffState* state);
+		explicit DiffState(Ref<Logger> logger);
+		virtual ~DiffState();
+
+		std::vector<std::string> GetErrors() const;
+		void ClearErrors();
+
+		Ref<class DiffObject> GenerateDiff(
+			Ref<DatabaseObject> base,
+			Ref<DatabaseObject> left,
+			Ref<DatabaseObject> right
+		);
+
+		bool ApplyDiff(
+			Ref<class DiffObject> diff,
+			Ref<DatabaseObject> base,
+			Ref<DatabaseObject> left,
+			Ref<DatabaseObject> right,
+			Ref<DatabaseObject> result
+		);
+
+		bool IsDiffed(Ref<DatabaseObject> object) const;
+		bool IsApplied(Ref<class DiffObject> object) const;
+	};
+
+	class DiffObject:
+		public CoreRefCountObject<BNDiffObject, BNNewDiffObjectReference, BNFreeDiffObject>
+	{
+	public:
+		DiffObject(BNDiffObject* object);
+		virtual ~DiffObject();
+
+		std::string GetBase() const;
+		std::string GetLeft() const;
+		std::string GetRight() const;
+
+		std::unordered_map<std::string, Ref<DiffObject>> GetChildren() const;
+
+		BNMergeStrategy GetMergeStrategy() const;
+		void SetMergeStrategy(BNMergeStrategy strategy);
+	};
 }  // namespace BinaryNinja
 
 

merge.cpp

@@ -0,0 +1,251 @@
+// Copyright (c) 2015-2025 Vector 35 Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+#include "binaryninjaapi.h"
+
+using namespace BinaryNinja;
+using namespace std;
+
+DatabaseObject::DatabaseObject(BNDatabaseObject* object)
+{
+	m_object = object;
+}
+
+
+DatabaseObject::~DatabaseObject() = default;
+
+
+Ref<DatabaseObject> DatabaseObject::GetParent() const
+{
+	BNDatabaseObject* parent = BNGetDatabaseObjectParent(m_object);
+	if (!parent)
+	{
+		return nullptr;
+	}
+	return new DatabaseObject(parent);
+}
+
+
+std::string DatabaseObject::GetId() const
+{
+	char* id = BNGetDatabaseObjectId(m_object);
+	std::string result = id;
+	BNFreeString(id);
+	return result;
+}
+
+
+std::string DatabaseObject::GetDescription() const
+{
+	char* desc = BNGetDatabaseObjectDescription(m_object);
+	std::string result = desc;
+	BNFreeString(desc);
+	return result;
+}
+
+
+int DatabaseObject::GetType() const
+{
+	return BNGetDatabaseObjectType(m_object);
+}
+
+
+std::unordered_map<std::string, Ref<DatabaseObject>> DatabaseObject::GetChildren()
+{
+	char** names;
+	BNDatabaseObject** objects;
+	size_t count = BNGetDatabaseObjectChildren(m_object, &names, &objects);
+
+	std::unordered_map<std::string, Ref<DatabaseObject>> result;
+	for (size_t i = 0; i < count; i++)
+	{
+		result[names[i]] = new DatabaseObject(BNNewDatabaseObjectReference(objects[i]));
+	}
+
+	BNFreeStringList(names, count);
+	BNFreeDatabaseObjectList(objects, count);
+	return result;
+}
+
+
+std::vector<std::string> DatabaseObject::GetDependencies() const
+{
+	size_t count;
+	char** deps = BNGetDatabaseObjectDependencies(m_object, &count);
+
+	std::vector<std::string> result;
+	for (size_t i = 0; i < count; i++)
+	{
+		result.push_back(deps[i]);
+	}
+
+	BNFreeStringList(deps, count);
+	return result;
+}
+
+
+DiffState::DiffState(BNDiffState* state)
+{
+	m_object = state;
+}
+
+
+DiffState::DiffState(Ref<Logger> logger)
+{
+	m_object = BNCreateDiffState(logger->GetObject());
+}
+
+
+DiffState::~DiffState() = default;
+
+
+std::vector<std::string> DiffState::GetErrors() const
+{
+	size_t count;
+	char** errors = BNGetDiffStateErrors(m_object, &count);
+
+	std::vector<std::string> result;
+	for (size_t i = 0; i < count; i++)
+	{
+		result.push_back(errors[i]);
+	}
+
+	BNFreeStringList(errors, count);
+	return result;
+}
+
+
+void DiffState::ClearErrors()
+{
+	BNClearDiffStateErrors(m_object);
+}
+
+
+Ref<DiffObject> DiffState::GenerateDiff(
+	Ref<DatabaseObject> base,
+	Ref<DatabaseObject> left,
+	Ref<DatabaseObject> right
+)
+{
+	BNDiffObject* diff = BNDiffStateGenerateDiff(
+		m_object,
+		base->GetObject(),
+		left->GetObject(),
+		right->GetObject()
+	);
+
+	if (!diff)
+	{
+		return nullptr;
+	}
+	return new DiffObject(diff);
+}
+
+
+bool DiffState::ApplyDiff(
+	Ref<DiffObject> diff,
+	Ref<DatabaseObject> base,
+	Ref<DatabaseObject> left,
+	Ref<DatabaseObject> right,
+	Ref<DatabaseObject> result
+)
+{
+	return BNDiffStateApplyDiff(
+		m_object, diff->GetObject(), base->GetObject(),
+		left->GetObject(), right->GetObject(), result->GetObject());
+}
+
+
+bool DiffState::IsDiffed(Ref<DatabaseObject> object) const
+{
+	return BNDiffStateIsDiffed(m_object, object->GetObject());
+}
+
+
+bool DiffState::IsApplied(Ref<DiffObject> object) const
+{
+	return BNDiffStateIsApplied(m_object, object->GetObject());
+}
+
+
+DiffObject::DiffObject(BNDiffObject* object)
+{
+	m_object = object;
+}
+
+
+DiffObject::~DiffObject() = default;
+
+
+std::string DiffObject::GetBase() const
+{
+	char* base = BNGetDiffObjectBase(m_object);
+	std::string result = base;
+	BNFreeString(base);
+	return result;
+}
+
+
+std::string DiffObject::GetLeft() const
+{
+	char* left = BNGetDiffObjectLeft(m_object);
+	std::string result = left;
+	BNFreeString(left);
+	return result;
+}
+
+
+std::string DiffObject::GetRight() const
+{
+	char* right = BNGetDiffObjectRight(m_object);
+	std::string result = right;
+	BNFreeString(right);
+	return result;
+}
+
+
+std::unordered_map<std::string, Ref<DiffObject>> DiffObject::GetChildren() const
+{
+	char** names;
+	BNDiffObject** objects;
+	size_t count = BNGetDiffObjectChildren(m_object, &names, &objects);
+
+	std::unordered_map<std::string, Ref<DiffObject>> result;
+	for (size_t i = 0; i < count; i++)
+	{
+		result[names[i]] = new DiffObject(BNNewDiffObjectReference(objects[i]));
+	}
+
+	BNFreeStringList(names, count);
+	BNFreeDiffObjectList(objects, count);
+	return result;
+}
+
+
+BNMergeStrategy DiffObject::GetMergeStrategy() const
+{
+	return BNGetDiffObjectMergeStrategy(m_object);
+}
+
+
+void DiffObject::SetMergeStrategy(BNMergeStrategy strategy)
+{
+	BNSetDiffObjectMergeStrategy(m_object, strategy);
+}