feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

debugger: implementation progress in the trk manual test

Browse Source
This commit is contained in:
hjk
2009-07-16 16:05:43 +02:00
parent d88fceb202
commit 66216448e9
4 changed files with 679 additions and 709 deletions
Download Patch File Download Diff File Expand all files Collapse all files

689
tests/manual/trk/adapter.cpp
View File

@@ -30,6 +30,7 @@
#include "trkutils.h" #include "trkutils.h"
#include <QtCore/QCoreApplication> #include <QtCore/QCoreApplication>
#include <QtCore/QQueue>
#include <QtCore/QTimer> #include <QtCore/QTimer>
#include <QtNetwork/QTcpServer> #include <QtNetwork/QTcpServer>
@@ -50,6 +51,9 @@ void signalHandler(int)
using namespace trk; using namespace trk;
#define CB(s) &Adapter::s
class Adapter : public QObject class Adapter : public QObject
{ {
Q_OBJECT Q_OBJECT
@@ -68,10 +72,73 @@ private:
// //
Q_SLOT void readFromTrk(); Q_SLOT void readFromTrk();
trk::TrkClient m_trkClient; typedef void (Adapter::*TrkCallBack)(const TrkResult &);
struct TrkMessage
{
TrkMessage() { token = 0; callBack = 0; }
byte command;
byte token;
QByteArray data;
TrkCallBack callBack;
};
bool openTrkPort(const QString &port); // or server name for local server
void sendTrkMessage(byte command, TrkCallBack callBack = 0,
const QByteArray &lit = QByteArray());
// adds message to 'send' queue
void queueTrkMessage(const TrkMessage &msg);
void tryTrkWrite();
void tryTrkRead();
// actually writes a message to the device
void trkWrite(const TrkMessage &msg);
// convienience messages
void sendTrkInitialPing();
void waitForTrkFinished();
void sendTrkAck(byte token);
// kill process and breakpoints
void cleanUp();
void timerEvent(QTimerEvent *ev);
byte nextTrkWriteToken();
void handleTrkCpuType(const TrkResult &result);
void handleTrkCreateProcess(const TrkResult &result);
void handleTrkDeleteProcess(const TrkResult &result);
void handleTrkSetBreakpoint(const TrkResult &result);
void handleTrkClearBreakpoint(const TrkResult &result);
void handleTrkContinue(const TrkResult &result);
void handleTrkReadInfo(const TrkResult &result);
void handleTrkWaitForFinished(const TrkResult &result);
void handleTrkStep(const TrkResult &result);
void handleTrkStop(const TrkResult &result);
void handleTrkReadRegisters(const TrkResult &result);
void handleTrkWriteRegisters(const TrkResult &result);
void handleTrkReadMemory(const TrkResult &result);
void handleTrkWriteMemory(const TrkResult &result);
void handleTrkSupportMask(const TrkResult &result);
void handleTrkDisconnect(const TrkResult &result);
void setTrkBreakpoint(const Breakpoint &bp);
void clearTrkBreakpoint(const Breakpoint &bp);
void handleTrkResult(const TrkResult &data);
QLocalSocket *m_trkDevice;
QString m_trkServerName; QString m_trkServerName;
QByteArray m_trkReadBuffer; QByteArray m_trkReadBuffer;
unsigned char m_trkWriteToken;
QQueue<TrkMessage> m_trkWriteQueue;
QHash<byte, TrkMessage> m_writtenTrkMessages;
QByteArray m_trkReadQueue;
bool m_trkWriteBusy;
QList<Breakpoint> m_breakpoints;
Session m_session;
// //
// Gdb // Gdb
// //
@@ -89,22 +156,44 @@ private:
QString m_gdbServerName; QString m_gdbServerName;
quint16 m_gdbServerPort; quint16 m_gdbServerPort;
QByteArray m_gdbReadBuffer; QByteArray m_gdbReadBuffer;
bool m_ackMode; bool m_gdbAckMode;
uint m_registers[100]; uint m_registers[100];
}; };
Adapter::Adapter() Adapter::Adapter()
{ {
// Trk
#if USE_NATIVE
m_hdevice = NULL;
#else
m_trkDevice = 0;
#endif
m_trkWriteToken = 0;
m_trkWriteBusy = false;
//m_breakpoints.append(Breakpoint(0x0370));
//m_breakpoints.append(Breakpoint(0x0340));
//m_breakpoints.append(Breakpoint(0x0040)); // E32Main
startTimer(100);
// Gdb
m_gdbConnection = 0; m_gdbConnection = 0;
m_ackMode = true; m_gdbAckMode = true;
} }
Adapter::~Adapter() Adapter::~Adapter()
{ {
// Trk
#if USE_NATIVE
CloseHandle(m_hdevice);
#else
delete m_trkDevice;
#endif
// Gdb
m_gdbServer.close(); m_gdbServer.close();
//m_trkClient->disconnectFromServer(); //>disconnectFromServer();
m_trkClient.abort(); m_trkDevice->abort();
logMessage("Shutting down.\n"); logMessage("Shutting down.\n");
} }
@@ -122,26 +211,26 @@ void Adapter::setGdbServerName(const QString &name)
void Adapter::startServer() void Adapter::startServer()
{ {
if (!m_trkClient.openPort(m_trkServerName)) { if (!openTrkPort(m_trkServerName)) {
logMessage("Unable to connect to TRK server"); logMessage("Unable to connect to TRK server");
return; return;
} }
m_trkClient.sendInitialPing(); sendTrkInitialPing();
m_trkClient.sendMessage(0x01); // Connect sendTrkMessage(0x01); // Connect
//m_trkClient.sendMessage(0x05, CB(handleSupportMask)); sendTrkMessage(0x05, CB(handleTrkSupportMask));
//m_trkClient.sendMessage(0x06, CB(handleCpuType)); sendTrkMessage(0x06, CB(handleTrkCpuType));
m_trkClient.sendMessage(0x04); // Versions sendTrkMessage(0x04); // Versions
//sendMessage(0x09); Unrecognized command sendTrkMessage(0x09); // Unrecognized command
m_trkClient.sendMessage(0x4a, 0, sendTrkMessage(0x4a, 0,
"10 " + formatString("C:\\data\\usingdlls.sisx")); // Open File "10 " + formatString("C:\\data\\usingdlls.sisx")); // Open File
m_trkClient.sendMessage(0x4B, 0, "00 00 00 01 73 1C 3A C8"); // Close File sendTrkMessage(0x4B, 0, "00 00 00 01 73 1C 3A C8"); // Close File
QByteArray exe = "C:\\sys\\bin\\UsingDLLs.exe"; QByteArray exe = "C:\\sys\\bin\\UsingDLLs.exe";
exe.append('\0'); exe.append('\0');
exe.append('\0'); exe.append('\0');
//m_trkClient.sendMessage(0x40, CB(handleCreateProcess), sendTrkMessage(0x40, CB(handleTrkCreateProcess),
// "00 00 00 " + formatString(exe)); // Create Item "00 00 00 " + formatString(exe)); // Create Item
logMessage("Connected to TRK server"); logMessage("Connected to TRK server");
@@ -240,7 +329,7 @@ void Adapter::readFromGdb()
void Adapter::writeAckToGdb() void Adapter::writeAckToGdb()
{ {
if (!m_ackMode) if (!m_gdbAckMode)
return; return;
QByteArray packet = "+"; QByteArray packet = "+";
logMessage("gdb: <- " + packet); logMessage("gdb: <- " + packet);
@@ -288,7 +377,7 @@ void Adapter::handleGdbResponse(const QByteArray &response)
//$qSupported#37 //$qSupported#37
//logMessage("Handling 'QStartNoAckMode'"); //logMessage("Handling 'QStartNoAckMode'");
writeToGdb(QByteArray("OK")); writeToGdb(QByteArray("OK"));
m_ackMode = false; m_gdbAckMode = false;
} }
else if (response == "g") { else if (response == "g") {
@@ -341,6 +430,570 @@ void Adapter::readFromTrk()
//logMessage("Read from gdb: " + ba); //logMessage("Read from gdb: " + ba);
} }
bool Adapter::openTrkPort(const QString &port)
{
// QFile does not work with "COM3", so work around
/*
FILE *f = fopen("COM3", "r+");
if (!f) {
logMessage("Could not open file ");
return;
}
m_trkDevice = new QFile;
if (!m_trkDevice->open(f, QIODevice::ReadWrite))
*/
#if 0
m_trkDevice = new Win_QextSerialPort(port);
m_trkDevice->setBaudRate(BAUD115200);
m_trkDevice->setDataBits(DATA_8);
m_trkDevice->setParity(PAR_NONE);
//m_trkDevice->setStopBits(STO);
m_trkDevice->setFlowControl(FLOW_OFF);
m_trkDevice->setTimeout(0, 500);
if (!m_trkDevice->open(QIODevice::ReadWrite)) {
QByteArray ba = m_trkDevice->errorString().toLatin1();
logMessage("Could not open device " << ba);
return;
}
#else
m_trkDevice = new QLocalSocket(this);
m_trkDevice->connectToServer(port);
return m_trkDevice->waitForConnected();
#endif
}
void Adapter::timerEvent(QTimerEvent *)
{
//qDebug(".");
tryTrkWrite();
tryTrkRead();
}
unsigned char Adapter::nextTrkWriteToken()
{
++m_trkWriteToken;
if (m_trkWriteToken == 0)
++m_trkWriteToken;
return m_trkWriteToken;
}
void Adapter::sendTrkMessage(byte command, TrkCallBack callBack,
const QByteArray &lit)
{
TrkMessage msg;
msg.command = command;
msg.token = nextTrkWriteToken();
msg.callBack = callBack;
QList<QByteArray> list = lit.split(' ');
foreach (const QByteArray &item, list) {
if (item.isEmpty())
continue;
bool ok = false;
int i = item.toInt(&ok, 16);
msg.data.append(char(i));
}
//logMessage("PARSED: " << lit << " -> " << stringFromArray(data).toLatin1().data());
queueTrkMessage(msg);
}
void Adapter::sendTrkInitialPing()
{
TrkMessage msg;
msg.command = 0x00; // Ping
msg.token = 0; // reset sequence count
queueTrkMessage(msg);
}
void Adapter::waitForTrkFinished()
{
TrkMessage msg;
// initiate one last roundtrip to ensure all is flushed
msg.command = 0x00; // Ping
msg.token = nextTrkWriteToken();
msg.callBack = CB(handleTrkWaitForFinished);
queueTrkMessage(msg);
}
void Adapter::sendTrkAck(byte token)
{
logMessage(QString("SENDING ACKNOWLEDGEMENT FOR TOKEN ").arg(int(token)));
TrkMessage msg;
msg.command = 0x80;
msg.token = token;
msg.data.append('\0');
// The acknowledgement must not be queued!
//queueMessage(msg);
trkWrite(msg);
// 01 90 00 07 7e 80 01 00 7d 5e 7e
}
void Adapter::queueTrkMessage(const TrkMessage &msg)
{
m_trkWriteQueue.append(msg);
}
void Adapter::tryTrkWrite()
{
if (m_trkWriteBusy)
return;
if (m_trkWriteQueue.isEmpty())
return;
trkWrite(m_trkWriteQueue.dequeue());
}
void Adapter::trkWrite(const TrkMessage &msg)
{
QByteArray ba = frameMessage(msg.command, msg.token, msg.data);
m_writtenTrkMessages.insert(msg.token, msg);
m_trkWriteBusy = true;
#if USE_NATIVE
DWORD charsWritten;
if (!WriteFile(m_hdevice, ba.data(), ba.size(), &charsWritten, NULL))
logMessage("WRITE ERROR: ");
logMessage("WRITE: " + stringFromArray(ba));
FlushFileBuffers(m_hdevice);
#else
logMessage("WRITE: " + stringFromArray(ba));
if (!m_trkDevice->write(ba))
logMessage("WRITE ERROR: " + m_trkDevice->errorString());
m_trkDevice->flush();
#endif
}
void Adapter::tryTrkRead()
{
//logMessage("TRY READ: " << m_trkDevice->bytesAvailable()
// << stringFromArray(m_trkReadQueue);
#if USE_NATIVE
const int BUFFERSIZE = 1024;
char buffer[BUFFERSIZE];
DWORD charsRead;
while (ReadFile(m_hdevice, buffer, BUFFERSIZE, &charsRead, NULL)
&& BUFFERSIZE == charsRead) {
m_trkReadQueue.append(buffer, charsRead);
}
m_trkReadQueue.append(buffer, charsRead);
#else // USE_NATIVE
if (m_trkDevice->bytesAvailable() == 0 && m_trkReadQueue.isEmpty())
return;
QByteArray res = m_trkDevice->readAll();
m_trkReadQueue.append(res);
#endif // USE_NATIVE
if (m_trkReadQueue.size() < 9) {
logMessage("ERROR READBUFFER INVALID (1): "
+ stringFromArray(m_trkReadQueue));
m_trkReadQueue.clear();
return;
}
while (!m_trkReadQueue.isEmpty())
handleTrkResult(extractResult(&m_trkReadQueue));
m_trkWriteBusy = false;
}
void Adapter::handleTrkResult(const TrkResult &result)
{
QByteArray prefix = "READ BUF: ";
QByteArray str = result.toString().toUtf8();
switch (result.code) {
case 0x80: { // ACK
logMessage(prefix + "ACK: " + str);
if (!result.data.isEmpty() && result.data.at(0))
logMessage(prefix + "ERR: " +QByteArray::number(result.data.at(0)));
//logMessage("READ RESULT FOR TOKEN: " << token);
if (!m_writtenTrkMessages.contains(result.token)) {
logMessage("NO ENTRY FOUND!");
}
TrkMessage msg = m_writtenTrkMessages.take(result.token);
TrkCallBack cb = msg.callBack;
if (cb) {
//logMessage("HANDLE: " << stringFromArray(result.data));
(this->*cb)(result);
}
break;
}
case 0xff: { // NAK
logMessage(prefix + "NAK: " + str);
//logMessage(prefix << "TOKEN: " << result.token);
logMessage(prefix + "ERROR: " + errorMessage(result.data.at(0)));
break;
}
case 0x90: { // Notified Stopped
logMessage(prefix + "NOTE: STOPPED" + str);
// 90 01 78 6a 40 40 00 00 07 23 00 00 07 24 00 00
//const char *data = result.data.data();
// uint addr = extractInt(data); //code address: 4 bytes; code base address for the library
// uint pid = extractInt(data + 4); // ProcessID: 4 bytes;
// uint tid = extractInt(data + 8); // ThreadID: 4 bytes
//logMessage(prefix << " ADDR: " << addr << " PID: " << pid << " TID: " << tid);
sendTrkAck(result.token);
//Sleep(10000);
//cleanUp();
break;
}
case 0x91: { // Notify Exception (obsolete)
logMessage(prefix + "NOTE: EXCEPTION" + str);
sendTrkAck(result.token);
break;
}
case 0x92: { //
logMessage(prefix + "NOTE: INTERNAL ERROR: " + str);
sendTrkAck(result.token);
break;
}
// target->host OS notification
case 0xa0: { // Notify Created
/*
const char *data = result.data.data();
byte error = result.data.at(0);
byte type = result.data.at(1); // type: 1 byte; for dll item, this value is 2.
uint pid = extractInt(data + 2); // ProcessID: 4 bytes;
uint tid = extractInt(data + 6); //threadID: 4 bytes
uint codeseg = extractInt(data + 10); //code address: 4 bytes; code base address for the library
uint dataseg = extractInt(data + 14); //data address: 4 bytes; data base address for the library
uint len = extractShort(data + 18); //length: 2 bytes; length of the library name string to follow
QByteArray name = result.data.mid(20, len); // name: library name
logMessage(prefix + "NOTE: LIBRARY LOAD: " + str);
logMessage(prefix + "TOKEN: " + result.token);
logMessage(prefix + "ERROR: " + int(error));
logMessage(prefix + "TYPE: " + int(type));
logMessage(prefix + "PID: " + pid);
logMessage(prefix + "TID: " + tid);
logMessage(prefix + "CODE: " + codeseg);
logMessage(prefix + "DATA: " + dataseg);
logMessage(prefix + "LEN: " + len);
logMessage(prefix + "NAME: " + name);
*/
sendTrkMessage(0x18, CB(handleTrkContinue),
formatInt(m_session.pid) + formatInt(m_session.tid));
//sendTrkAck(result.token)
break;
}
case 0xa1: { // NotifyDeleted
logMessage(prefix + "NOTE: LIBRARY UNLOAD: " + str);
sendTrkAck(result.token);
break;
}
case 0xa2: { // NotifyProcessorStarted
logMessage(prefix + "NOTE: PROCESSOR STARTED: " + str);
sendTrkAck(result.token);
break;
}
case 0xa6: { // NotifyProcessorStandby
logMessage(prefix + "NOTE: PROCESSOR STANDBY: " + str);
sendTrkAck(result.token);
break;
}
case 0xa7: { // NotifyProcessorReset
logMessage(prefix + "NOTE: PROCESSOR RESET: " + str);
sendTrkAck(result.token);
break;
}
default: {
logMessage(prefix + "INVALID: " + str);
break;
}
}
}
void Adapter::handleTrkCpuType(const TrkResult &result)
{
logMessage("HANDLE CPU TYPE: " + result.toString());
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 03 00 04 00 00 04 00 00 00]
m_session.cpuMajor = result.data[0];
m_session.cpuMinor = result.data[1];
m_session.bigEndian = result.data[2];
m_session.defaultTypeSize = result.data[3];
m_session.fpTypeSize = result.data[4];
m_session.extended1TypeSize = result.data[5];
//m_session.extended2TypeSize = result.data[6];
}
void Adapter::handleTrkCreateProcess(const TrkResult &result)
{
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 08 00 00 00 01 B5 00 00 01 B6 78 67 40 00 00
// 40 00 00]
logMessage(" RESULT: " + result.toString());
const char *data = result.data.data();
m_session.pid = extractInt(data);
m_session.tid = extractInt(data + 4);
m_session.codeseg = extractInt(data + 8);
m_session.dataseg = extractInt(data + 12);
/*
logMessage("PID: " + formatInt(m_session.pid) + m_session.pid);
logMessage("TID: " + formatInt(m_session.tid) + m_session.tid);
logMessage("COD: " + formatInt(m_session.codeseg) + m_session.codeseg);
logMessage("DAT: " + formatInt(m_session.dataseg) + m_session.dataseg);
*/
//setTrkBreakpoint(0x0000, ArmMode);
//clearTrkBreakpoint(0x0000);
#if 1
foreach (const Breakpoint &bp, m_breakpoints)
setTrkBreakpoint(bp);
#endif
#if 1
//---IDE------------------------------------------------------
// Command: 0x42 Read Info
// [42 0C 00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F
// 72 70 68 69 63 44 4C 4C 32 2E 64 6C 6C 00]
sendTrkMessage(0x42, CB(handleTrkReadInfo),
"00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F "
"72 70 68 69 63 44 4C 4C 32 2E 64 6C 6C 00");
//sendTrkMessage(0x42, CB(handleTrkReadInfo),
// "00 01 00 00 00 00");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x20 Unspecified general OS-related error
// [80 0C 20]
//---IDE------------------------------------------------------
// Command: 0x42 Read Info
// [42 0D 00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F
// 72 70 68 69 63 44 4C 4C 31 2E 64 6C 6C 00]
sendTrkMessage(0x42, CB(handleTrkReadInfo),
"00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F "
"72 70 68 69 63 44 4C 4C 31 2E 64 6C 6C 00");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x20 Unspecified general OS-related error
// [80 0D 20]
#endif
//sendTrkMessage(0x18, CB(handleTrkStop),
// "01 " + formatInt(m_session.pid) + formatInt(m_session.tid));
//---IDE------------------------------------------------------
// Command: 0x18 Continue
//ProcessID: 0x000001B5 (437)
// ThreadID: 0x000001B6 (438)
// [18 0E 00 00 01 B5 00 00 01 B6]
sendTrkMessage(0x18, CB(handleTrkContinue),
formatInt(m_session.pid) + formatInt(m_session.tid));
//sendTrkMessage(0x18, CB(handleTrkContinue),
// formatInt(m_session.pid) + "ff ff ff ff");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 0E 00]
}
void Adapter::setTrkBreakpoint(const Breakpoint &bp)
{
//---IDE------------------------------------------------------
// Command: 0x1B Set Break
//BreakType: 0x82
// Options: 0x00
// Address: 0x78674340 (2020033344) i.e + 0x00000340
// Length: 0x00000001 (1)
// Count: 0x00000000 (0)
//ProcessID: 0x000001b5 (437)
// ThreadID: 0xffffffff (-1)
// [1B 09 82 00 78 67 43 40 00 00 00 01 00 00 00 00
// 00 00 01 B5 FF FF FF FF]
sendTrkMessage(0x1B, CB(handleTrkSetBreakpoint),
"82 "
+ QByteArray(bp.mode == ArmMode ? "00 " : "01 ")
+ formatInt(m_session.codeseg + bp.offset)
+ "00 00 00 01 00 00 00 00 " + formatInt(m_session.pid)
+ "FF FF FF FF");
//m_session.toekn
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
}
void Adapter::handleTrkSetBreakpoint(const TrkResult &result)
{
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
uint bpnr = extractInt(result.data.data());
logMessage("SET BREAKPOINT " + bpnr
+ stringFromArray(result.data.data()));
}
void Adapter::clearTrkBreakpoint(const Breakpoint &bp)
{
sendTrkMessage(0x1C, CB(handleTrkClearBreakpoint),
//formatInt(m_session.codeseg + bp.offset));
"00 " + formatShort(bp.number)
+ formatInt(m_session.codeseg + bp.offset));
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 25 00 00 00 0A 78 6A 43 40]
}
void Adapter::handleTrkClearBreakpoint(const TrkResult &result)
{
Q_UNUSED(result);
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
logMessage("CLEAR BREAKPOINT ");
}
void Adapter::handleTrkContinue(const TrkResult &result)
{
logMessage(" HANDLE CONTINUE: " + stringFromArray(result.data));
//if (result.result.token)
//logMessage(" ERROR: " + byte(result.result.token)
// sendTrkMessage(0x18, CB(handleTrkContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void Adapter::handleTrkDisconnect(const TrkResult &result)
{
logMessage(" HANDLE DISCONNECT: " + stringFromArray(result.data));
//if (result.result.token)
//logMessage(" ERROR: " + byte(result.result.token)
// sendTrkMessage(0x18, CB(handleTrkContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void Adapter::handleTrkDeleteProcess(const TrkResult &result)
{
logMessage(" HANDLE DELETE PROCESS: " + stringFromArray(result.data));
//if (result.result.token)
//logMessage(" ERROR: " + byte(result.token)
// sendTrkMessage(0x18, CB(handleTrkContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void Adapter::handleTrkStep(const TrkResult &result)
{
logMessage(" HANDLE STEP: " + stringFromArray(result.data));
}
void Adapter::handleTrkStop(const TrkResult &result)
{
logMessage(" HANDLE STOP: " + stringFromArray(result.data));
}
void Adapter::handleTrkReadInfo(const TrkResult &result)
{
logMessage(" HANDLE READ INFO: " + stringFromArray(result.data));
}
void Adapter::handleTrkWaitForFinished(const TrkResult &result)
{
logMessage(" FINISHED: " + stringFromArray(result.data));
//qApp->exit(1);
}
void Adapter::handleTrkSupportMask(const TrkResult &result)
{
const char *data = result.data.data();
QByteArray str;
for (int i = 0; i < 32; ++i) {
//str.append(" [" + formatByte(data[i]) + "]: ");
for (int j = 0; j < 8; ++j)
if (data[i] & (1 << j))
str.append(formatByte(i * 8 + j));
}
logMessage("SUPPORTED: " + str);
}
void Adapter::cleanUp()
{
//
//---IDE------------------------------------------------------
// Command: 0x41 Delete Item
// Sub Cmd: Delete Process
//ProcessID: 0x0000071F (1823)
// [41 24 00 00 00 00 07 1F]
sendTrkMessage(0x41, CB(handleTrkDeleteProcess),
"00 00 " + formatInt(m_session.pid));
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 24 00]
foreach (const Breakpoint &bp, m_breakpoints)
clearTrkBreakpoint(bp);
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 25 00 00 00 0A 78 6A 43 40]
//---TRK------------------------------------------------------
// Command: 0xA1 Notify Deleted
// [A1 09 00 00 00 00 00 00 00 00 07 1F]
//---IDE------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00]
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 25 00]
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 26 00 00 00 0B 78 6A 43 70]
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 26 00]
//---IDE------------------------------------------------------
// Command: 0x02 Disconnect
// [02 27]
sendTrkMessage(0x02, CB(handleTrkDisconnect));
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
}
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
if (argc < 3) { if (argc < 3) {

8
tests/manual/trk/trkserver.cpp
View File

@@ -177,14 +177,18 @@ void TrkServer::writeToAdapter(byte command, byte token, const QByteArray &data)
void TrkServer::handleAdapterMessage(const TrkResult &result) void TrkServer::handleAdapterMessage(const TrkResult &result)
{ {
QByteArray data; QByteArray data;
data.append(char(0x00)); // No error
switch (result.code) { switch (result.code) {
case 0x00: { // Ping case 0x00: { // Ping
data.append(char(0x00)); // No error
writeToAdapter(0x80, 0x00, data); writeToAdapter(0x80, 0x00, data);
break; break;
} }
case 0x01: { // Connect
writeToAdapter(0x80, result.token, data);
break;
}
default: default:
data.append(char(0x10)); // Command not supported data[0] = 0x10; // Command not supported
writeToAdapter(0xff, result.token, data); writeToAdapter(0xff, result.token, data);
break; break;
} }

604
tests/manual/trk/trkutils.cpp
View File

@@ -192,8 +192,6 @@ QByteArray encode7d(const QByteArray &ba)
return res; return res;
} }
#define CB(s) &TrkClient::s
// FIXME: Use the QByteArray based version below? // FIXME: Use the QByteArray based version below?
QString stringFromByte(byte c) QString stringFromByte(byte c)
{ {
@@ -278,608 +276,6 @@ QByteArray errorMessage(byte code)
return "Unknown error"; return "Unknown error";
} }
TrkClient::TrkClient()
{
#if USE_NATIVE
m_hdevice = NULL;
#else
m_device = 0;
#endif
m_writeToken = 0;
m_readToken = 0;
m_writeBusy = false;
//m_breakpoints.append(Breakpoint(0x0370));
//m_breakpoints.append(Breakpoint(0x0340));
//m_breakpoints.append(Breakpoint(0x0040)); // E32Main
startTimer(100);
}
TrkClient::~TrkClient()
{
#if USE_NATIVE
CloseHandle(m_hdevice);
#else
delete m_device;
#endif
}
bool TrkClient::openPort(const QString &port)
{
// QFile does not work with "COM3", so work around
/*
FILE *f = fopen("COM3", "r+");
if (!f) {
logMessage("Could not open file ");
return;
}
m_device = new QFile;
if (!m_device->open(f, QIODevice::ReadWrite))
*/
#if 0
m_device = new Win_QextSerialPort(port);
m_device->setBaudRate(BAUD115200);
m_device->setDataBits(DATA_8);
m_device->setParity(PAR_NONE);
//m_device->setStopBits(STO);
m_device->setFlowControl(FLOW_OFF);
m_device->setTimeout(0, 500);
if (!m_device->open(QIODevice::ReadWrite)) {
QByteArray ba = m_device->errorString().toLatin1();
logMessage("Could not open device " << ba);
return;
}
#else
m_device = new QLocalSocket(this);
m_device->connectToServer(port);
return m_device->waitForConnected();
#endif
}
void TrkClient::timerEvent(QTimerEvent *)
{
//qDebug(".");
tryWrite();
tryRead();
}
unsigned char TrkClient::nextWriteToken()
{
++m_writeToken;
if (m_writeToken == 0)
++m_writeToken;
return m_writeToken;
}
void TrkClient::sendMessage(byte command,
CallBack callBack, const QByteArray &lit)
{
Message msg;
msg.command = command;
msg.token = nextWriteToken();
msg.callBack = callBack;
QList<QByteArray> list = lit.split(' ');
foreach (const QByteArray &item, list) {
if (item.isEmpty())
continue;
bool ok = false;
int i = item.toInt(&ok, 16);
msg.data.append(char(i));
}
//logMessage("PARSED: " << lit << " -> " << stringFromArray(data).toLatin1().data());
queueMessage(msg);
}
void TrkClient::sendInitialPing()
{
Message msg;
msg.command = 0x00; // Ping
msg.token = 0; // reset sequence count
queueMessage(msg);
}
void TrkClient::waitForFinished()
{
Message msg;
// initiate one last roundtrip to ensure all is flushed
msg.command = 0x00; // Ping
msg.token = nextWriteToken();
msg.callBack = CB(handleWaitForFinished);
queueMessage(msg);
}
void TrkClient::sendAck(byte token)
{
logMessage(QString("SENDING ACKNOWLEDGEMENT FOR TOKEN ").arg(int(token)));
Message msg;
msg.command = 0x80;
msg.token = token;
msg.data.append('\0');
// The acknowledgement must not be queued!
//queueMessage(msg);
doWrite(msg);
// 01 90 00 07 7e 80 01 00 7d 5e 7e
}
void TrkClient::queueMessage(const Message &msg)
{
m_writeQueue.append(msg);
}
void TrkClient::tryWrite()
{
if (m_writeBusy)
return;
if (m_writeQueue.isEmpty())
return;
doWrite(m_writeQueue.dequeue());
}
void TrkClient::doWrite(const Message &msg)
{
QByteArray ba = frameMessage(msg.command, msg.token, msg.data);
m_written.insert(msg.token, msg);
m_writeBusy = true;
#if USE_NATIVE
DWORD charsWritten;
if (!WriteFile( m_hdevice,
ba.data(),
ba.size(),
&charsWritten,
NULL)){
logMessage("WRITE ERROR: ");
}
logMessage("WRITE: " << qPrintable(stringFromArray(ba)));
FlushFileBuffers(m_hdevice);
#else
logMessage("WRITE: " << qPrintable(stringFromArray(ba)));
if (!m_device->write(ba))
logMessage("WRITE ERROR: " << m_device->errorString());
m_device->flush();
#endif
}
void TrkClient::tryRead()
{
//logMessage("TRY READ: " << m_device->bytesAvailable()
// << stringFromArray(m_readQueue);
#if USE_NATIVE
const int BUFFERSIZE = 1024;
char buffer[BUFFERSIZE];
DWORD charsRead;
while (ReadFile(m_hdevice, buffer, BUFFERSIZE, &charsRead, NULL)
&& BUFFERSIZE == charsRead) {
m_readQueue.append(buffer, charsRead);
}
m_readQueue.append(buffer, charsRead);
#else // USE_NATIVE
if (m_device->bytesAvailable() == 0 && m_readQueue.isEmpty())
return;
QByteArray res = m_device->readAll();
m_readQueue.append(res);
#endif // USE_NATIVE
if (m_readQueue.size() < 9) {
logMessage("ERROR READBUFFER INVALID (1): "
<< stringFromArray(m_readQueue));
m_readQueue.clear();
return;
}
while (!m_readQueue.isEmpty())
handleResult(extractResult(&m_readQueue));
m_writeBusy = false;
}
void TrkClient::handleResult(const TrkResult &result)
{
const char *prefix = "READ BUF: ";
QByteArray str = result.toString().toUtf8();
switch (result.code) {
case 0x80: { // ACK
logMessage(prefix << "ACK: " << str.data());
if (!result.data.isEmpty() && result.data.at(0))
logMessage(prefix << "ERR: " << QByteArray::number(result.data.at(0)));
//logMessage("READ RESULT FOR TOKEN: " << token);
if (!m_written.contains(result.token)) {
logMessage("NO ENTRY FOUND!");
}
Message msg = m_written.take(result.token);
CallBack cb = msg.callBack;
if (cb) {
//logMessage("HANDLE: " << stringFromArray(result.data));
(this->*cb)(result);
}
break;
}
case 0xff: { // NAK
logMessage(prefix << "NAK: " << str.data());
//logMessage(prefix << "TOKEN: " << result.token);
logMessage(prefix << "ERROR: " << errorMessage(result.data.at(0)));
break;
}
case 0x90: { // Notified Stopped
logMessage(prefix << "NOTE: STOPPED" << str.data());
// 90 01 78 6a 40 40 00 00 07 23 00 00 07 24 00 00
const char *data = result.data.data();
uint addr = extractInt(data); //code address: 4 bytes; code base address for the library
uint pid = extractInt(data + 4); // ProcessID: 4 bytes;
uint tid = extractInt(data + 8); // ThreadID: 4 bytes
logMessage(prefix << " ADDR: " << addr << " PID: " << pid << " TID: " << tid);
sendAck(result.token);
//Sleep(10000);
//cleanUp();
break;
}
case 0x91: { // Notify Exception (obsolete)
logMessage(prefix << "NOTE: EXCEPTION" << str.data());
sendAck(result.token);
break;
}
case 0x92: { //
logMessage(prefix << "NOTE: INTERNAL ERROR: " << str.data());
sendAck(result.token);
break;
}
// target->host OS notification
case 0xa0: { // Notify Created
const char *data = result.data.data();
byte error = result.data.at(0);
byte type = result.data.at(1); // type: 1 byte; for dll item, this value is 2.
uint pid = extractInt(data + 2); // ProcessID: 4 bytes;
uint tid = extractInt(data + 6); //threadID: 4 bytes
uint codeseg = extractInt(data + 10); //code address: 4 bytes; code base address for the library
uint dataseg = extractInt(data + 14); //data address: 4 bytes; data base address for the library
uint len = extractShort(data + 18); //length: 2 bytes; length of the library name string to follow
QByteArray name = result.data.mid(20, len); // name: library name
logMessage(prefix << "NOTE: LIBRARY LOAD: " << str.data());
logMessage(prefix << "TOKEN: " << result.token);
logMessage(prefix << "ERROR: " << int(error));
logMessage(prefix << "TYPE: " << int(type));
logMessage(prefix << "PID: " << pid);
logMessage(prefix << "TID: " << tid);
logMessage(prefix << "CODE: " << codeseg);
logMessage(prefix << "DATA: " << dataseg);
logMessage(prefix << "LEN: " << len);
logMessage(prefix << "NAME: " << name);
sendMessage(0x18, CB(handleContinue),
formatInt(m_session.pid) + formatInt(m_session.tid));
//sendAck(result.token)
break;
}
case 0xa1: { // NotifyDeleted
logMessage(prefix << "NOTE: LIBRARY UNLOAD: " << str.data());
sendAck(result.token);
break;
}
case 0xa2: { // NotifyProcessorStarted
logMessage(prefix << "NOTE: PROCESSOR STARTED: " << str.data());
sendAck(result.token);
break;
}
case 0xa6: { // NotifyProcessorStandby
logMessage(prefix << "NOTE: PROCESSOR STANDBY: " << str.data());
sendAck(result.token);
break;
}
case 0xa7: { // NotifyProcessorReset
logMessage(prefix << "NOTE: PROCESSOR RESET: " << str.data());
sendAck(result.token);
break;
}
default: {
logMessage(prefix << "INVALID: " << str << result.data.size());
break;
}
}
}
void TrkClient::handleCpuType(const TrkResult &result)
{
logMessage("HANDLE CPU TYPE: " << result.toString());
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 03 00 04 00 00 04 00 00 00]
m_session.cpuMajor = result.data[0];
m_session.cpuMinor = result.data[1];
m_session.bigEndian = result.data[2];
m_session.defaultTypeSize = result.data[3];
m_session.fpTypeSize = result.data[4];
m_session.extended1TypeSize = result.data[5];
//m_session.extended2TypeSize = result.data[6];
}
void TrkClient::handleCreateProcess(const TrkResult &result)
{
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 08 00 00 00 01 B5 00 00 01 B6 78 67 40 00 00
// 40 00 00]
logMessage(" RESULT: " << qPrintable(result.toString()));
const char *data = result.data.data();
m_session.pid = extractInt(data);
m_session.tid = extractInt(data + 4);
m_session.codeseg = extractInt(data + 8);
m_session.dataseg = extractInt(data + 12);
logMessage("PID: " << formatInt(m_session.pid) << m_session.pid);
logMessage("TID: " << formatInt(m_session.tid) << m_session.tid);
logMessage("COD: " << formatInt(m_session.codeseg) << m_session.codeseg);
logMessage("DAT: " << formatInt(m_session.dataseg) << m_session.dataseg);
//setBreakpoint(0x0000, ArmMode);
//clearBreakpoint(0x0000);
#if 1
foreach (const Breakpoint &bp, m_breakpoints)
setBreakpoint(bp);
#endif
#if 1
//---IDE------------------------------------------------------
// Command: 0x42 Read Info
// [42 0C 00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F
// 72 70 68 69 63 44 4C 4C 32 2E 64 6C 6C 00]
sendMessage(0x42, CB(handleReadInfo),
"00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F "
"72 70 68 69 63 44 4C 4C 32 2E 64 6C 6C 00");
//sendMessage(0x42, CB(handleReadInfo),
// "00 01 00 00 00 00");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x20 Unspecified general OS-related error
// [80 0C 20]
//---IDE------------------------------------------------------
// Command: 0x42 Read Info
// [42 0D 00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F
// 72 70 68 69 63 44 4C 4C 31 2E 64 6C 6C 00]
sendMessage(0x42, CB(handleReadInfo),
"00 06 00 00 00 00 00 14 50 6F 6C 79 6D 6F "
"72 70 68 69 63 44 4C 4C 31 2E 64 6C 6C 00");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x20 Unspecified general OS-related error
// [80 0D 20]
#endif
//sendMessage(0x18, CB(handleStop),
// "01 " + formatInt(m_session.pid) + formatInt(m_session.tid));
//---IDE------------------------------------------------------
// Command: 0x18 Continue
//ProcessID: 0x000001B5 (437)
// ThreadID: 0x000001B6 (438)
// [18 0E 00 00 01 B5 00 00 01 B6]
sendMessage(0x18, CB(handleContinue),
formatInt(m_session.pid) + formatInt(m_session.tid));
//sendMessage(0x18, CB(handleContinue),
// formatInt(m_session.pid) + "ff ff ff ff");
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 0E 00]
}
void TrkClient::setBreakpoint(const Breakpoint &bp)
{
//---IDE------------------------------------------------------
// Command: 0x1B Set Break
//BreakType: 0x82
// Options: 0x00
// Address: 0x78674340 (2020033344) i.e + 0x00000340
// Length: 0x00000001 (1)
// Count: 0x00000000 (0)
//ProcessID: 0x000001b5 (437)
// ThreadID: 0xffffffff (-1)
// [1B 09 82 00 78 67 43 40 00 00 00 01 00 00 00 00
// 00 00 01 B5 FF FF FF FF]
sendMessage(0x1B, CB(handleSetBreakpoint),
"82 "
+ QByteArray(bp.mode == ArmMode ? "00 " : "01 ")
+ formatInt(m_session.codeseg + bp.offset)
+ "00 00 00 01 00 00 00 00 " + formatInt(m_session.pid)
+ "FF FF FF FF");
//m_session.toekn
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
}
void TrkClient::handleSetBreakpoint(const TrkResult &result)
{
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
uint bpnr = extractInt(result.data.data());
logMessage("SET BREAKPOINT " << bpnr
<< stringFromArray(result.data.data()));
}
void TrkClient::clearBreakpoint(const Breakpoint &bp)
{
sendMessage(0x1C, CB(handleClearBreakpoint),
//formatInt(m_session.codeseg + bp.offset));
"00 " + formatShort(bp.number)
+ formatInt(m_session.codeseg + bp.offset));
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 25 00 00 00 0A 78 6A 43 40]
}
void TrkClient::handleClearBreakpoint(const TrkResult &result)
{
Q_UNUSED(result);
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00 00 00 00 0A]
logMessage("CLEAR BREAKPOINT ");
}
void TrkClient::handleContinue(const TrkResult &result)
{
logMessage(" HANDLE CONTINUE: " << qPrintable(stringFromArray(result.data)));
//if (result.result.token)
//logMessage(" ERROR: " << byte(result.result.token)
// sendMessage(0x18, CB(handleContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void TrkClient::handleDisconnect(const TrkResult &result)
{
logMessage(" HANDLE DISCONNECT: "
<< qPrintable(stringFromArray(result.data)));
//if (result.result.token)
//logMessage(" ERROR: " << byte(result.result.token)
// sendMessage(0x18, CB(handleContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void TrkClient::handleDeleteProcess(const TrkResult &result)
{
logMessage(" HANDLE DELETE PROCESS: " <<
qPrintable(stringFromArray(result.data)));
//if (result.result.token)
//logMessage(" ERROR: " << byte(result.token)
// sendMessage(0x18, CB(handleContinue),
// formatInt(m_session.pid) + formatInt(m_session.tid));
//}
}
void TrkClient::handleStep(const TrkResult &result)
{
logMessage(" HANDLE STEP: " <<
qPrintable(stringFromArray(result.data)));
}
void TrkClient::handleStop(const TrkResult &result)
{
logMessage(" HANDLE STOP: " <<
qPrintable(stringFromArray(result.data)));
}
void TrkClient::handleReadInfo(const TrkResult &result)
{
logMessage(" HANDLE READ INFO: " <<
qPrintable(stringFromArray(result.data)));
}
void TrkClient::handleWaitForFinished(const TrkResult &result)
{
logMessage(" FINISHED: " << qPrintable(stringFromArray(result.data)));
//qApp->exit(1);
}
void TrkClient::handleSupportMask(const TrkResult &result)
{
const char *data = result.data.data();
QByteArray str;
for (int i = 0; i < 32; ++i) {
//str.append(" [" + formatByte(data[i]) + "]: ");
for (int j = 0; j < 8; ++j)
if (data[i] & (1 << j))
str.append(formatByte(i * 8 + j));
}
logMessage("SUPPORTED: " << str);
}
void TrkClient::cleanUp()
{
//
//---IDE------------------------------------------------------
// Command: 0x41 Delete Item
// Sub Cmd: Delete Process
//ProcessID: 0x0000071F (1823)
// [41 24 00 00 00 00 07 1F]
sendMessage(0x41, CB(handleDeleteProcess),
"00 00 " + formatInt(m_session.pid));
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 24 00]
foreach (const Breakpoint &bp, m_breakpoints)
clearBreakpoint(bp);
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 25 00 00 00 0A 78 6A 43 40]
//---TRK------------------------------------------------------
// Command: 0xA1 Notify Deleted
// [A1 09 00 00 00 00 00 00 00 00 07 1F]
//---IDE------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 09 00]
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 25 00]
//---IDE------------------------------------------------------
// Command: 0x1C Clear Break
// [1C 26 00 00 00 0B 78 6A 43 70]
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
// [80 26 00]
//---IDE------------------------------------------------------
// Command: 0x02 Disconnect
// [02 27]
sendMessage(0x02, CB(handleDisconnect));
//---TRK------------------------------------------------------
// Command: 0x80 Acknowledge
// Error: 0x00
}
void TrkClient::onStopped(const TrkResult &result)
{
Q_UNUSED(result);
}
} // namespace trk } // namespace trk

87
tests/manual/trk/trkutils.h
View File

@@ -32,12 +32,8 @@
#include <QtCore/QByteArray> #include <QtCore/QByteArray>
#include <QtCore/QHash> #include <QtCore/QHash>
#include <QtCore/QObject>
#include <QtCore/QQueue>
#include <QtCore/QString> #include <QtCore/QString>
#include <QtNetwork/QLocalSocket>
namespace trk { namespace trk {
typedef unsigned char byte; typedef unsigned char byte;
@@ -111,7 +107,7 @@ struct Breakpoint
struct TrkResult struct TrkResult
{ {
TrkResult() {} TrkResult() { code = token = 0; }
QString toString() const; QString toString() const;
byte code; byte code;
@@ -119,89 +115,10 @@ struct TrkResult
QByteArray data; QByteArray data;
}; };
class TrkClient : public QObject
{
Q_OBJECT
public:
TrkClient();
~TrkClient();
struct Message;
typedef void (TrkClient::*CallBack)(const TrkResult &);
public slots:
void abort() { m_device->abort(); }
bool openPort(const QString &port); // or server name for local server
void sendMessage(byte command, CallBack callBack = 0,
const QByteArray &lit = QByteArray());
// adds message to 'send' queue
void queueMessage(const Message &msg);
void tryWrite();
void tryRead();
// actually writes a message to the device
void doWrite(const Message &msg);
// convienience messages
void sendInitialPing();
void waitForFinished();
void sendAck(byte token);
// kill process and breakpoints
void cleanUp();
public:
struct Message
{
Message() { token = 0; callBack = 0; }
byte command;
byte token;
QByteArray data;
CallBack callBack;
};
private:
void timerEvent(QTimerEvent *ev);
byte nextWriteToken();
void handleCpuType(const TrkResult &result);
void handleCreateProcess(const TrkResult &result);
void handleDeleteProcess(const TrkResult &result);
void handleSetBreakpoint(const TrkResult &result);
void handleClearBreakpoint(const TrkResult &result);
void handleContinue(const TrkResult &result);
void handleReadInfo(const TrkResult &result);
void handleWaitForFinished(const TrkResult &result);
void handleStep(const TrkResult &result);
void handleStop(const TrkResult &result);
void handleReadRegisters(const TrkResult &result);
void handleWriteRegisters(const TrkResult &result);
void handleReadMemory(const TrkResult &result);
void handleWriteMemory(const TrkResult &result);
void handleSupportMask(const TrkResult &result);
void handleDisconnect(const TrkResult &result);
void setBreakpoint(const Breakpoint &bp);
void clearBreakpoint(const Breakpoint &bp);
void onStopped(const TrkResult &result);
void handleResult(const TrkResult &data);
QLocalSocket *m_device;
unsigned char m_writeToken;
QQueue<Message> m_writeQueue;
QHash<byte, Message> m_written;
unsigned char m_readToken;
QByteArray m_readQueue;
bool m_writeBusy;
QList<Breakpoint> m_breakpoints;
Session m_session;
};
// returns a QByteArray containing 0x01 0x90 <len> 0x7e encoded7d(ba) 0x7e // returns a QByteArray containing 0x01 0x90 <len> 0x7e encoded7d(ba) 0x7e
QByteArray frameMessage(byte command, byte token, const QByteArray &data); QByteArray frameMessage(byte command, byte token, const QByteArray &data);
TrkResult extractResult(QByteArray *buffer); TrkResult extractResult(QByteArray *buffer);
QByteArray errorMessage(byte code);
} // namespace trk } // namespace trk