doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated TargetControllerConsole to use template method for triggering events for the TargetController.

Browse Source
This commit is contained in:
Nav
2021-08-20 22:53:31 +01:00
parent e3ec4e31e8
commit 092a7df675
14 changed files with 54 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
src/TargetController/TargetControllerConsole.cpp
View File

@@ -11,53 +11,28 @@ using namespace Bloom::Events;
using namespace Bloom::Exceptions;
TargetControllerState TargetControllerConsole::getTargetControllerState() {
auto getStateEvent = std::make_shared<ReportTargetControllerState>();
this->eventManager.triggerEvent(getStateEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetControllerStateReported,
TargetControllerErrorOccurred
>(this->defaultTimeout, getStateEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto stateReportedEvent = std::get<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value());
return stateReportedEvent->state;
return this->triggerTargetControllerEventAndWaitForResponse(
std::make_shared<ReportTargetControllerState>()
)->state;
}
bool TargetControllerConsole::isTargetControllerInService() noexcept {
try {
return this->getTargetControllerState() == TargetControllerState::ACTIVE;
} catch (const std::runtime_error&) {
} catch (...) {
return false;
}
}
Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
auto descriptorExtractedEvent = this->triggerTargetControllerEventAndWaitForResponse(
return this->triggerTargetControllerEventAndWaitForResponse(
std::make_shared<ExtractTargetDescriptor>()
);
return descriptorExtractedEvent->targetDescriptor;
)->targetDescriptor;
}
void TargetControllerConsole::stopTargetExecution() {
auto stopTargetEvent = std::make_shared<StopTargetExecution>();
this->eventManager.triggerEvent(stopTargetEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionStopped,
TargetControllerErrorOccurred
>(this->defaultTimeout, stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(std::make_shared<StopTargetExecution>());
}
void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -67,17 +42,7 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
resumeExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(resumeExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(resumeExecutionEvent);
}
void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
@@ -87,56 +52,21 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
stepExecutionEvent->fromProgramCounter = fromAddress.value();
}
this->eventManager.triggerEvent(stepExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(stepExecutionEvent);
}
TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
readRegistersEvent->descriptors = descriptors;
this->eventManager.triggerEvent(readRegistersEvent);
auto responseEvent = this->eventListener.waitForEvent<
RegistersRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<RegistersRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->registers;
return this->triggerTargetControllerEventAndWaitForResponse(readRegistersEvent)->registers;
}
void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
auto event = std::make_shared<WriteRegistersToTarget>();
event->registers = std::move(registers);
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
RegistersWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
TargetMemoryBuffer TargetControllerConsole::readMemory(
@@ -149,22 +79,7 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
this->eventManager.triggerEvent(readMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
MemoryRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<MemoryRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->data;
return this->triggerTargetControllerEventAndWaitForResponse(readMemoryEvent)->data;
}
void TargetControllerConsole::writeMemory(
@@ -177,51 +92,21 @@ void TargetControllerConsole::writeMemory(
writeMemoryEvent->startAddress = startAddress;
writeMemoryEvent->buffer = buffer;
this->eventManager.triggerEvent(writeMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
MemoryWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(writeMemoryEvent);
}
void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
BreakpointSetOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<RemoveBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
BreakpointRemovedOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
this->triggerTargetControllerEventAndWaitForResponse(event);
}
void TargetControllerConsole::requestPinStates(int variantId) {