Clean up possible early deletion issues in API callbacks

12 files changed, 107 insertions, 105 deletions

diff --git a/architecture.cpp b/architecture.cpp
index 50cb09cc..d0147dc0 100644
--- a/architecture.cpp
+++ b/architecture.cpp
@@ -179,56 +179,56 @@ Architecture::Architecture(const string& name) : m_nameForRegister(name)
 
 void Architecture::InitCallback(void* ctxt, BNArchitecture* obj)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	arch->m_object = obj;
 }
 
 
 BNEndianness Architecture::GetEndiannessCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetEndianness();
 }
 
 
 size_t Architecture::GetAddressSizeCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetAddressSize();
 }
 
 
 size_t Architecture::GetDefaultIntegerSizeCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetDefaultIntegerSize();
 }
 
 
 size_t Architecture::GetInstructionAlignmentCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetInstructionAlignment();
 }
 
 
 size_t Architecture::GetMaxInstructionLengthCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetMaxInstructionLength();
 }
 
 
 size_t Architecture::GetOpcodeDisplayLengthCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetOpcodeDisplayLength();
 }
 
 
 BNArchitecture* Architecture::GetAssociatedArchitectureByAddressCallback(void* ctxt, uint64_t* addr)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetAssociatedArchitectureByAddress(*addr)->GetObject();
 }
 
@@ -236,7 +236,7 @@ BNArchitecture* Architecture::GetAssociatedArchitectureByAddressCallback(void* c
 bool Architecture::GetInstructionInfoCallback(
     void* ctxt, const uint8_t* data, uint64_t addr, size_t maxLen, BNInstructionInfo* result)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 
 	InstructionInfo info;
 	bool ok = arch->GetInstructionInfo(data, addr, maxLen, info);
@@ -248,7 +248,7 @@ bool Architecture::GetInstructionInfoCallback(
 bool Architecture::GetInstructionTextCallback(
     void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNInstructionTextToken** result, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 
 	vector<InstructionTextToken> tokens;
 	bool ok = arch->GetInstructionText(data, addr, *len, tokens);
@@ -281,7 +281,7 @@ void Architecture::FreeInstructionTextCallback(BNInstructionTextToken* tokens, s
 bool Architecture::GetInstructionLowLevelILCallback(
     void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
 	return arch->GetInstructionLowLevelIL(data, addr, *len, *func);
 }
@@ -289,7 +289,7 @@ bool Architecture::GetInstructionLowLevelILCallback(
 
 char* Architecture::GetRegisterNameCallback(void* ctxt, uint32_t reg)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetRegisterName(reg);
 	return BNAllocString(result.c_str());
 }
@@ -297,7 +297,7 @@ char* Architecture::GetRegisterNameCallback(void* ctxt, uint32_t reg)
 
 char* Architecture::GetFlagNameCallback(void* ctxt, uint32_t flag)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetFlagName(flag);
 	return BNAllocString(result.c_str());
 }
@@ -305,7 +305,7 @@ char* Architecture::GetFlagNameCallback(void* ctxt, uint32_t flag)
 
 char* Architecture::GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetFlagWriteTypeName(flags);
 	return BNAllocString(result.c_str());
 }
@@ -313,7 +313,7 @@ char* Architecture::GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags)
 
 char* Architecture::GetSemanticFlagClassNameCallback(void* ctxt, uint32_t semClass)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetSemanticFlagClassName(semClass);
 	return BNAllocString(result.c_str());
 }
@@ -321,7 +321,7 @@ char* Architecture::GetSemanticFlagClassNameCallback(void* ctxt, uint32_t semCla
 
 char* Architecture::GetSemanticFlagGroupNameCallback(void* ctxt, uint32_t semGroup)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetSemanticFlagGroupName(semGroup);
 	return BNAllocString(result.c_str());
 }
@@ -329,7 +329,7 @@ char* Architecture::GetSemanticFlagGroupNameCallback(void* ctxt, uint32_t semGro
 
 uint32_t* Architecture::GetFullWidthRegistersCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetFullWidthRegisters();
 	*count = regs.size();
 
@@ -342,7 +342,7 @@ uint32_t* Architecture::GetFullWidthRegistersCallback(void* ctxt, size_t* count)
 
 uint32_t* Architecture::GetAllRegistersCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllRegisters();
 	*count = regs.size();
 
@@ -355,7 +355,7 @@ uint32_t* Architecture::GetAllRegistersCallback(void* ctxt, size_t* count)
 
 uint32_t* Architecture::GetAllFlagsCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllFlags();
 	*count = regs.size();
 
@@ -368,7 +368,7 @@ uint32_t* Architecture::GetAllFlagsCallback(void* ctxt, size_t* count)
 
 uint32_t* Architecture::GetAllFlagWriteTypesCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllFlagWriteTypes();
 	*count = regs.size();
 
@@ -381,7 +381,7 @@ uint32_t* Architecture::GetAllFlagWriteTypesCallback(void* ctxt, size_t* count)
 
 uint32_t* Architecture::GetAllSemanticFlagClassesCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllSemanticFlagClasses();
 	*count = regs.size();
 
@@ -394,7 +394,7 @@ uint32_t* Architecture::GetAllSemanticFlagClassesCallback(void* ctxt, size_t* co
 
 uint32_t* Architecture::GetAllSemanticFlagGroupsCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllSemanticFlagGroups();
 	*count = regs.size();
 
@@ -407,7 +407,7 @@ uint32_t* Architecture::GetAllSemanticFlagGroupsCallback(void* ctxt, size_t* cou
 
 BNFlagRole Architecture::GetFlagRoleCallback(void* ctxt, uint32_t flag, uint32_t semClass)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetFlagRole(flag, semClass);
 }
 
@@ -415,7 +415,7 @@ BNFlagRole Architecture::GetFlagRoleCallback(void* ctxt, uint32_t flag, uint32_t
 uint32_t* Architecture::GetFlagsRequiredForFlagConditionCallback(
     void* ctxt, BNLowLevelILFlagCondition cond, uint32_t semClass, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> flags = arch->GetFlagsRequiredForFlagCondition(cond, semClass);
 	*count = flags.size();
 
@@ -428,7 +428,7 @@ uint32_t* Architecture::GetFlagsRequiredForFlagConditionCallback(
 
 uint32_t* Architecture::GetFlagsRequiredForSemanticFlagGroupCallback(void* ctxt, uint32_t semGroup, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> flags = arch->GetFlagsRequiredForSemanticFlagGroup(semGroup);
 	*count = flags.size();
 
@@ -442,7 +442,7 @@ uint32_t* Architecture::GetFlagsRequiredForSemanticFlagGroupCallback(void* ctxt,
 BNFlagConditionForSemanticClass* Architecture::GetFlagConditionsForSemanticFlagGroupCallback(
     void* ctxt, uint32_t semGroup, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	map<uint32_t, BNLowLevelILFlagCondition> conditions = arch->GetFlagConditionsForSemanticFlagGroup(semGroup);
 	*count = conditions.size();
 
@@ -466,7 +466,7 @@ void Architecture::FreeFlagConditionsForSemanticFlagGroupCallback(void*, BNFlagC
 
 uint32_t* Architecture::GetFlagsWrittenByFlagWriteTypeCallback(void* ctxt, uint32_t writeType, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> flags = arch->GetFlagsWrittenByFlagWriteType(writeType);
 	*count = flags.size();
 
@@ -479,7 +479,7 @@ uint32_t* Architecture::GetFlagsWrittenByFlagWriteTypeCallback(void* ctxt, uint3
 
 uint32_t Architecture::GetSemanticClassForFlagWriteTypeCallback(void* ctxt, uint32_t writeType)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetSemanticClassForFlagWriteType(writeType);
 }
 
@@ -488,7 +488,7 @@ size_t Architecture::GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOper
     uint32_t flagWriteType, uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount,
     BNLowLevelILFunction* il)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
 	return arch->GetFlagWriteLowLevelIL(op, size, flagWriteType, flag, operands, operandCount, *func);
 }
@@ -497,7 +497,7 @@ size_t Architecture::GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOper
 size_t Architecture::GetFlagConditionLowLevelILCallback(
     void* ctxt, BNLowLevelILFlagCondition cond, uint32_t semClass, BNLowLevelILFunction* il)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
 	return arch->GetFlagConditionLowLevelIL(cond, semClass, *func);
 }
@@ -505,7 +505,7 @@ size_t Architecture::GetFlagConditionLowLevelILCallback(
 
 size_t Architecture::GetSemanticFlagGroupLowLevelILCallback(void* ctxt, uint32_t semGroup, BNLowLevelILFunction* il)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
 	return arch->GetSemanticFlagGroupLowLevelIL(semGroup, *func);
 }
@@ -519,28 +519,28 @@ void Architecture::FreeRegisterListCallback(void*, uint32_t* regs)
 
 void Architecture::GetRegisterInfoCallback(void* ctxt, uint32_t reg, BNRegisterInfo* result)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	*result = arch->GetRegisterInfo(reg);
 }
 
 
 uint32_t Architecture::GetStackPointerRegisterCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetStackPointerRegister();
 }
 
 
 uint32_t Architecture::GetLinkRegisterCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->GetLinkRegister();
 }
 
 
 uint32_t* Architecture::GetGlobalRegistersCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetGlobalRegisters();
 	*count = regs.size();
 
@@ -553,7 +553,7 @@ uint32_t* Architecture::GetGlobalRegistersCallback(void* ctxt, size_t* count)
 
 uint32_t* Architecture::GetSystemRegistersCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetSystemRegisters();
 	*count = regs.size();
 
@@ -566,7 +566,7 @@ uint32_t* Architecture::GetSystemRegistersCallback(void* ctxt, size_t* count)
 
 char* Architecture::GetRegisterStackNameCallback(void* ctxt, uint32_t regStack)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetRegisterStackName(regStack);
 	return BNAllocString(result.c_str());
 }
@@ -574,7 +574,7 @@ char* Architecture::GetRegisterStackNameCallback(void* ctxt, uint32_t regStack)
 
 uint32_t* Architecture::GetAllRegisterStacksCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllRegisterStacks();
 	*count = regs.size();
 
@@ -587,14 +587,14 @@ uint32_t* Architecture::GetAllRegisterStacksCallback(void* ctxt, size_t* count)
 
 void Architecture::GetRegisterStackInfoCallback(void* ctxt, uint32_t regStack, BNRegisterStackInfo* result)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	*result = arch->GetRegisterStackInfo(regStack);
 }
 
 
 char* Architecture::GetIntrinsicNameCallback(void* ctxt, uint32_t intrinsic)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	string result = arch->GetIntrinsicName(intrinsic);
 	return BNAllocString(result.c_str());
 }
@@ -602,7 +602,7 @@ char* Architecture::GetIntrinsicNameCallback(void* ctxt, uint32_t intrinsic)
 
 uint32_t* Architecture::GetAllIntrinsicsCallback(void* ctxt, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<uint32_t> regs = arch->GetAllIntrinsics();
 	*count = regs.size();
 
@@ -615,7 +615,7 @@ uint32_t* Architecture::GetAllIntrinsicsCallback(void* ctxt, size_t* count)
 
 BNNameAndType* Architecture::GetIntrinsicInputsCallback(void* ctxt, uint32_t intrinsic, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<NameAndType> inputs = arch->GetIntrinsicInputs(intrinsic);
 	*count = inputs.size();
 
@@ -643,7 +643,7 @@ void Architecture::FreeNameAndTypeListCallback(void*, BNNameAndType* nt, size_t
 
 BNTypeWithConfidence* Architecture::GetIntrinsicOutputsCallback(void* ctxt, uint32_t intrinsic, size_t* count)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	vector<Confidence<Ref<Type>>> outputs = arch->GetIntrinsicOutputs(intrinsic);
 	*count = outputs.size();
 
@@ -666,13 +666,13 @@ void Architecture::FreeTypeListCallback(void*, BNTypeWithConfidence* types, size
 
 bool Architecture::CanAssembleCallback(void* ctxt)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->CanAssemble();
 }
 
 bool Architecture::AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	DataBuffer buf;
 	string errorStr;
 	bool ok = arch->Assemble(code, addr, buf, errorStr);
@@ -685,28 +685,28 @@ bool Architecture::AssembleCallback(void* ctxt, const char* code, uint64_t addr,
 
 bool Architecture::IsNeverBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->IsNeverBranchPatchAvailable(data, addr, len);
 }
 
 
 bool Architecture::IsAlwaysBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->IsAlwaysBranchPatchAvailable(data, addr, len);
 }
 
 
 bool Architecture::IsInvertBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->IsInvertBranchPatchAvailable(data, addr, len);
 }
 
 
 bool Architecture::IsSkipAndReturnZeroPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->IsSkipAndReturnZeroPatchAvailable(data, addr, len);
 }
 
@@ -714,35 +714,35 @@ bool Architecture::IsSkipAndReturnZeroPatchAvailableCallback(void* ctxt, const u
 bool Architecture::IsSkipAndReturnValuePatchAvailableCallback(
     void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->IsSkipAndReturnValuePatchAvailable(data, addr, len);
 }
 
 
 bool Architecture::ConvertToNopCallback(void* ctxt, uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->ConvertToNop(data, addr, len);
 }
 
 
 bool Architecture::AlwaysBranchCallback(void* ctxt, uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->AlwaysBranch(data, addr, len);
 }
 
 
 bool Architecture::InvertBranchCallback(void* ctxt, uint8_t* data, uint64_t addr, size_t len)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->InvertBranch(data, addr, len);
 }
 
 
 bool Architecture::SkipAndReturnValueCallback(void* ctxt, uint8_t* data, uint64_t addr, size_t len, uint64_t value)
 {
-	Architecture* arch = (Architecture*)ctxt;
+	CallbackRef<Architecture> arch(ctxt);
 	return arch->SkipAndReturnValue(data, addr, len, value);
 }
 
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index c08e2c1a..a5ad242d 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -218,6 +218,8 @@ namespace BinaryNinja {
 		void Release() { ReleaseInternal(); }
 
 		void AddRefForRegistration() { AddRefInternal(); }
+		void AddRefForCallback() {}
+		void ReleaseForCallback() {}
 	};
 
 	/*!
diff --git a/binaryview.cpp b/binaryview.cpp
index 84267ba3..c818bed6 100644
--- a/binaryview.cpp
+++ b/binaryview.cpp
@@ -1027,7 +1027,7 @@ bool BinaryView::InitCallback(void* ctxt)
 
 void BinaryView::FreeCallback(void* ctxt)
 {
-	CallbackRef<BinaryView> view(ctxt);
+	BinaryView* view = (BinaryView*)ctxt;
 	view->ReleaseForRegistration();
 }
 
diff --git a/binaryviewtype.cpp b/binaryviewtype.cpp
index 8ab09aae..bf67c04a 100644
--- a/binaryviewtype.cpp
+++ b/binaryviewtype.cpp
@@ -26,7 +26,7 @@ using namespace std;
 
 BNBinaryView* BinaryViewType::CreateCallback(void* ctxt, BNBinaryView* data)
 {
-	BinaryViewType* type = (BinaryViewType*)ctxt;
+	CallbackRef<BinaryViewType> type(ctxt);
 	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	Ref<BinaryView> result = type->Create(view);
 	if (!result)
@@ -37,7 +37,7 @@ BNBinaryView* BinaryViewType::CreateCallback(void* ctxt, BNBinaryView* data)
 
 BNBinaryView* BinaryViewType::ParseCallback(void* ctxt, BNBinaryView* data)
 {
-	BinaryViewType* type = (BinaryViewType*)ctxt;
+	CallbackRef<BinaryViewType> type(ctxt);
 	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	Ref<BinaryView> result = type->Parse(view);
 	if (!result)
@@ -48,7 +48,7 @@ BNBinaryView* BinaryViewType::ParseCallback(void* ctxt, BNBinaryView* data)
 
 bool BinaryViewType::IsValidCallback(void* ctxt, BNBinaryView* data)
 {
-	BinaryViewType* type = (BinaryViewType*)ctxt;
+	CallbackRef<BinaryViewType> type(ctxt);
 	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	return type->IsTypeValidForData(view);
 }
@@ -56,14 +56,14 @@ bool BinaryViewType::IsValidCallback(void* ctxt, BNBinaryView* data)
 
 bool BinaryViewType::IsDeprecatedCallback(void* ctxt)
 {
-	BinaryViewType* type = (BinaryViewType*)ctxt;
+	CallbackRef<BinaryViewType> type(ctxt);
 	return type->IsDeprecated();
 }
 
 
 BNSettings* BinaryViewType::GetSettingsCallback(void* ctxt, BNBinaryView* data)
 {
-	BinaryViewType* type = (BinaryViewType*)ctxt;
+	CallbackRef<BinaryViewType> type(ctxt);
 	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	Ref<Settings> result = type->GetLoadSettingsForData(view);
 	if (!result)
diff --git a/callingconvention.cpp b/callingconvention.cpp
index 8bf02d03..b0f2700e 100644
--- a/callingconvention.cpp
+++ b/callingconvention.cpp
@@ -69,7 +69,7 @@ void CallingConvention::FreeCallback(void* ctxt)
 
 uint32_t* CallingConvention::GetCallerSavedRegistersCallback(void* ctxt, size_t* count)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	vector<uint32_t> regs = cc->GetCallerSavedRegisters();
 	*count = regs.size();
 
@@ -82,7 +82,7 @@ uint32_t* CallingConvention::GetCallerSavedRegistersCallback(void* ctxt, size_t*
 
 uint32_t* CallingConvention::GetCalleeSavedRegistersCallback(void* ctxt, size_t* count)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	vector<uint32_t> regs = cc->GetCalleeSavedRegisters();
 	*count = regs.size();
 
@@ -95,7 +95,7 @@ uint32_t* CallingConvention::GetCalleeSavedRegistersCallback(void* ctxt, size_t*
 
 uint32_t* CallingConvention::GetIntegerArgumentRegistersCallback(void* ctxt, size_t* count)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	vector<uint32_t> regs = cc->GetIntegerArgumentRegisters();
 	*count = regs.size();
 
@@ -108,7 +108,7 @@ uint32_t* CallingConvention::GetIntegerArgumentRegistersCallback(void* ctxt, siz
 
 uint32_t* CallingConvention::GetFloatArgumentRegistersCallback(void* ctxt, size_t* count)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	vector<uint32_t> regs = cc->GetFloatArgumentRegisters();
 	*count = regs.size();
 
@@ -127,70 +127,70 @@ void CallingConvention::FreeRegisterListCallback(void*, uint32_t* regs)
 
 bool CallingConvention::AreArgumentRegistersSharedIndexCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->AreArgumentRegistersSharedIndex();
 }
 
 
 bool CallingConvention::AreArgumentRegistersUsedForVarArgsCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->AreArgumentRegistersUsedForVarArgs();
 }
 
 
 bool CallingConvention::IsStackReservedForArgumentRegistersCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->IsStackReservedForArgumentRegisters();
 }
 
 
 bool CallingConvention::IsStackAdjustedOnReturnCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->IsStackAdjustedOnReturn();
 }
 
 
 bool CallingConvention::IsEligibleForHeuristicsCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->IsEligibleForHeuristics();
 }
 
 
 uint32_t CallingConvention::GetIntegerReturnValueRegisterCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->GetIntegerReturnValueRegister();
 }
 
 
 uint32_t CallingConvention::GetHighIntegerReturnValueRegisterCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->GetHighIntegerReturnValueRegister();
 }
 
 
 uint32_t CallingConvention::GetFloatReturnValueRegisterCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->GetFloatReturnValueRegister();
 }
 
 
 uint32_t CallingConvention::GetGlobalPointerRegisterCallback(void* ctxt)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	return cc->GetGlobalPointerRegister();
 }
 
 
 uint32_t* CallingConvention::GetImplicitlyDefinedRegistersCallback(void* ctxt, size_t* count)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	vector<uint32_t> regs = cc->GetImplicitlyDefinedRegisters();
 	*count = regs.size();
 
@@ -204,7 +204,7 @@ uint32_t* CallingConvention::GetImplicitlyDefinedRegistersCallback(void* ctxt, s
 void CallingConvention::GetIncomingRegisterValueCallback(
     void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	Ref<Function> funcObj;
 	if (func)
 		funcObj = new Function(BNNewFunctionReference(func));
@@ -215,7 +215,7 @@ void CallingConvention::GetIncomingRegisterValueCallback(
 void CallingConvention::GetIncomingFlagValueCallback(
     void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	Ref<Function> funcObj;
 	if (func)
 		funcObj = new Function(BNNewFunctionReference(func));
@@ -226,7 +226,7 @@ void CallingConvention::GetIncomingFlagValueCallback(
 void CallingConvention::GetIncomingVariableForParameterVariableCallback(
     void* ctxt, const BNVariable* var, BNFunction* func, BNVariable* result)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	Ref<Function> funcObj;
 	if (func)
 		funcObj = new Function(BNNewFunctionReference(func));
@@ -237,7 +237,7 @@ void CallingConvention::GetIncomingVariableForParameterVariableCallback(
 void CallingConvention::GetParameterVariableForIncomingVariableCallback(
     void* ctxt, const BNVariable* var, BNFunction* func, BNVariable* result)
 {
-	CallingConvention* cc = (CallingConvention*)ctxt;
+	CallbackRef<CallingConvention> cc(ctxt);
 	Ref<Function> funcObj;
 	if (func)
 		funcObj = new Function(BNNewFunctionReference(func));
diff --git a/datarenderer.cpp b/datarenderer.cpp
index b6dd6ec9..8d1b16b4 100644
--- a/datarenderer.cpp
+++ b/datarenderer.cpp
@@ -39,7 +39,7 @@ bool DataRenderer::IsStructOfTypeName(Type* type, const string& name, vector<pai
 bool DataRenderer::IsValidForDataCallback(
     void* ctxt, BNBinaryView* view, uint64_t addr, BNType* type, BNTypeContext* typeCtx, size_t ctxCount)
 {
-	DataRenderer* renderer = (DataRenderer*)ctxt;
+	CallbackRef<DataRenderer> renderer(ctxt);
 	Ref<BinaryView> viewObj = new BinaryView(BNNewViewReference(view));
 	Ref<Type> typeObj = new Type(BNNewTypeReference(type));
 	vector<pair<Type*, size_t>> context;
@@ -55,7 +55,7 @@ BNDisassemblyTextLine* DataRenderer::GetLinesForDataCallback(void* ctxt, BNBinar
     BNType* type, const BNInstructionTextToken* prefix, size_t prefixCount, size_t width, size_t* count,
     BNTypeContext* typeCtx, size_t ctxCount)
 {
-	DataRenderer* renderer = (DataRenderer*)ctxt;
+	CallbackRef<DataRenderer> renderer(ctxt);
 	Ref<BinaryView> viewObj = new BinaryView(BNNewViewReference(view));
 	Ref<Type> typeObj = new Type(BNNewTypeReference(type));
 	vector<InstructionTextToken> prefixes = InstructionTextToken::ConvertInstructionTextTokenList(prefix, prefixCount);
diff --git a/downloadprovider.cpp b/downloadprovider.cpp
index 2de462fb..28695718 100644
--- a/downloadprovider.cpp
+++ b/downloadprovider.cpp
@@ -52,7 +52,7 @@ void DownloadInstance::DestroyInstanceCallback(void* ctxt)
 
 int DownloadInstance::PerformRequestCallback(void* ctxt, const char* url)
 {
-	DownloadInstance* instance = (DownloadInstance*)ctxt;
+	CallbackRef<DownloadInstance> instance(ctxt);
 	return instance->PerformRequest(url);
 }
 
@@ -61,7 +61,7 @@ int DownloadInstance::PerformCustomRequestCallback(void* ctxt, const char* metho
     uint64_t headerCount, const char* const* headerKeys, const char* const* headerValues,
     BNDownloadInstanceResponse** response)
 {
-	DownloadInstance* instance = (DownloadInstance*)ctxt;
+	CallbackRef<DownloadInstance> instance(ctxt);
 	unordered_map<string, string> headers;
 	for (uint64_t i = 0; i < headerCount; i++)
 	{
diff --git a/flowgraph.cpp b/flowgraph.cpp
index b812e57d..66e8eb7f 100644
--- a/flowgraph.cpp
+++ b/flowgraph.cpp
@@ -94,28 +94,28 @@ FlowGraph::FlowGraph(BNFlowGraph* graph)
 
 void FlowGraph::PrepareForLayoutCallback(void* ctxt)
 {
-	FlowGraph* graph = (FlowGraph*)ctxt;
+	CallbackRef<FlowGraph> graph(ctxt);
 	graph->PrepareForLayout();
 }
 
 
 void FlowGraph::PopulateNodesCallback(void* ctxt)
 {
-	FlowGraph* graph = (FlowGraph*)ctxt;
+	CallbackRef<FlowGraph> graph(ctxt);
 	graph->PopulateNodes();
 }
 
 
 void FlowGraph::CompleteLayoutCallback(void* ctxt)
 {
-	FlowGraph* graph = (FlowGraph*)ctxt;
+	CallbackRef<FlowGraph> graph(ctxt);
 	graph->CompleteLayout();
 }
 
 
 BNFlowGraph* FlowGraph::UpdateCallback(void* ctxt)
 {
-	FlowGraph* graph = (FlowGraph*)ctxt;
+	CallbackRef<FlowGraph> graph(ctxt);
 	Ref<FlowGraph> result = graph->Update();
 	if (!result)
 		return nullptr;
diff --git a/relocationhandler.cpp b/relocationhandler.cpp
index d1233ad0..045e9fa6 100644
--- a/relocationhandler.cpp
+++ b/relocationhandler.cpp
@@ -54,7 +54,7 @@ void RelocationHandler::FreeCallback(void* ctxt)
 bool RelocationHandler::GetRelocationInfoCallback(
     void* ctxt, BNBinaryView* view, BNArchitecture* arch, BNRelocationInfo* result, size_t resultCount)
 {
-	RelocationHandler* handler = (RelocationHandler*)ctxt;
+	CallbackRef<RelocationHandler> handler(ctxt);
 	Ref<BinaryView> viewObj = new BinaryView(BNNewViewReference(view));
 	Ref<Architecture> archObj = new CoreArchitecture(arch);
 	if (!result)
@@ -70,7 +70,7 @@ bool RelocationHandler::GetRelocationInfoCallback(
 bool RelocationHandler::ApplyRelocationCallback(
     void* ctxt, BNBinaryView* view, BNArchitecture* arch, BNRelocation* reloc, uint8_t* dest, size_t len)
 {
-	RelocationHandler* handler = (RelocationHandler*)ctxt;
+	CallbackRef<RelocationHandler> handler(ctxt);
 	Ref<Architecture> archObj = new CoreArchitecture(arch);
 	Ref<BinaryView> viewObj = new BinaryView(BNNewViewReference(view));
 	Ref<Relocation> relocObj = new Relocation(BNNewRelocationReference(reloc));
@@ -81,7 +81,7 @@ bool RelocationHandler::ApplyRelocationCallback(
 size_t RelocationHandler::GetOperandForExternalRelocationCallback(
     void* ctxt, const uint8_t* data, uint64_t addr, size_t length, BNLowLevelILFunction* il, BNRelocation* reloc)
 {
-	RelocationHandler* handler = (RelocationHandler*)ctxt;
+	CallbackRef<RelocationHandler> handler(ctxt);
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
 	Ref<Relocation> relocObj = new Relocation(BNNewRelocationReference(reloc));
 	return handler->GetOperandForExternalRelocation(data, addr, length, func, relocObj);
diff --git a/scriptingprovider.cpp b/scriptingprovider.cpp
index e1b7445e..def9c4c0 100644
--- a/scriptingprovider.cpp
+++ b/scriptingprovider.cpp
@@ -79,21 +79,21 @@ void ScriptingInstance::DestroyInstanceCallback(void* ctxt)
 
 BNScriptingProviderExecuteResult ScriptingInstance::ExecuteScriptInputCallback(void* ctxt, const char* input)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	return instance->ExecuteScriptInput(input);
 }
 
 
 void ScriptingInstance::CancelScriptInputCallback(void* ctxt)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	instance->CancelScriptInput();
 }
 
 
 void ScriptingInstance::SetCurrentBinaryViewCallback(void* ctxt, BNBinaryView* view)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	Ref<BinaryView> object = view ? new BinaryView(BNNewViewReference(view)) : nullptr;
 	instance->SetCurrentBinaryView(object);
 }
@@ -101,7 +101,7 @@ void ScriptingInstance::SetCurrentBinaryViewCallback(void* ctxt, BNBinaryView* v
 
 void ScriptingInstance::SetCurrentFunctionCallback(void* ctxt, BNFunction* func)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	Ref<Function> object = func ? new Function(BNNewFunctionReference(func)) : nullptr;
 	instance->SetCurrentFunction(object);
 }
@@ -109,7 +109,7 @@ void ScriptingInstance::SetCurrentFunctionCallback(void* ctxt, BNFunction* func)
 
 void ScriptingInstance::SetCurrentBasicBlockCallback(void* ctxt, BNBasicBlock* block)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	Ref<BasicBlock> object = block ? new BasicBlock(BNNewBasicBlockReference(block)) : nullptr;
 	instance->SetCurrentBasicBlock(object);
 }
@@ -117,21 +117,21 @@ void ScriptingInstance::SetCurrentBasicBlockCallback(void* ctxt, BNBasicBlock* b
 
 void ScriptingInstance::SetCurrentAddressCallback(void* ctxt, uint64_t addr)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	instance->SetCurrentAddress(addr);
 }
 
 
 void ScriptingInstance::SetCurrentSelectionCallback(void* ctxt, uint64_t begin, uint64_t end)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	instance->SetCurrentSelection(begin, end);
 }
 
 
 char* ScriptingInstance::CompleteInputCallback(void* ctxt, const char* text, uint64_t state)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	std::string completed = instance->CompleteInput(text, state);
 	if (completed.c_str() == nullptr)
 	{
@@ -144,7 +144,7 @@ char* ScriptingInstance::CompleteInputCallback(void* ctxt, const char* text, uin
 
 void ScriptingInstance::StopCallback(void* ctxt)
 {
-	ScriptingInstance* instance = (ScriptingInstance*)ctxt;
+	CallbackRef<ScriptingInstance> instance(ctxt);
 	instance->Stop();
 }
 
diff --git a/transform.cpp b/transform.cpp
index d9548689..fb5c568b 100644
--- a/transform.cpp
+++ b/transform.cpp
@@ -39,7 +39,7 @@ Transform::Transform(BNTransformType type, const string& name, const string& lon
 
 BNTransformParameterInfo* Transform::GetParametersCallback(void* ctxt, size_t* count)
 {
-	Transform* xform = (Transform*)ctxt;
+	CallbackRef<Transform> xform(ctxt);
 	vector<TransformParameter> params = xform->GetParameters();
 	*count = params.size();
 	BNTransformParameterInfo* result = new BNTransformParameterInfo[params.size()];
@@ -76,7 +76,7 @@ bool Transform::DecodeCallback(
 	DataBuffer inputBuf(BNDuplicateDataBuffer(input));
 	DataBuffer outputBuf;
 
-	Transform* xform = (Transform*)ctxt;
+	CallbackRef<Transform> xform(ctxt);
 	bool result = xform->Decode(inputBuf, outputBuf, paramMap);
 	BNAssignDataBuffer(output, outputBuf.GetBufferObject());
 	return result;
@@ -93,7 +93,7 @@ bool Transform::EncodeCallback(
 	DataBuffer inputBuf(BNDuplicateDataBuffer(input));
 	DataBuffer outputBuf;
 
-	Transform* xform = (Transform*)ctxt;
+	CallbackRef<Transform> xform(ctxt);
 	bool result = xform->Encode(inputBuf, outputBuf, paramMap);
 	BNAssignDataBuffer(output, outputBuf.GetBufferObject());
 	return result;
diff --git a/websocketprovider.cpp b/websocketprovider.cpp
index 48782715..52b8e721 100644
--- a/websocketprovider.cpp
+++ b/websocketprovider.cpp
@@ -59,28 +59,28 @@ bool WebsocketClient::ConnectCallback(
 		headers[headerKeys[i]] = headerValues[i];
 	}
 
-	WebsocketClient* client = (WebsocketClient*)ctxt;
+	CallbackRef<WebsocketClient> client(ctxt);
 	return client->Connect(host, headers);
 }
 
 
 bool WebsocketClient::DisconnectCallback(void* ctxt)
 {
-	WebsocketClient* client = (WebsocketClient*)ctxt;
+	CallbackRef<WebsocketClient> client(ctxt);
 	return client->Disconnect();
 }
 
 
 void WebsocketClient::ErrorCallback(const char* msg, void* ctxt)
 {
-	WebsocketClient* client = (WebsocketClient*)ctxt;
+	CallbackRef<WebsocketClient> client(ctxt);
 	BNNotifyWebsocketClientError(client->m_object, msg);
 }
 
 
 bool WebsocketClient::WriteCallback(const uint8_t* data, uint64_t len, void* ctxt)
 {
-	WebsocketClient* client = (WebsocketClient*)ctxt;
+	CallbackRef<WebsocketClient> client(ctxt);
 	return client->Write(vector<uint8_t>(data, data + len));
 }