void
Driver::MainLoop ()
{
SBEvent event;
while (!GetIsDone())
{
m_listener->WaitForEvent (UINT32_MAX, event);
if (event.IsValid())
{
ProcessEvent(event);
}
}
DestroyPseudoTerminal();
CloseIOChannelFile ();
if (!iochannel_thread_exited)
{
event.Clear();
m_listener->GetNextEventForBroadcasterWithType (*m_io_channel_ap,
IOChannel::eBroadcastBitThreadDidExit,
event);
if (!event.IsValid())
{
// Send end EOF to the driver file descriptor
m_io_channel_ap->Stop();
}
}
SBDebugger::Destroy (m_debugger);
}
BreakpointEventType
SBBreakpoint::GetBreakpointEventTypeFromEvent (const SBEvent& event)
{
if (event.IsValid())
return Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (event.GetSP());
return eBreakpointEventTypeInvalidType;
}
WatchpointEventType
SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
if (event.IsValid())
return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
event.GetSP());
return eWatchpointEventTypeInvalidType;
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
// send process description
SBProcess process = SBProcess::GetProcessFromEvent(event);
if (!process.IsValid())
throw Exception("process is not valid");
if (SBProcess::GetStateFromEvent(event) != lldb::eStateStopped || SBProcess::GetRestartedFromEvent(event))
continue; // Only interested in "stopped" events.
SBStream description;
for (int i = 0; i < process.GetNumThreads(); ++i) {
// send each thread description
SBThread thread = process.GetThreadAtIndex(i);
// send each frame function name
uint32_t num_frames = thread.GetNumFrames();
for(int j = 0; j < num_frames; ++j) {
const char* function_name = thread.GetFrameAtIndex(j).GetSymbol().GetName();
if (function_name)
g_frame_functions.push(string(function_name));
}
}
}
}
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
// send process description
SBProcess process = SBProcess::GetProcessFromEvent(event);
SBStream description;
for (int i = 0; i < process.GetNumThreads(); ++i) {
// send each thread description
description.Clear();
SBThread thread = process.GetThreadAtIndex(i);
thread.GetDescription(description);
g_thread_descriptions.push(description.GetData());
// send each frame function name
uint32_t num_frames = thread.GetNumFrames();
for(int j = 0; j < num_frames; ++j) {
const char* function_name = thread.GetFrameAtIndex(j).GetSymbol().GetName();
if (function_name)
g_frame_functions.push(function_name);
}
}
}
}
}
bool
SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
{
if (m_opaque_sp && broadcaster.IsValid())
{
event.reset (m_opaque_sp->PeekAtNextEventForBroadcaster (broadcaster.get()));
return event.IsValid();
}
event.reset (NULL);
return false;
}
bool
SBListener::PeekAtNextEvent (SBEvent &event)
{
if (m_opaque_sp)
{
event.reset (m_opaque_sp->PeekAtNextEvent ());
return event.IsValid();
}
event.reset (NULL);
return false;
}
bool
SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask,
SBEvent &event)
{
if (m_opaque_sp && broadcaster.IsValid())
{
event.reset(m_opaque_sp->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask));
return event.IsValid();
}
event.reset (NULL);
return false;
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
SBStream description;
event.GetDescription(description);
string str(description.GetData());
g_event_descriptions.push(str);
}
}
}
void listener_func() {
while (!g_done) {
SBEvent event;
bool got_event = g_listener.WaitForEvent(1, event);
if (got_event) {
if (!event.IsValid())
throw Exception("event is not valid in listener thread");
SBProcess process = SBProcess::GetProcessFromEvent(event);
if (process.GetState() == eStateStopped) {
SBError error = process.Continue();
if (!error.Success())
throw Exception(string("Cannot continue process from listener thread: ")
+ error.GetCString());
g_process_started.push(true);
}
}
}
}
void
IOChannel::Run ()
{
SBListener listener("IOChannel::Run");
std::string new_line;
SBBroadcaster interpreter_broadcaster (m_driver->GetDebugger().GetCommandInterpreter().GetBroadcaster());
listener.StartListeningForEvents (interpreter_broadcaster,
SBCommandInterpreter::eBroadcastBitResetPrompt |
SBCommandInterpreter::eBroadcastBitThreadShouldExit |
SBCommandInterpreter::eBroadcastBitQuitCommandReceived);
listener.StartListeningForEvents (*this,
IOChannel::eBroadcastBitThreadShouldExit);
listener.StartListeningForEvents (*m_driver,
Driver::eBroadcastBitReadyForInput |
Driver::eBroadcastBitThreadShouldExit);
// Let anyone know that the IO channel is up and listening and ready for events
BroadcastEventByType (eBroadcastBitThreadDidStart);
bool done = false;
while (!done)
{
SBEvent event;
listener.WaitForEvent (UINT32_MAX, event);
if (!event.IsValid())
continue;
const uint32_t event_type = event.GetType();
if (event.GetBroadcaster().IsValid())
{
if (event.BroadcasterMatchesPtr (m_driver))
{
if (event_type & Driver::eBroadcastBitReadyForInput)
{
std::string line;
if (CommandQueueIsEmpty())
{
if (LibeditGetInput(line) == false)
{
// EOF or some other file error occurred
done = true;
continue;
}
}
else
{
GetCommandFromQueue (line);
}
// TO BE DONE: FIGURE OUT WHICH COMMANDS SHOULD NOT BE REPEATED IF USER PRESSES PLAIN 'RETURN'
// AND TAKE CARE OF THAT HERE.
SBEvent line_event(IOChannel::eBroadcastBitHasUserInput,
line.c_str(),
line.size());
BroadcastEvent (line_event);
}
else if (event_type & Driver::eBroadcastBitThreadShouldExit)
{
done = true;
break;
}
}
else if (event.BroadcasterMatchesRef (interpreter_broadcaster))
{
switch (event_type)
{
case SBCommandInterpreter::eBroadcastBitResetPrompt:
{
const char *new_prompt = SBEvent::GetCStringFromEvent (event);
if (new_prompt)
g_prompt_map[m_edit_line] = new_prompt;
}
break;
case SBCommandInterpreter::eBroadcastBitThreadShouldExit:
case SBCommandInterpreter::eBroadcastBitQuitCommandReceived:
done = true;
break;
}
}
else if (event.BroadcasterMatchesPtr (this))
{
if (event_type & IOChannel::eBroadcastBitThreadShouldExit)
{
done = true;
break;
}
}
}
}
BroadcastEventByType (IOChannel::eBroadcastBitThreadDidExit);
m_driver = NULL;
m_read_thread = NULL;
}
