Format All Files

1 files changed, 100 insertions, 108 deletions

diff --git a/plugin.cpp b/plugin.cpp
index 2233200b..23b4b1ea 100644
--- a/plugin.cpp
+++ b/plugin.cpp
@@ -101,8 +101,8 @@ void PluginCommand::FunctionPluginCommandActionCallback(void* ctxt, BNBinaryView
 }
 
 
-void PluginCommand::LowLevelILFunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNLowLevelILFunction* func)
+void PluginCommand::LowLevelILFunctionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNLowLevelILFunction* func)
 {
 	RegisteredLowLevelILFunctionCommand* cmd = (RegisteredLowLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -111,8 +111,8 @@ void PluginCommand::LowLevelILFunctionPluginCommandActionCallback(void* ctxt, BN
 }
 
 
-void PluginCommand::LowLevelILInstructionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNLowLevelILFunction* func, size_t instr)
+void PluginCommand::LowLevelILInstructionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNLowLevelILFunction* func, size_t instr)
 {
 	RegisteredLowLevelILInstructionCommand* cmd = (RegisteredLowLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -122,8 +122,8 @@ void PluginCommand::LowLevelILInstructionPluginCommandActionCallback(void* ctxt,
 }
 
 
-void PluginCommand::MediumLevelILFunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNMediumLevelILFunction* func)
+void PluginCommand::MediumLevelILFunctionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNMediumLevelILFunction* func)
 {
 	RegisteredMediumLevelILFunctionCommand* cmd = (RegisteredMediumLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -132,8 +132,8 @@ void PluginCommand::MediumLevelILFunctionPluginCommandActionCallback(void* ctxt,
 }
 
 
-void PluginCommand::MediumLevelILInstructionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNMediumLevelILFunction* func, size_t instr)
+void PluginCommand::MediumLevelILInstructionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNMediumLevelILFunction* func, size_t instr)
 {
 	RegisteredMediumLevelILInstructionCommand* cmd = (RegisteredMediumLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -143,8 +143,8 @@ void PluginCommand::MediumLevelILInstructionPluginCommandActionCallback(void* ct
 }
 
 
-void PluginCommand::HighLevelILFunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNHighLevelILFunction* func)
+void PluginCommand::HighLevelILFunctionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNHighLevelILFunction* func)
 {
 	RegisteredHighLevelILFunctionCommand* cmd = (RegisteredHighLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -153,8 +153,8 @@ void PluginCommand::HighLevelILFunctionPluginCommandActionCallback(void* ctxt, B
 }
 
 
-void PluginCommand::HighLevelILInstructionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
-	BNHighLevelILFunction* func, size_t instr)
+void PluginCommand::HighLevelILInstructionPluginCommandActionCallback(
+    void* ctxt, BNBinaryView* view, BNHighLevelILFunction* func, size_t instr)
 {
 	RegisteredHighLevelILInstructionCommand* cmd = (RegisteredHighLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -197,8 +197,8 @@ bool PluginCommand::FunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryVie
 }
 
 
-bool PluginCommand::LowLevelILFunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNLowLevelILFunction* func)
+bool PluginCommand::LowLevelILFunctionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNLowLevelILFunction* func)
 {
 	RegisteredLowLevelILFunctionCommand* cmd = (RegisteredLowLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -207,8 +207,8 @@ bool PluginCommand::LowLevelILFunctionPluginCommandIsValidCallback(void* ctxt, B
 }
 
 
-bool PluginCommand::LowLevelILInstructionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNLowLevelILFunction* func, size_t instr)
+bool PluginCommand::LowLevelILInstructionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNLowLevelILFunction* func, size_t instr)
 {
 	RegisteredLowLevelILInstructionCommand* cmd = (RegisteredLowLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -218,8 +218,8 @@ bool PluginCommand::LowLevelILInstructionPluginCommandIsValidCallback(void* ctxt
 }
 
 
-bool PluginCommand::MediumLevelILFunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNMediumLevelILFunction* func)
+bool PluginCommand::MediumLevelILFunctionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNMediumLevelILFunction* func)
 {
 	RegisteredMediumLevelILFunctionCommand* cmd = (RegisteredMediumLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -228,8 +228,8 @@ bool PluginCommand::MediumLevelILFunctionPluginCommandIsValidCallback(void* ctxt
 }
 
 
-bool PluginCommand::MediumLevelILInstructionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNMediumLevelILFunction* func, size_t instr)
+bool PluginCommand::MediumLevelILInstructionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNMediumLevelILFunction* func, size_t instr)
 {
 	RegisteredMediumLevelILInstructionCommand* cmd = (RegisteredMediumLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -239,8 +239,8 @@ bool PluginCommand::MediumLevelILInstructionPluginCommandIsValidCallback(void* c
 }
 
 
-bool PluginCommand::HighLevelILFunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNHighLevelILFunction* func)
+bool PluginCommand::HighLevelILFunctionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNHighLevelILFunction* func)
 {
 	RegisteredHighLevelILFunctionCommand* cmd = (RegisteredHighLevelILFunctionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -249,8 +249,8 @@ bool PluginCommand::HighLevelILFunctionPluginCommandIsValidCallback(void* ctxt,
 }
 
 
-bool PluginCommand::HighLevelILInstructionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
-	BNHighLevelILFunction* func, size_t instr)
+bool PluginCommand::HighLevelILInstructionPluginCommandIsValidCallback(
+    void* ctxt, BNBinaryView* view, BNHighLevelILFunction* func, size_t instr)
 {
 	RegisteredHighLevelILInstructionCommand* cmd = (RegisteredHighLevelILInstructionCommand*)ctxt;
 	Ref<BinaryView> viewObject = new BinaryView(BNNewViewReference(view));
@@ -260,204 +260,196 @@ bool PluginCommand::HighLevelILInstructionPluginCommandIsValidCallback(void* ctx
 }
 
 
-void PluginCommand::Register(const string& name, const string& description,
-                             const function<void(BinaryView* view)>& action)
+void PluginCommand::Register(
+    const string& name, const string& description, const function<void(BinaryView* view)>& action)
 {
 	Register(name, description, action, [](BinaryView*) { return true; });
 }
 
 
 void PluginCommand::Register(const string& name, const string& description,
-                             const function<void(BinaryView* view)>& action,
-                             const function<bool(BinaryView* view)>& isValid)
+    const function<void(BinaryView* view)>& action, const function<bool(BinaryView* view)>& isValid)
 {
 	RegisteredDefaultCommand* cmd = new RegisteredDefaultCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommand(name.c_str(), description.c_str(), DefaultPluginCommandActionCallback,
-	                        DefaultPluginCommandIsValidCallback, cmd);
+	    DefaultPluginCommandIsValidCallback, cmd);
 }
 
 
-void PluginCommand::RegisterForAddress(const string& name, const string& description,
-                                       const function<void(BinaryView* view, uint64_t addr)>& action)
+void PluginCommand::RegisterForAddress(
+    const string& name, const string& description, const function<void(BinaryView* view, uint64_t addr)>& action)
 {
 	RegisterForAddress(name, description, action, [](BinaryView*, uint64_t) { return true; });
 }
 
 
 void PluginCommand::RegisterForAddress(const string& name, const string& description,
-                                       const function<void(BinaryView* view, uint64_t addr)>& action,
-                                       const function<bool(BinaryView* view, uint64_t addr)>& isValid)
+    const function<void(BinaryView* view, uint64_t addr)>& action,
+    const function<bool(BinaryView* view, uint64_t addr)>& isValid)
 {
 	RegisteredAddressCommand* cmd = new RegisteredAddressCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForAddress(name.c_str(), description.c_str(), AddressPluginCommandActionCallback,
-	                                  AddressPluginCommandIsValidCallback, cmd);
+	    AddressPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForRange(const string& name, const string& description,
-                                     const function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action)
+    const function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action)
 {
 	RegisterForRange(name, description, action, [](BinaryView*, uint64_t, uint64_t) { return true; });
 }
 
 
 void PluginCommand::RegisterForRange(const string& name, const string& description,
-                                     const function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action,
-                                     const function<bool(BinaryView* view, uint64_t addr, uint64_t len)>& isValid)
+    const function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action,
+    const function<bool(BinaryView* view, uint64_t addr, uint64_t len)>& isValid)
 {
 	RegisteredRangeCommand* cmd = new RegisteredRangeCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
-	BNRegisterPluginCommandForRange(name.c_str(), description.c_str(), RangePluginCommandActionCallback,
-	                                RangePluginCommandIsValidCallback, cmd);
+	BNRegisterPluginCommandForRange(
+	    name.c_str(), description.c_str(), RangePluginCommandActionCallback, RangePluginCommandIsValidCallback, cmd);
 }
 
 
-void PluginCommand::RegisterForFunction(const string& name, const string& description,
-                                        const function<void(BinaryView* view, Function* func)>& action)
+void PluginCommand::RegisterForFunction(
+    const string& name, const string& description, const function<void(BinaryView* view, Function* func)>& action)
 {
 	RegisterForFunction(name, description, action, [](BinaryView*, Function*) { return true; });
 }
 
 
 void PluginCommand::RegisterForFunction(const string& name, const string& description,
-                                        const function<void(BinaryView* view, Function* func)>& action,
-                                        const function<bool(BinaryView* view, Function* func)>& isValid)
+    const function<void(BinaryView* view, Function* func)>& action,
+    const function<bool(BinaryView* view, Function* func)>& isValid)
 {
 	RegisteredFunctionCommand* cmd = new RegisteredFunctionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForFunction(name.c_str(), description.c_str(), FunctionPluginCommandActionCallback,
-	                                   FunctionPluginCommandIsValidCallback, cmd);
+	    FunctionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForLowLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, LowLevelILFunction* func)>& action)
+    const function<void(BinaryView* view, LowLevelILFunction* func)>& action)
 {
 	RegisterForLowLevelILFunction(name, description, action, [](BinaryView*, LowLevelILFunction*) { return true; });
 }
 
 
 void PluginCommand::RegisterForLowLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, LowLevelILFunction* func)>& action,
-	const function<bool(BinaryView* view, LowLevelILFunction* func)>& isValid)
+    const function<void(BinaryView* view, LowLevelILFunction* func)>& action,
+    const function<bool(BinaryView* view, LowLevelILFunction* func)>& isValid)
 {
 	RegisteredLowLevelILFunctionCommand* cmd = new RegisteredLowLevelILFunctionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForLowLevelILFunction(name.c_str(), description.c_str(),
-		LowLevelILFunctionPluginCommandActionCallback,
-		LowLevelILFunctionPluginCommandIsValidCallback, cmd);
+	    LowLevelILFunctionPluginCommandActionCallback, LowLevelILFunctionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForLowLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action)
+    const function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action)
 {
-	RegisterForLowLevelILInstruction(name, description, action,
-		[](BinaryView*, const LowLevelILInstruction&) { return true; });
+	RegisterForLowLevelILInstruction(
+	    name, description, action, [](BinaryView*, const LowLevelILInstruction&) { return true; });
 }
 
 
 void PluginCommand::RegisterForLowLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action,
-	const function<bool(BinaryView* view, const LowLevelILInstruction& instr)>& isValid)
+    const function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action,
+    const function<bool(BinaryView* view, const LowLevelILInstruction& instr)>& isValid)
 {
 	RegisteredLowLevelILInstructionCommand* cmd = new RegisteredLowLevelILInstructionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForLowLevelILInstruction(name.c_str(), description.c_str(),
-		LowLevelILInstructionPluginCommandActionCallback,
-		LowLevelILInstructionPluginCommandIsValidCallback, cmd);
+	    LowLevelILInstructionPluginCommandActionCallback, LowLevelILInstructionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForMediumLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, MediumLevelILFunction* func)>& action)
+    const function<void(BinaryView* view, MediumLevelILFunction* func)>& action)
 {
-	RegisterForMediumLevelILFunction(name, description, action,
-		[](BinaryView*, MediumLevelILFunction*) { return true; });
+	RegisterForMediumLevelILFunction(
+	    name, description, action, [](BinaryView*, MediumLevelILFunction*) { return true; });
 }
 
 
 void PluginCommand::RegisterForMediumLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, MediumLevelILFunction* func)>& action,
-	const function<bool(BinaryView* view, MediumLevelILFunction* func)>& isValid)
+    const function<void(BinaryView* view, MediumLevelILFunction* func)>& action,
+    const function<bool(BinaryView* view, MediumLevelILFunction* func)>& isValid)
 {
 	RegisteredMediumLevelILFunctionCommand* cmd = new RegisteredMediumLevelILFunctionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForMediumLevelILFunction(name.c_str(), description.c_str(),
-		MediumLevelILFunctionPluginCommandActionCallback,
-		MediumLevelILFunctionPluginCommandIsValidCallback, cmd);
+	    MediumLevelILFunctionPluginCommandActionCallback, MediumLevelILFunctionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForMediumLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action)
+    const function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action)
 {
-	RegisterForMediumLevelILInstruction(name, description, action,
-		[](BinaryView*, const MediumLevelILInstruction&) { return true; });
+	RegisterForMediumLevelILInstruction(
+	    name, description, action, [](BinaryView*, const MediumLevelILInstruction&) { return true; });
 }
 
 
 void PluginCommand::RegisterForMediumLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action,
-	const function<bool(BinaryView* view, const MediumLevelILInstruction& instr)>& isValid)
+    const function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action,
+    const function<bool(BinaryView* view, const MediumLevelILInstruction& instr)>& isValid)
 {
 	RegisteredMediumLevelILInstructionCommand* cmd = new RegisteredMediumLevelILInstructionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForMediumLevelILInstruction(name.c_str(), description.c_str(),
-		MediumLevelILInstructionPluginCommandActionCallback,
-		MediumLevelILInstructionPluginCommandIsValidCallback, cmd);
+	    MediumLevelILInstructionPluginCommandActionCallback, MediumLevelILInstructionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForHighLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, HighLevelILFunction* func)>& action)
+    const function<void(BinaryView* view, HighLevelILFunction* func)>& action)
 {
-	RegisterForHighLevelILFunction(name, description, action,
-		[](BinaryView*, HighLevelILFunction*) { return true; });
+	RegisterForHighLevelILFunction(name, description, action, [](BinaryView*, HighLevelILFunction*) { return true; });
 }
 
 
 void PluginCommand::RegisterForHighLevelILFunction(const string& name, const string& description,
-	const function<void(BinaryView* view, HighLevelILFunction* func)>& action,
-	const function<bool(BinaryView* view, HighLevelILFunction* func)>& isValid)
+    const function<void(BinaryView* view, HighLevelILFunction* func)>& action,
+    const function<bool(BinaryView* view, HighLevelILFunction* func)>& isValid)
 {
 	RegisteredHighLevelILFunctionCommand* cmd = new RegisteredHighLevelILFunctionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForHighLevelILFunction(name.c_str(), description.c_str(),
-		HighLevelILFunctionPluginCommandActionCallback,
-		HighLevelILFunctionPluginCommandIsValidCallback, cmd);
+	    HighLevelILFunctionPluginCommandActionCallback, HighLevelILFunctionPluginCommandIsValidCallback, cmd);
 }
 
 
 void PluginCommand::RegisterForHighLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const HighLevelILInstruction& instr)>& action)
+    const function<void(BinaryView* view, const HighLevelILInstruction& instr)>& action)
 {
-	RegisterForHighLevelILInstruction(name, description, action,
-		[](BinaryView*, const HighLevelILInstruction&) { return true; });
+	RegisterForHighLevelILInstruction(
+	    name, description, action, [](BinaryView*, const HighLevelILInstruction&) { return true; });
 }
 
 
 void PluginCommand::RegisterForHighLevelILInstruction(const string& name, const string& description,
-	const function<void(BinaryView* view, const HighLevelILInstruction& instr)>& action,
-	const function<bool(BinaryView* view, const HighLevelILInstruction& instr)>& isValid)
+    const function<void(BinaryView* view, const HighLevelILInstruction& instr)>& action,
+    const function<bool(BinaryView* view, const HighLevelILInstruction& instr)>& isValid)
 {
 	RegisteredHighLevelILInstructionCommand* cmd = new RegisteredHighLevelILInstructionCommand;
 	cmd->action = action;
 	cmd->isValid = isValid;
 	BNRegisterPluginCommandForHighLevelILInstruction(name.c_str(), description.c_str(),
-		HighLevelILInstructionPluginCommandActionCallback,
-		HighLevelILInstructionPluginCommandIsValidCallback, cmd);
+	    HighLevelILInstructionPluginCommandActionCallback, HighLevelILInstructionPluginCommandIsValidCallback, cmd);
 }
 
 
@@ -519,8 +511,8 @@ bool PluginCommand::IsValid(const PluginCommandContext& ctxt) const
 			return false;
 		if (!m_command.lowLevelILFunctionIsValid)
 			return true;
-		return m_command.lowLevelILFunctionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.lowLevelILFunction->GetObject());
+		return m_command.lowLevelILFunctionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.lowLevelILFunction->GetObject());
 	case LowLevelILInstructionPluginCommand:
 		if (!ctxt.lowLevelILFunction)
 			return false;
@@ -528,15 +520,15 @@ bool PluginCommand::IsValid(const PluginCommandContext& ctxt) const
 			return false;
 		if (!m_command.lowLevelILInstructionIsValid)
 			return true;
-		return m_command.lowLevelILInstructionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.lowLevelILFunction->GetObject(), ctxt.instrIndex);
+		return m_command.lowLevelILInstructionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.lowLevelILFunction->GetObject(), ctxt.instrIndex);
 	case MediumLevelILFunctionPluginCommand:
 		if (!ctxt.mediumLevelILFunction)
 			return false;
 		if (!m_command.mediumLevelILFunctionIsValid)
 			return true;
-		return m_command.mediumLevelILFunctionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.mediumLevelILFunction->GetObject());
+		return m_command.mediumLevelILFunctionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.mediumLevelILFunction->GetObject());
 	case MediumLevelILInstructionPluginCommand:
 		if (!ctxt.mediumLevelILFunction)
 			return false;
@@ -544,15 +536,15 @@ bool PluginCommand::IsValid(const PluginCommandContext& ctxt) const
 			return false;
 		if (!m_command.mediumLevelILInstructionIsValid)
 			return true;
-		return m_command.mediumLevelILInstructionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.mediumLevelILFunction->GetObject(), ctxt.instrIndex);
+		return m_command.mediumLevelILInstructionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.mediumLevelILFunction->GetObject(), ctxt.instrIndex);
 	case HighLevelILFunctionPluginCommand:
 		if (!ctxt.highLevelILFunction)
 			return false;
 		if (!m_command.highLevelILFunctionIsValid)
 			return true;
-		return m_command.highLevelILFunctionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.highLevelILFunction->GetObject());
+		return m_command.highLevelILFunctionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.highLevelILFunction->GetObject());
 	case HighLevelILInstructionPluginCommand:
 		if (!ctxt.highLevelILFunction)
 			return false;
@@ -560,8 +552,8 @@ bool PluginCommand::IsValid(const PluginCommandContext& ctxt) const
 			return false;
 		if (!m_command.highLevelILInstructionIsValid)
 			return true;
-		return m_command.highLevelILInstructionIsValid(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.highLevelILFunction->GetObject(), ctxt.instrIndex);
+		return m_command.highLevelILInstructionIsValid(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.highLevelILFunction->GetObject(), ctxt.instrIndex);
 	default:
 		return false;
 	}
@@ -588,28 +580,28 @@ void PluginCommand::Execute(const PluginCommandContext& ctxt) const
 		m_command.functionCommand(m_command.context, ctxt.binaryView->GetObject(), ctxt.function->GetObject());
 		break;
 	case LowLevelILFunctionPluginCommand:
-		m_command.lowLevelILFunctionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.lowLevelILFunction->GetObject());
+		m_command.lowLevelILFunctionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.lowLevelILFunction->GetObject());
 		break;
 	case LowLevelILInstructionPluginCommand:
-		m_command.lowLevelILInstructionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.lowLevelILFunction->GetObject(), ctxt.instrIndex);
+		m_command.lowLevelILInstructionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.lowLevelILFunction->GetObject(), ctxt.instrIndex);
 		break;
 	case MediumLevelILFunctionPluginCommand:
-		m_command.mediumLevelILFunctionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.mediumLevelILFunction->GetObject());
+		m_command.mediumLevelILFunctionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.mediumLevelILFunction->GetObject());
 		break;
 	case MediumLevelILInstructionPluginCommand:
-		m_command.mediumLevelILInstructionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.mediumLevelILFunction->GetObject(), ctxt.instrIndex);
+		m_command.mediumLevelILInstructionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.mediumLevelILFunction->GetObject(), ctxt.instrIndex);
 		break;
 	case HighLevelILFunctionPluginCommand:
-		m_command.highLevelILFunctionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.highLevelILFunction->GetObject());
+		m_command.highLevelILFunctionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.highLevelILFunction->GetObject());
 		break;
 	case HighLevelILInstructionPluginCommand:
-		m_command.highLevelILInstructionCommand(m_command.context, ctxt.binaryView->GetObject(),
-			ctxt.highLevelILFunction->GetObject(), ctxt.instrIndex);
+		m_command.highLevelILInstructionCommand(
+		    m_command.context, ctxt.binaryView->GetObject(), ctxt.highLevelILFunction->GetObject(), ctxt.instrIndex);
 		break;
 	default:
 		break;