コード例 #1
0
static void setDisassembly(PDWriter* writer, int start, int instCount)
{
    char temp[65536];

    disassembleToBuffer(temp, &start, &instCount);

    PDWrite_eventBegin(writer, PDEventType_setDisassembly);
    PDWrite_u16(writer, "address_start", (uint16_t)start);
    PDWrite_u16(writer, "instruction_count", (uint16_t)instCount);
    PDWrite_string(writer, "string_buffer", temp);
    PDWrite_eventEnd(writer);
}
コード例 #2
0
static void setExceptionLocation(PDWriter* writer)
{
    PDWrite_eventBegin(writer,PDEventType_setExceptionLocation); 
    PDWrite_u16(writer, "address", pc);
    PDWrite_u8(writer, "address_size", 2);
    PDWrite_eventEnd(writer);
}
コード例 #3
0
static void parseForCallstack(PDWriter* writer, const char* data, int length)
{
	uint16_t callStackEntries[256 * 2];
	int callStackCount = 0;

	memcpy(s_tempBuffer, data, length);
	s_tempBuffer[length] = 0;

    char* pch = strtok(s_tempBuffer, "\n");

    while (pch)
    {
        // expected format of each line:
        // xxx.. .C:080e  A9 22       LDA #$22

        if (pch[0] == '(' &&  pch[1] != 'C')
		{
			uint32_t offset = (uint32_t)atoi(&pch[2]);

			char* endOffset = strstr(&pch[2], ") ");

			if (endOffset)
			{
				endOffset += 2;

				uint16_t address = (uint16_t)strtol(endOffset, 0, 16);

				callStackEntries[(callStackCount * 2) + 0] = address;
				callStackEntries[(callStackCount * 2) + 1] = (uint16_t)offset;

				callStackCount++;
			}
		}

		pch = strtok(0, "\n");
    }
	
	if (callStackCount == 0)
		return;

    PDWrite_eventBegin(writer, PDEventType_setCallstack);
    PDWrite_arrayBegin(writer, "callstack");

    for (int i = 0; i < callStackCount; ++i)
	{
        PDWrite_arrayEntryBegin(writer);
        PDWrite_u16(writer, "address", callStackEntries[(i * 2) + 0] + callStackEntries[(i * 2) + 1]);
        PDWrite_arrayEntryEnd(writer);
	}

    PDWrite_arrayEnd(writer);
    PDWrite_eventEnd(writer);
}
コード例 #4
0
static void writeRegister(PDWriter* writer, const char* name, uint8_t size, uint16_t reg, uint8_t readOnly)
{
    PDWrite_arrayEntryBegin(writer);
    PDWrite_string(writer, "name", name);
    PDWrite_u8(writer, "size", size);

    if (readOnly)
        PDWrite_u8(writer, "read_only", 1);

    if (size == 2)
    	PDWrite_u16(writer, "register", reg);
	else
    	PDWrite_u8(writer, "register", (uint8_t)reg);

    PDWrite_arrayEntryEnd(writer);
}
コード例 #5
0
static bool parse_for_callstack(PluginData* data, const char* res, int length, PDReader* reader, PDWriter* writer) {
    uint16_t callstack_entries[256];
    int callstack_count = 0;

    (void)data;
    (void)reader;

    memcpy(TEMP_BUFFER, res, length);
    TEMP_BUFFER[length] = 0;

    char* pch = strtok(TEMP_BUFFER, "\n");

    while (pch) {
        const char* startText;
        const char* endText;

        if (!find_parentheses(pch, &startText, &endText))
            break;

        // startText points at (xx)
        // endText points at ) xxxx

        uint16_t offset = (uint16_t)atoi(startText + 1);
        uint16_t address = (uint16_t)strtol(endText + 2, 0, 16);

        callstack_entries[callstack_count++] = address + offset;

        pch = strtok(0, "\n");
    }

    if (callstack_count == 0)
        return false;

    PDWrite_event_begin(writer, PDEventType_SetCallstack);
    PDWrite_array_begin(writer, "callstack");

    for (int i = 0; i < callstack_count; ++i) {
        PDWrite_array_entry_begin(writer);
        PDWrite_u16(writer, "address", callstack_entries[i]);
        PDWrite_entry_end(writer);
    }

    PDWrite_array_end(writer);
    PDWrite_event_end(writer);

    return true;
}
コード例 #6
0
bool parse_disassassembly_call(PluginData* plugin, const char* res, int len, PDReader* reader, PDWriter* writer) {
    memcpy(TEMP_BUFFER, res, len);
    TEMP_BUFFER[len] = 0;

    (void)plugin;
    (void)reader;

    // parse the buffer

    char* pch = strtok(TEMP_BUFFER, "\n");

    PDWrite_event_begin(writer, PDEventType_SetDisassembly);
    PDWrite_array_begin(writer, "disassembly");

    bool hasAllDisasembly = false;

    while (pch) {
        // expected format of each line:
        // xxx.. .C:080e  A9 22       LDA #$22

        char* endOfStream = strstr(pch, "(C:");
        char* line = strstr(pch, ".C");

        if (endOfStream) {
            hasAllDisasembly = true;
            break;
        }

        if (!line)
            break;

        uint16_t address = (uint16_t)strtol(&line[3], 0, 16);

        PDWrite_array_entry_begin(writer);
        PDWrite_u16(writer, "address", address);
        PDWrite_string(writer, "line", parse_disassembly_line(&line[9]));

        PDWrite_entry_end(writer);

        pch = strtok(0, "\n");
    }

    PDWrite_array_end(writer);
    PDWrite_event_end(writer);

    return hasAllDisasembly;
}
コード例 #7
0
static void write_register(PDWriter* writer, const char* name, uint8_t size, uint16_t reg, uint8_t read_only) {
    PDWrite_array_entry_begin(writer);
    PDWrite_string(writer, "name", name);
    PDWrite_u8(writer, "size", size);

    if (read_only) {
        PDWrite_u8(writer, "read_only", 1);
	}

    if (size == 2) {
        PDWrite_u16(writer, "register", reg);
	} else {
        PDWrite_u8(writer, "register", (uint8_t)reg);
	}

    PDWrite_entry_end(writer);
}
コード例 #8
0
static void parseDisassembly(PDWriter* writer, const char* data, int length)
{
	memcpy(s_tempBuffer, data, length);
	s_tempBuffer[length] = 0;

    // parse the buffer

    char* pch = strtok(s_tempBuffer, "\n");

    PDWrite_eventBegin(writer, PDEventType_setDisassembly);
    PDWrite_arrayBegin(writer, "disassembly");

    while (pch)
    {
        // expected format of each line:
        // xxx.. .C:080e  A9 22       LDA #$22

		char* line = strstr(pch, ".C");

        if (!line)
            break;

        uint16_t address = (uint16_t)strtol(&line[3], 0, 16);

        PDWrite_arrayEntryBegin(writer);
        PDWrite_u16(writer, "address", address);
        PDWrite_string(writer, "line", parseDisassemblyLine(&line[9]));

        PDWrite_arrayEntryEnd(writer);

        pch = strtok(0, "\n");
    }

    PDWrite_arrayEnd(writer);
    PDWrite_eventEnd(writer);
}