static PDDebugState update(void* userData, PDAction action, PDReader* reader, PDWriter* writer) {
//int event = 0;
(void)reader;
AngelScriptDebugger* debugger = (AngelScriptDebugger*)userData;
/*processEvents(plugin, reader, writer);
doAction(plugin, action);
if (plugin->state == PDDebugState_running)
updateLLDBEvent(plugin, writer);*/
//doAction(debugger, action, writer);
uint32_t event;
while ((event = PDRead_get_event(reader)) != 0) {
switch (event) {
case PDEventType_GetCallstack:
log_out("GetCallstack!\n");
//debugger->engine
//getCallstack(reader, writer);
break;
case PDEventType_GetLocals:
log_out("GetLocals!\n");
//getLocals(reader, writer);
break;
}
}
return PDDebugState(debugger->runState);
}
static void processEvents(LLDBPlugin* plugin, PDReader* reader, PDWriter* writer)
{
uint32_t event;
while ((event = PDRead_get_event(reader)))
{
//printf("LLDBPlugin: %d Got event %s\n", event, eventTypes[event]);
switch (event)
{
case PDEventType_GetExceptionLocation : setExceptionLocation(plugin, writer); break;
case PDEventType_GetCallstack : setCallstack(plugin, writer); break;
case PDEventType_SetExecutable : setExecutable(plugin, reader); break;
case PDEventType_SelectThread : selectThread(plugin, reader, writer); break;
case PDEventType_SelectFrame : selectFrame(plugin, reader, writer); break;
case PDEventType_GetLocals : setLocals(plugin, writer); break;
case PDEventType_GetThreads : setThreads(plugin, writer); break;
case PDEventType_GetSourceFiles : setSourceFiles(plugin, writer); break;
case PDEventType_SetBreakpoint : setBreakpoint(plugin, reader, writer); break;
case PDEventType_Action : eventAction(plugin, reader); break;
}
}
setTty(plugin, writer);
}
static void test_lldb(void** state) {
(void)state;
// we only do the LLDB test on Mac for now
#ifdef __APPLE__
PluginData* pluginData;
Session* session;
int count = 0;
assert_true(PluginHandler_addPlugin(OBJECT_DIR, "lldb_plugin"));
assert_non_null(pluginData = PluginHandler_getBackendPlugins(&count)[0]);
session = Session_createLocal((PDBackendPlugin*)pluginData->plugin, OBJECT_DIR "/crashing_native");
assert_non_null(session);
// I hate to do this but there is really no good way to deal with this otherwise (at least currently)
Time_sleepMs(800);
Session_update(session);
Session_update(session);
// Expect that we have a crash here and thus are in PDDebugState_stopException state
assert_int_equal(session->state, PDDebugState_StopException);
// Request locals location.
PDWriter* writer = session->currentWriter;
PDReader* reader = session->reader;
PDWrite_event_begin(writer, PDEventType_GetCallstack);
PDWrite_u8(writer, "dummy", 0);
PDWrite_event_end(writer);
Session_update(session);
PDBinaryWriter_finalize(session->currentWriter);
PDBinaryReader_initStream(reader, PDBinaryWriter_getData(session->currentWriter), PDBinaryWriter_getSize(session->currentWriter));
uint32_t event;
bool foundCallstack = false;
while ((event = PDRead_get_event(reader)) != 0) {
switch (event) {
case PDEventType_SetCallstack:
{
foundCallstack = true;
break;
}
}
}
assert_true(foundCallstack);
#endif
}
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* writer) {
uint32_t event;
DissassemblyData* data = (DissassemblyData*)user_data;
data->requestDisassembly = false;
while ((event = PDRead_get_event(inEvents)) != 0) {
switch (event) {
case PDEventType_SetDisassembly:
{
setDisassemblyCode(data, inEvents);
break;
}
case PDEventType_SetExceptionLocation:
{
uint64_t location = 0;
PDRead_find_u64(inEvents, &location, "address", 0);
if (location != data->location) {
data->location = location;
data->requestDisassembly = true;
}
PDRead_find_u8(inEvents, &data->locationSize, "address_size", 0);
break;
}
case PDEventType_SetRegisters:
{
updateRegisters(data, inEvents);
break;
}
}
}
renderUI(data, uiFuncs);
if (data->requestDisassembly) {
int pc = (int)(data->pc) & ~(BlockSize - 1);
PDWrite_event_begin(writer, PDEventType_GetDisassembly);
PDWrite_u64(writer, "address_start", (uint64_t)pc);
PDWrite_u32(writer, "instruction_count", (uint32_t)BlockSize / 3);
PDWrite_event_end(writer);
}
return 0;
}
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* outEvents) {
uint32_t event;
RegistersData* data = (RegistersData*)user_data;
(void)outEvents;
// Loop over all the in events
while ((event = PDRead_get_event(inEvents)) != 0) {
switch (event) {
case PDEventType_SetRegisters:
updateRegisters(data, inEvents); break;
}
}
showUI(data, uiFuncs);
return 0;
}
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* outEvents) {
uint32_t event = 0;
ThreadsData* data = (ThreadsData*)user_data;
data->requestData = false;
data->setSelectedThread = false;
while ((event = PDRead_get_event(inEvents)) != 0) {
switch (event) {
case PDEventType_SetThreads:
{
showInUI((ThreadsData*)user_data, inEvents, uiFuncs);
break;
}
case PDEventType_SetExceptionLocation:
{
data->requestData = true;
break;
}
}
}
// Request threads data
if (data->setSelectedThread) {
PDWrite_event_begin(outEvents, PDEventType_SelectThread);
printf("writing thread id %d\n", data->threadId);
PDWrite_u32(outEvents, "thread_id", (uint32_t)data->threadId);
PDWrite_event_end(outEvents);
}
if (data->requestData) {
PDWrite_event_begin(outEvents, PDEventType_GetThreads);
PDWrite_event_end(outEvents);
}
return 0;
}
static void processEvents(DbgEngPlugin* plugin, PDReader* reader, PDWriter* writer) {
printf("DbgEngPlugin: processEvents\n");
PDEventType event;
while ((event = (PDEventType)PDRead_get_event(reader))) {
printf("DbgEngPlugin: %d Got event %s\n", (int)event, eventTypes[event]);
switch (event) {
case PDEventType_getExceptionLocation:
setExceptionLocation(plugin, writer); break;
case PDEventType_getCallstack:
setCallstack(plugin, writer); break;
case PDEventType_setExecutable:
setExecutable(plugin, reader); break;
case PDEventType_getLocals:
setLocals(plugin, writer); break;
case PDEventType_setBreakpoint:
setBreakpoint(plugin, reader, writer); break;
case PDEventType_action:
eventAction(plugin, reader); break;
}
}
}
static void process_events(PluginData* data, PDReader* reader, PDWriter* writer) {
uint32_t event;
while ((event = PDRead_get_event(reader))) {
switch (event) {
//case PDEventType_getExceptionLocation : setExceptionLocation(plugin, writer); break;
//case PDEventType_getCallstack : set_callstack(plugin, writer); break;
case PDEventType_GetRegisters:
{
get_registers(data);
break;
}
case PDEventType_GetCallstack:
{
if (should_send_command(data))
set_callstack(data, reader, writer);
break;
}
case PDEventType_GetDisassembly:
{
if (should_send_command(data))
get_disassembly(data, reader, writer);
break;
}
case PDEventType_GetMemory:
{
if (should_send_command(data))
get_memory(data, reader, writer);
break;
}
case PDEventType_MenuEvent:
{
on_menu(data, reader);
break;
}
case PDEventType_SetBreakpoint:
{
set_breakpoint(data, reader, writer);
// if we add a breakpoint to VICE it will always stop but if we are already running when
// adding the breakpoint we just force VICE to run again
if (data->state == PDDebugState_Running)
send_command(data, "ret\n");
break;
}
case PDEventType_DeleteBreakpoint:
{
del_breakpoint(data, reader, writer);
break;
}
case PDEventType_SetExecutable:
{
//if (should_send_command(data))
set_executable(data, reader);
break;
}
}
}
}
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* writer) {
uint32_t event;
(void)uiFuncs;
SourceCodeData* data = (SourceCodeData*)user_data;
PDUISCInterface* sourceFuncs = uiFuncs->sc_input_text("test", 800, 700, 0, 0);
while ((event = PDRead_get_event(inEvents)) != 0) {
switch (event) {
case PDEventType_SetExceptionLocation:
{
setExceptionLocation(uiFuncs, sourceFuncs, data, inEvents);
data->requestFiles = true;
break;
}
case PDEventType_SetSourceCodeFile:
{
const char* filename;
if (PDRead_find_string(inEvents, &filename, "filename", 0) == PDReadStatus_NotFound)
break;
setSourceCodeFile(uiFuncs, sourceFuncs, data, filename, 0);
break;
}
case PDEventType_ToggleBreakpointCurrentLine:
{
toggleBreakpointCurrentLine(sourceFuncs, data, writer);
break;
}
case PDEventType_SetSourceFiles:
{
// TODO: Store the files
data->hasFiles = true;
break;
}
}
}
updateKeyboard(data, sourceFuncs, uiFuncs);
PDUI_sc_update(sourceFuncs);
PDUI_sc_draw(sourceFuncs);
//showInUI(data, uiFuncs);
PDWrite_event_begin(writer, PDEventType_GetExceptionLocation);
PDWrite_event_end(writer);
if (!data->hasFiles && data->requestFiles) {
PDWrite_event_begin(writer, PDEventType_GetSourceFiles);
PDWrite_event_end(writer);
}
return 0;
}
static int update(void* user_data, PDUI* uiFuncs, PDReader* reader, PDWriter* writer) {
uint32_t event;
CallstackData* data = (CallstackData*)user_data;
data->request = false;
data->setSelectedFrame = false;
while ((event = PDRead_get_event(reader)) != 0) {
switch (event) {
case PDEventType_SetCallstack:
{
updateCallstack(data, reader);
break;
}
case PDEventType_SelectFrame:
{
PDRead_find_u32(reader, &data->selectedFrame, "frame", 0);
break;
}
case PDEventType_SetExceptionLocation:
{
const char* filename = 0;
uint32_t line = 0;
uint64_t location = 0;
PDRead_find_u64(reader, &location, "address", 0);
if (location != data->location) {
data->location = location;
data->request = true;
}
PDRead_find_string(reader, &filename, "filename", 0);
PDRead_find_u32(reader, &line, "line", 0);
if (!filename || line == 0)
break;
if (strcmp(data->filename, filename)) {
strcpy(data->filename, filename);
data->line = (int)line;
data->request = true;
}
}
}
}
showUI(uiFuncs, data);
if (data->setSelectedFrame) {
PDWrite_event_begin(writer, PDEventType_SelectFrame);
PDWrite_u32(writer, "frame", (uint32_t)data->selectedFrame);
PDWrite_event_end(writer);
}
if (data->request) {
PDWrite_event_begin(writer, PDEventType_GetCallstack);
PDWrite_event_end(writer);
}
return 0;
}
