Format All Files

1 files changed, 101 insertions, 88 deletions

diff --git a/architecture.cpp b/architecture.cpp
index cf0033a9..cd5306ea 100644
--- a/architecture.cpp
+++ b/architecture.cpp
@@ -49,7 +49,8 @@ void InstructionInfo::AddBranch(BNBranchType type, uint64_t target, Architecture
 }
 
 
-InstructionTextToken::InstructionTextToken(): type(TextToken), value(0), width(WidthIsByteCount), confidence(BN_FULL_CONFIDENCE)
+InstructionTextToken::InstructionTextToken() :
+    type(TextToken), value(0), width(WidthIsByteCount), confidence(BN_FULL_CONFIDENCE)
 {
 	if (width == WidthIsByteCount)
 	{
@@ -58,9 +59,11 @@ InstructionTextToken::InstructionTextToken(): type(TextToken), value(0), width(W
 }
 
 
-InstructionTextToken::InstructionTextToken(BNInstructionTextTokenType t, const std::string& txt, uint64_t val,
-	size_t s, size_t o, uint8_t c, const vector<string>& n, uint64_t w) : type(t), text(txt), value(val), width(w), size(s), operand(o),
-	context(NoTokenContext), confidence(c), address(0), typeNames(n)
+InstructionTextToken::InstructionTextToken(BNInstructionTextTokenType t, const std::string& txt, uint64_t val, size_t s,
+    size_t o, uint8_t c, const vector<string>& n, uint64_t w) :
+    type(t),
+    text(txt), value(val), width(w), size(s), operand(o), context(NoTokenContext), confidence(c), address(0),
+    typeNames(n)
 {
 	if (width == WidthIsByteCount)
 	{
@@ -70,8 +73,9 @@ InstructionTextToken::InstructionTextToken(BNInstructionTextTokenType t, const s
 
 
 InstructionTextToken::InstructionTextToken(BNInstructionTextTokenType t, BNInstructionTextTokenContext ctxt,
-	const string& txt, uint64_t a, uint64_t val, size_t s, size_t o, uint8_t c, const vector<string>& n, uint64_t w):
-	type(t), text(txt), value(val), width(w), size(s), operand(o), context(ctxt), confidence(c), address(a), typeNames(n)
+    const string& txt, uint64_t a, uint64_t val, size_t s, size_t o, uint8_t c, const vector<string>& n, uint64_t w) :
+    type(t),
+    text(txt), value(val), width(w), size(s), operand(o), context(ctxt), confidence(c), address(a), typeNames(n)
 {
 	if (width == WidthIsByteCount)
 	{
@@ -80,9 +84,9 @@ InstructionTextToken::InstructionTextToken(BNInstructionTextTokenType t, BNInstr
 }
 
 
-InstructionTextToken::InstructionTextToken(const BNInstructionTextToken& token):
-	type(token.type), text(token.text), value(token.value), width(token.width), size(token.size),
-	operand(token.operand), context(token.context), confidence(token.confidence), address(token.address)
+InstructionTextToken::InstructionTextToken(const BNInstructionTextToken& token) :
+    type(token.type), text(token.text), value(token.value), width(token.width), size(token.size),
+    operand(token.operand), context(token.context), confidence(token.confidence), address(token.address)
 {
 	typeNames.reserve(token.namesCount);
 	for (size_t j = 0; j < token.namesCount; j++)
@@ -118,7 +122,8 @@ static void ConvertInstructionTextToken(const InstructionTextToken& token, BNIns
 }
 
 
-vector<InstructionTextToken> InstructionTextToken::ConvertAndFreeInstructionTextTokenList(BNInstructionTextToken* tokens, size_t count)
+vector<InstructionTextToken> InstructionTextToken::ConvertAndFreeInstructionTextTokenList(
+    BNInstructionTextToken* tokens, size_t count)
 {
 	auto result = ConvertInstructionTextTokenList(tokens, count);
 	BNFreeInstructionText(tokens, count);
@@ -135,7 +140,8 @@ BNInstructionTextToken* InstructionTextToken::CreateInstructionTextTokenList(con
 }
 
 
-vector<InstructionTextToken> InstructionTextToken::ConvertInstructionTextTokenList(const BNInstructionTextToken* tokens, size_t count)
+vector<InstructionTextToken> InstructionTextToken::ConvertInstructionTextTokenList(
+    const BNInstructionTextToken* tokens, size_t count)
 {
 	vector<InstructionTextToken> result;
 	result.reserve(count);
@@ -151,7 +157,7 @@ Architecture::Architecture(BNArchitecture* arch)
 }
 
 
-Architecture::Architecture(const string& name): m_nameForRegister(name)
+Architecture::Architecture(const string& name) : m_nameForRegister(name)
 {
 	m_object = nullptr;
 }
@@ -213,8 +219,8 @@ BNArchitecture* Architecture::GetAssociatedArchitectureByAddressCallback(void* c
 }
 
 
-bool Architecture::GetInstructionInfoCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t maxLen,
-	BNInstructionInfo* result)
+bool Architecture::GetInstructionInfoCallback(
+    void* ctxt, const uint8_t* data, uint64_t addr, size_t maxLen, BNInstructionInfo* result)
 {
 	Architecture* arch = (Architecture*)ctxt;
 
@@ -225,8 +231,8 @@ bool Architecture::GetInstructionInfoCallback(void* ctxt, const uint8_t* data, u
 }
 
 
-bool Architecture::GetInstructionTextCallback(void* ctxt, const uint8_t* data, uint64_t addr,
-                                              size_t* len, BNInstructionTextToken** result, size_t* count)
+bool Architecture::GetInstructionTextCallback(
+    void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNInstructionTextToken** result, size_t* count)
 {
 	Architecture* arch = (Architecture*)ctxt;
 
@@ -258,8 +264,8 @@ void Architecture::FreeInstructionTextCallback(BNInstructionTextToken* tokens, s
 }
 
 
-bool Architecture::GetInstructionLowLevelILCallback(void* ctxt, const uint8_t* data, uint64_t addr,
-                                                    size_t* len, BNLowLevelILFunction* il)
+bool Architecture::GetInstructionLowLevelILCallback(
+    void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
@@ -392,8 +398,8 @@ BNFlagRole Architecture::GetFlagRoleCallback(void* ctxt, uint32_t flag, uint32_t
 }
 
 
-uint32_t* Architecture::GetFlagsRequiredForFlagConditionCallback(void* ctxt, BNLowLevelILFlagCondition cond,
-	uint32_t semClass, size_t* count)
+uint32_t* Architecture::GetFlagsRequiredForFlagConditionCallback(
+    void* ctxt, BNLowLevelILFlagCondition cond, uint32_t semClass, size_t* count)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	vector<uint32_t> flags = arch->GetFlagsRequiredForFlagCondition(cond, semClass);
@@ -419,8 +425,8 @@ uint32_t* Architecture::GetFlagsRequiredForSemanticFlagGroupCallback(void* ctxt,
 }
 
 
-BNFlagConditionForSemanticClass* Architecture::GetFlagConditionsForSemanticFlagGroupCallback(void* ctxt,
-	uint32_t semGroup, size_t* count)
+BNFlagConditionForSemanticClass* Architecture::GetFlagConditionsForSemanticFlagGroupCallback(
+    void* ctxt, uint32_t semGroup, size_t* count)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	map<uint32_t, BNLowLevelILFlagCondition> conditions = arch->GetFlagConditionsForSemanticFlagGroup(semGroup);
@@ -464,8 +470,9 @@ uint32_t Architecture::GetSemanticClassForFlagWriteTypeCallback(void* ctxt, uint
 }
 
 
-size_t Architecture::GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
-	uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, BNLowLevelILFunction* il)
+size_t Architecture::GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOperation op, size_t size,
+    uint32_t flagWriteType, uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount,
+    BNLowLevelILFunction* il)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
@@ -473,8 +480,8 @@ size_t Architecture::GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOper
 }
 
 
-size_t Architecture::GetFlagConditionLowLevelILCallback(void* ctxt, BNLowLevelILFlagCondition cond, uint32_t semClass,
-	BNLowLevelILFunction* il)
+size_t Architecture::GetFlagConditionLowLevelILCallback(
+    void* ctxt, BNLowLevelILFlagCondition cond, uint32_t semClass, BNLowLevelILFunction* il)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));
@@ -690,7 +697,8 @@ bool Architecture::IsSkipAndReturnZeroPatchAvailableCallback(void* ctxt, const u
 }
 
 
-bool Architecture::IsSkipAndReturnValuePatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
+bool Architecture::IsSkipAndReturnValuePatchAvailableCallback(
+    void* ctxt, const uint8_t* data, uint64_t addr, size_t len)
 {
 	Architecture* arch = (Architecture*)ctxt;
 	return arch->IsSkipAndReturnValuePatchAvailable(data, addr, len);
@@ -990,31 +998,31 @@ uint32_t Architecture::GetSemanticClassForFlagWriteType(uint32_t)
 
 
 size_t Architecture::GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
-	uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount,LowLevelILFunction& il)
+    uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
 {
 	BNFlagRole role = GetFlagRole(flag, GetSemanticClassForFlagWriteType(flagWriteType));
-	return BNGetDefaultArchitectureFlagWriteLowLevelIL(m_object, op, size, role, operands,
-		operandCount, il.GetObject());
+	return BNGetDefaultArchitectureFlagWriteLowLevelIL(
+	    m_object, op, size, role, operands, operandCount, il.GetObject());
 }
 
 
 size_t Architecture::GetDefaultFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, BNFlagRole role,
-	BNRegisterOrConstant* operands, size_t operandCount,LowLevelILFunction& il)
+    BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
 {
-	return BNGetDefaultArchitectureFlagWriteLowLevelIL(m_object, op, size, role, operands,
-		operandCount, il.GetObject());
+	return BNGetDefaultArchitectureFlagWriteLowLevelIL(
+	    m_object, op, size, role, operands, operandCount, il.GetObject());
 }
 
 
-ExprId Architecture::GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
-	uint32_t semClass, LowLevelILFunction& il)
+ExprId Architecture::GetFlagConditionLowLevelIL(
+    BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il)
 {
 	return BNGetDefaultArchitectureFlagConditionLowLevelIL(m_object, cond, semClass, il.GetObject());
 }
 
 
-ExprId Architecture::GetDefaultFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
-	uint32_t semClass, LowLevelILFunction& il)
+ExprId Architecture::GetDefaultFlagConditionLowLevelIL(
+    BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il)
 {
 	return BNGetDefaultArchitectureFlagConditionLowLevelIL(m_object, cond, semClass, il.GetObject());
 }
@@ -1354,9 +1362,7 @@ void Architecture::AddArchitectureRedirection(Architecture* from, Architecture*
 }
 
 
-CoreArchitecture::CoreArchitecture(BNArchitecture* arch): Architecture(arch)
-{
-}
+CoreArchitecture::CoreArchitecture(BNArchitecture* arch) : Architecture(arch) {}
 
 
 BNEndianness CoreArchitecture::GetEndianness() const
@@ -1407,7 +1413,8 @@ bool CoreArchitecture::GetInstructionInfo(const uint8_t* data, uint64_t addr, si
 }
 
 
-bool CoreArchitecture::GetInstructionText(const uint8_t* data, uint64_t addr, size_t& len, std::vector<InstructionTextToken>& result)
+bool CoreArchitecture::GetInstructionText(
+    const uint8_t* data, uint64_t addr, size_t& len, std::vector<InstructionTextToken>& result)
 {
 	BNInstructionTextToken* tokens = nullptr;
 	size_t count = 0;
@@ -1596,8 +1603,8 @@ vector<uint32_t> CoreArchitecture::GetFlagsRequiredForSemanticFlagGroup(uint32_t
 map<uint32_t, BNLowLevelILFlagCondition> CoreArchitecture::GetFlagConditionsForSemanticFlagGroup(uint32_t semGroup)
 {
 	size_t count;
-	BNFlagConditionForSemanticClass* conditions = BNGetArchitectureFlagConditionsForSemanticFlagGroup(m_object,
-		semGroup, &count);
+	BNFlagConditionForSemanticClass* conditions =
+	    BNGetArchitectureFlagConditionsForSemanticFlagGroup(m_object, semGroup, &count);
 
 	map<uint32_t, BNLowLevelILFlagCondition> result;
 	for (size_t i = 0; i < count; i++)
@@ -1630,15 +1637,15 @@ uint32_t CoreArchitecture::GetSemanticClassForFlagWriteType(uint32_t writeType)
 
 
 size_t CoreArchitecture::GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
-	uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
+    uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
 {
-	return BNGetArchitectureFlagWriteLowLevelIL(m_object, op, size, flagWriteType, flag, operands,
-		operandCount, il.GetObject());
+	return BNGetArchitectureFlagWriteLowLevelIL(
+	    m_object, op, size, flagWriteType, flag, operands, operandCount, il.GetObject());
 }
 
 
-ExprId CoreArchitecture::GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
-	uint32_t semClass, LowLevelILFunction& il)
+ExprId CoreArchitecture::GetFlagConditionLowLevelIL(
+    BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il)
 {
 	return (ExprId)BNGetArchitectureFlagConditionLowLevelIL(m_object, cond, semClass, il.GetObject());
 }
@@ -1758,8 +1765,8 @@ vector<NameAndType> CoreArchitecture::GetIntrinsicInputs(uint32_t intrinsic)
 	vector<NameAndType> result;
 	for (size_t i = 0; i < count; i++)
 	{
-		result.push_back(NameAndType(inputs[i].name, Confidence<Ref<Type>>(
-			new Type(BNNewTypeReference(inputs[i].type)), inputs[i].typeConfidence)));
+		result.push_back(NameAndType(inputs[i].name,
+		    Confidence<Ref<Type>>(new Type(BNNewTypeReference(inputs[i].type)), inputs[i].typeConfidence)));
 	}
 
 	BNFreeNameAndTypeList(inputs, count);
@@ -1852,9 +1859,8 @@ bool CoreArchitecture::SkipAndReturnValue(uint8_t* data, uint64_t addr, size_t l
 }
 
 
-ArchitectureExtension::ArchitectureExtension(const string& name, Architecture* base): Architecture(name), m_base(base)
-{
-}
+ArchitectureExtension::ArchitectureExtension(const string& name, Architecture* base) : Architecture(name), m_base(base)
+{}
 
 
 void ArchitectureExtension::Register(BNCustomArchitecture* callbacks)
@@ -1909,20 +1915,22 @@ Ref<Architecture> ArchitectureExtension::GetAssociatedArchitectureByAddress(uint
 }
 
 
-bool ArchitectureExtension::GetInstructionInfo(const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result)
+bool ArchitectureExtension::GetInstructionInfo(
+    const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result)
 {
 	return m_base->GetInstructionInfo(data, addr, maxLen, result);
 }
 
 
-bool ArchitectureExtension::GetInstructionText(const uint8_t* data, uint64_t addr, size_t& len,
-	vector<InstructionTextToken>& result)
+bool ArchitectureExtension::GetInstructionText(
+    const uint8_t* data, uint64_t addr, size_t& len, vector<InstructionTextToken>& result)
 {
 	return m_base->GetInstructionText(data, addr, len, result);
 }
 
 
-bool ArchitectureExtension::GetInstructionLowLevelIL(const uint8_t* data, uint64_t addr, size_t& len, LowLevelILFunction& il)
+bool ArchitectureExtension::GetInstructionLowLevelIL(
+    const uint8_t* data, uint64_t addr, size_t& len, LowLevelILFunction& il)
 {
 	return m_base->GetInstructionLowLevelIL(data, addr, len, il);
 }
@@ -2000,8 +2008,8 @@ BNFlagRole ArchitectureExtension::GetFlagRole(uint32_t flag, uint32_t semClass)
 }
 
 
-vector<uint32_t> ArchitectureExtension::GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond,
-	uint32_t semClass)
+vector<uint32_t> ArchitectureExtension::GetFlagsRequiredForFlagCondition(
+    BNLowLevelILFlagCondition cond, uint32_t semClass)
 {
 	return m_base->GetFlagsRequiredForFlagCondition(cond, semClass);
 }
@@ -2032,14 +2040,14 @@ uint32_t ArchitectureExtension::GetSemanticClassForFlagWriteType(uint32_t writeT
 
 
 ExprId ArchitectureExtension::GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
-	uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
+    uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il)
 {
 	return m_base->GetFlagWriteLowLevelIL(op, size, flagWriteType, flag, operands, operandCount, il);
 }
 
 
-ExprId ArchitectureExtension::GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
-	uint32_t semClass, LowLevelILFunction& il)
+ExprId ArchitectureExtension::GetFlagConditionLowLevelIL(
+    BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il)
 {
 	return m_base->GetFlagConditionLowLevelIL(cond, semClass, il);
 }
@@ -2187,7 +2195,7 @@ bool ArchitectureExtension::SkipAndReturnValue(uint8_t* data, uint64_t addr, siz
 }
 
 
-ArchitectureHook::ArchitectureHook(Architecture* base): CoreArchitecture(nullptr), m_base(base)
+ArchitectureHook::ArchitectureHook(Architecture* base) : CoreArchitecture(nullptr), m_base(base)
 {
 	// Architecture hooks allow existing architecture implementations to be extended without creating
 	// a new Architecture object for the changes. By deriving from the ArchitectureHook class and passing
@@ -2225,8 +2233,8 @@ void ArchitectureHook::Register(BNCustomArchitecture* callbacks)
 }
 
 
-string DisassemblyTextRenderer::GetDisplayStringForInteger(Ref<BinaryView> binaryView, BNIntegerDisplayType type,
-	uint64_t value, size_t inputWidth, bool isSigned)
+string DisassemblyTextRenderer::GetDisplayStringForInteger(
+    Ref<BinaryView> binaryView, BNIntegerDisplayType type, uint64_t value, size_t inputWidth, bool isSigned)
 {
 	char* str = BNGetDisplayStringForInteger(binaryView->GetObject(), type, value, inputWidth, isSigned);
 	string s(str);
@@ -2249,13 +2257,15 @@ DisassemblyTextRenderer::DisassemblyTextRenderer(LowLevelILFunction* func, Disas
 
 DisassemblyTextRenderer::DisassemblyTextRenderer(MediumLevelILFunction* func, DisassemblySettings* settings)
 {
-	m_object = BNCreateMediumLevelILDisassemblyTextRenderer(func->GetObject(), settings ? settings->GetObject() : nullptr);
+	m_object =
+	    BNCreateMediumLevelILDisassemblyTextRenderer(func->GetObject(), settings ? settings->GetObject() : nullptr);
 }
 
 
 DisassemblyTextRenderer::DisassemblyTextRenderer(HighLevelILFunction* func, DisassemblySettings* settings)
 {
-	m_object = BNCreateHighLevelILDisassemblyTextRenderer(func->GetObject(), settings ? settings->GetObject() : nullptr);
+	m_object =
+	    BNCreateHighLevelILDisassemblyTextRenderer(func->GetObject(), settings ? settings->GetObject() : nullptr);
 }
 
 
@@ -2359,8 +2369,7 @@ void DisassemblyTextRenderer::GetInstructionAnnotations(vector<InstructionTextTo
 }
 
 
-bool DisassemblyTextRenderer::GetInstructionText(uint64_t addr, size_t& len,
-	vector<DisassemblyTextLine>& lines)
+bool DisassemblyTextRenderer::GetInstructionText(uint64_t addr, size_t& len, vector<DisassemblyTextLine>& lines)
 {
 	BNDisassemblyTextLine* result = nullptr;
 	size_t count = 0;
@@ -2383,8 +2392,8 @@ bool DisassemblyTextRenderer::GetInstructionText(uint64_t addr, size_t& len,
 }
 
 
-vector<DisassemblyTextLine> DisassemblyTextRenderer::PostProcessInstructionTextLines(uint64_t addr,
-	size_t len, const vector<DisassemblyTextLine>& lines, const string& indentSpaces)
+vector<DisassemblyTextLine> DisassemblyTextRenderer::PostProcessInstructionTextLines(
+    uint64_t addr, size_t len, const vector<DisassemblyTextLine>& lines, const string& indentSpaces)
 {
 	BNDisassemblyTextLine* inLines = new BNDisassemblyTextLine[lines.size()];
 	for (size_t i = 0; i < lines.size(); i++)
@@ -2399,8 +2408,8 @@ vector<DisassemblyTextLine> DisassemblyTextRenderer::PostProcessInstructionTextL
 
 	BNDisassemblyTextLine* result = nullptr;
 	size_t count = 0;
-	result = BNPostProcessDisassemblyTextRendererLines(m_object, addr, len, inLines, lines.size(), &count,
-		indentSpaces.c_str());
+	result = BNPostProcessDisassemblyTextRendererLines(
+	    m_object, addr, len, inLines, lines.size(), &count, indentSpaces.c_str());
 	BNFreeDisassemblyTextLines(inLines, lines.size());
 
 	vector<DisassemblyTextLine> outLines;
@@ -2449,20 +2458,22 @@ void DisassemblyTextRenderer::ResetDeduplicatedComments()
 }
 
 
-bool DisassemblyTextRenderer::AddSymbolToken(vector<InstructionTextToken>& tokens, uint64_t addr, size_t size, size_t operand)
+bool DisassemblyTextRenderer::AddSymbolToken(
+    vector<InstructionTextToken>& tokens, uint64_t addr, size_t size, size_t operand)
 {
 	BNInstructionTextToken* result = nullptr;
 	size_t count = 0;
 	if (!BNGetDisassemblyTextRendererSymbolTokens(m_object, addr, size, operand, &result, &count))
 		return false;
-	vector<InstructionTextToken> newTokens = InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
+	vector<InstructionTextToken> newTokens =
+	    InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
 	tokens.insert(tokens.end(), newTokens.begin(), newTokens.end());
 	return true;
 }
 
 
-void DisassemblyTextRenderer::AddStackVariableReferenceTokens(vector<InstructionTextToken>& tokens,
-	const StackVariableReference& ref)
+void DisassemblyTextRenderer::AddStackVariableReferenceTokens(
+    vector<InstructionTextToken>& tokens, const StackVariableReference& ref)
 {
 	BNStackVariableReference stackRef;
 	stackRef.sourceOperand = ref.sourceOperand;
@@ -2474,11 +2485,12 @@ void DisassemblyTextRenderer::AddStackVariableReferenceTokens(vector<Instruction
 	stackRef.size = ref.size;
 
 	size_t count = 0;
-	BNInstructionTextToken* result = BNGetDisassemblyTextRendererStackVariableReferenceTokens(
-		m_object, &stackRef, &count);
+	BNInstructionTextToken* result =
+	    BNGetDisassemblyTextRendererStackVariableReferenceTokens(m_object, &stackRef, &count);
 	BNFreeString(stackRef.name);
 
-	vector<InstructionTextToken> newTokens = InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
+	vector<InstructionTextToken> newTokens =
+	    InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
 	tokens.insert(tokens.end(), newTokens.begin(), newTokens.end());
 }
 
@@ -2489,17 +2501,18 @@ bool DisassemblyTextRenderer::IsIntegerToken(BNInstructionTextTokenType type)
 }
 
 
-void DisassemblyTextRenderer::AddIntegerToken(vector<InstructionTextToken>& tokens, const InstructionTextToken& token,
-	Architecture* arch, uint64_t addr)
+void DisassemblyTextRenderer::AddIntegerToken(
+    vector<InstructionTextToken>& tokens, const InstructionTextToken& token, Architecture* arch, uint64_t addr)
 {
 	BNInstructionTextToken inToken;
 	ConvertInstructionTextToken(token, &inToken);
 
 	size_t count = 0;
-	BNInstructionTextToken* result = BNGetDisassemblyTextRendererIntegerTokens(m_object, &inToken,
-		arch ? arch->GetObject() : nullptr, addr, &count);
+	BNInstructionTextToken* result =
+	    BNGetDisassemblyTextRendererIntegerTokens(m_object, &inToken, arch ? arch->GetObject() : nullptr, addr, &count);
 
-	vector<InstructionTextToken> newTokens = InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
+	vector<InstructionTextToken> newTokens =
+	    InstructionTextToken::ConvertAndFreeInstructionTextTokenList(result, count);
 	tokens.insert(tokens.end(), newTokens.begin(), newTokens.end());
 
 	BNFreeString(inToken.text);
@@ -2510,7 +2523,7 @@ void DisassemblyTextRenderer::AddIntegerToken(vector<InstructionTextToken>& toke
 
 
 void DisassemblyTextRenderer::WrapComment(DisassemblyTextLine& line, vector<DisassemblyTextLine>& lines,
-	const string& comment, bool hasAutoAnnotations, const string& leadingSpaces, const string& indentSpaces)
+    const string& comment, bool hasAutoAnnotations, const string& leadingSpaces, const string& indentSpaces)
 {
 	BNDisassemblyTextLine inLine;
 	inLine.addr = line.addr;
@@ -2521,8 +2534,8 @@ void DisassemblyTextRenderer::WrapComment(DisassemblyTextLine& line, vector<Disa
 	inLine.tags = Tag::CreateTagList(line.tags, &inLine.tagCount);
 
 	size_t count = 0;
-	BNDisassemblyTextLine* result = BNDisassemblyTextRendererWrapComment(m_object, &inLine, &count,
-		comment.c_str(), hasAutoAnnotations, leadingSpaces.c_str(), indentSpaces.c_str());
+	BNDisassemblyTextLine* result = BNDisassemblyTextRendererWrapComment(
+	    m_object, &inLine, &count, comment.c_str(), hasAutoAnnotations, leadingSpaces.c_str(), indentSpaces.c_str());
 
 	for (size_t i = 0; i < count; i++)
 	{