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

Symbian: tcftrk renamed to Coda

Browse Source
This commit is contained in:
Pawel Polanski
2011-02-07 14:26:34 +01:00
parent 3212e1152c
commit 532a8ad2e7
17 changed files with 535 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
src/plugins/debugger/gdb/tcftrkgdbadapter.cpp → src/plugins/debugger/gdb/codagdbadapter.cpp
View File

@@ -31,10 +31,10 @@
** **
**************************************************************************/ **************************************************************************/
#include "tcftrkgdbadapter.h" #include "codagdbadapter.h"
#include "debuggerstartparameters.h" #include "debuggerstartparameters.h"
#include "tcftrkdevice.h" #include "codadevice.h"
#include "trkutils.h" #include "trkutils.h"
#include "gdbmi.h" #include "gdbmi.h"
#include "virtualserialdevice.h" #include "virtualserialdevice.h"
@@ -66,7 +66,7 @@
#endif #endif
#define CB(callback) \ #define CB(callback) \
static_cast<GdbEngine::AdapterCallback>(&TcfTrkGdbAdapter::callback), \ static_cast<GdbEngine::AdapterCallback>(&CodaGdbAdapter::callback), \
STRINGIFY(callback) STRINGIFY(callback)
enum { debug = 0 }; enum { debug = 0 };
@@ -88,17 +88,17 @@ namespace Debugger {
namespace Internal { namespace Internal {
using namespace Symbian; using namespace Symbian;
using namespace tcftrk; using namespace Coda;
static inline QString startMsg(const trk::Session &session) static inline QString startMsg(const trk::Session &session)
{ {
return TcfTrkGdbAdapter::tr("Process started, PID: 0x%1, thread id: 0x%2, " return CodaGdbAdapter::tr("Process started, PID: 0x%1, thread id: 0x%2, "
"code segment: 0x%3, data segment: 0x%4.") "code segment: 0x%3, data segment: 0x%4.")
.arg(session.pid, 0, 16).arg(session.tid, 0, 16) .arg(session.pid, 0, 16).arg(session.tid, 0, 16)
.arg(session.codeseg, 0, 16).arg(session.dataseg, 0, 16); .arg(session.codeseg, 0, 16).arg(session.dataseg, 0, 16);
} }
/* -------------- TcfTrkGdbAdapter: /* -------------- CodaGdbAdapter:
* Startup-sequence: * Startup-sequence:
* - startAdapter connects both sockets/devices * - startAdapter connects both sockets/devices
* - In the TCF Locator Event, gdb is started and the engine is notified * - In the TCF Locator Event, gdb is started and the engine is notified
@@ -119,11 +119,11 @@ static inline QString startMsg(const trk::Session &session)
* - Stop all threads once one stops? * - Stop all threads once one stops?
* - Breakpoints do not trigger in threads other than the main thread. */ * - Breakpoints do not trigger in threads other than the main thread. */
TcfTrkGdbAdapter::TcfTrkGdbAdapter(GdbEngine *engine) : CodaGdbAdapter::CodaGdbAdapter(GdbEngine *engine) :
AbstractGdbAdapter(engine), AbstractGdbAdapter(engine),
m_running(false), m_running(false),
m_stopReason(0), m_stopReason(0),
m_trkDevice(new TcfTrkDevice(this)), m_trkDevice(new CodaDevice(this)),
m_gdbAckMode(true), m_gdbAckMode(true),
m_uid(0), m_uid(0),
m_verbose(0), m_verbose(0),
@@ -149,38 +149,38 @@ TcfTrkGdbAdapter::TcfTrkGdbAdapter(GdbEngine *engine) :
connect(debuggerCore()->action(VerboseLog), SIGNAL(valueChanged(QVariant)), connect(debuggerCore()->action(VerboseLog), SIGNAL(valueChanged(QVariant)),
this, SLOT(setVerbose(QVariant))); this, SLOT(setVerbose(QVariant)));
connect(m_trkDevice, SIGNAL(error(QString)), connect(m_trkDevice, SIGNAL(error(QString)),
this, SLOT(tcftrkDeviceError(QString))); this, SLOT(codaDeviceError(QString)));
connect(m_trkDevice, SIGNAL(logMessage(QString)), connect(m_trkDevice, SIGNAL(logMessage(QString)),
this, SLOT(trkLogMessage(QString))); this, SLOT(trkLogMessage(QString)));
connect(m_trkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)), connect(m_trkDevice, SIGNAL(tcfEvent(Coda::CodaEvent)),
this, SLOT(tcftrkEvent(tcftrk::TcfTrkEvent))); this, SLOT(codaEvent(Coda::CodaEvent)));
} }
TcfTrkGdbAdapter::~TcfTrkGdbAdapter() CodaGdbAdapter::~CodaGdbAdapter()
{ {
cleanup(); cleanup();
logMessage("Shutting down.\n"); logMessage("Shutting down.\n");
} }
void TcfTrkGdbAdapter::setVerbose(const QVariant &value) void CodaGdbAdapter::setVerbose(const QVariant &value)
{ {
setVerbose(value.toInt()); setVerbose(value.toInt());
} }
void TcfTrkGdbAdapter::setVerbose(int verbose) void CodaGdbAdapter::setVerbose(int verbose)
{ {
if (debug) if (debug)
qDebug("TcfTrkGdbAdapter::setVerbose %d", verbose); qDebug("CodaGdbAdapter::setVerbose %d", verbose);
m_verbose = verbose; m_verbose = verbose;
m_trkDevice->setVerbose(m_verbose); m_trkDevice->setVerbose(m_verbose);
} }
void TcfTrkGdbAdapter::trkLogMessage(const QString &msg) void CodaGdbAdapter::trkLogMessage(const QString &msg)
{ {
logMessage(_("TRK ") + msg); logMessage(_("TRK ") + msg);
} }
void TcfTrkGdbAdapter::setGdbServerName(const QString &name) void CodaGdbAdapter::setGdbServerName(const QString &name)
{ {
m_gdbServerName = name; m_gdbServerName = name;
} }
@@ -201,7 +201,7 @@ static QPair<QString, unsigned short> splitIpAddressSpec(const QString &addressS
return QPair<QString, unsigned short>(address, port); return QPair<QString, unsigned short>(address, port);
} }
void TcfTrkGdbAdapter::handleTcfTrkRunControlModuleLoadContextSuspendedEvent(const TcfTrkRunControlModuleLoadContextSuspendedEvent &se) void CodaGdbAdapter::handleCodaRunControlModuleLoadContextSuspendedEvent(const CodaRunControlModuleLoadContextSuspendedEvent &se)
{ {
m_snapshot.resetMemory(); m_snapshot.resetMemory();
const ModuleLoadEventInfo &minfo = se.info(); const ModuleLoadEventInfo &minfo = se.info();
@@ -278,12 +278,12 @@ void TcfTrkGdbAdapter::handleTcfTrkRunControlModuleLoadContextSuspendedEvent(con
qDebug() << "Initial module load suspended: " << m_session.toString(); qDebug() << "Initial module load suspended: " << m_session.toString();
} else { } else {
// Consecutive module load suspended: (not observed yet): Just continue // Consecutive module load suspended: (not observed yet): Just continue
m_trkDevice->sendRunControlResumeCommand(TcfTrkCallback(), se.id()); m_trkDevice->sendRunControlResumeCommand(CodaCallback(), se.id());
} }
} }
} }
void TcfTrkGdbAdapter::handleTargetRemote(const GdbResponse &record) void CodaGdbAdapter::handleTargetRemote(const GdbResponse &record)
{ {
QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());
if (record.resultClass == GdbResultDone) { if (record.resultClass == GdbResultDone) {
@@ -297,29 +297,29 @@ void TcfTrkGdbAdapter::handleTargetRemote(const GdbResponse &record)
} }
} }
void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e) void CodaGdbAdapter::codaEvent(const CodaEvent &e)
{ {
if (debug) if (debug)
qDebug() << e.toString() << m_session.toString() << m_snapshot.toString(); qDebug() << e.toString() << m_session.toString() << m_snapshot.toString();
logMessage(e.toString()); logMessage(e.toString());
switch (e.type()) { switch (e.type()) {
case TcfTrkEvent::LocatorHello: case CodaEvent::LocatorHello:
m_trkDevice->sendLoggingAddListenerCommand(TcfTrkCallback()); m_trkDevice->sendLoggingAddListenerCommand(CodaCallback());
startGdb(); // Commands are only accepted after hello startGdb(); // Commands are only accepted after hello
break; break;
case TcfTrkEvent::RunControlModuleLoadSuspended: // A module was loaded case CodaEvent::RunControlModuleLoadSuspended: // A module was loaded
handleTcfTrkRunControlModuleLoadContextSuspendedEvent( handleCodaRunControlModuleLoadContextSuspendedEvent(
static_cast<const TcfTrkRunControlModuleLoadContextSuspendedEvent &>(e)); static_cast<const CodaRunControlModuleLoadContextSuspendedEvent &>(e));
break; break;
case TcfTrkEvent::RunControlContextAdded: // Thread/process added case CodaEvent::RunControlContextAdded: // Thread/process added
foreach(const RunControlContext &rc, static_cast<const TcfTrkRunControlContextAddedEvent &>(e).contexts()) foreach(const RunControlContext &rc, static_cast<const CodaRunControlContextAddedEvent &>(e).contexts())
if (rc.type() == RunControlContext::Thread) if (rc.type() == RunControlContext::Thread)
addThread(rc.threadId()); addThread(rc.threadId());
break; break;
case TcfTrkEvent::RunControlContextRemoved: // Thread/process removed case CodaEvent::RunControlContextRemoved: // Thread/process removed
foreach (const QByteArray &id, foreach (const QByteArray &id,
static_cast<const TcfTrkRunControlContextRemovedEvent &>(e).ids()) static_cast<const CodaRunControlContextRemovedEvent &>(e).ids())
switch (RunControlContext::typeFromTcfId(id)) { switch (RunControlContext::typeFromTcfId(id)) {
case RunControlContext::Thread: case RunControlContext::Thread:
m_snapshot.removeThread(RunControlContext::threadIdFromTcdfId(id)); m_snapshot.removeThread(RunControlContext::threadIdFromTcdfId(id));
@@ -329,10 +329,10 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
break; break;
} }
break; break;
case TcfTrkEvent::RunControlSuspended: { case CodaEvent::RunControlSuspended: {
// Thread suspended/stopped // Thread suspended/stopped
const TcfTrkRunControlContextSuspendedEvent &se = const CodaRunControlContextSuspendedEvent &se =
static_cast<const TcfTrkRunControlContextSuspendedEvent &>(e); static_cast<const CodaRunControlContextSuspendedEvent &>(e);
const unsigned threadId = RunControlContext::threadIdFromTcdfId(se.id()); const unsigned threadId = RunControlContext::threadIdFromTcdfId(se.id());
const QString reason = QString::fromUtf8(se.reasonID()); const QString reason = QString::fromUtf8(se.reasonID());
const QString message = QString::fromUtf8(se.message()).replace(QLatin1String("\n"), QLatin1String(", ")); const QString message = QString::fromUtf8(se.message()).replace(QLatin1String("\n"), QLatin1String(", "));
@@ -350,12 +350,12 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
|| reason.contains(QLatin1String("panic"), Qt::CaseInsensitive) ? || reason.contains(QLatin1String("panic"), Qt::CaseInsensitive) ?
gdbServerSignalSegfault : gdbServerSignalTrap; gdbServerSignalSegfault : gdbServerSignalTrap;
m_trkDevice->sendRegistersGetMRangeCommand( m_trkDevice->sendRegistersGetMRangeCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop), CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegistersAfterStop),
currentThreadContextId(), 0, currentThreadContextId(), 0,
Symbian::RegisterCount); Symbian::RegisterCount);
} }
break; break;
case tcftrk::TcfTrkEvent::LoggingWriteEvent: // TODO: Not tested yet. case Coda::CodaEvent::LoggingWriteEvent: // TODO: Not tested yet.
showMessage(e.toString(), AppOutput); showMessage(e.toString(), AppOutput);
break; break;
default: default:
@@ -363,7 +363,7 @@ void TcfTrkGdbAdapter::tcftrkEvent(const TcfTrkEvent &e)
} }
} }
void TcfTrkGdbAdapter::startGdb() void CodaGdbAdapter::startGdb()
{ {
QStringList gdbArgs; QStringList gdbArgs;
gdbArgs.append(QLatin1String("--nx")); // Do not read .gdbinit file gdbArgs.append(QLatin1String("--nx")); // Do not read .gdbinit file
@@ -374,7 +374,7 @@ void TcfTrkGdbAdapter::startGdb()
m_engine->handleAdapterStarted(); m_engine->handleAdapterStarted();
} }
void TcfTrkGdbAdapter::tcftrkDeviceError(const QString &errorString) void CodaGdbAdapter::codaDeviceError(const QString &errorString)
{ {
logMessage(errorString); logMessage(errorString);
if (state() == EngineSetupRequested) { if (state() == EngineSetupRequested) {
@@ -384,7 +384,7 @@ void TcfTrkGdbAdapter::tcftrkDeviceError(const QString &errorString)
} }
} }
void TcfTrkGdbAdapter::logMessage(const QString &msg, int channel) void CodaGdbAdapter::logMessage(const QString &msg, int channel)
{ {
if (m_verbose || channel != LogDebug) if (m_verbose || channel != LogDebug)
showMessage(msg, channel); showMessage(msg, channel);
@@ -395,7 +395,7 @@ void TcfTrkGdbAdapter::logMessage(const QString &msg, int channel)
// //
// Gdb // Gdb
// //
void TcfTrkGdbAdapter::handleGdbConnection() void CodaGdbAdapter::handleGdbConnection()
{ {
logMessage("HANDLING GDB CONNECTION"); logMessage("HANDLING GDB CONNECTION");
QTC_ASSERT(m_gdbConnection == 0, /**/); QTC_ASSERT(m_gdbConnection == 0, /**/);
@@ -412,7 +412,7 @@ static inline QString msgGdbPacket(const QString &p)
return QLatin1String("gdb: ") + p; return QLatin1String("gdb: ") + p;
} }
void TcfTrkGdbAdapter::readGdbServerCommand() void CodaGdbAdapter::readGdbServerCommand()
{ {
QTC_ASSERT(m_gdbConnection, return); QTC_ASSERT(m_gdbConnection, return);
QByteArray packet = m_gdbConnection->readAll(); QByteArray packet = m_gdbConnection->readAll();
@@ -482,7 +482,7 @@ void TcfTrkGdbAdapter::readGdbServerCommand()
} }
} }
bool TcfTrkGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlush) bool CodaGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlush)
{ {
if (!m_gdbConnection) { if (!m_gdbConnection) {
logMessage(_("Cannot write to gdb: No connection (%1)") logMessage(_("Cannot write to gdb: No connection (%1)")
@@ -504,7 +504,7 @@ bool TcfTrkGdbAdapter::sendGdbServerPacket(const QByteArray &packet, bool doFlus
return true; return true;
} }
void TcfTrkGdbAdapter::sendGdbServerAck() void CodaGdbAdapter::sendGdbServerAck()
{ {
if (!m_gdbAckMode) if (!m_gdbAckMode)
return; return;
@@ -512,7 +512,7 @@ void TcfTrkGdbAdapter::sendGdbServerAck()
sendGdbServerPacket(QByteArray(1, '+'), false); sendGdbServerPacket(QByteArray(1, '+'), false);
} }
void TcfTrkGdbAdapter::sendGdbServerMessage(const QByteArray &msg, const QByteArray &logNote) void CodaGdbAdapter::sendGdbServerMessage(const QByteArray &msg, const QByteArray &logNote)
{ {
trk::byte sum = 0; trk::byte sum = 0;
for (int i = 0; i != msg.size(); ++i) for (int i = 0; i != msg.size(); ++i)
@@ -545,7 +545,7 @@ static QByteArray msgStepRangeReceived(unsigned from, unsigned to, bool over)
return rc; return rc;
} }
void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd) void CodaGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
{ {
if (debug) if (debug)
qDebug("handleGdbServerCommand: %s", cmd.constData()); qDebug("handleGdbServerCommand: %s", cmd.constData());
@@ -689,7 +689,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
arg(addrLength.second).arg(addrLength.first, 0, 16). arg(addrLength.second).arg(addrLength.first, 0, 16).
arg(QString::fromAscii(data.toHex()))); arg(QString::fromAscii(data.toHex())));
m_trkDevice->sendMemorySetCommand( m_trkDevice->sendMemorySetCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleWriteMemory), CodaCallback(this, &CodaGdbAdapter::handleWriteMemory),
m_tcfProcessId, addrLength.first, data); m_tcfProcessId, addrLength.first, data);
} }
@@ -708,7 +708,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
} else { } else {
//qDebug() << "Fetching single register"; //qDebug() << "Fetching single register";
m_trkDevice->sendRegistersGetMRangeCommand( m_trkDevice->sendRegistersGetMRangeCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegister), CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegister),
currentThreadContextId(), registerNumber, 1); currentThreadContextId(), registerNumber, 1);
} }
} }
@@ -724,7 +724,7 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
QByteArray registerValue; QByteArray registerValue;
trk::appendInt(&registerValue, trk::BigEndian); // Registers are big endian trk::appendInt(&registerValue, trk::BigEndian); // Registers are big endian
m_trkDevice->sendRegistersSetCommand( m_trkDevice->sendRegistersSetCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleWriteRegister), CodaCallback(this, &CodaGdbAdapter::handleWriteRegister),
currentThreadContextId(), regnumValue.first, registerValue, currentThreadContextId(), regnumValue.first, registerValue,
QVariant(regnumValue.first)); QVariant(regnumValue.first));
// Note that App TRK refuses to write registers 13 and 14 // Note that App TRK refuses to write registers 13 and 14
@@ -894,13 +894,13 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
logMessage(_("Inserting breakpoint at 0x%1, %2") logMessage(_("Inserting breakpoint at 0x%1, %2")
.arg(addrLen.first, 0, 16).arg(addrLen.second)); .arg(addrLen.first, 0, 16).arg(addrLen.second));
// const QByteArray ba = trkBreakpointMessage(addr, len, len == 4); // const QByteArray ba = trkBreakpointMessage(addr, len, len == 4);
tcftrk::Breakpoint bp(addrLen.first); Coda::Breakpoint bp(addrLen.first);
bp.size = addrLen.second; bp.size = addrLen.second;
bp.setContextId(m_session.pid); bp.setContextId(m_session.pid);
// We use the automatic ids calculated from the location // We use the automatic ids calculated from the location
// address instead of the map in snapshot. // address instead of the map in snapshot.
m_trkDevice->sendBreakpointsAddCommand( m_trkDevice->sendBreakpointsAddCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportSetBreakpoint), CodaCallback(this, &CodaGdbAdapter::handleAndReportSetBreakpoint),
bp); bp);
} else { } else {
logMessage("MISPARSED BREAKPOINT '" + cmd + "'')" , LogError); logMessage("MISPARSED BREAKPOINT '" + cmd + "'')" , LogError);
@@ -915,8 +915,8 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
const int pos = cmd.lastIndexOf(','); const int pos = cmd.lastIndexOf(',');
const uint addr = cmd.mid(3, pos - 3).toUInt(0, 16); const uint addr = cmd.mid(3, pos - 3).toUInt(0, 16);
m_trkDevice->sendBreakpointsRemoveCommand( m_trkDevice->sendBreakpointsRemoveCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleClearBreakpoint), CodaCallback(this, &CodaGdbAdapter::handleClearBreakpoint),
tcftrk::Breakpoint::idFromLocation(addr)); Coda::Breakpoint::idFromLocation(addr));
} }
else if (cmd.startsWith("qPart:") || cmd.startsWith("qXfer:")) { else if (cmd.startsWith("qPart:") || cmd.startsWith("qXfer:")) {
@@ -955,16 +955,16 @@ void TcfTrkGdbAdapter::handleGdbServerCommand(const QByteArray &cmd)
} }
} }
void TcfTrkGdbAdapter::sendRunControlTerminateCommand() void CodaGdbAdapter::sendRunControlTerminateCommand()
{ {
// Requires id of main thread to terminate. // Requires id of main thread to terminate.
// Note that calling 'Settings|set|removeExecutable' crashes TCF TRK, // Note that calling 'Settings|set|removeExecutable' crashes TCF TRK,
// so, it is apparently not required. // so, it is apparently not required.
m_trkDevice->sendRunControlTerminateCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRunControlTerminate), m_trkDevice->sendRunControlTerminateCommand(CodaCallback(this, &CodaGdbAdapter::handleRunControlTerminate),
mainThreadContextId()); mainThreadContextId());
} }
void TcfTrkGdbAdapter::handleRunControlTerminate(const tcftrk::TcfTrkCommandResult &) void CodaGdbAdapter::handleRunControlTerminate(const Coda::CodaCommandResult &)
{ {
QString msg = QString::fromLatin1("CODA disconnected"); QString msg = QString::fromLatin1("CODA disconnected");
const bool emergencyShutdown = m_gdbProc.state() != QProcess::Running; const bool emergencyShutdown = m_gdbProc.state() != QProcess::Running;
@@ -977,7 +977,7 @@ void TcfTrkGdbAdapter::handleRunControlTerminate(const tcftrk::TcfTrkCommandResu
} }
} }
void TcfTrkGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *why) void CodaGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *why)
{ {
// Thread ID from Hg/Hc commands: '-1': All, '0': arbitrary, else hex thread id. // Thread ID from Hg/Hc commands: '-1': All, '0': arbitrary, else hex thread id.
const QByteArray id = cmd.mid(2); const QByteArray id = cmd.mid(2);
@@ -991,12 +991,12 @@ void TcfTrkGdbAdapter::gdbSetCurrentThread(const QByteArray &cmd, const char *wh
sendGdbServerMessage("OK", message); sendGdbServerMessage("OK", message);
} }
void TcfTrkGdbAdapter::interruptInferior() void CodaGdbAdapter::interruptInferior()
{ {
m_trkDevice->sendRunControlSuspendCommand(TcfTrkCallback(), m_tcfProcessId); m_trkDevice->sendRunControlSuspendCommand(CodaCallback(), m_tcfProcessId);
} }
void TcfTrkGdbAdapter::startAdapter() void CodaGdbAdapter::startAdapter()
{ {
m_snapshot.fullReset(); m_snapshot.fullReset();
m_session.reset(); m_session.reset();
@@ -1011,13 +1011,13 @@ void TcfTrkGdbAdapter::startAdapter()
if (!m_symbolFile.isEmpty()) if (!m_symbolFile.isEmpty())
m_symbolFileFolder = QFileInfo(m_symbolFile).absolutePath(); m_symbolFileFolder = QFileInfo(m_symbolFile).absolutePath();
QPair<QString, unsigned short> tcfTrkAddress; QPair<QString, unsigned short> codaAddress;
QSharedPointer<QTcpSocket> tcfTrkSocket; QSharedPointer<QTcpSocket> codaSocket;
if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) { if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) {
tcfTrkSocket = QSharedPointer<QTcpSocket>(new QTcpSocket); codaSocket = QSharedPointer<QTcpSocket>(new QTcpSocket);
m_trkDevice->setDevice(tcfTrkSocket); m_trkDevice->setDevice(codaSocket);
m_trkIODevice = tcfTrkSocket; m_trkIODevice = codaSocket;
} else { } else {
QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(parameters.remoteChannel)); QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(parameters.remoteChannel));
m_trkDevice->setSerialFrame(true); m_trkDevice->setSerialFrame(true);
@@ -1037,7 +1037,7 @@ void TcfTrkGdbAdapter::startAdapter()
qDebug() << parameters.processArgs; qDebug() << parameters.processArgs;
m_uid = parameters.executableUid; m_uid = parameters.executableUid;
tcfTrkAddress = QPair<QString, unsigned short>(parameters.serverAddress, parameters.serverPort); codaAddress = QPair<QString, unsigned short>(parameters.serverAddress, parameters.serverPort);
// m_remoteArguments.clear(); FIXME: Should this be here? // m_remoteArguments.clear(); FIXME: Should this be here?
// Unixish gdbs accept only forward slashes // Unixish gdbs accept only forward slashes
@@ -1045,7 +1045,7 @@ void TcfTrkGdbAdapter::startAdapter()
// Start // Start
QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state()); QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
showMessage(_("TRYING TO START ADAPTER")); showMessage(_("TRYING TO START ADAPTER"));
logMessage(QLatin1String("### Starting TcfTrkGdbAdapter")); logMessage(QLatin1String("### Starting CodaGdbAdapter"));
QTC_ASSERT(m_gdbServer == 0, delete m_gdbServer); QTC_ASSERT(m_gdbServer == 0, delete m_gdbServer);
QTC_ASSERT(m_gdbConnection == 0, m_gdbConnection = 0); QTC_ASSERT(m_gdbConnection == 0, m_gdbConnection = 0);
@@ -1068,14 +1068,14 @@ void TcfTrkGdbAdapter::startAdapter()
if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) { if (parameters.communicationChannel == DebuggerStartParameters::CommunicationChannelTcpIp) {
logMessage(_("Connecting to TCF TRK on %1:%2") logMessage(_("Connecting to TCF TRK on %1:%2")
.arg(tcfTrkAddress.first).arg(tcfTrkAddress.second)); .arg(codaAddress.first).arg(codaAddress.second));
tcfTrkSocket->connectToHost(tcfTrkAddress.first, tcfTrkAddress.second); codaSocket->connectToHost(codaAddress.first, codaAddress.second);
} else { } else {
m_trkDevice->sendSerialPing(false); m_trkDevice->sendSerialPing(false);
} }
} }
void TcfTrkGdbAdapter::setupInferior() void CodaGdbAdapter::setupInferior()
{ {
QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());
@@ -1086,12 +1086,12 @@ void TcfTrkGdbAdapter::setupInferior()
libraries.push_back(QString::fromAscii(librariesC[i])); libraries.push_back(QString::fromAscii(librariesC[i]));
m_trkDevice->sendProcessStartCommand( m_trkDevice->sendProcessStartCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleCreateProcess), CodaCallback(this, &CodaGdbAdapter::handleCreateProcess),
m_remoteExecutable, m_uid, m_remoteArguments, m_remoteExecutable, m_uid, m_remoteArguments,
QString(), true, libraries); QString(), true, libraries);
} }
void TcfTrkGdbAdapter::addThread(unsigned id) void CodaGdbAdapter::addThread(unsigned id)
{ {
showMessage(QString::fromLatin1("Thread %1 reported").arg(id), LogMisc); showMessage(QString::fromLatin1("Thread %1 reported").arg(id), LogMisc);
// Make thread known, register as main if it is the first one. // Make thread known, register as main if it is the first one.
@@ -1104,13 +1104,13 @@ void TcfTrkGdbAdapter::addThread(unsigned id)
} }
// We cannot retrieve register values unless the registers of that // We cannot retrieve register values unless the registers of that
// thread have been retrieved (TCF TRK oddity). // thread have been retrieved (TCF TRK oddity).
const QByteArray contextId = tcftrk::RunControlContext::tcfId(m_session.pid, id); const QByteArray contextId = Coda::RunControlContext::tcfId(m_session.pid, id);
m_trkDevice->sendRegistersGetChildrenCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRegisterChildren), m_trkDevice->sendRegistersGetChildrenCommand(CodaCallback(this, &CodaGdbAdapter::handleRegisterChildren),
contextId, QVariant(contextId)); contextId, QVariant(contextId));
} }
} }
void TcfTrkGdbAdapter::handleCreateProcess(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleCreateProcess(const CodaCommandResult &result)
{ {
if (debug) if (debug)
qDebug() << "ProcessCreated: " << result.toString(); qDebug() << "ProcessCreated: " << result.toString();
@@ -1135,7 +1135,7 @@ void TcfTrkGdbAdapter::handleCreateProcess(const TcfTrkCommandResult &result)
m_session.dataseg = 0; m_session.dataseg = 0;
} }
void TcfTrkGdbAdapter::runEngine() void CodaGdbAdapter::runEngine()
{ {
QTC_ASSERT(state() == EngineRunRequested, qDebug() << state()); QTC_ASSERT(state() == EngineRunRequested, qDebug() << state());
m_engine->notifyEngineRunAndInferiorStopOk(); m_engine->notifyEngineRunAndInferiorStopOk();
@@ -1147,7 +1147,7 @@ void TcfTrkGdbAdapter::runEngine()
// AbstractGdbAdapter interface implementation // AbstractGdbAdapter interface implementation
// //
void TcfTrkGdbAdapter::write(const QByteArray &data) void CodaGdbAdapter::write(const QByteArray &data)
{ {
// Write magic packets directly to TRK. // Write magic packets directly to TRK.
if (data.startsWith("@#")) { if (data.startsWith("@#")) {
@@ -1179,7 +1179,7 @@ void TcfTrkGdbAdapter::write(const QByteArray &data)
m_gdbProc.write(data); m_gdbProc.write(data);
} }
void TcfTrkGdbAdapter::cleanup() void CodaGdbAdapter::cleanup()
{ {
delete m_gdbServer; delete m_gdbServer;
m_gdbServer = 0; m_gdbServer = 0;
@@ -1199,12 +1199,12 @@ void TcfTrkGdbAdapter::cleanup()
} //!m_trkIODevice.isNull() } //!m_trkIODevice.isNull()
} }
void TcfTrkGdbAdapter::shutdownInferior() void CodaGdbAdapter::shutdownInferior()
{ {
m_engine->defaultInferiorShutdown("kill"); m_engine->defaultInferiorShutdown("kill");
} }
void TcfTrkGdbAdapter::shutdownAdapter() void CodaGdbAdapter::shutdownAdapter()
{ {
if (m_gdbProc.state() == QProcess::Running) { if (m_gdbProc.state() == QProcess::Running) {
cleanup(); cleanup();
@@ -1218,18 +1218,18 @@ void TcfTrkGdbAdapter::shutdownAdapter()
} }
} }
void TcfTrkGdbAdapter::trkReloadRegisters() void CodaGdbAdapter::trkReloadRegisters()
{ {
// Take advantage of direct access to cached register values. // Take advantage of direct access to cached register values.
m_snapshot.syncRegisters(m_session.tid, m_engine->registerHandler()); m_snapshot.syncRegisters(m_session.tid, m_engine->registerHandler());
} }
void TcfTrkGdbAdapter::trkReloadThreads() void CodaGdbAdapter::trkReloadThreads()
{ {
m_snapshot.syncThreads(m_engine->threadsHandler()); m_snapshot.syncThreads(m_engine->threadsHandler());
} }
void TcfTrkGdbAdapter::handleWriteRegister(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleWriteRegister(const CodaCommandResult &result)
{ {
const int registerNumber = result.cookie.toInt(); const int registerNumber = result.cookie.toInt();
if (result) { if (result) {
@@ -1241,18 +1241,18 @@ void TcfTrkGdbAdapter::handleWriteRegister(const TcfTrkCommandResult &result)
} }
} }
void TcfTrkGdbAdapter::sendRegistersGetMCommand() void CodaGdbAdapter::sendRegistersGetMCommand()
{ {
// Send off a register command, which requires the names to be present. // Send off a register command, which requires the names to be present.
QTC_ASSERT(!m_trkDevice->registerNames().isEmpty(), return ) QTC_ASSERT(!m_trkDevice->registerNames().isEmpty(), return )
m_trkDevice->sendRegistersGetMRangeCommand( m_trkDevice->sendRegistersGetMRangeCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleAndReportReadRegisters), CodaCallback(this, &CodaGdbAdapter::handleAndReportReadRegisters),
currentThreadContextId(), 0, currentThreadContextId(), 0,
Symbian::RegisterCount); Symbian::RegisterCount);
} }
void TcfTrkGdbAdapter::reportRegisters() void CodaGdbAdapter::reportRegisters()
{ {
const int threadIndex = m_snapshot.indexOfThread(m_session.tid); const int threadIndex = m_snapshot.indexOfThread(m_session.tid);
QTC_ASSERT(threadIndex != -1, return); QTC_ASSERT(threadIndex != -1, return);
@@ -1260,7 +1260,7 @@ void TcfTrkGdbAdapter::reportRegisters()
sendGdbServerMessage(thread.gdbReportRegisters(), thread.gdbRegisterLogMessage(m_verbose)); sendGdbServerMessage(thread.gdbReportRegisters(), thread.gdbRegisterLogMessage(m_verbose));
} }
void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult &result) void CodaGdbAdapter::handleRegisterChildren(const Coda::CodaCommandResult &result)
{ {
const QByteArray contextId = result.cookie.toByteArray(); const QByteArray contextId = result.cookie.toByteArray();
if (!result) { if (!result) {
@@ -1271,9 +1271,9 @@ void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult
// If this is a single 'pid.tid.rGPR' parent entry, recurse to get the actual registers, // If this is a single 'pid.tid.rGPR' parent entry, recurse to get the actual registers,
// ('pid.tid.rGPR.R0'..). At least 'pid.tid.rGPR' must have been retrieved to be // ('pid.tid.rGPR.R0'..). At least 'pid.tid.rGPR' must have been retrieved to be
// able to access the register contents. // able to access the register contents.
QVector<QByteArray> registerNames = tcftrk::TcfTrkDevice::parseRegisterGetChildren(result); QVector<QByteArray> registerNames = Coda::CodaDevice::parseRegisterGetChildren(result);
if (registerNames.size() == 1) { if (registerNames.size() == 1) {
m_trkDevice->sendRegistersGetChildrenCommand(TcfTrkCallback(this, &TcfTrkGdbAdapter::handleRegisterChildren), m_trkDevice->sendRegistersGetChildrenCommand(CodaCallback(this, &CodaGdbAdapter::handleRegisterChildren),
registerNames.front(), result.cookie); registerNames.front(), result.cookie);
return; return;
} }
@@ -1304,7 +1304,7 @@ void TcfTrkGdbAdapter::handleRegisterChildren(const tcftrk::TcfTrkCommandResult
} }
} }
void TcfTrkGdbAdapter::handleReadRegisters(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleReadRegisters(const CodaCommandResult &result)
{ {
// check for errors // check for errors
if (!result) { if (!result) {
@@ -1336,13 +1336,13 @@ void TcfTrkGdbAdapter::handleReadRegisters(const TcfTrkCommandResult &result)
qDebug() << "handleReadRegisters: " << m_snapshot.toString(); qDebug() << "handleReadRegisters: " << m_snapshot.toString();
} }
void TcfTrkGdbAdapter::handleAndReportReadRegisters(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleAndReportReadRegisters(const CodaCommandResult &result)
{ {
handleReadRegisters(result); handleReadRegisters(result);
reportRegisters(); reportRegisters();
} }
void TcfTrkGdbAdapter::handleAndReportReadRegister(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleAndReportReadRegister(const CodaCommandResult &result)
{ {
handleReadRegisters(result); handleReadRegisters(result);
const uint registerNumber = result.cookie.toUInt(); const uint registerNumber = result.cookie.toUInt();
@@ -1353,7 +1353,7 @@ void TcfTrkGdbAdapter::handleAndReportReadRegister(const TcfTrkCommandResult &re
thread.gdbSingleRegisterLogMessage(registerNumber)); thread.gdbSingleRegisterLogMessage(registerNumber));
} }
QByteArray TcfTrkGdbAdapter::stopMessage() const QByteArray CodaGdbAdapter::stopMessage() const
{ {
QByteArray logMsg = "Stopped with registers in thread 0x"; QByteArray logMsg = "Stopped with registers in thread 0x";
logMsg += QByteArray::number(m_session.tid, 16); logMsg += QByteArray::number(m_session.tid, 16);
@@ -1374,7 +1374,7 @@ QByteArray TcfTrkGdbAdapter::stopMessage() const
return logMsg; return logMsg;
} }
void TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleAndReportReadRegistersAfterStop(const CodaCommandResult &result)
{ {
handleReadRegisters(result); handleReadRegisters(result);
handleReadRegisters(result); handleReadRegisters(result);
@@ -1382,7 +1382,7 @@ void TcfTrkGdbAdapter::handleAndReportReadRegistersAfterStop(const TcfTrkCommand
sendGdbServerMessage(m_snapshot.gdbStopMessage(m_session.tid, m_stopReason, reportThread), stopMessage()); sendGdbServerMessage(m_snapshot.gdbStopMessage(m_session.tid, m_stopReason, reportThread), stopMessage());
} }
void TcfTrkGdbAdapter::handleAndReportSetBreakpoint(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleAndReportSetBreakpoint(const CodaCommandResult &result)
{ {
if (result) { if (result) {
sendGdbServerMessage("OK"); sendGdbServerMessage("OK");
@@ -1392,7 +1392,7 @@ void TcfTrkGdbAdapter::handleAndReportSetBreakpoint(const TcfTrkCommandResult &r
} }
} }
void TcfTrkGdbAdapter::handleClearBreakpoint(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleClearBreakpoint(const CodaCommandResult &result)
{ {
logMessage("CLEAR BREAKPOINT "); logMessage("CLEAR BREAKPOINT ");
if (!result) if (!result)
@@ -1400,7 +1400,7 @@ void TcfTrkGdbAdapter::handleClearBreakpoint(const TcfTrkCommandResult &result)
sendGdbServerMessage("OK"); sendGdbServerMessage("OK");
} }
void TcfTrkGdbAdapter::readMemory(uint addr, uint len, bool buffered) void CodaGdbAdapter::readMemory(uint addr, uint len, bool buffered)
{ {
Q_ASSERT(len < (2 << 16)); Q_ASSERT(len < (2 << 16));
@@ -1419,20 +1419,20 @@ static QString msgMemoryReadError(uint addr, uint len = 0)
return _("Memory read error at: 0x%1 %2").arg(addr, 0, 16).arg(lenS); return _("Memory read error at: 0x%1 %2").arg(addr, 0, 16).arg(lenS);
} }
void TcfTrkGdbAdapter::sendMemoryGetCommand(const MemoryRange &range, bool buffered) void CodaGdbAdapter::sendMemoryGetCommand(const MemoryRange &range, bool buffered)
{ {
const QVariant cookie = QVariant::fromValue(range); const QVariant cookie = QVariant::fromValue(range);
const TcfTrkCallback cb = buffered ? const CodaCallback cb = buffered ?
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleReadMemoryBuffered) : CodaCallback(this, &CodaGdbAdapter::handleReadMemoryBuffered) :
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleReadMemoryUnbuffered); CodaCallback(this, &CodaGdbAdapter::handleReadMemoryUnbuffered);
m_trkDevice->sendMemoryGetCommand(cb, currentThreadContextId(), range.from, range.size(), cookie); m_trkDevice->sendMemoryGetCommand(cb, currentThreadContextId(), range.from, range.size(), cookie);
} }
void TcfTrkGdbAdapter::handleReadMemoryBuffered(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleReadMemoryBuffered(const CodaCommandResult &result)
{ {
QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return); QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return);
const QByteArray memory = TcfTrkDevice::parseMemoryGet(result); const QByteArray memory = CodaDevice::parseMemoryGet(result);
const MemoryRange range = result.cookie.value<MemoryRange>(); const MemoryRange range = result.cookie.value<MemoryRange>();
const bool error = !result; const bool error = !result;
@@ -1453,11 +1453,11 @@ void TcfTrkGdbAdapter::handleReadMemoryBuffered(const TcfTrkCommandResult &resul
tryAnswerGdbMemoryRequest(true); tryAnswerGdbMemoryRequest(true);
} }
void TcfTrkGdbAdapter::handleReadMemoryUnbuffered(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleReadMemoryUnbuffered(const CodaCommandResult &result)
{ {
QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return); QTC_ASSERT(qVariantCanConvert<MemoryRange>(result.cookie), return);
const QByteArray memory = TcfTrkDevice::parseMemoryGet(result); const QByteArray memory = CodaDevice::parseMemoryGet(result);
const MemoryRange range = result.cookie.value<MemoryRange>(); const MemoryRange range = result.cookie.value<MemoryRange>();
const bool error = !result; const bool error = !result;
@@ -1475,7 +1475,7 @@ void TcfTrkGdbAdapter::handleReadMemoryUnbuffered(const TcfTrkCommandResult &res
tryAnswerGdbMemoryRequest(false); tryAnswerGdbMemoryRequest(false);
} }
void TcfTrkGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered) void CodaGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered)
{ {
//logMessage("TRYING TO ANSWER MEMORY REQUEST "); //logMessage("TRYING TO ANSWER MEMORY REQUEST ");
MemoryRange wanted = m_snapshot.wantedMemory; MemoryRange wanted = m_snapshot.wantedMemory;
@@ -1537,7 +1537,7 @@ void TcfTrkGdbAdapter::tryAnswerGdbMemoryRequest(bool buffered)
} }
} }
void TcfTrkGdbAdapter::handleWriteMemory(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleWriteMemory(const CodaCommandResult &result)
{ {
if (result) { if (result) {
sendGdbServerMessage("OK", "Write memory"); sendGdbServerMessage("OK", "Write memory");
@@ -1547,26 +1547,26 @@ void TcfTrkGdbAdapter::handleWriteMemory(const TcfTrkCommandResult &result)
} }
} }
QByteArray TcfTrkGdbAdapter::mainThreadContextId() const QByteArray CodaGdbAdapter::mainThreadContextId() const
{ {
return RunControlContext::tcfId(m_session.pid, m_session.mainTid); return RunControlContext::tcfId(m_session.pid, m_session.mainTid);
} }
QByteArray TcfTrkGdbAdapter::currentThreadContextId() const QByteArray CodaGdbAdapter::currentThreadContextId() const
{ {
return RunControlContext::tcfId(m_session.pid, m_session.tid); return RunControlContext::tcfId(m_session.pid, m_session.tid);
} }
void TcfTrkGdbAdapter::sendTrkContinue() void CodaGdbAdapter::sendTrkContinue()
{ {
// Remove all but main thread as we do not know whether they will exist // Remove all but main thread as we do not know whether they will exist
// at the next stop. // at the next stop.
if (m_snapshot.threadInfo.size() > 1) if (m_snapshot.threadInfo.size() > 1)
m_snapshot.threadInfo.remove(1, m_snapshot.threadInfo.size() - 1); m_snapshot.threadInfo.remove(1, m_snapshot.threadInfo.size() - 1);
m_trkDevice->sendRunControlResumeCommand(TcfTrkCallback(), m_tcfProcessId); m_trkDevice->sendRunControlResumeCommand(CodaCallback(), m_tcfProcessId);
} }
void TcfTrkGdbAdapter::sendTrkStepRange() void CodaGdbAdapter::sendTrkStepRange()
{ {
uint from = m_snapshot.lineFromAddress; uint from = m_snapshot.lineFromAddress;
uint to = m_snapshot.lineToAddress; uint to = m_snapshot.lineToAddress;
@@ -1587,12 +1587,12 @@ void TcfTrkGdbAdapter::sendTrkStepRange()
logMessage(_("Stepping from 0x%1 to 0x%2 (current PC=0x%3), mode %4"). logMessage(_("Stepping from 0x%1 to 0x%2 (current PC=0x%3), mode %4").
arg(from, 0, 16).arg(to, 0, 16).arg(pc).arg(int(mode))); arg(from, 0, 16).arg(to, 0, 16).arg(pc).arg(int(mode)));
m_trkDevice->sendRunControlResumeCommand( m_trkDevice->sendRunControlResumeCommand(
TcfTrkCallback(this, &TcfTrkGdbAdapter::handleStep), CodaCallback(this, &CodaGdbAdapter::handleStep),
currentThreadContextId(), currentThreadContextId(),
mode, 1, from, to); mode, 1, from, to);
} }
void TcfTrkGdbAdapter::handleStep(const TcfTrkCommandResult &result) void CodaGdbAdapter::handleStep(const CodaCommandResult &result)
{ {
if (!result) { // Try fallback with Continue. if (!result) { // Try fallback with Continue.

62
src/plugins/debugger/gdb/tcftrkgdbadapter.h → src/plugins/debugger/gdb/codagdbadapter.h
View File

@@ -31,8 +31,8 @@
** **
**************************************************************************/ **************************************************************************/
#ifndef DEBUGGER_TCFTRKGDBADAPTER_H #ifndef DEBUGGER_CODAGDBADAPTER_H
#define DEBUGGER_TCFTRKGDBADAPTER_H #define DEBUGGER_CODAGDBADAPTER_H
#include "abstractgdbadapter.h" #include "abstractgdbadapter.h"
#include "localgdbprocess.h" #include "localgdbprocess.h"
@@ -51,11 +51,11 @@ class QTcpSocket;
class QIODevice; class QIODevice;
QT_END_NAMESPACE QT_END_NAMESPACE
namespace tcftrk { namespace Coda {
struct TcfTrkCommandResult; struct CodaCommandResult;
class TcfTrkDevice; class CodaDevice;
class TcfTrkEvent; class CodaEvent;
class TcfTrkRunControlModuleLoadContextSuspendedEvent; class CodaRunControlModuleLoadContextSuspendedEvent;
} }
namespace Debugger { namespace Debugger {
@@ -66,21 +66,21 @@ struct GdbResult;
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
// //
// TcfTrkGdbAdapter // CodaGdbAdapter
// //
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
class TcfTrkGdbAdapter : public AbstractGdbAdapter class CodaGdbAdapter : public AbstractGdbAdapter
{ {
Q_OBJECT Q_OBJECT
public: public:
typedef trk::Callback<const GdbResult &> GdbResultCallback; typedef trk::Callback<const GdbResult &> GdbResultCallback;
typedef trk::Callback<const tcftrk::TcfTrkCommandResult &> TcfTrkCallback; typedef trk::Callback<const Coda::CodaCommandResult &> CodaCallback;
typedef trk::Callback<const GdbResponse &> GdbCallback; typedef trk::Callback<const GdbResponse &> GdbCallback;
explicit TcfTrkGdbAdapter(GdbEngine *engine); explicit CodaGdbAdapter(GdbEngine *engine);
virtual ~TcfTrkGdbAdapter(); virtual ~CodaGdbAdapter();
void setGdbServerName(const QString &name); void setGdbServerName(const QString &name);
QString gdbServerName() const { return m_gdbServerName; } QString gdbServerName() const { return m_gdbServerName; }
@@ -113,22 +113,22 @@ private:
void shutdownInferior(); void shutdownInferior();
void shutdownAdapter(); void shutdownAdapter();
void sendRunControlTerminateCommand(); void sendRunControlTerminateCommand();
void handleRunControlTerminate(const tcftrk::TcfTrkCommandResult &); void handleRunControlTerminate(const Coda::CodaCommandResult &);
void sendRegistersGetMCommand(); void sendRegistersGetMCommand();
void handleWriteRegister(const tcftrk::TcfTrkCommandResult &result); void handleWriteRegister(const Coda::CodaCommandResult &result);
void reportRegisters(); void reportRegisters();
void handleReadRegisters(const tcftrk::TcfTrkCommandResult &result); void handleReadRegisters(const Coda::CodaCommandResult &result);
void handleRegisterChildren(const tcftrk::TcfTrkCommandResult &result); void handleRegisterChildren(const Coda::CodaCommandResult &result);
void handleAndReportReadRegisters(const tcftrk::TcfTrkCommandResult &result); void handleAndReportReadRegisters(const Coda::CodaCommandResult &result);
void handleAndReportReadRegister(const tcftrk::TcfTrkCommandResult &result); void handleAndReportReadRegister(const Coda::CodaCommandResult &result);
void handleAndReportReadRegistersAfterStop(const tcftrk::TcfTrkCommandResult &result); void handleAndReportReadRegistersAfterStop(const Coda::CodaCommandResult &result);
QByteArray stopMessage() const; QByteArray stopMessage() const;
void handleAndReportSetBreakpoint(const tcftrk::TcfTrkCommandResult &result); void handleAndReportSetBreakpoint(const Coda::CodaCommandResult &result);
void handleClearBreakpoint(const tcftrk::TcfTrkCommandResult &result); void handleClearBreakpoint(const Coda::CodaCommandResult &result);
void readMemory(uint addr, uint len, bool buffered); void readMemory(uint addr, uint len, bool buffered);
void handleReadMemoryBuffered(const tcftrk::TcfTrkCommandResult &result); void handleReadMemoryBuffered(const Coda::CodaCommandResult &result);
void handleReadMemoryUnbuffered(const tcftrk::TcfTrkCommandResult &result); void handleReadMemoryUnbuffered(const Coda::CodaCommandResult &result);
void handleWriteMemory(const tcftrk::TcfTrkCommandResult &result); void handleWriteMemory(const Coda::CodaCommandResult &result);
void tryAnswerGdbMemoryRequest(bool buffered); void tryAnswerGdbMemoryRequest(bool buffered);
inline void sendMemoryGetCommand(const MemoryRange &range, bool buffered); inline void sendMemoryGetCommand(const MemoryRange &range, bool buffered);
void addThread(unsigned id); void addThread(unsigned id);
@@ -144,7 +144,7 @@ private:
QString m_gdbServerName; // 127.0.0.1:(2222+uid) QString m_gdbServerName; // 127.0.0.1:(2222+uid)
bool m_running; bool m_running;
int m_stopReason; int m_stopReason;
tcftrk::TcfTrkDevice *m_trkDevice; Coda::CodaDevice *m_trkDevice;
QSharedPointer<QIODevice> m_trkIODevice; QSharedPointer<QIODevice> m_trkIODevice;
// //
@@ -152,14 +152,14 @@ private:
// //
Q_SLOT void handleGdbConnection(); Q_SLOT void handleGdbConnection();
Q_SLOT void readGdbServerCommand(); Q_SLOT void readGdbServerCommand();
Q_SLOT void tcftrkDeviceError(const QString &); Q_SLOT void codaDeviceError(const QString &);
void startGdb(); void startGdb();
Q_SLOT void tcftrkEvent(const tcftrk::TcfTrkEvent &knownEvent); Q_SLOT void codaEvent(const Coda::CodaEvent &knownEvent);
void handleTcfTrkRunControlModuleLoadContextSuspendedEvent(const tcftrk::TcfTrkRunControlModuleLoadContextSuspendedEvent &e); void handleCodaRunControlModuleLoadContextSuspendedEvent(const Coda::CodaRunControlModuleLoadContextSuspendedEvent &e);
inline void sendTrkContinue(); inline void sendTrkContinue();
void sendTrkStepRange(); void sendTrkStepRange();
void handleStep(const tcftrk::TcfTrkCommandResult &result); void handleStep(const Coda::CodaCommandResult &result);
void handleCreateProcess(const tcftrk::TcfTrkCommandResult &result); void handleCreateProcess(const Coda::CodaCommandResult &result);
void readGdbResponse(); void readGdbResponse();
void handleGdbServerCommand(const QByteArray &cmd); void handleGdbServerCommand(const QByteArray &cmd);
@@ -197,4 +197,4 @@ private:
} // namespace Internal } // namespace Internal
} // namespace Debugger } // namespace Debugger
#endif // DEBUGGER_TCFTRKGDBADAPTER_H #endif // DEBUGGER_CODAGDBADAPTER_H

4
src/plugins/debugger/gdb/gdb.pri
View File

@@ -10,7 +10,7 @@ HEADERS += \
$$PWD/termgdbadapter.h \ $$PWD/termgdbadapter.h \
$$PWD/remotegdbserveradapter.h \ $$PWD/remotegdbserveradapter.h \
$$PWD/trkgdbadapter.h \ $$PWD/trkgdbadapter.h \
$$PWD/tcftrkgdbadapter.h \ $$PWD/codagdbadapter.h \
$$PWD/s60debuggerbluetoothstarter.h \ $$PWD/s60debuggerbluetoothstarter.h \
$$PWD/abstractgdbprocess.h \ $$PWD/abstractgdbprocess.h \
$$PWD/localgdbprocess.h \ $$PWD/localgdbprocess.h \
@@ -33,7 +33,7 @@ SOURCES += \
$$PWD/termgdbadapter.cpp \ $$PWD/termgdbadapter.cpp \
$$PWD/remotegdbserveradapter.cpp \ $$PWD/remotegdbserveradapter.cpp \
$$PWD/trkgdbadapter.cpp \ $$PWD/trkgdbadapter.cpp \
$$PWD/tcftrkgdbadapter.cpp \ $$PWD/codagdbadapter.cpp \
$$PWD/s60debuggerbluetoothstarter.cpp \ $$PWD/s60debuggerbluetoothstarter.cpp \
$$PWD/abstractgdbprocess.cpp \ $$PWD/abstractgdbprocess.cpp \
$$PWD/localgdbprocess.cpp \ $$PWD/localgdbprocess.cpp \

4
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -44,7 +44,7 @@
#include "remotegdbserveradapter.h" #include "remotegdbserveradapter.h"
#include "remoteplaingdbadapter.h" #include "remoteplaingdbadapter.h"
#include "trkgdbadapter.h" #include "trkgdbadapter.h"
#include "tcftrkgdbadapter.h" #include "codagdbadapter.h"
#include "debuggeractions.h" #include "debuggeractions.h"
#include "debuggerconstants.h" #include "debuggerconstants.h"
@@ -1798,7 +1798,7 @@ AbstractGdbAdapter *GdbEngine::createAdapter()
case ProjectExplorer::ToolChain_RVCT_ARMV5_GNUPOC: case ProjectExplorer::ToolChain_RVCT_ARMV5_GNUPOC:
case ProjectExplorer::ToolChain_GCCE_GNUPOC: case ProjectExplorer::ToolChain_GCCE_GNUPOC:
if (sp.debugClient == DebuggerStartParameters::DebugClientCoda) if (sp.debugClient == DebuggerStartParameters::DebugClientCoda)
return new TcfTrkGdbAdapter(this); return new CodaGdbAdapter(this);
else else
return new TrkGdbAdapter(this); return new TrkGdbAdapter(this);
default: default:

2
src/plugins/debugger/gdb/gdbengine.h
View File

@@ -100,7 +100,7 @@ private:
friend class RemoteGdbServerAdapter; friend class RemoteGdbServerAdapter;
friend class RemotePlainGdbAdapter; friend class RemotePlainGdbAdapter;
friend class TrkGdbAdapter; friend class TrkGdbAdapter;
friend class TcfTrkGdbAdapter; friend class CodaGdbAdapter;
private: ////////// General Interface ////////// private: ////////// General Interface //////////

2
src/plugins/debugger/gdb/trkgdbadapter.cpp
View File

@@ -1673,7 +1673,7 @@ void TrkGdbAdapter::handleCreateProcess(const TrkResult &result)
logMessage(startMsg, LogMisc); logMessage(startMsg, LogMisc);
// 26.8.2010: When paging occurs in S^3, bogus starting ROM addresses // 26.8.2010: When paging occurs in S^3, bogus starting ROM addresses
// like 0x500000 or 0x40000 are reported. Warn about symbol resolution errors. // like 0x500000 or 0x40000 are reported. Warn about symbol resolution errors.
// Code duplicated in TcfTrkAdapter. @TODO: Hopefully fixed in future TRK versions. // Code duplicated in CodaAdapter. @TODO: Hopefully fixed in future TRK versions.
if ((m_session.codeseg & 0xFFFFF) == 0) { if ((m_session.codeseg & 0xFFFFF) == 0) {
const QString warnMessage = tr("The reported code segment address (0x%1) might be invalid. Symbol resolution or setting breakoints may not work."). const QString warnMessage = tr("The reported code segment address (0x%1) might be invalid. Symbol resolution or setting breakoints may not work.").
arg(m_session.codeseg, 0, 16); arg(m_session.codeseg, 0, 16);

100
src/plugins/qt4projectmanager/qt-s60/codaruncontrol.cpp
View File

@@ -36,8 +36,8 @@
#include "s60deployconfiguration.h" #include "s60deployconfiguration.h"
#include "s60devicerunconfiguration.h" #include "s60devicerunconfiguration.h"
#include "tcftrkdevice.h" #include "codadevice.h"
#include "tcftrkmessage.h" #include "codamessage.h"
#include "qt4buildconfiguration.h" #include "qt4buildconfiguration.h"
#include "qt4symbiantarget.h" #include "qt4symbiantarget.h"
@@ -63,13 +63,13 @@
using namespace ProjectExplorer; using namespace ProjectExplorer;
using namespace Qt4ProjectManager; using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal; using namespace Qt4ProjectManager::Internal;
using namespace tcftrk; using namespace Coda;
enum { debug = 0 }; enum { debug = 0 };
CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString &mode) : CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString &mode) :
S60RunControlBase(runConfiguration, mode), S60RunControlBase(runConfiguration, mode),
m_tcfTrkDevice(0), m_codaDevice(0),
m_port(0), m_port(0),
m_state(StateUninit) m_state(StateUninit)
{ {
@@ -91,8 +91,8 @@ CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString
CodaRunControl::~CodaRunControl() CodaRunControl::~CodaRunControl()
{ {
if (m_tcfTrkDevice) if (m_codaDevice)
m_tcfTrkDevice->deleteLater(); m_codaDevice->deleteLater();
} }
bool CodaRunControl::doStart() bool CodaRunControl::doStart()
@@ -115,22 +115,22 @@ bool CodaRunControl::isRunning() const
bool CodaRunControl::setupLauncher() bool CodaRunControl::setupLauncher()
{ {
QTC_ASSERT(!m_tcfTrkDevice, return false); QTC_ASSERT(!m_codaDevice, return false);
m_tcfTrkDevice = new TcfTrkDevice; m_codaDevice = new CodaDevice;
if (debug) if (debug)
m_tcfTrkDevice->setVerbose(debug); m_codaDevice->setVerbose(debug);
connect(m_tcfTrkDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString))); connect(m_codaDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString)));
connect(m_tcfTrkDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString))); connect(m_codaDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString)));
connect(m_tcfTrkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)), this, SLOT(slotTcftrkEvent(tcftrk::TcfTrkEvent))); connect(m_codaDevice, SIGNAL(tcfEvent(Coda::CodaEvent)), this, SLOT(slotCodaEvent(Coda::CodaEvent)));
connect(m_tcfTrkDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString))); connect(m_codaDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString)));
if (m_serialPort.length()) { if (m_serialPort.length()) {
const QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(m_serialPort)); const QSharedPointer<SymbianUtils::VirtualSerialDevice> serialDevice(new SymbianUtils::VirtualSerialDevice(m_serialPort));
appendMessage(tr("Conecting to '%2'...").arg(m_serialPort), NormalMessageFormat); appendMessage(tr("Conecting to '%2'...").arg(m_serialPort), NormalMessageFormat);
m_tcfTrkDevice->setSerialFrame(true); m_codaDevice->setSerialFrame(true);
m_tcfTrkDevice->setDevice(serialDevice); m_codaDevice->setDevice(serialDevice);
bool ok = serialDevice->open(QIODevice::ReadWrite); bool ok = serialDevice->open(QIODevice::ReadWrite);
if (!ok) { if (!ok) {
appendMessage(tr("Couldn't open serial device: %1").arg(serialDevice->errorString()), ErrorMessageFormat); appendMessage(tr("Couldn't open serial device: %1").arg(serialDevice->errorString()), ErrorMessageFormat);
@@ -139,12 +139,12 @@ bool CodaRunControl::setupLauncher()
connect(SymbianUtils::SymbianDeviceManager::instance(), SIGNAL(deviceRemoved(const SymbianUtils::SymbianDevice)), connect(SymbianUtils::SymbianDeviceManager::instance(), SIGNAL(deviceRemoved(const SymbianUtils::SymbianDevice)),
this, SLOT(deviceRemoved(SymbianUtils::SymbianDevice))); this, SLOT(deviceRemoved(SymbianUtils::SymbianDevice)));
m_state = StateConnecting; m_state = StateConnecting;
m_tcfTrkDevice->sendSerialPing(false); m_codaDevice->sendSerialPing(false);
QTimer::singleShot(4000, this, SLOT(checkForTimeout())); QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
} else { } else {
const QSharedPointer<QTcpSocket> tcfTrkSocket(new QTcpSocket); const QSharedPointer<QTcpSocket> codaSocket(new QTcpSocket);
m_tcfTrkDevice->setDevice(tcfTrkSocket); m_codaDevice->setDevice(codaSocket);
tcfTrkSocket->connectToHost(m_address, m_port); codaSocket->connectToHost(m_address, m_port);
m_state = StateConnecting; m_state = StateConnecting;
appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), NormalMessageFormat); appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), NormalMessageFormat);
QTimer::singleShot(4000, this, SLOT(checkForTimeout())); QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
@@ -162,7 +162,7 @@ void CodaRunControl::doStop()
break; break;
case StateProcessRunning: case StateProcessRunning:
QTC_ASSERT(!m_runningProcessId.isEmpty(), return); QTC_ASSERT(!m_runningProcessId.isEmpty(), return);
m_tcfTrkDevice->sendRunControlTerminateCommand(TcfTrkCallback(), m_codaDevice->sendRunControlTerminateCommand(CodaCallback(),
m_runningProcessId.toAscii()); m_runningProcessId.toAscii());
break; break;
} }
@@ -187,34 +187,34 @@ void CodaRunControl::slotSerialPong(const QString &message)
qDebug() << "CODA serial pong:" << message; qDebug() << "CODA serial pong:" << message;
} }
void CodaRunControl::slotTcftrkEvent(const TcfTrkEvent &event) void CodaRunControl::slotCodaEvent(const CodaEvent &event)
{ {
if (debug) if (debug)
qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString(); qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString();
switch (event.type()) { switch (event.type()) {
case TcfTrkEvent::LocatorHello: { // Commands accepted now case CodaEvent::LocatorHello: { // Commands accepted now
m_state = StateConnected; m_state = StateConnected;
appendMessage(tr("Connected."), NormalMessageFormat); appendMessage(tr("Connected."), NormalMessageFormat);
setProgress(maxProgress()*0.80); setProgress(maxProgress()*0.80);
initCommunication(); initCommunication();
} }
break; break;
case TcfTrkEvent::RunControlContextRemoved: case CodaEvent::RunControlContextRemoved:
handleContextRemoved(event); handleContextRemoved(event);
break; break;
case TcfTrkEvent::RunControlContextAdded: case CodaEvent::RunControlContextAdded:
m_state = StateProcessRunning; m_state = StateProcessRunning;
reportLaunchFinished(); reportLaunchFinished();
handleContextAdded(event); handleContextAdded(event);
break; break;
case TcfTrkEvent::RunControlSuspended: case CodaEvent::RunControlSuspended:
handleContextSuspended(event); handleContextSuspended(event);
break; break;
case TcfTrkEvent::RunControlModuleLoadSuspended: case CodaEvent::RunControlModuleLoadSuspended:
handleModuleLoadSuspended(event); handleModuleLoadSuspended(event);
break; break;
case TcfTrkEvent::LoggingWriteEvent: case CodaEvent::LoggingWriteEvent:
handleLogging(event); handleLogging(event);
break; break;
default: default:
@@ -226,13 +226,13 @@ void CodaRunControl::slotTcftrkEvent(const TcfTrkEvent &event)
void CodaRunControl::initCommunication() void CodaRunControl::initCommunication()
{ {
m_tcfTrkDevice->sendLoggingAddListenerCommand(TcfTrkCallback(this, &CodaRunControl::handleAddListener)); m_codaDevice->sendLoggingAddListenerCommand(CodaCallback(this, &CodaRunControl::handleAddListener));
} }
void CodaRunControl::handleContextRemoved(const TcfTrkEvent &event) void CodaRunControl::handleContextRemoved(const CodaEvent &event)
{ {
const QVector<QByteArray> removedItems const QVector<QByteArray> removedItems
= static_cast<const TcfTrkRunControlContextRemovedEvent &>(event).ids(); = static_cast<const CodaRunControlContextRemovedEvent &>(event).ids();
if (!m_runningProcessId.isEmpty() if (!m_runningProcessId.isEmpty()
&& removedItems.contains(m_runningProcessId.toAscii())) { && removedItems.contains(m_runningProcessId.toAscii())) {
appendMessage(tr("Process has finished."), NormalMessageFormat); appendMessage(tr("Process has finished."), NormalMessageFormat);
@@ -240,9 +240,9 @@ void CodaRunControl::handleContextRemoved(const TcfTrkEvent &event)
} }
} }
void CodaRunControl::handleContextAdded(const TcfTrkEvent &event) void CodaRunControl::handleContextAdded(const CodaEvent &event)
{ {
typedef TcfTrkRunControlContextAddedEvent TcfAddedEvent; typedef CodaRunControlContextAddedEvent TcfAddedEvent;
const TcfAddedEvent &me = static_cast<const TcfAddedEvent &>(event); const TcfAddedEvent &me = static_cast<const TcfAddedEvent &>(event);
foreach (const RunControlContext &context, me.contexts()) { foreach (const RunControlContext &context, me.contexts()) {
@@ -251,9 +251,9 @@ void CodaRunControl::handleContextAdded(const TcfTrkEvent &event)
} }
} }
void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event) void CodaRunControl::handleContextSuspended(const CodaEvent &event)
{ {
typedef TcfTrkRunControlContextSuspendedEvent TcfSuspendEvent; typedef CodaRunControlContextSuspendedEvent TcfSuspendEvent;
const TcfSuspendEvent &me = static_cast<const TcfSuspendEvent &>(event); const TcfSuspendEvent &me = static_cast<const TcfSuspendEvent &>(event);
@@ -262,7 +262,7 @@ void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event)
appendMessage(tr("Thread has crashed: %1").arg(QString::fromLatin1(me.message())), ErrorMessageFormat); appendMessage(tr("Thread has crashed: %1").arg(QString::fromLatin1(me.message())), ErrorMessageFormat);
//If we get a crash report then we display it and stop the process. //If we get a crash report then we display it and stop the process.
//Now sure if this should be the final solution but it works for now. //Now sure if this should be the final solution but it works for now.
//m_tcfTrkDevice->sendRunControlResumeCommand(TcfTrkCallback(), me.id()); //TODO: Should I resume automaticly //m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id()); //TODO: Should I resume automaticly
stop(); stop();
break; break;
default: default:
@@ -272,31 +272,31 @@ void CodaRunControl::handleContextSuspended(const TcfTrkEvent &event)
} }
} }
void CodaRunControl::handleModuleLoadSuspended(const TcfTrkEvent &event) void CodaRunControl::handleModuleLoadSuspended(const CodaEvent &event)
{ {
// Debug mode start: Continue: // Debug mode start: Continue:
typedef TcfTrkRunControlModuleLoadContextSuspendedEvent TcfModuleLoadSuspendedEvent; typedef CodaRunControlModuleLoadContextSuspendedEvent TcfModuleLoadSuspendedEvent;
const TcfModuleLoadSuspendedEvent &me = static_cast<const TcfModuleLoadSuspendedEvent &>(event); const TcfModuleLoadSuspendedEvent &me = static_cast<const TcfModuleLoadSuspendedEvent &>(event);
if (me.info().requireResume) if (me.info().requireResume)
m_tcfTrkDevice->sendRunControlResumeCommand(TcfTrkCallback(), me.id()); m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id());
} }
void CodaRunControl::handleLogging(const TcfTrkEvent &event) void CodaRunControl::handleLogging(const CodaEvent &event)
{ {
const TcfTrkLoggingWriteEvent &me = static_cast<const TcfTrkLoggingWriteEvent &>(event); const CodaLoggingWriteEvent &me = static_cast<const CodaLoggingWriteEvent &>(event);
appendMessage(me.message(), StdOutFormat); appendMessage(me.message(), StdOutFormat);
} }
void CodaRunControl::handleAddListener(const TcfTrkCommandResult &result) void CodaRunControl::handleAddListener(const CodaCommandResult &result)
{ {
Q_UNUSED(result) Q_UNUSED(result)
m_tcfTrkDevice->sendSymbianOsDataFindProcessesCommand(TcfTrkCallback(this, &CodaRunControl::handleFindProcesses), m_codaDevice->sendSymbianOsDataFindProcessesCommand(CodaCallback(this, &CodaRunControl::handleFindProcesses),
QByteArray(), QByteArray(),
QByteArray::number(executableUid(), 16)); QByteArray::number(executableUid(), 16));
} }
void CodaRunControl::handleFindProcesses(const TcfTrkCommandResult &result) void CodaRunControl::handleFindProcesses(const CodaCommandResult &result)
{ {
if (result.values.size() && result.values.at(0).type() == JsonValue::Array && result.values.at(0).children().count()) { if (result.values.size() && result.values.at(0).type() == JsonValue::Array && result.values.at(0).children().count()) {
//there are processes running. Cannot run mine //there are processes running. Cannot run mine
@@ -304,15 +304,15 @@ void CodaRunControl::handleFindProcesses(const TcfTrkCommandResult &result)
finishRunControl(); finishRunControl();
} else { } else {
setProgress(maxProgress()*0.90); setProgress(maxProgress()*0.90);
m_tcfTrkDevice->sendProcessStartCommand(TcfTrkCallback(this, &CodaRunControl::handleCreateProcess), m_codaDevice->sendProcessStartCommand(CodaCallback(this, &CodaRunControl::handleCreateProcess),
executableName(), executableUid(), commandLineArguments().split(" "), QString(), true); executableName(), executableUid(), commandLineArguments().split(" "), QString(), true);
appendMessage(tr("Launching: %1").arg(executableName()), NormalMessageFormat); appendMessage(tr("Launching: %1").arg(executableName()), NormalMessageFormat);
} }
} }
void CodaRunControl::handleCreateProcess(const TcfTrkCommandResult &result) void CodaRunControl::handleCreateProcess(const CodaCommandResult &result)
{ {
const bool ok = result.type == TcfTrkCommandResult::SuccessReply; const bool ok = result.type == CodaCommandResult::SuccessReply;
if (ok) { if (ok) {
setProgress(maxProgress()); setProgress(maxProgress());
appendMessage(tr("Launched."), NormalMessageFormat); appendMessage(tr("Launched."), NormalMessageFormat);
@@ -325,9 +325,9 @@ void CodaRunControl::handleCreateProcess(const TcfTrkCommandResult &result)
void CodaRunControl::finishRunControl() void CodaRunControl::finishRunControl()
{ {
m_runningProcessId.clear(); m_runningProcessId.clear();
if (m_tcfTrkDevice) if (m_codaDevice)
m_tcfTrkDevice->deleteLater(); m_codaDevice->deleteLater();
m_tcfTrkDevice = 0; m_codaDevice = 0;
m_state = StateUninit; m_state = StateUninit;
emit finished(); emit finished();
} }
@@ -366,7 +366,7 @@ void CodaRunControl::cancelConnection()
void CodaRunControl::deviceRemoved(const SymbianUtils::SymbianDevice &device) void CodaRunControl::deviceRemoved(const SymbianUtils::SymbianDevice &device)
{ {
if (m_tcfTrkDevice && device.portName() == m_serialPort) { if (m_codaDevice && device.portName() == m_serialPort) {
QString msg = tr("The device '%1' has been disconnected").arg(device.friendlyName()); QString msg = tr("The device '%1' has been disconnected").arg(device.friendlyName());
appendMessage(msg, ErrorMessageFormat); appendMessage(msg, ErrorMessageFormat);
finishRunControl(); finishRunControl();

30
src/plugins/qt4projectmanager/qt-s60/codaruncontrol.h
View File

@@ -41,10 +41,10 @@ class QMessageBox;
class QWidget; class QWidget;
QT_END_NAMESPACE QT_END_NAMESPACE
namespace tcftrk { namespace Coda {
struct TcfTrkCommandResult; struct CodaCommandResult;
class TcfTrkDevice; class CodaDevice;
class TcfTrkEvent; class CodaEvent;
} }
namespace SymbianUtils { namespace SymbianUtils {
@@ -54,7 +54,7 @@ class SymbianDevice;
namespace Qt4ProjectManager { namespace Qt4ProjectManager {
namespace Internal { namespace Internal {
// CodaRunControl configures tcftrk to run the application // CodaRunControl configures Coda to run the application
class CodaRunControl : public S60RunControlBase class CodaRunControl : public S60RunControlBase
{ {
Q_OBJECT Q_OBJECT
@@ -79,22 +79,22 @@ protected slots:
private slots: private slots:
void slotError(const QString &error); void slotError(const QString &error);
void slotTrkLogMessage(const QString &log); void slotTrkLogMessage(const QString &log);
void slotTcftrkEvent(const tcftrk::TcfTrkEvent &event); void slotCodaEvent(const Coda::CodaEvent &event);
void slotSerialPong(const QString &message); void slotSerialPong(const QString &message);
private: private:
void initCommunication(); void initCommunication();
void handleModuleLoadSuspended(const tcftrk::TcfTrkEvent &event); void handleModuleLoadSuspended(const Coda::CodaEvent &event);
void handleContextSuspended(const tcftrk::TcfTrkEvent &event); void handleContextSuspended(const Coda::CodaEvent &event);
void handleContextAdded(const tcftrk::TcfTrkEvent &event); void handleContextAdded(const Coda::CodaEvent &event);
void handleContextRemoved(const tcftrk::TcfTrkEvent &event); void handleContextRemoved(const Coda::CodaEvent &event);
void handleLogging(const tcftrk::TcfTrkEvent &event); void handleLogging(const Coda::CodaEvent &event);
private: private:
void handleCreateProcess(const tcftrk::TcfTrkCommandResult &result); void handleCreateProcess(const Coda::CodaCommandResult &result);
void handleAddListener(const tcftrk::TcfTrkCommandResult &result); void handleAddListener(const Coda::CodaCommandResult &result);
void handleFindProcesses(const tcftrk::TcfTrkCommandResult &result); void handleFindProcesses(const Coda::CodaCommandResult &result);
private: private:
enum State { enum State {
@@ -104,7 +104,7 @@ private:
StateProcessRunning StateProcessRunning
}; };
tcftrk::TcfTrkDevice *m_tcfTrkDevice; Coda::CodaDevice *m_codaDevice;
QString m_address; QString m_address;
unsigned short m_port; unsigned short m_port;

46
src/plugins/qt4projectmanager/qt-s60/s60deploystep.cpp
View File

@@ -37,7 +37,7 @@
#include "s60deployconfiguration.h" #include "s60deployconfiguration.h"
#include "s60devicerunconfiguration.h" #include "s60devicerunconfiguration.h"
#include "s60runconfigbluetoothstarter.h" #include "s60runconfigbluetoothstarter.h"
#include "tcftrkdevice.h" #include "codadevice.h"
#include "trkruncontrol.h" #include "trkruncontrol.h"
#include <coreplugin/icore.h> #include <coreplugin/icore.h>
@@ -295,7 +295,7 @@ void S60DeployStep::start()
} }
if (!trkClient) { if (!trkClient) {
QTC_ASSERT(!m_trkDevice, return); QTC_ASSERT(!m_trkDevice, return);
m_trkDevice = new tcftrk::TcfTrkDevice; m_trkDevice = new Coda::CodaDevice;
if (m_address.isEmpty() && !serialConnection) { if (m_address.isEmpty() && !serialConnection) {
errorMessage = tr("No address for a device has been defined. Please define an address and try again."); errorMessage = tr("No address for a device has been defined. Please define an address and try again.");
reportError(errorMessage); reportError(errorMessage);
@@ -347,7 +347,7 @@ void S60DeployStep::setupConnections()
} else { } else {
connect(m_trkDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString))); connect(m_trkDevice, SIGNAL(error(QString)), this, SLOT(slotError(QString)));
connect(m_trkDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString))); connect(m_trkDevice, SIGNAL(logMessage(QString)), this, SLOT(slotTrkLogMessage(QString)));
connect(m_trkDevice, SIGNAL(tcfEvent(tcftrk::TcfTrkEvent)), this, SLOT(slotTcftrkEvent(tcftrk::TcfTrkEvent)), Qt::DirectConnection); connect(m_trkDevice, SIGNAL(tcfEvent(Coda::CodaEvent)), this, SLOT(slotCodaEvent(Coda::CodaEvent)), Qt::DirectConnection);
connect(m_trkDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString))); connect(m_trkDevice, SIGNAL(serialPong(QString)), this, SLOT(slotSerialPong(QString)));
connect(this, SIGNAL(manualInstallation()), this, SLOT(showManualInstallationInfo())); connect(this, SIGNAL(manualInstallation()), this, SLOT(showManualInstallationInfo()));
} }
@@ -400,9 +400,9 @@ void S60DeployStep::startDeployment()
m_trkDevice->sendSerialPing(false); m_trkDevice->sendSerialPing(false);
QTimer::singleShot(4000, this, SLOT(checkForTimeout())); QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
} else { } else {
const QSharedPointer<QTcpSocket> tcfTrkSocket(new QTcpSocket); const QSharedPointer<QTcpSocket> codaSocket(new QTcpSocket);
m_trkDevice->setDevice(tcfTrkSocket); m_trkDevice->setDevice(codaSocket);
tcfTrkSocket->connectToHost(m_address, m_port); codaSocket->connectToHost(m_address, m_port);
m_state = StateConnecting; m_state = StateConnecting;
appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), false); appendMessage(tr("Connecting to %1:%2...").arg(m_address).arg(m_port), false);
QTimer::singleShot(4000, this, SLOT(checkForTimeout())); QTimer::singleShot(4000, this, SLOT(checkForTimeout()));
@@ -466,13 +466,13 @@ void S60DeployStep::slotSerialPong(const QString &message)
qDebug() << "CODA serial pong:" << message; qDebug() << "CODA serial pong:" << message;
} }
void S60DeployStep::slotTcftrkEvent (const tcftrk::TcfTrkEvent &event) void S60DeployStep::slotCodaEvent (const Coda::CodaEvent &event)
{ {
if (debug) if (debug)
qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString(); qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString();
switch (event.type()) { switch (event.type()) {
case tcftrk::TcfTrkEvent::LocatorHello: {// Commands accepted now case Coda::CodaEvent::LocatorHello: {// Commands accepted now
m_state = StateConnected; m_state = StateConnected;
emit codaConnected(); emit codaConnected();
startTransferring(); startTransferring();
@@ -491,14 +491,14 @@ void S60DeployStep::initFileSending()
QTC_ASSERT(m_currentFileIndex >= 0, return); QTC_ASSERT(m_currentFileIndex >= 0, return);
const unsigned flags = const unsigned flags =
tcftrk::TcfTrkDevice::FileSystem_TCF_O_WRITE Coda::CodaDevice::FileSystem_TCF_O_WRITE
|tcftrk::TcfTrkDevice::FileSystem_TCF_O_CREAT |Coda::CodaDevice::FileSystem_TCF_O_CREAT
|tcftrk::TcfTrkDevice::FileSystem_TCF_O_TRUNC; |Coda::CodaDevice::FileSystem_TCF_O_TRUNC;
m_putWriteOk = false; m_putWriteOk = false;
QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName()); QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName());
QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName); QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName);
m_trkDevice->sendFileSystemOpenCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemOpen), m_trkDevice->sendFileSystemOpenCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemOpen),
remoteFileLocation.toAscii(), flags); remoteFileLocation.toAscii(), flags);
appendMessage(tr("Copying \"%1\"...").arg(packageName), false); appendMessage(tr("Copying \"%1\"...").arg(packageName), false);
} }
@@ -511,11 +511,11 @@ void S60DeployStep::initFileInstallation()
QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName()); QString packageName(QFileInfo(m_signedPackages.at(m_currentFileIndex)).fileName());
QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName); QString remoteFileLocation = QString::fromLatin1("%1:\\Data\\%2").arg(m_installationDrive).arg(packageName);
if (m_silentInstall) { if (m_silentInstall) {
m_trkDevice->sendSymbianInstallSilentInstallCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleSymbianInstall), m_trkDevice->sendSymbianInstallSilentInstallCommand(Coda::CodaCallback(this, &S60DeployStep::handleSymbianInstall),
remoteFileLocation.toAscii(), QString::fromLatin1("%1:").arg(m_installationDrive).toAscii()); remoteFileLocation.toAscii(), QString::fromLatin1("%1:").arg(m_installationDrive).toAscii());
appendMessage(tr("Installing package \"%1\" on drive %2:...").arg(packageName).arg(m_installationDrive), false); appendMessage(tr("Installing package \"%1\" on drive %2:...").arg(packageName).arg(m_installationDrive), false);
} else { } else {
m_trkDevice->sendSymbianInstallUIInstallCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleSymbianInstall), m_trkDevice->sendSymbianInstallUIInstallCommand(Coda::CodaCallback(this, &S60DeployStep::handleSymbianInstall),
remoteFileLocation.toAscii()); remoteFileLocation.toAscii());
appendMessage(tr("Please continue the installation on your device."), false); appendMessage(tr("Please continue the installation on your device."), false);
emit manualInstallation(); emit manualInstallation();
@@ -536,9 +536,9 @@ void S60DeployStep::startInstalling()
m_state = StateInstalling; m_state = StateInstalling;
} }
void S60DeployStep::handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &result) void S60DeployStep::handleFileSystemOpen(const Coda::CodaCommandResult &result)
{ {
if (result.type != tcftrk::TcfTrkCommandResult::SuccessReply) { if (result.type != Coda::CodaCommandResult::SuccessReply) {
reportError(tr("Open remote file failed: %1").arg(result.errorString())); reportError(tr("Open remote file failed: %1").arg(result.errorString()));
return; return;
} }
@@ -558,9 +558,9 @@ void S60DeployStep::handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &resu
putSendNextChunk(); putSendNextChunk();
} }
void S60DeployStep::handleSymbianInstall(const tcftrk::TcfTrkCommandResult &result) void S60DeployStep::handleSymbianInstall(const Coda::CodaCommandResult &result)
{ {
if (result.type == tcftrk::TcfTrkCommandResult::SuccessReply) { if (result.type == Coda::CodaCommandResult::SuccessReply) {
appendMessage(tr("Installation has finished"), false); appendMessage(tr("Installation has finished"), false);
if (++m_currentFileIndex >= m_signedPackages.count()) if (++m_currentFileIndex >= m_signedPackages.count())
emit allFilesInstalled(); emit allFilesInstalled();
@@ -587,7 +587,7 @@ void S60DeployStep::putSendNextChunk()
qDebug("Writing %llu bytes to remote file '%s' at %llu\n", qDebug("Writing %llu bytes to remote file '%s' at %llu\n",
m_putLastChunkSize, m_putLastChunkSize,
m_remoteFileHandle.constData(), pos); m_remoteFileHandle.constData(), pos);
m_trkDevice->sendFileSystemWriteCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemWrite), m_trkDevice->sendFileSystemWriteCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemWrite),
m_remoteFileHandle, data, unsigned(pos)); m_remoteFileHandle, data, unsigned(pos));
setCopyProgress((100*(m_putLastChunkSize+pos))/size); setCopyProgress((100*(m_putLastChunkSize+pos))/size);
} }
@@ -595,11 +595,11 @@ void S60DeployStep::putSendNextChunk()
void S60DeployStep::closeRemoteFile() void S60DeployStep::closeRemoteFile()
{ {
m_trkDevice->sendFileSystemCloseCommand(tcftrk::TcfTrkCallback(this, &S60DeployStep::handleFileSystemClose), m_trkDevice->sendFileSystemCloseCommand(Coda::CodaCallback(this, &S60DeployStep::handleFileSystemClose),
m_remoteFileHandle); m_remoteFileHandle);
} }
void S60DeployStep::handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &result) void S60DeployStep::handleFileSystemWrite(const Coda::CodaCommandResult &result)
{ {
// Close remote file even if copy fails // Close remote file even if copy fails
m_putWriteOk = result; m_putWriteOk = result;
@@ -615,9 +615,9 @@ void S60DeployStep::handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &res
} }
} }
void S60DeployStep::handleFileSystemClose(const tcftrk::TcfTrkCommandResult &result) void S60DeployStep::handleFileSystemClose(const Coda::CodaCommandResult &result)
{ {
if (result.type == tcftrk::TcfTrkCommandResult::SuccessReply) { if (result.type == Coda::CodaCommandResult::SuccessReply) {
if (debug) if (debug)
qDebug("File closed.\n"); qDebug("File closed.\n");
if (++m_currentFileIndex >= m_signedPackages.count()) if (++m_currentFileIndex >= m_signedPackages.count())

20
src/plugins/qt4projectmanager/qt-s60/s60deploystep.h
View File

@@ -49,10 +49,10 @@ namespace trk{
class Launcher; class Launcher;
} }
namespace tcftrk { namespace Coda {
struct TcfTrkCommandResult; struct CodaCommandResult;
class TcfTrkDevice; class CodaDevice;
class TcfTrkEvent; class CodaEvent;
} }
namespace ProjectExplorer { namespace ProjectExplorer {
@@ -129,7 +129,7 @@ private slots:
void slotError(const QString &error); void slotError(const QString &error);
void slotTrkLogMessage(const QString &log); void slotTrkLogMessage(const QString &log);
void slotSerialPong(const QString &message); void slotSerialPong(const QString &message);
void slotTcftrkEvent(const tcftrk::TcfTrkEvent &event); void slotCodaEvent(const Coda::CodaEvent &event);
void startInstalling(); void startInstalling();
void startTransferring(); void startTransferring();
@@ -167,12 +167,12 @@ private:
void appendMessage(const QString &error, bool isError); void appendMessage(const QString &error, bool isError);
void reportError(const QString &error); void reportError(const QString &error);
void handleSymbianInstall(const tcftrk::TcfTrkCommandResult &result); void handleSymbianInstall(const Coda::CodaCommandResult &result);
void handleFileSystemOpen(const tcftrk::TcfTrkCommandResult &result); void handleFileSystemOpen(const Coda::CodaCommandResult &result);
void handleFileSystemWrite(const tcftrk::TcfTrkCommandResult &result); void handleFileSystemWrite(const Coda::CodaCommandResult &result);
void closeRemoteFile(); void closeRemoteFile();
void putSendNextChunk(); void putSendNextChunk();
void handleFileSystemClose(const tcftrk::TcfTrkCommandResult &result); void handleFileSystemClose(const Coda::CodaCommandResult &result);
void initFileSending(); void initFileSending();
void initFileInstallation(); void initFileInstallation();
@@ -201,7 +201,7 @@ private:
QFutureInterface<bool> *m_futureInterface; //not owned QFutureInterface<bool> *m_futureInterface; //not owned
trk::Launcher *m_launcher; trk::Launcher *m_launcher;
tcftrk::TcfTrkDevice *m_trkDevice; Coda::CodaDevice *m_trkDevice;
QEventLoop *m_eventLoop; QEventLoop *m_eventLoop;
bool m_deployResult; bool m_deployResult;

280
src/shared/symbianutils/tcftrkdevice.cpp → src/shared/symbianutils/codadevice.cpp
View File

@@ -31,7 +31,7 @@
** **
**************************************************************************/ **************************************************************************/
#include "tcftrkdevice.h" #include "codadevice.h"
#include "json.h" #include "json.h"
#include "trkutils.h" #include "trkutils.h"
@@ -106,18 +106,18 @@ static inline QByteArray encodeUsbSerialMessage(const QByteArray &dataIn)
pos = chunkEnd; pos = chunkEnd;
} }
if (debug > 1) if (debug > 1)
qDebug("Serial chunked:\n%s", qPrintable(tcftrk::formatData(frame))); qDebug("Serial chunked:\n%s", qPrintable(Coda::formatData(frame)));
return frame; return frame;
} }
namespace tcftrk { namespace Coda {
// ------------- TcfTrkCommandError // ------------- CodaCommandError
TcfTrkCommandError::TcfTrkCommandError() : timeMS(0), code(0), alternativeCode(0) CodaCommandError::CodaCommandError() : timeMS(0), code(0), alternativeCode(0)
{ {
} }
void TcfTrkCommandError::clear() void CodaCommandError::clear()
{ {
timeMS = 0; timeMS = 0;
code = alternativeCode = 0; code = alternativeCode = 0;
@@ -125,17 +125,17 @@ void TcfTrkCommandError::clear()
alternativeOrganization.clear(); alternativeOrganization.clear();
} }
QDateTime TcfTrkCommandResult::tcfTimeToQDateTime(quint64 tcfTimeMS) QDateTime CodaCommandResult::tcfTimeToQDateTime(quint64 tcfTimeMS)
{ {
const QDateTime time(QDate(1970, 1, 1)); const QDateTime time(QDate(1970, 1, 1));
return time.addMSecs(tcfTimeMS); return time.addMSecs(tcfTimeMS);
} }
void TcfTrkCommandError::write(QTextStream &str) const void CodaCommandError::write(QTextStream &str) const
{ {
if (isError()) { if (isError()) {
if (timeMS) if (timeMS)
str << TcfTrkCommandResult::tcfTimeToQDateTime(timeMS).toString(Qt::ISODate) << ": "; str << CodaCommandResult::tcfTimeToQDateTime(timeMS).toString(Qt::ISODate) << ": ";
str << "Error code: " << code str << "Error code: " << code
<< " '" << format << '\''; << " '" << format << '\'';
if (!alternativeOrganization.isEmpty()) if (!alternativeOrganization.isEmpty())
@@ -145,7 +145,7 @@ void TcfTrkCommandError::write(QTextStream &str) const
} }
} }
QString TcfTrkCommandError::toString() const QString CodaCommandError::toString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
@@ -153,13 +153,13 @@ QString TcfTrkCommandError::toString() const
return rc; return rc;
} }
bool TcfTrkCommandError::isError() const bool CodaCommandError::isError() const
{ {
return timeMS != 0 || code != 0 || !format.isEmpty() || alternativeCode != 0; return timeMS != 0 || code != 0 || !format.isEmpty() || alternativeCode != 0;
} }
/* {"Time":1277459762255,"Code":1,"AltCode":-6,"AltOrg":"POSIX","Format":"Unknown error: -6"} */ /* {"Time":1277459762255,"Code":1,"AltCode":-6,"AltOrg":"POSIX","Format":"Unknown error: -6"} */
bool TcfTrkCommandError::parse(const QVector<JsonValue> &values) bool CodaCommandError::parse(const QVector<JsonValue> &values)
{ {
// Parse an arbitrary hash (that could as well be a command response) // Parse an arbitrary hash (that could as well be a command response)
// and check for error elements. It looks like sometimes errors are appended // and check for error elements. It looks like sometimes errors are appended
@@ -199,21 +199,21 @@ bool TcfTrkCommandError::parse(const QVector<JsonValue> &values)
if (!errorFound) if (!errorFound)
clear(); clear();
if (debug) { if (debug) {
qDebug("TcfTrkCommandError::parse: Found error %d (%u): ", errorFound, errorKeyCount); qDebug("CodaCommandError::parse: Found error %d (%u): ", errorFound, errorKeyCount);
if (!values.isEmpty()) if (!values.isEmpty())
qDebug() << values.back().toString(); qDebug() << values.back().toString();
} }
return errorFound; return errorFound;
} }
// ------------ TcfTrkCommandResult // ------------ CodaCommandResult
TcfTrkCommandResult::TcfTrkCommandResult(Type t) : CodaCommandResult::CodaCommandResult(Type t) :
type(t), service(LocatorService) type(t), service(LocatorService)
{ {
} }
TcfTrkCommandResult::TcfTrkCommandResult(char typeChar, Services s, CodaCommandResult::CodaCommandResult(char typeChar, Services s,
const QByteArray &r, const QByteArray &r,
const QVector<JsonValue> &v, const QVector<JsonValue> &v,
const QVariant &ck) : const QVariant &ck) :
@@ -234,7 +234,7 @@ TcfTrkCommandResult::TcfTrkCommandResult(char typeChar, Services s,
} }
} }
QString TcfTrkCommandResult::errorString() const QString CodaCommandResult::errorString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
@@ -259,7 +259,7 @@ QString TcfTrkCommandResult::errorString() const
return rc; return rc;
} }
QString TcfTrkCommandResult::toString() const QString CodaCommandResult::toString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
@@ -292,19 +292,19 @@ QString TcfTrkCommandResult::toString() const
return rc; return rc;
} }
TcfTrkStatResponse::TcfTrkStatResponse() : size(0) CodaStatResponse::CodaStatResponse() : size(0)
{ {
} }
struct TcfTrkSendQueueEntry struct CodaSendQueueEntry
{ {
typedef TcfTrkDevice::MessageType MessageType; typedef CodaDevice::MessageType MessageType;
explicit TcfTrkSendQueueEntry(MessageType mt, explicit CodaSendQueueEntry(MessageType mt,
int tok, int tok,
Services s, Services s,
const QByteArray &d, const QByteArray &d,
const TcfTrkCallback &cb= TcfTrkCallback(), const CodaCallback &cb= CodaCallback(),
const QVariant &ck = QVariant()) : const QVariant &ck = QVariant()) :
messageType(mt), service(s), data(d), token(tok), cookie(ck), callback(cb) {} messageType(mt), service(s), data(d), token(tok), cookie(ck), callback(cb) {}
@@ -313,15 +313,15 @@ struct TcfTrkSendQueueEntry
QByteArray data; QByteArray data;
int token; int token;
QVariant cookie; QVariant cookie;
TcfTrkCallback callback; CodaCallback callback;
unsigned specialHandling; unsigned specialHandling;
}; };
struct TcfTrkDevicePrivate { struct CodaDevicePrivate {
typedef TcfTrkDevice::IODevicePtr IODevicePtr; typedef CodaDevice::IODevicePtr IODevicePtr;
typedef QHash<int, TcfTrkSendQueueEntry> TokenWrittenMessageMap; typedef QHash<int, CodaSendQueueEntry> TokenWrittenMessageMap;
TcfTrkDevicePrivate(); CodaDevicePrivate();
const QByteArray m_tcpMessageTerminator; const QByteArray m_tcpMessageTerminator;
@@ -330,7 +330,7 @@ struct TcfTrkDevicePrivate {
QByteArray m_readBuffer; QByteArray m_readBuffer;
QByteArray m_serialBuffer; // for chunked messages QByteArray m_serialBuffer; // for chunked messages
int m_token; int m_token;
QQueue<TcfTrkSendQueueEntry> m_sendQueue; QQueue<CodaSendQueueEntry> m_sendQueue;
TokenWrittenMessageMap m_writtenMessages; TokenWrittenMessageMap m_writtenMessages;
QVector<QByteArray> m_registerNames; QVector<QByteArray> m_registerNames;
QVector<QByteArray> m_fakeGetMRegisterValues; QVector<QByteArray> m_fakeGetMRegisterValues;
@@ -338,28 +338,28 @@ struct TcfTrkDevicePrivate {
bool m_serialPingOnly; bool m_serialPingOnly;
}; };
TcfTrkDevicePrivate::TcfTrkDevicePrivate() : CodaDevicePrivate::CodaDevicePrivate() :
m_tcpMessageTerminator(tcpMessageTerminatorC), m_tcpMessageTerminator(tcpMessageTerminatorC),
m_verbose(0), m_token(0), m_serialFrame(false), m_serialPingOnly(false) m_verbose(0), m_token(0), m_serialFrame(false), m_serialPingOnly(false)
{ {
} }
TcfTrkDevice::TcfTrkDevice(QObject *parent) : CodaDevice::CodaDevice(QObject *parent) :
QObject(parent), d(new TcfTrkDevicePrivate) QObject(parent), d(new CodaDevicePrivate)
{ {
} }
TcfTrkDevice::~TcfTrkDevice() CodaDevice::~CodaDevice()
{ {
delete d; delete d;
} }
QVector<QByteArray> TcfTrkDevice::registerNames() const QVector<QByteArray> CodaDevice::registerNames() const
{ {
return d->m_registerNames; return d->m_registerNames;
} }
void TcfTrkDevice::setRegisterNames(const QVector<QByteArray>& n) void CodaDevice::setRegisterNames(const QVector<QByteArray>& n)
{ {
d->m_registerNames = n; d->m_registerNames = n;
if (d->m_verbose) { if (d->m_verbose) {
@@ -373,12 +373,12 @@ void TcfTrkDevice::setRegisterNames(const QVector<QByteArray>& n)
} }
} }
TcfTrkDevice::IODevicePtr TcfTrkDevice::device() const CodaDevice::IODevicePtr CodaDevice::device() const
{ {
return d->m_device; return d->m_device;
} }
TcfTrkDevice::IODevicePtr TcfTrkDevice::takeDevice() CodaDevice::IODevicePtr CodaDevice::takeDevice()
{ {
const IODevicePtr old = d->m_device; const IODevicePtr old = d->m_device;
if (!old.isNull()) { if (!old.isNull()) {
@@ -391,7 +391,7 @@ TcfTrkDevice::IODevicePtr TcfTrkDevice::takeDevice()
return old; return old;
} }
void TcfTrkDevice::setDevice(const IODevicePtr &dp) void CodaDevice::setDevice(const IODevicePtr &dp)
{ {
if (dp.data() == d->m_device.data()) if (dp.data() == d->m_device.data())
return; return;
@@ -408,14 +408,14 @@ void TcfTrkDevice::setDevice(const IODevicePtr &dp)
} }
} }
void TcfTrkDevice::slotDeviceError() void CodaDevice::slotDeviceError()
{ {
const QString message = d->m_device->errorString(); const QString message = d->m_device->errorString();
emitLogMessage(message); emitLogMessage(message);
emit error(message); emit error(message);
} }
void TcfTrkDevice::slotDeviceSocketStateChanged() void CodaDevice::slotDeviceSocketStateChanged()
{ {
if (const QAbstractSocket *s = qobject_cast<const QAbstractSocket *>(d->m_device.data())) { if (const QAbstractSocket *s = qobject_cast<const QAbstractSocket *>(d->m_device.data())) {
const QAbstractSocket::SocketState st = s->state(); const QAbstractSocket::SocketState st = s->state();
@@ -455,7 +455,7 @@ static inline QString debugMessage(QByteArray message, const char *prefix = 0)
(QLatin1String(prefix) + messageS) : messageS; (QLatin1String(prefix) + messageS) : messageS;
} }
void TcfTrkDevice::slotDeviceReadyRead() void CodaDevice::slotDeviceReadyRead()
{ {
const QByteArray newData = d->m_device->readAll(); const QByteArray newData = d->m_device->readAll();
d->m_readBuffer += newData; d->m_readBuffer += newData;
@@ -492,7 +492,7 @@ static inline QPair<int, int> findSerialHeader(const QByteArray &in)
return QPair<int, int>(-1, -1); return QPair<int, int>(-1, -1);
} }
void TcfTrkDevice::deviceReadyReadSerial() void CodaDevice::deviceReadyReadSerial()
{ {
do { do {
// Extract message (pos,len) // Extract message (pos,len)
@@ -509,7 +509,7 @@ void TcfTrkDevice::deviceReadyReadSerial()
checkSendQueue(); // Send off further messages checkSendQueue(); // Send off further messages
} }
void TcfTrkDevice::processSerialMessage(const QByteArray &message) void CodaDevice::processSerialMessage(const QByteArray &message)
{ {
if (debug > 1) if (debug > 1)
qDebug("Serial message: %s",qPrintable(trk::stringFromArray(message))); qDebug("Serial message: %s",qPrintable(trk::stringFromArray(message)));
@@ -551,7 +551,7 @@ void TcfTrkDevice::processSerialMessage(const QByteArray &message)
} }
} }
void TcfTrkDevice::deviceReadyReadTcp() void CodaDevice::deviceReadyReadTcp()
{ {
// Take complete message off front of readbuffer. // Take complete message off front of readbuffer.
do { do {
@@ -569,7 +569,7 @@ void TcfTrkDevice::deviceReadyReadTcp()
checkSendQueue(); // Send off further messages checkSendQueue(); // Send off further messages
} }
void TcfTrkDevice::processMessage(const QByteArray &message) void CodaDevice::processMessage(const QByteArray &message)
{ {
if (debug) if (debug)
qDebug("Read %d bytes:\n%s", message.size(), qPrintable(formatData(message))); qDebug("Read %d bytes:\n%s", message.size(), qPrintable(formatData(message)));
@@ -598,7 +598,7 @@ static inline QVector<QByteArray> splitMessage(const QByteArray &message)
return tokens; return tokens;
} }
int TcfTrkDevice::parseMessage(const QByteArray &message) int CodaDevice::parseMessage(const QByteArray &message)
{ {
if (d->m_verbose) if (d->m_verbose)
emitLogMessage(debugMessage(message, "TCF ->")); emitLogMessage(debugMessage(message, "TCF ->"));
@@ -630,9 +630,9 @@ int TcfTrkDevice::parseMessage(const QByteArray &message)
return 0; return 0;
} }
int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tokens) int CodaDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tokens)
{ {
typedef TcfTrkDevicePrivate::TokenWrittenMessageMap::iterator TokenWrittenMessageMapIterator; typedef CodaDevicePrivate::TokenWrittenMessageMap::iterator TokenWrittenMessageMapIterator;
// Find the corresponding entry in the written messages hash. // Find the corresponding entry in the written messages hash.
const int tokenCount = tokens.size(); const int tokenCount = tokens.size();
if (tokenCount < 1) if (tokenCount < 1)
@@ -643,7 +643,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
return 235; return 235;
const TokenWrittenMessageMapIterator it = d->m_writtenMessages.find(token); const TokenWrittenMessageMapIterator it = d->m_writtenMessages.find(token);
if (it == d->m_writtenMessages.end()) { if (it == d->m_writtenMessages.end()) {
qWarning("TcfTrkDevice: Internal error: token %d not found for '%s'", qWarning("CodaDevice: Internal error: token %d not found for '%s'",
token, qPrintable(joinByteArrays(tokens))); token, qPrintable(joinByteArrays(tokens)));
return 236; return 236;
} }
@@ -670,7 +670,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
} }
} }
// Construct result and invoke callback, remove entry from map. // Construct result and invoke callback, remove entry from map.
TcfTrkCommandResult result(type, it.value().service, it.value().data, CodaCommandResult result(type, it.value().service, it.value().data,
values, it.value().cookie); values, it.value().cookie);
if (it.value().callback) if (it.value().callback)
@@ -679,7 +679,7 @@ int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tok
return 0; return 0;
} }
int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens) int CodaDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
{ {
// Event: Ignore the periodical heartbeat event, answer 'Hello', // Event: Ignore the periodical heartbeat event, answer 'Hello',
// emit signal for the rest // emit signal for the rest
@@ -696,10 +696,10 @@ int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
values.push_back(value); values.push_back(value);
} }
// Parse known events, emit signals // Parse known events, emit signals
QScopedPointer<TcfTrkEvent> knownEvent(TcfTrkEvent::parseEvent(service, tokens.at(1), values)); QScopedPointer<CodaEvent> knownEvent(CodaEvent::parseEvent(service, tokens.at(1), values));
if (!knownEvent.isNull()) { if (!knownEvent.isNull()) {
// Answer hello event (WLAN) // Answer hello event (WLAN)
if (knownEvent->type() == TcfTrkEvent::LocatorHello) if (knownEvent->type() == CodaEvent::LocatorHello)
if (!d->m_serialFrame) if (!d->m_serialFrame)
writeMessage(QByteArray(locatorAnswerC, sizeof(locatorAnswerC))); writeMessage(QByteArray(locatorAnswerC, sizeof(locatorAnswerC)));
emit tcfEvent(*knownEvent); emit tcfEvent(*knownEvent);
@@ -722,47 +722,47 @@ int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)
return 0; return 0;
} }
unsigned TcfTrkDevice::verbose() const unsigned CodaDevice::verbose() const
{ {
return d->m_verbose; return d->m_verbose;
} }
bool TcfTrkDevice::serialFrame() const bool CodaDevice::serialFrame() const
{ {
return d->m_serialFrame; return d->m_serialFrame;
} }
void TcfTrkDevice::setSerialFrame(bool s) void CodaDevice::setSerialFrame(bool s)
{ {
d->m_serialFrame = s; d->m_serialFrame = s;
} }
void TcfTrkDevice::setVerbose(unsigned v) void CodaDevice::setVerbose(unsigned v)
{ {
d->m_verbose = v; d->m_verbose = v;
} }
void TcfTrkDevice::emitLogMessage(const QString &m) void CodaDevice::emitLogMessage(const QString &m)
{ {
if (debug) if (debug)
qWarning("%s", qPrintable(m)); qWarning("%s", qPrintable(m));
emit logMessage(m); emit logMessage(m);
} }
bool TcfTrkDevice::checkOpen() bool CodaDevice::checkOpen()
{ {
if (d->m_device.isNull()) { if (d->m_device.isNull()) {
emitLogMessage(QLatin1String("Internal error: No device set on TcfTrkDevice.")); emitLogMessage(QLatin1String("Internal error: No device set on CodaDevice."));
return false; return false;
} }
if (!d->m_device->isOpen()) { if (!d->m_device->isOpen()) {
emitLogMessage(QLatin1String("Internal error: Device not open in TcfTrkDevice.")); emitLogMessage(QLatin1String("Internal error: Device not open in CodaDevice."));
return false; return false;
} }
return true; return true;
} }
void TcfTrkDevice::sendSerialPing(bool pingOnly) void CodaDevice::sendSerialPing(bool pingOnly)
{ {
if (!checkOpen()) if (!checkOpen())
return; return;
@@ -774,10 +774,10 @@ void TcfTrkDevice::sendSerialPing(bool pingOnly)
emitLogMessage(QLatin1String("Ping...")); emitLogMessage(QLatin1String("Ping..."));
} }
void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const char *command, void CodaDevice::sendCodaMessage(MessageType mt, Services service, const char *command,
const char *commandParameters, // may contain '\0' const char *commandParameters, // may contain '\0'
int commandParametersLength, int commandParametersLength,
const TcfTrkCallback &callBack, const CodaCallback &callBack,
const QVariant &cookie) const QVariant &cookie)
{ {
@@ -797,22 +797,22 @@ void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const cha
data.append('\0'); data.append('\0');
if (commandParametersLength) if (commandParametersLength)
data.append(commandParameters, commandParametersLength); data.append(commandParameters, commandParametersLength);
const TcfTrkSendQueueEntry entry(mt, token, service, data, callBack, cookie); const CodaSendQueueEntry entry(mt, token, service, data, callBack, cookie);
d->m_sendQueue.enqueue(entry); d->m_sendQueue.enqueue(entry);
checkSendQueue(); checkSendQueue();
} }
void TcfTrkDevice::sendTcfTrkMessage(MessageType mt, Services service, const char *command, void CodaDevice::sendCodaMessage(MessageType mt, Services service, const char *command,
const QByteArray &commandParameters, const QByteArray &commandParameters,
const TcfTrkCallback &callBack, const CodaCallback &callBack,
const QVariant &cookie) const QVariant &cookie)
{ {
sendTcfTrkMessage(mt, service, command, commandParameters.constData(), commandParameters.size(), sendCodaMessage(mt, service, command, commandParameters.constData(), commandParameters.size(),
callBack, cookie); callBack, cookie);
} }
// Enclose in message frame and write. // Enclose in message frame and write.
void TcfTrkDevice::writeMessage(QByteArray data, bool ensureTerminating0) void CodaDevice::writeMessage(QByteArray data, bool ensureTerminating0)
{ {
if (!checkOpen()) if (!checkOpen())
return; return;
@@ -844,14 +844,14 @@ void TcfTrkDevice::writeMessage(QByteArray data, bool ensureTerminating0)
as->flush(); as->flush();
} }
void TcfTrkDevice::checkSendQueue() void CodaDevice::checkSendQueue()
{ {
// Fire off messages or invoke noops until a message with reply is found // Fire off messages or invoke noops until a message with reply is found
// and an entry to writtenMessages is made. // and an entry to writtenMessages is made.
while (d->m_writtenMessages.empty()) { while (d->m_writtenMessages.empty()) {
if (d->m_sendQueue.isEmpty()) if (d->m_sendQueue.isEmpty())
break; break;
TcfTrkSendQueueEntry entry = d->m_sendQueue.dequeue(); CodaSendQueueEntry entry = d->m_sendQueue.dequeue();
switch (entry.messageType) { switch (entry.messageType) {
case MessageWithReply: case MessageWithReply:
d->m_writtenMessages.insert(entry.token, entry); d->m_writtenMessages.insert(entry.token, entry);
@@ -862,7 +862,7 @@ void TcfTrkDevice::checkSendQueue()
break; break;
case NoopMessage: // Invoke the noop-callback for synchronization case NoopMessage: // Invoke the noop-callback for synchronization
if (entry.callback) { if (entry.callback) {
TcfTrkCommandResult noopResult(TcfTrkCommandResult::SuccessReply); CodaCommandResult noopResult(CodaCommandResult::SuccessReply);
noopResult.cookie = entry.cookie; noopResult.cookie = entry.cookie;
entry.callback(noopResult); entry.callback(noopResult);
} }
@@ -879,7 +879,7 @@ static inline QString fixFileName(QString in)
} }
// Start a process (consisting of a non-reply setSettings and start). // Start a process (consisting of a non-reply setSettings and start).
void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack, void CodaDevice::sendProcessStartCommand(const CodaCallback &callBack,
const QString &binaryIn, const QString &binaryIn,
unsigned uid, unsigned uid,
QStringList arguments, QStringList arguments,
@@ -911,7 +911,7 @@ void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack,
<< '{' << binaryFileName << ':' << QString::number(uid, 16) << '}' << ',' << '{' << binaryFileName << ':' << QString::number(uid, 16) << '}' << ','
<< additionalLibraries << ',' << true << additionalLibraries << ',' << true
<< ']'; << ']';
sendTcfTrkMessage( sendCodaMessage(
#if 1 #if 1
MessageWithReply, // TCF TRK 4.0.5 onwards MessageWithReply, // TCF TRK 4.0.5 onwards
#else #else
@@ -925,10 +925,10 @@ void TcfTrkDevice::sendProcessStartCommand(const TcfTrkCallback &callBack,
<< '\0' << binaryFileName << '\0' << arguments << '\0' << '\0' << binaryFileName << '\0' << arguments << '\0'
<< QStringList() << '\0' // Env is an array ["PATH=value"] (non-standard) << QStringList() << '\0' // Env is an array ["PATH=value"] (non-standard)
<< debugControl; << debugControl;
sendTcfTrkMessage(MessageWithReply, ProcessesService, "start", startData, callBack, cookie); sendCodaMessage(MessageWithReply, ProcessesService, "start", startData, callBack, cookie);
} }
void TcfTrkDevice::sendSettingsEnableLogCommand() void CodaDevice::sendSettingsEnableLogCommand()
{ {
QByteArray setData; QByteArray setData;
@@ -938,7 +938,7 @@ void TcfTrkDevice::sendSettingsEnableLogCommand()
<< '\0' << '[' << '\0' << '['
<< true << true
<< ']'; << ']';
sendTcfTrkMessage( sendCodaMessage(
#if 1 #if 1
MessageWithReply, // TCF TRK 4.0.5 onwards MessageWithReply, // TCF TRK 4.0.5 onwards
#else #else
@@ -947,28 +947,28 @@ void TcfTrkDevice::sendSettingsEnableLogCommand()
SettingsService, "set", setData); SettingsService, "set", setData);
} }
void TcfTrkDevice::sendProcessTerminateCommand(const TcfTrkCallback &callBack, void CodaDevice::sendProcessTerminateCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << id; str << id;
sendTcfTrkMessage(MessageWithReply, ProcessesService, "terminate", data, callBack, cookie); sendCodaMessage(MessageWithReply, ProcessesService, "terminate", data, callBack, cookie);
} }
void TcfTrkDevice::sendRunControlTerminateCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRunControlTerminateCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << id; str << id;
sendTcfTrkMessage(MessageWithReply, RunControlService, "terminate", data, callBack, cookie); sendCodaMessage(MessageWithReply, RunControlService, "terminate", data, callBack, cookie);
} }
// Non-standard: Remove executable from settings // Non-standard: Remove executable from settings
void TcfTrkDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn, void CodaDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn,
unsigned uid, unsigned uid,
const QStringList &additionalLibraries, const QStringList &additionalLibraries,
const QVariant &cookie) const QVariant &cookie)
@@ -981,10 +981,10 @@ void TcfTrkDevice::sendSettingsRemoveExecutableCommand(const QString &binaryIn,
<< '{' << QFileInfo(binaryIn).fileName() << ':' << QString::number(uid, 16) << '}' << ',' << '{' << QFileInfo(binaryIn).fileName() << ':' << QString::number(uid, 16) << '}' << ','
<< additionalLibraries << additionalLibraries
<< ']'; << ']';
sendTcfTrkMessage(MessageWithoutReply, SettingsService, "set", setData, TcfTrkCallback(), cookie); sendCodaMessage(MessageWithoutReply, SettingsService, "set", setData, CodaCallback(), cookie);
} }
void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRunControlResumeCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
RunControlResumeMode mode, RunControlResumeMode mode,
unsigned count, unsigned count,
@@ -1006,54 +1006,54 @@ void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack,
default: default:
break; break;
} }
sendTcfTrkMessage(MessageWithReply, RunControlService, "resume", resumeData, callBack, cookie); sendCodaMessage(MessageWithReply, RunControlService, "resume", resumeData, callBack, cookie);
} }
void TcfTrkDevice::sendRunControlSuspendCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRunControlSuspendCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << id; str << id;
sendTcfTrkMessage(MessageWithReply, RunControlService, "suspend", data, callBack, cookie); sendCodaMessage(MessageWithReply, RunControlService, "suspend", data, callBack, cookie);
} }
void TcfTrkDevice::sendRunControlResumeCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRunControlResumeCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie) const QVariant &cookie)
{ {
sendRunControlResumeCommand(callBack, id, RM_RESUME, 1, 0, 0, cookie); sendRunControlResumeCommand(callBack, id, RM_RESUME, 1, 0, 0, cookie);
} }
void TcfTrkDevice::sendBreakpointsAddCommand(const TcfTrkCallback &callBack, void CodaDevice::sendBreakpointsAddCommand(const CodaCallback &callBack,
const Breakpoint &bp, const Breakpoint &bp,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << bp; str << bp;
sendTcfTrkMessage(MessageWithReply, BreakpointsService, "add", data, callBack, cookie); sendCodaMessage(MessageWithReply, BreakpointsService, "add", data, callBack, cookie);
} }
void TcfTrkDevice::sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack, void CodaDevice::sendBreakpointsRemoveCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie) const QVariant &cookie)
{ {
sendBreakpointsRemoveCommand(callBack, QVector<QByteArray>(1, id), cookie); sendBreakpointsRemoveCommand(callBack, QVector<QByteArray>(1, id), cookie);
} }
void TcfTrkDevice::sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack, void CodaDevice::sendBreakpointsRemoveCommand(const CodaCallback &callBack,
const QVector<QByteArray> &ids, const QVector<QByteArray> &ids,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << ids; str << ids;
sendTcfTrkMessage(MessageWithReply, BreakpointsService, "remove", data, callBack, cookie); sendCodaMessage(MessageWithReply, BreakpointsService, "remove", data, callBack, cookie);
} }
void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack, void CodaDevice::sendBreakpointsEnableCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
bool enable, bool enable,
const QVariant &cookie) const QVariant &cookie)
@@ -1061,7 +1061,7 @@ void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
sendBreakpointsEnableCommand(callBack, QVector<QByteArray>(1, id), enable, cookie); sendBreakpointsEnableCommand(callBack, QVector<QByteArray>(1, id), enable, cookie);
} }
void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack, void CodaDevice::sendBreakpointsEnableCommand(const CodaCallback &callBack,
const QVector<QByteArray> &ids, const QVector<QByteArray> &ids,
bool enable, bool enable,
const QVariant &cookie) const QVariant &cookie)
@@ -1069,12 +1069,12 @@ void TcfTrkDevice::sendBreakpointsEnableCommand(const TcfTrkCallback &callBack,
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << ids; str << ids;
sendTcfTrkMessage(MessageWithReply, BreakpointsService, sendCodaMessage(MessageWithReply, BreakpointsService,
enable ? "enable" : "disable", enable ? "enable" : "disable",
data, callBack, cookie); data, callBack, cookie);
} }
void TcfTrkDevice::sendMemorySetCommand(const TcfTrkCallback &callBack, void CodaDevice::sendMemorySetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
quint64 start, const QByteArray& data, quint64 start, const QByteArray& data,
const QVariant &cookie) const QVariant &cookie)
@@ -1084,10 +1084,10 @@ void TcfTrkDevice::sendMemorySetCommand(const TcfTrkCallback &callBack,
// start/word size/mode. Mode should ideally be 1 (continue on error?) // start/word size/mode. Mode should ideally be 1 (continue on error?)
str << contextId << '\0' << start << '\0' << 1 << '\0' << data.size() << '\0' << 1 str << contextId << '\0' << start << '\0' << 1 << '\0' << data.size() << '\0' << 1
<< '\0' << data.toBase64(); << '\0' << data.toBase64();
sendTcfTrkMessage(MessageWithReply, MemoryService, "set", getData, callBack, cookie); sendCodaMessage(MessageWithReply, MemoryService, "set", getData, callBack, cookie);
} }
void TcfTrkDevice::sendMemoryGetCommand(const TcfTrkCallback &callBack, void CodaDevice::sendMemoryGetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
quint64 start, quint64 size, quint64 start, quint64 size,
const QVariant &cookie) const QVariant &cookie)
@@ -1096,12 +1096,12 @@ void TcfTrkDevice::sendMemoryGetCommand(const TcfTrkCallback &callBack,
JsonInputStream str(data); JsonInputStream str(data);
// start/word size/mode. Mode should ideally be 1 (continue on error?) // start/word size/mode. Mode should ideally be 1 (continue on error?)
str << contextId << '\0' << start << '\0' << 1 << '\0' << size << '\0' << 1; str << contextId << '\0' << start << '\0' << 1 << '\0' << size << '\0' << 1;
sendTcfTrkMessage(MessageWithReply, MemoryService, "get", data, callBack, cookie); sendCodaMessage(MessageWithReply, MemoryService, "get", data, callBack, cookie);
} }
QByteArray TcfTrkDevice::parseMemoryGet(const TcfTrkCommandResult &r) QByteArray CodaDevice::parseMemoryGet(const CodaCommandResult &r)
{ {
if (r.type != TcfTrkCommandResult::SuccessReply || r.values.size() < 1) if (r.type != CodaCommandResult::SuccessReply || r.values.size() < 1)
return QByteArray(); return QByteArray();
const JsonValue &memoryV = r.values.front(); const JsonValue &memoryV = r.values.front();
@@ -1112,18 +1112,18 @@ QByteArray TcfTrkDevice::parseMemoryGet(const TcfTrkCommandResult &r)
// R.4."TlVMTA==".{"Time":1276786871255,"Code":1,"AltCode":-38,"AltOrg":"POSIX","Format":"BadDescriptor"} // R.4."TlVMTA==".{"Time":1276786871255,"Code":1,"AltCode":-38,"AltOrg":"POSIX","Format":"BadDescriptor"}
// Not sure what to make of it. // Not sure what to make of it.
if (r.values.size() >= 2 && r.values.at(1).type() == JsonValue::Object) if (r.values.size() >= 2 && r.values.at(1).type() == JsonValue::Object)
qWarning("TcfTrkDevice::parseMemoryGet(): Error retrieving memory: %s", r.values.at(1).toString(false).constData()); qWarning("CodaDevice::parseMemoryGet(): Error retrieving memory: %s", r.values.at(1).toString(false).constData());
// decode // decode
const QByteArray memory = QByteArray::fromBase64(memoryV.data()); const QByteArray memory = QByteArray::fromBase64(memoryV.data());
if (memory.isEmpty()) if (memory.isEmpty())
qWarning("Base64 decoding of %s failed.", memoryV.data().constData()); qWarning("Base64 decoding of %s failed.", memoryV.data().constData());
if (debug) if (debug)
qDebug("TcfTrkDevice::parseMemoryGet: received %d bytes", memory.size()); qDebug("CodaDevice::parseMemoryGet: received %d bytes", memory.size());
return memory; return memory;
} }
// Parse register children (array of names) // Parse register children (array of names)
QVector<QByteArray> TcfTrkDevice::parseRegisterGetChildren(const TcfTrkCommandResult &r) QVector<QByteArray> CodaDevice::parseRegisterGetChildren(const CodaCommandResult &r)
{ {
QVector<QByteArray> rc; QVector<QByteArray> rc;
if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Array) if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Array)
@@ -1135,9 +1135,9 @@ QVector<QByteArray> TcfTrkDevice::parseRegisterGetChildren(const TcfTrkCommandRe
return rc; return rc;
} }
TcfTrkStatResponse TcfTrkDevice::parseStat(const TcfTrkCommandResult &r) CodaStatResponse CodaDevice::parseStat(const CodaCommandResult &r)
{ {
TcfTrkStatResponse rc; CodaStatResponse rc;
if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Object) if (!r || r.values.size() < 1 || r.values.front().type() != JsonValue::Object)
return rc; return rc;
foreach(const JsonValue &v, r.values.front().children()) { foreach(const JsonValue &v, r.values.front().children()) {
@@ -1145,23 +1145,23 @@ TcfTrkStatResponse TcfTrkDevice::parseStat(const TcfTrkCommandResult &r)
rc.size = v.data().toULongLong(); rc.size = v.data().toULongLong();
} else if (v.name() == "ATime") { } else if (v.name() == "ATime") {
if (const quint64 atime = v.data().toULongLong()) if (const quint64 atime = v.data().toULongLong())
rc.accessTime = TcfTrkCommandResult::tcfTimeToQDateTime(atime); rc.accessTime = CodaCommandResult::tcfTimeToQDateTime(atime);
} else if (v.name() == "MTime") { } else if (v.name() == "MTime") {
if (const quint64 mtime = v.data().toULongLong()) if (const quint64 mtime = v.data().toULongLong())
rc.modTime = TcfTrkCommandResult::tcfTimeToQDateTime(mtime); rc.modTime = CodaCommandResult::tcfTimeToQDateTime(mtime);
} }
} }
return rc; return rc;
} }
void TcfTrkDevice::sendRegistersGetChildrenCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersGetChildrenCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << contextId; str << contextId;
sendTcfTrkMessage(MessageWithReply, RegistersService, "getChildren", data, callBack, cookie); sendCodaMessage(MessageWithReply, RegistersService, "getChildren", data, callBack, cookie);
} }
// Format id of register get request (needs contextId containing process and thread) // Format id of register get request (needs contextId containing process and thread)
@@ -1183,16 +1183,16 @@ static inline QByteArray registerGetData(const QByteArray &contextId, QByteArray
return data; return data;
} }
void TcfTrkDevice::sendRegistersGetCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersGetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
QByteArray id, QByteArray id,
const QVariant &cookie) const QVariant &cookie)
{ {
sendTcfTrkMessage(MessageWithReply, RegistersService, "get", sendCodaMessage(MessageWithReply, RegistersService, "get",
registerGetData(contextId, id), callBack, cookie); registerGetData(contextId, id), callBack, cookie);
} }
void TcfTrkDevice::sendRegistersGetMCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersGetMCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
const QVector<QByteArray> &ids, const QVector<QByteArray> &ids,
const QVariant &cookie) const QVariant &cookie)
@@ -1209,16 +1209,16 @@ void TcfTrkDevice::sendRegistersGetMCommand(const TcfTrkCallback &callBack,
str << '[' << registerId(contextId, ids.at(r)) << ',' << '0' << ',' << '4' << ']'; str << '[' << registerId(contextId, ids.at(r)) << ',' << '0' << ',' << '4' << ']';
} }
str << ']'; str << ']';
sendTcfTrkMessage(MessageWithReply, RegistersService, "getm", data, callBack, cookie); sendCodaMessage(MessageWithReply, RegistersService, "getm", data, callBack, cookie);
} }
void TcfTrkDevice::sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersGetMRangeCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
unsigned start, unsigned count) unsigned start, unsigned count)
{ {
const unsigned end = start + count; const unsigned end = start + count;
if (end > (unsigned)d->m_registerNames.size()) { if (end > (unsigned)d->m_registerNames.size()) {
qWarning("TcfTrkDevice: No register name set for index %u (size: %d).", end, d->m_registerNames.size()); qWarning("CodaDevice: No register name set for index %u (size: %d).", end, d->m_registerNames.size());
return; return;
} }
@@ -1230,7 +1230,7 @@ void TcfTrkDevice::sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack,
} }
// Set register // Set register
void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersSetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
QByteArray id, QByteArray id,
const QByteArray &value, const QByteArray &value,
@@ -1243,18 +1243,18 @@ void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
id.prepend(contextId); id.prepend(contextId);
} }
str << id << '\0' << value.toBase64(); str << id << '\0' << value.toBase64();
sendTcfTrkMessage(MessageWithReply, RegistersService, "set", data, callBack, cookie); sendCodaMessage(MessageWithReply, RegistersService, "set", data, callBack, cookie);
} }
// Set register // Set register
void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack, void CodaDevice::sendRegistersSetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
unsigned registerNumber, unsigned registerNumber,
const QByteArray &value, const QByteArray &value,
const QVariant &cookie) const QVariant &cookie)
{ {
if (registerNumber >= (unsigned)d->m_registerNames.size()) { if (registerNumber >= (unsigned)d->m_registerNames.size()) {
qWarning("TcfTrkDevice: No register name set for index %u (size: %d).", registerNumber, d->m_registerNames.size()); qWarning("CodaDevice: No register name set for index %u (size: %d).", registerNumber, d->m_registerNames.size());
return; return;
} }
sendRegistersSetCommand(callBack, contextId, sendRegistersSetCommand(callBack, contextId,
@@ -1265,23 +1265,23 @@ void TcfTrkDevice::sendRegistersSetCommand(const TcfTrkCallback &callBack,
//static const char outputListenerIDC[] = "org.eclipse.cdt.debug.edc.ui.ProgramOutputConsoleLogger"; //static const char outputListenerIDC[] = "org.eclipse.cdt.debug.edc.ui.ProgramOutputConsoleLogger";
static const char outputListenerIDC[] = "ProgramOutputConsoleLogger"; //TODO: this one might be the correct one static const char outputListenerIDC[] = "ProgramOutputConsoleLogger"; //TODO: this one might be the correct one
void TcfTrkDevice::sendLoggingAddListenerCommand(const TcfTrkCallback &callBack, void CodaDevice::sendLoggingAddListenerCommand(const CodaCallback &callBack,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << outputListenerIDC; str << outputListenerIDC;
sendTcfTrkMessage(MessageWithReply, LoggingService, "addListener", data, callBack, cookie); sendCodaMessage(MessageWithReply, LoggingService, "addListener", data, callBack, cookie);
} }
void TcfTrkDevice::sendSymbianOsDataGetThreadsCommand(const TcfTrkCallback &callBack, void CodaDevice::sendSymbianOsDataGetThreadsCommand(const CodaCallback &callBack,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
sendTcfTrkMessage(MessageWithReply, SymbianOSData, "getThreads", data, callBack, cookie); sendCodaMessage(MessageWithReply, SymbianOSData, "getThreads", data, callBack, cookie);
} }
void TcfTrkDevice::sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &callBack, void CodaDevice::sendSymbianOsDataFindProcessesCommand(const CodaCallback &callBack,
const QByteArray &processName, const QByteArray &processName,
const QByteArray &uid, const QByteArray &uid,
const QVariant &cookie) const QVariant &cookie)
@@ -1289,10 +1289,10 @@ void TcfTrkDevice::sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &c
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << processName << '\0' << uid; str << processName << '\0' << uid;
sendTcfTrkMessage(MessageWithReply, SymbianOSData, "findRunningProcesses", data, callBack, cookie); sendCodaMessage(MessageWithReply, SymbianOSData, "findRunningProcesses", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendFileSystemOpenCommand(const tcftrk::TcfTrkCallback &callBack, void Coda::CodaDevice::sendFileSystemOpenCommand(const Coda::CodaCallback &callBack,
const QByteArray &name, const QByteArray &name,
unsigned flags, unsigned flags,
const QVariant &cookie) const QVariant &cookie)
@@ -1300,20 +1300,20 @@ void tcftrk::TcfTrkDevice::sendFileSystemOpenCommand(const tcftrk::TcfTrkCallbac
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << name << '\0' << flags << '\0' << '{' << '}'; str << name << '\0' << flags << '\0' << '{' << '}';
sendTcfTrkMessage(MessageWithReply, FileSystemService, "open", data, callBack, cookie); sendCodaMessage(MessageWithReply, FileSystemService, "open", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendFileSystemFstatCommand(const TcfTrkCallback &callBack, void Coda::CodaDevice::sendFileSystemFstatCommand(const CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << handle; str << handle;
sendTcfTrkMessage(MessageWithReply, FileSystemService, "fstat", data, callBack, cookie); sendCodaMessage(MessageWithReply, FileSystemService, "fstat", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendFileSystemWriteCommand(const tcftrk::TcfTrkCallback &callBack, void Coda::CodaDevice::sendFileSystemWriteCommand(const Coda::CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QByteArray &dataIn, const QByteArray &dataIn,
unsigned offset, unsigned offset,
@@ -1322,20 +1322,20 @@ void tcftrk::TcfTrkDevice::sendFileSystemWriteCommand(const tcftrk::TcfTrkCallba
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << handle << '\0' << offset << '\0' << dataIn.toBase64(); str << handle << '\0' << offset << '\0' << dataIn.toBase64();
sendTcfTrkMessage(MessageWithReply, FileSystemService, "write", data, callBack, cookie); sendCodaMessage(MessageWithReply, FileSystemService, "write", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendFileSystemCloseCommand(const tcftrk::TcfTrkCallback &callBack, void Coda::CodaDevice::sendFileSystemCloseCommand(const Coda::CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << handle; str << handle;
sendTcfTrkMessage(MessageWithReply, FileSystemService, "close", data, callBack, cookie); sendCodaMessage(MessageWithReply, FileSystemService, "close", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendSymbianInstallSilentInstallCommand(const tcftrk::TcfTrkCallback &callBack, void Coda::CodaDevice::sendSymbianInstallSilentInstallCommand(const Coda::CodaCallback &callBack,
const QByteArray &file, const QByteArray &file,
const QByteArray &targetDrive, const QByteArray &targetDrive,
const QVariant &cookie) const QVariant &cookie)
@@ -1343,16 +1343,16 @@ void tcftrk::TcfTrkDevice::sendSymbianInstallSilentInstallCommand(const tcftrk::
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << file << '\0' << targetDrive; str << file << '\0' << targetDrive;
sendTcfTrkMessage(MessageWithReply, SymbianInstallService, "install", data, callBack, cookie); sendCodaMessage(MessageWithReply, SymbianInstallService, "install", data, callBack, cookie);
} }
void tcftrk::TcfTrkDevice::sendSymbianInstallUIInstallCommand(const tcftrk::TcfTrkCallback &callBack, void Coda::CodaDevice::sendSymbianInstallUIInstallCommand(const Coda::CodaCallback &callBack,
const QByteArray &file, const QByteArray &file,
const QVariant &cookie) const QVariant &cookie)
{ {
QByteArray data; QByteArray data;
JsonInputStream str(data); JsonInputStream str(data);
str << file; str << file;
sendTcfTrkMessage(MessageWithReply, SymbianInstallService, "installWithUI", data, callBack, cookie); sendCodaMessage(MessageWithReply, SymbianInstallService, "installWithUI", data, callBack, cookie);
} }
} // namespace tcftrk } // namespace Coda

124
src/shared/symbianutils/tcftrkdevice.h → src/shared/symbianutils/codadevice.h
View File

@@ -31,11 +31,11 @@
** **
**************************************************************************/ **************************************************************************/
#ifndef TCFTRKENGINE_H #ifndef CODAENGINE_H
#define TCFTRKENGINE_H #define CODAENGINE_H
#include "symbianutils_global.h" #include "symbianutils_global.h"
#include "tcftrkmessage.h" #include "Codamessage.h"
#include "callback.h" #include "callback.h"
#include "json.h" #include "json.h"
@@ -51,9 +51,9 @@ class QIODevice;
class QTextStream; class QTextStream;
QT_END_NAMESPACE QT_END_NAMESPACE
namespace tcftrk { namespace Coda {
struct TcfTrkDevicePrivate; struct CodaDevicePrivate;
struct Breakpoint; struct Breakpoint;
/* Command error handling in TCF: /* Command error handling in TCF:
@@ -61,12 +61,12 @@ struct Breakpoint;
* nonstandard message (\3\2 error parameters) and closes the connection. * nonstandard message (\3\2 error parameters) and closes the connection.
* 2) Protocol errors: 'N' without error message is returned. * 2) Protocol errors: 'N' without error message is returned.
* 3) Errors in command execution: 'R' with a TCF error hash is returned * 3) Errors in command execution: 'R' with a TCF error hash is returned
* (see TcfTrkCommandError). */ * (see CodaCommandError). */
/* Error code return in 'R' reply to command /* Error code return in 'R' reply to command
* (see top of 'Services' documentation). */ * (see top of 'Services' documentation). */
struct SYMBIANUTILS_EXPORT TcfTrkCommandError { struct SYMBIANUTILS_EXPORT CodaCommandError {
TcfTrkCommandError(); CodaCommandError();
void clear(); void clear();
bool isError() const; bool isError() const;
operator bool() const { return isError(); } operator bool() const { return isError(); }
@@ -83,17 +83,17 @@ struct SYMBIANUTILS_EXPORT TcfTrkCommandError {
}; };
/* Answer to a Tcf command passed to the callback. */ /* Answer to a Tcf command passed to the callback. */
struct SYMBIANUTILS_EXPORT TcfTrkCommandResult { struct SYMBIANUTILS_EXPORT CodaCommandResult {
enum Type enum Type
{ {
SuccessReply, // 'R' and no error -> all happy. SuccessReply, // 'R' and no error -> all happy.
CommandErrorReply, // 'R' with TcfTrkCommandError received CommandErrorReply, // 'R' with CodaCommandError received
ProgressReply, // 'P', progress indicator ProgressReply, // 'P', progress indicator
FailReply // 'N' Protocol NAK, severe error FailReply // 'N' Protocol NAK, severe error
}; };
explicit TcfTrkCommandResult(Type t = SuccessReply); explicit CodaCommandResult(Type t = SuccessReply);
explicit TcfTrkCommandResult(char typeChar, Services service, explicit CodaCommandResult(char typeChar, Services service,
const QByteArray &request, const QByteArray &request,
const QVector<JsonValue> &values, const QVector<JsonValue> &values,
const QVariant &cookie); const QVariant &cookie);
@@ -107,32 +107,32 @@ struct SYMBIANUTILS_EXPORT TcfTrkCommandResult {
Type type; Type type;
Services service; Services service;
QByteArray request; QByteArray request;
TcfTrkCommandError commandError; CodaCommandError commandError;
QVector<JsonValue> values; QVector<JsonValue> values;
QVariant cookie; QVariant cookie;
}; };
// Response to stat/fstat // Response to stat/fstat
struct SYMBIANUTILS_EXPORT TcfTrkStatResponse struct SYMBIANUTILS_EXPORT CodaStatResponse
{ {
TcfTrkStatResponse(); CodaStatResponse();
quint64 size; quint64 size;
QDateTime modTime; QDateTime modTime;
QDateTime accessTime; QDateTime accessTime;
}; };
typedef trk::Callback<const TcfTrkCommandResult &> TcfTrkCallback; typedef trk::Callback<const CodaCommandResult &> CodaCallback;
/* TcfTrkDevice: TCF communication helper using an asynchronous QIODevice /* CodaDevice: TCF communication helper using an asynchronous QIODevice
* implementing the TCF protocol according to: * implementing the TCF protocol according to:
http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Specification.html http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Specification.html
http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Services.html http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Services.html
* Commands can be sent along with callbacks that are passed a * Commands can be sent along with callbacks that are passed a
* TcfTrkCommandResult and an opaque QVariant cookie. In addition, events are emitted. * CodaCommandResult and an opaque QVariant cookie. In addition, events are emitted.
* *
* Note: As of 11.8.2010, TCF Trk 4.0.5 does not currently support 'Registers::getm' * Note: As of 11.8.2010, TCF Trk 4.0.5 does not currently support 'Registers::getm'
* (get multiple registers). So, TcfTrkDevice emulates it by sending a sequence of * (get multiple registers). So, CodaDevice emulates it by sending a sequence of
* single commands. As soon as 'Registers::getm' is natively supported, all code * single commands. As soon as 'Registers::getm' is natively supported, all code
* related to 'FakeRegisterGetm' should be removed. The workaround requires that * related to 'FakeRegisterGetm' should be removed. The workaround requires that
* the register name is known. * the register name is known.
@@ -146,7 +146,7 @@ http://dev.eclipse.org/svnroot/dsdp/org.eclipse.tm.tcf/trunk/docs/TCF%20Services
* Receive Locator Hello Event from CODA -> Commands are accepted. * Receive Locator Hello Event from CODA -> Commands are accepted.
*/ */
class SYMBIANUTILS_EXPORT TcfTrkDevice : public QObject class SYMBIANUTILS_EXPORT CodaDevice : public QObject
{ {
Q_PROPERTY(unsigned verbose READ verbose WRITE setVerbose) Q_PROPERTY(unsigned verbose READ verbose WRITE setVerbose)
Q_PROPERTY(bool serialFrame READ serialFrame WRITE setSerialFrame) Q_PROPERTY(bool serialFrame READ serialFrame WRITE setSerialFrame)
@@ -172,8 +172,8 @@ public:
typedef QSharedPointer<QIODevice> IODevicePtr; typedef QSharedPointer<QIODevice> IODevicePtr;
explicit TcfTrkDevice(QObject *parent = 0); explicit CodaDevice(QObject *parent = 0);
virtual ~TcfTrkDevice(); virtual ~CodaDevice();
unsigned verbose() const; unsigned verbose() const;
bool serialFrame() const; bool serialFrame() const;
@@ -193,18 +193,18 @@ public:
void sendSerialPing(bool pingOnly = false); void sendSerialPing(bool pingOnly = false);
// Send with parameters from string (which may contain '\0'). // Send with parameters from string (which may contain '\0').
void sendTcfTrkMessage(MessageType mt, Services service, const char *command, void sendCodaMessage(MessageType mt, Services service, const char *command,
const char *commandParameters, int commandParametersLength, const char *commandParameters, int commandParametersLength,
const TcfTrkCallback &callBack = TcfTrkCallback(), const CodaCallback &callBack = CodaCallback(),
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendTcfTrkMessage(MessageType mt, Services service, const char *command, void sendCodaMessage(MessageType mt, Services service, const char *command,
const QByteArray &commandParameters, const QByteArray &commandParameters,
const TcfTrkCallback &callBack = TcfTrkCallback(), const CodaCallback &callBack = CodaCallback(),
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Convenience messages: Start a process // Convenience messages: Start a process
void sendProcessStartCommand(const TcfTrkCallback &callBack, void sendProcessStartCommand(const CodaCallback &callBack,
const QString &binary, const QString &binary,
unsigned uid, unsigned uid,
QStringList arguments = QStringList(), QStringList arguments = QStringList(),
@@ -214,11 +214,11 @@ public:
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Preferred over Processes:Terminate by TCF TRK. // Preferred over Processes:Terminate by TCF TRK.
void sendRunControlTerminateCommand(const TcfTrkCallback &callBack, void sendRunControlTerminateCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendProcessTerminateCommand(const TcfTrkCallback &callBack, void sendProcessTerminateCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
@@ -229,12 +229,12 @@ public:
const QStringList &additionalLibraries = QStringList(), const QStringList &additionalLibraries = QStringList(),
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendRunControlSuspendCommand(const TcfTrkCallback &callBack, void sendRunControlSuspendCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Resume / Step (see RunControlResumeMode). // Resume / Step (see RunControlResumeMode).
void sendRunControlResumeCommand(const TcfTrkCallback &callBack, void sendRunControlResumeCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
RunControlResumeMode mode, RunControlResumeMode mode,
unsigned count /* = 1, currently ignored. */, unsigned count /* = 1, currently ignored. */,
@@ -242,117 +242,117 @@ public:
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Convenience to resume a suspended process // Convenience to resume a suspended process
void sendRunControlResumeCommand(const TcfTrkCallback &callBack, void sendRunControlResumeCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendBreakpointsAddCommand(const TcfTrkCallback &callBack, void sendBreakpointsAddCommand(const CodaCallback &callBack,
const Breakpoint &b, const Breakpoint &b,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack, void sendBreakpointsRemoveCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendBreakpointsRemoveCommand(const TcfTrkCallback &callBack, void sendBreakpointsRemoveCommand(const CodaCallback &callBack,
const QVector<QByteArray> &id, const QVector<QByteArray> &id,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendBreakpointsEnableCommand(const TcfTrkCallback &callBack, void sendBreakpointsEnableCommand(const CodaCallback &callBack,
const QByteArray &id, const QByteArray &id,
bool enable, bool enable,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendBreakpointsEnableCommand(const TcfTrkCallback &callBack, void sendBreakpointsEnableCommand(const CodaCallback &callBack,
const QVector<QByteArray> &id, const QVector<QByteArray> &id,
bool enable, bool enable,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendMemoryGetCommand(const TcfTrkCallback &callBack, void sendMemoryGetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
quint64 start, quint64 size, quint64 start, quint64 size,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendMemorySetCommand(const TcfTrkCallback &callBack, void sendMemorySetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
quint64 start, const QByteArray& data, quint64 start, const QByteArray& data,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Get register names (children of context). // Get register names (children of context).
// It is possible to recurse from thread id down to single registers. // It is possible to recurse from thread id down to single registers.
void sendRegistersGetChildrenCommand(const TcfTrkCallback &callBack, void sendRegistersGetChildrenCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Register get // Register get
void sendRegistersGetCommand(const TcfTrkCallback &callBack, void sendRegistersGetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
QByteArray id, QByteArray id,
const QVariant &cookie); const QVariant &cookie);
void sendRegistersGetMCommand(const TcfTrkCallback &callBack, void sendRegistersGetMCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
const QVector<QByteArray> &ids, const QVector<QByteArray> &ids,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Convenience to get a range of register "R0" .. "R<n>". // Convenience to get a range of register "R0" .. "R<n>".
// Cookie will be an int containing "start". // Cookie will be an int containing "start".
void sendRegistersGetMRangeCommand(const TcfTrkCallback &callBack, void sendRegistersGetMRangeCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
unsigned start, unsigned count); unsigned start, unsigned count);
// Set register // Set register
void sendRegistersSetCommand(const TcfTrkCallback &callBack, void sendRegistersSetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
QByteArray ids, QByteArray ids,
const QByteArray &value, // binary value const QByteArray &value, // binary value
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Set register // Set register
void sendRegistersSetCommand(const TcfTrkCallback &callBack, void sendRegistersSetCommand(const CodaCallback &callBack,
const QByteArray &contextId, const QByteArray &contextId,
unsigned registerNumber, unsigned registerNumber,
const QByteArray &value, // binary value const QByteArray &value, // binary value
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// File System // File System
void sendFileSystemOpenCommand(const TcfTrkCallback &callBack, void sendFileSystemOpenCommand(const CodaCallback &callBack,
const QByteArray &name, const QByteArray &name,
unsigned flags = FileSystem_TCF_O_READ, unsigned flags = FileSystem_TCF_O_READ,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendFileSystemFstatCommand(const TcfTrkCallback &callBack, void sendFileSystemFstatCommand(const CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendFileSystemWriteCommand(const TcfTrkCallback &callBack, void sendFileSystemWriteCommand(const CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QByteArray &data, const QByteArray &data,
unsigned offset = 0, unsigned offset = 0,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendFileSystemCloseCommand(const TcfTrkCallback &callBack, void sendFileSystemCloseCommand(const CodaCallback &callBack,
const QByteArray &handle, const QByteArray &handle,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// Symbian Install // Symbian Install
void sendSymbianInstallSilentInstallCommand(const TcfTrkCallback &callBack, void sendSymbianInstallSilentInstallCommand(const CodaCallback &callBack,
const QByteArray &file, const QByteArray &file,
const QByteArray &targetDrive, const QByteArray &targetDrive,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendSymbianInstallUIInstallCommand(const TcfTrkCallback &callBack, void sendSymbianInstallUIInstallCommand(const CodaCallback &callBack,
const QByteArray &file, const QByteArray &file,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendLoggingAddListenerCommand(const TcfTrkCallback &callBack, void sendLoggingAddListenerCommand(const CodaCallback &callBack,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
// SymbianOs Data // SymbianOs Data
void sendSymbianOsDataGetThreadsCommand(const TcfTrkCallback &callBack, void sendSymbianOsDataGetThreadsCommand(const CodaCallback &callBack,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
void sendSymbianOsDataFindProcessesCommand(const TcfTrkCallback &callBack, void sendSymbianOsDataFindProcessesCommand(const CodaCallback &callBack,
const QByteArray &processName, const QByteArray &processName,
const QByteArray &uid, const QByteArray &uid,
const QVariant &cookie = QVariant()); const QVariant &cookie = QVariant());
@@ -360,13 +360,13 @@ public:
// Settings // Settings
void sendSettingsEnableLogCommand(); void sendSettingsEnableLogCommand();
static QByteArray parseMemoryGet(const TcfTrkCommandResult &r); static QByteArray parseMemoryGet(const CodaCommandResult &r);
static QVector<QByteArray> parseRegisterGetChildren(const TcfTrkCommandResult &r); static QVector<QByteArray> parseRegisterGetChildren(const CodaCommandResult &r);
static TcfTrkStatResponse parseStat(const TcfTrkCommandResult &r); static CodaStatResponse parseStat(const CodaCommandResult &r);
signals: signals:
void genericTcfEvent(int service, const QByteArray &name, const QVector<tcftrk::JsonValue> &value); void genericTcfEvent(int service, const QByteArray &name, const QVector<JsonValue> &value);
void tcfEvent(const tcftrk::TcfTrkEvent &knownEvent); void tcfEvent(const Coda::CodaEvent &knownEvent);
void serialPong(const QString &codaVersion); void serialPong(const QString &codaVersion);
void logMessage(const QString &); void logMessage(const QString &);
@@ -393,9 +393,9 @@ private:
inline void processSerialMessage(const QByteArray &message); inline void processSerialMessage(const QByteArray &message);
int parseTcfCommandReply(char type, const QVector<QByteArray> &tokens); int parseTcfCommandReply(char type, const QVector<QByteArray> &tokens);
int parseTcfEvent(const QVector<QByteArray> &tokens); int parseTcfEvent(const QVector<QByteArray> &tokens);
TcfTrkDevicePrivate *d; CodaDevicePrivate *d;
}; };
} // namespace tcftrk } // namespace Coda
#endif // TCFTRKENGINE_H #endif // CODAENGINE_H

104
src/shared/symbianutils/tcftrkmessage.cpp → src/shared/symbianutils/codamessage.cpp
View File

@@ -31,7 +31,7 @@
** **
**************************************************************************/ **************************************************************************/
#include "tcftrkmessage.h" #include "codamessage.h"
#include "json.h" #include "json.h"
#include <QtCore/QString> #include <QtCore/QString>
@@ -43,7 +43,7 @@ static const char *serviceNamesC[] =
"Registers", "Logging", "FileSystem", "SymbianInstall", "SymbianOSData", "Registers", "Logging", "FileSystem", "SymbianInstall", "SymbianOSData",
"UnknownService"}; "UnknownService"};
namespace tcftrk { namespace Coda {
SYMBIANUTILS_EXPORT QString joinByteArrays(const QVector<QByteArray> &a, char sep) SYMBIANUTILS_EXPORT QString joinByteArrays(const QVector<QByteArray> &a, char sep)
{ {
@@ -333,7 +333,7 @@ QString Breakpoint::toString() const
JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b) JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b)
{ {
if (b.contextIds.isEmpty()) if (b.contextIds.isEmpty())
qWarning("tcftrk::Breakpoint: No context ids specified"); qWarning("Coda::Breakpoint: No context ids specified");
str << '{' << "ID" << ':' << QString::fromUtf8(b.id) << ',' str << '{' << "ID" << ':' << QString::fromUtf8(b.id) << ','
<< "BreakpointType" << ':' << breakPointTypesC[b.type] << ',' << "BreakpointType" << ':' << breakPointTypesC[b.type] << ','
@@ -348,27 +348,27 @@ JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b)
} }
// --- Events // --- Events
TcfTrkEvent::TcfTrkEvent(Type type) : m_type(type) CodaEvent::CodaEvent(Type type) : m_type(type)
{ {
} }
TcfTrkEvent::~TcfTrkEvent() CodaEvent::~CodaEvent()
{ {
} }
TcfTrkEvent::Type TcfTrkEvent::type() const CodaEvent::Type CodaEvent::type() const
{ {
return m_type; return m_type;
} }
QString TcfTrkEvent::toString() const QString CodaEvent::toString() const
{ {
return QString(); return QString();
} }
static const char sharedLibrarySuspendReasonC[] = "Shared Library"; static const char sharedLibrarySuspendReasonC[] = "Shared Library";
TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const QVector<JsonValue> &values) CodaEvent *CodaEvent::parseEvent(Services s, const QByteArray &nameBA, const QVector<JsonValue> &values)
{ {
switch (s) { switch (s) {
case LocatorService: case LocatorService:
@@ -376,7 +376,7 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
QStringList services; QStringList services;
foreach (const JsonValue &jv, values.front().children()) foreach (const JsonValue &jv, values.front().children())
services.push_back(QString::fromUtf8(jv.data())); services.push_back(QString::fromUtf8(jv.data()));
return new TcfTrkLocatorHelloEvent(services); return new CodaLocatorHelloEvent(services);
} }
break; break;
case RunControlService: case RunControlService:
@@ -393,27 +393,27 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
ModuleLoadEventInfo info; ModuleLoadEventInfo info;
if (!info.parse(values.at(3))) if (!info.parse(values.at(3)))
return 0; return 0;
return new TcfTrkRunControlModuleLoadContextSuspendedEvent(idBA, reasonBA, pc, info); return new CodaRunControlModuleLoadContextSuspendedEvent(idBA, reasonBA, pc, info);
} else { } else {
// hash containing a 'message'-key with a verbose crash message. // hash containing a 'message'-key with a verbose crash message.
if (values.at(3).type() == JsonValue::Object && values.at(3).childCount() if (values.at(3).type() == JsonValue::Object && values.at(3).childCount()
&& values.at(3).children().at(0).type() == JsonValue::String) && values.at(3).children().at(0).type() == JsonValue::String)
messageBA = values.at(3).children().at(0).data(); messageBA = values.at(3).children().at(0).data();
} }
return new TcfTrkRunControlContextSuspendedEvent(idBA, reasonBA, messageBA, pc); return new CodaRunControlContextSuspendedEvent(idBA, reasonBA, messageBA, pc);
} // "contextSuspended" } // "contextSuspended"
if (nameBA == "contextAdded") if (nameBA == "contextAdded")
return TcfTrkRunControlContextAddedEvent::parseEvent(values); return CodaRunControlContextAddedEvent::parseEvent(values);
if (nameBA == "contextRemoved" && values.front().type() == JsonValue::Array) { if (nameBA == "contextRemoved" && values.front().type() == JsonValue::Array) {
QVector<QByteArray> ids; QVector<QByteArray> ids;
foreach(const JsonValue &c, values.front().children()) foreach(const JsonValue &c, values.front().children())
ids.push_back(c.data()); ids.push_back(c.data());
return new TcfTrkRunControlContextRemovedEvent(ids); return new CodaRunControlContextRemovedEvent(ids);
} }
break; break;
case LoggingService: case LoggingService:
if ((nameBA == "writeln" || nameBA == "write" /*not yet used*/) && values.size() >= 2) if ((nameBA == "writeln" || nameBA == "write" /*not yet used*/) && values.size() >= 2)
return new TcfTrkLoggingWriteEvent(values.at(0).data(), values.at(1).data()); return new CodaLoggingWriteEvent(values.at(0).data(), values.at(1).data());
break; break;
default: default:
break; break;
@@ -421,26 +421,26 @@ TcfTrkEvent *TcfTrkEvent::parseEvent(Services s, const QByteArray &nameBA, const
return 0; return 0;
} }
// -------------- TcfTrkServiceHelloEvent // -------------- CodaServiceHelloEvent
TcfTrkLocatorHelloEvent::TcfTrkLocatorHelloEvent(const QStringList &s) : CodaLocatorHelloEvent::CodaLocatorHelloEvent(const QStringList &s) :
TcfTrkEvent(LocatorHello), CodaEvent(LocatorHello),
m_services(s) m_services(s)
{ {
} }
QString TcfTrkLocatorHelloEvent::toString() const QString CodaLocatorHelloEvent::toString() const
{ {
return QLatin1String("ServiceHello: ") + m_services.join(QLatin1String(", ")); return QLatin1String("ServiceHello: ") + m_services.join(QLatin1String(", "));
} }
// -------------- Logging event // -------------- Logging event
TcfTrkLoggingWriteEvent::TcfTrkLoggingWriteEvent(const QByteArray &console, const QByteArray &message) : CodaLoggingWriteEvent::CodaLoggingWriteEvent(const QByteArray &console, const QByteArray &message) :
TcfTrkEvent(LoggingWriteEvent), m_console(console), m_message(message) CodaEvent(LoggingWriteEvent), m_console(console), m_message(message)
{ {
} }
QString TcfTrkLoggingWriteEvent::toString() const QString CodaLoggingWriteEvent::toString() const
{ {
QByteArray msgBA = m_console; QByteArray msgBA = m_console;
msgBA += ": "; msgBA += ": ";
@@ -448,31 +448,31 @@ QString TcfTrkLoggingWriteEvent::toString() const
return QString::fromUtf8(msgBA); return QString::fromUtf8(msgBA);
} }
// -------------- TcfTrkIdEvent // -------------- CodaIdEvent
TcfTrkIdEvent::TcfTrkIdEvent(Type t, const QByteArray &id) : CodaIdEvent::CodaIdEvent(Type t, const QByteArray &id) :
TcfTrkEvent(t), m_id(id) CodaEvent(t), m_id(id)
{ {
} }
// ---------- TcfTrkIdsEvent // ---------- CodaIdsEvent
TcfTrkIdsEvent::TcfTrkIdsEvent(Type t, const QVector<QByteArray> &ids) : CodaIdsEvent::CodaIdsEvent(Type t, const QVector<QByteArray> &ids) :
TcfTrkEvent(t), m_ids(ids) CodaEvent(t), m_ids(ids)
{ {
} }
QString TcfTrkIdsEvent::joinedIdString(const char sep) const QString CodaIdsEvent::joinedIdString(const char sep) const
{ {
return joinByteArrays(m_ids, sep); return joinByteArrays(m_ids, sep);
} }
// ---------------- TcfTrkRunControlContextAddedEvent // ---------------- CodaRunControlContextAddedEvent
TcfTrkRunControlContextAddedEvent::TcfTrkRunControlContextAddedEvent(const RunControlContexts &c) : CodaRunControlContextAddedEvent::CodaRunControlContextAddedEvent(const RunControlContexts &c) :
TcfTrkEvent(RunControlContextAdded), m_contexts(c) CodaEvent(RunControlContextAdded), m_contexts(c)
{ {
} }
TcfTrkRunControlContextAddedEvent CodaRunControlContextAddedEvent
*TcfTrkRunControlContextAddedEvent::parseEvent(const QVector<JsonValue> &values) *CodaRunControlContextAddedEvent::parseEvent(const QVector<JsonValue> &values)
{ {
// Parse array of contexts // Parse array of contexts
if (values.size() < 1 || values.front().type() != JsonValue::Array) if (values.size() < 1 || values.front().type() != JsonValue::Array)
@@ -484,10 +484,10 @@ TcfTrkRunControlContextAddedEvent
if (context.parse(v)) if (context.parse(v))
contexts.push_back(context); contexts.push_back(context);
} }
return new TcfTrkRunControlContextAddedEvent(contexts); return new CodaRunControlContextAddedEvent(contexts);
} }
QString TcfTrkRunControlContextAddedEvent::toString() const QString CodaRunControlContextAddedEvent::toString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
@@ -501,35 +501,35 @@ QString TcfTrkRunControlContextAddedEvent::toString() const
return rc; return rc;
} }
// --------------- TcfTrkRunControlContextRemovedEvent // --------------- CodaRunControlContextRemovedEvent
TcfTrkRunControlContextRemovedEvent::TcfTrkRunControlContextRemovedEvent(const QVector<QByteArray> &ids) : CodaRunControlContextRemovedEvent::CodaRunControlContextRemovedEvent(const QVector<QByteArray> &ids) :
TcfTrkIdsEvent(RunControlContextRemoved, ids) CodaIdsEvent(RunControlContextRemoved, ids)
{ {
} }
QString TcfTrkRunControlContextRemovedEvent::toString() const QString CodaRunControlContextRemovedEvent::toString() const
{ {
return QLatin1String("RunControl: Removed contexts '") + joinedIdString() + ("'."); return QLatin1String("RunControl: Removed contexts '") + joinedIdString() + ("'.");
} }
// --------------- TcfTrkRunControlContextSuspendedEvent // --------------- CodaRunControlContextSuspendedEvent
TcfTrkRunControlContextSuspendedEvent::TcfTrkRunControlContextSuspendedEvent(const QByteArray &id, CodaRunControlContextSuspendedEvent::CodaRunControlContextSuspendedEvent(const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
const QByteArray &message, const QByteArray &message,
quint64 pc) : quint64 pc) :
TcfTrkIdEvent(RunControlSuspended, id), m_pc(pc), m_reason(reason), m_message(message) CodaIdEvent(RunControlSuspended, id), m_pc(pc), m_reason(reason), m_message(message)
{ {
} }
TcfTrkRunControlContextSuspendedEvent::TcfTrkRunControlContextSuspendedEvent(Type t, CodaRunControlContextSuspendedEvent::CodaRunControlContextSuspendedEvent(Type t,
const QByteArray &id, const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
quint64 pc) : quint64 pc) :
TcfTrkIdEvent(t, id), m_pc(pc), m_reason(reason) CodaIdEvent(t, id), m_pc(pc), m_reason(reason)
{ {
} }
void TcfTrkRunControlContextSuspendedEvent::format(QTextStream &str) const void CodaRunControlContextSuspendedEvent::format(QTextStream &str) const
{ {
str.setIntegerBase(16); str.setIntegerBase(16);
str << "RunControl: '" << idString() << "' suspended at 0x" str << "RunControl: '" << idString() << "' suspended at 0x"
@@ -539,7 +539,7 @@ void TcfTrkRunControlContextSuspendedEvent::format(QTextStream &str) const
str << " (" <<m_message << ')'; str << " (" <<m_message << ')';
} }
QString TcfTrkRunControlContextSuspendedEvent::toString() const QString CodaRunControlContextSuspendedEvent::toString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
@@ -547,7 +547,7 @@ QString TcfTrkRunControlContextSuspendedEvent::toString() const
return rc; return rc;
} }
TcfTrkRunControlContextSuspendedEvent::Reason TcfTrkRunControlContextSuspendedEvent::reason() const CodaRunControlContextSuspendedEvent::Reason CodaRunControlContextSuspendedEvent::reason() const
{ {
if (m_reason == sharedLibrarySuspendReasonC) if (m_reason == sharedLibrarySuspendReasonC)
return ModuleLoad; return ModuleLoad;
@@ -559,24 +559,24 @@ TcfTrkRunControlContextSuspendedEvent::Reason TcfTrkRunControlContextSuspendedEv
return Other; return Other;
} }
TcfTrkRunControlModuleLoadContextSuspendedEvent::TcfTrkRunControlModuleLoadContextSuspendedEvent(const QByteArray &id, CodaRunControlModuleLoadContextSuspendedEvent::CodaRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
quint64 pc, quint64 pc,
const ModuleLoadEventInfo &mi) : const ModuleLoadEventInfo &mi) :
TcfTrkRunControlContextSuspendedEvent(RunControlModuleLoadSuspended, id, reason, pc), CodaRunControlContextSuspendedEvent(RunControlModuleLoadSuspended, id, reason, pc),
m_mi(mi) m_mi(mi)
{ {
} }
QString TcfTrkRunControlModuleLoadContextSuspendedEvent::toString() const QString CodaRunControlModuleLoadContextSuspendedEvent::toString() const
{ {
QString rc; QString rc;
QTextStream str(&rc); QTextStream str(&rc);
TcfTrkRunControlContextSuspendedEvent::format(str); CodaRunControlContextSuspendedEvent::format(str);
str << ' '; str << ' ';
m_mi.format(str); m_mi.format(str);
return rc; return rc;
} }
} // namespace tcftrk } // namespace Coda

52
src/shared/symbianutils/tcftrkmessage.h → src/shared/symbianutils/codamessage.h
View File

@@ -43,7 +43,7 @@ QT_BEGIN_NAMESPACE
class QTextStream; class QTextStream;
QT_END_NAMESPACE QT_END_NAMESPACE
namespace tcftrk { namespace Coda {
class JsonValue; class JsonValue;
class JsonInputStream; class JsonInputStream;
@@ -133,7 +133,7 @@ struct SYMBIANUTILS_EXPORT ModuleLoadEventInfo {
bool requireResume; bool requireResume;
}; };
// Breakpoint as supported by TcfTrk source June 2010 // Breakpoint as supported by Coda source June 2010
// TODO: Add watchpoints,etc once they are implemented // TODO: Add watchpoints,etc once they are implemented
struct SYMBIANUTILS_EXPORT Breakpoint { struct SYMBIANUTILS_EXPORT Breakpoint {
enum Type { Software, Hardware, Auto }; enum Type { Software, Hardware, Auto };
@@ -157,8 +157,8 @@ struct SYMBIANUTILS_EXPORT Breakpoint {
SYMBIANUTILS_EXPORT JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b); SYMBIANUTILS_EXPORT JsonInputStream &operator<<(JsonInputStream &str, const Breakpoint &b);
// Event hierarchy // Event hierarchy
class SYMBIANUTILS_EXPORT TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaEvent {
Q_DISABLE_COPY(TcfTrkEvent) Q_DISABLE_COPY(CodaEvent)
public: public:
enum Type { None, enum Type { None,
LocatorHello, LocatorHello,
@@ -171,24 +171,24 @@ public:
LoggingWriteEvent // Non-standard LoggingWriteEvent // Non-standard
}; };
virtual ~TcfTrkEvent(); virtual ~CodaEvent();
Type type() const; Type type() const;
virtual QString toString() const; virtual QString toString() const;
static TcfTrkEvent *parseEvent(Services s, const QByteArray &name, const QVector<JsonValue> &val); static CodaEvent *parseEvent(Services s, const QByteArray &name, const QVector<JsonValue> &val);
protected: protected:
explicit TcfTrkEvent(Type type = None); explicit CodaEvent(Type type = None);
private: private:
const Type m_type; const Type m_type;
}; };
// ServiceHello // ServiceHello
class SYMBIANUTILS_EXPORT TcfTrkLocatorHelloEvent : public TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaLocatorHelloEvent : public CodaEvent {
public: public:
explicit TcfTrkLocatorHelloEvent(const QStringList &); explicit CodaLocatorHelloEvent(const QStringList &);
const QStringList &services() { return m_services; } const QStringList &services() { return m_services; }
virtual QString toString() const; virtual QString toString() const;
@@ -198,9 +198,9 @@ private:
}; };
// Logging event (non-standard, trk specific) // Logging event (non-standard, trk specific)
class SYMBIANUTILS_EXPORT TcfTrkLoggingWriteEvent : public TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaLoggingWriteEvent : public CodaEvent {
public: public:
explicit TcfTrkLoggingWriteEvent(const QByteArray &console, const QByteArray &message); explicit CodaLoggingWriteEvent(const QByteArray &console, const QByteArray &message);
QByteArray message() const { return m_message; } QByteArray message() const { return m_message; }
QByteArray console() const { return m_console; } QByteArray console() const { return m_console; }
@@ -214,9 +214,9 @@ private:
// Base for events that just have one id as parameter // Base for events that just have one id as parameter
// (simple suspend) // (simple suspend)
class SYMBIANUTILS_EXPORT TcfTrkIdEvent : public TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaIdEvent : public CodaEvent {
protected: protected:
explicit TcfTrkIdEvent(Type t, const QByteArray &id); explicit CodaIdEvent(Type t, const QByteArray &id);
public: public:
QByteArray id() const { return m_id; } QByteArray id() const { return m_id; }
QString idString() const { return QString::fromUtf8(m_id); } QString idString() const { return QString::fromUtf8(m_id); }
@@ -227,9 +227,9 @@ private:
// Base for events that just have some ids as parameter // Base for events that just have some ids as parameter
// (context removed) // (context removed)
class SYMBIANUTILS_EXPORT TcfTrkIdsEvent : public TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaIdsEvent : public CodaEvent {
protected: protected:
explicit TcfTrkIdsEvent(Type t, const QVector<QByteArray> &ids); explicit CodaIdsEvent(Type t, const QVector<QByteArray> &ids);
public: public:
QVector<QByteArray> ids() const { return m_ids; } QVector<QByteArray> ids() const { return m_ids; }
@@ -240,34 +240,34 @@ private:
}; };
// RunControlContextAdded // RunControlContextAdded
class SYMBIANUTILS_EXPORT TcfTrkRunControlContextAddedEvent : public TcfTrkEvent { class SYMBIANUTILS_EXPORT CodaRunControlContextAddedEvent : public CodaEvent {
public: public:
typedef QVector<RunControlContext> RunControlContexts; typedef QVector<RunControlContext> RunControlContexts;
explicit TcfTrkRunControlContextAddedEvent(const RunControlContexts &c); explicit CodaRunControlContextAddedEvent(const RunControlContexts &c);
const RunControlContexts &contexts() const { return m_contexts; } const RunControlContexts &contexts() const { return m_contexts; }
virtual QString toString() const; virtual QString toString() const;
static TcfTrkRunControlContextAddedEvent *parseEvent(const QVector<JsonValue> &val); static CodaRunControlContextAddedEvent *parseEvent(const QVector<JsonValue> &val);
private: private:
const RunControlContexts m_contexts; const RunControlContexts m_contexts;
}; };
// RunControlContextRemoved // RunControlContextRemoved
class SYMBIANUTILS_EXPORT TcfTrkRunControlContextRemovedEvent : public TcfTrkIdsEvent { class SYMBIANUTILS_EXPORT CodaRunControlContextRemovedEvent : public CodaIdsEvent {
public: public:
explicit TcfTrkRunControlContextRemovedEvent(const QVector<QByteArray> &id); explicit CodaRunControlContextRemovedEvent(const QVector<QByteArray> &id);
virtual QString toString() const; virtual QString toString() const;
}; };
// Simple RunControlContextSuspended (process/thread) // Simple RunControlContextSuspended (process/thread)
class SYMBIANUTILS_EXPORT TcfTrkRunControlContextSuspendedEvent : public TcfTrkIdEvent { class SYMBIANUTILS_EXPORT CodaRunControlContextSuspendedEvent : public CodaIdEvent {
public: public:
enum Reason { BreakPoint, ModuleLoad, Crash, Other } ; enum Reason { BreakPoint, ModuleLoad, Crash, Other } ;
explicit TcfTrkRunControlContextSuspendedEvent(const QByteArray &id, explicit CodaRunControlContextSuspendedEvent(const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
const QByteArray &message, const QByteArray &message,
quint64 pc = 0); quint64 pc = 0);
@@ -279,7 +279,7 @@ public:
QByteArray message() const { return m_message; } QByteArray message() const { return m_message; }
protected: protected:
explicit TcfTrkRunControlContextSuspendedEvent(Type t, explicit CodaRunControlContextSuspendedEvent(Type t,
const QByteArray &id, const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
quint64 pc = 0); quint64 pc = 0);
@@ -292,9 +292,9 @@ private:
}; };
// RunControlContextSuspended due to module load // RunControlContextSuspended due to module load
class SYMBIANUTILS_EXPORT TcfTrkRunControlModuleLoadContextSuspendedEvent : public TcfTrkRunControlContextSuspendedEvent { class SYMBIANUTILS_EXPORT CodaRunControlModuleLoadContextSuspendedEvent : public CodaRunControlContextSuspendedEvent {
public: public:
explicit TcfTrkRunControlModuleLoadContextSuspendedEvent(const QByteArray &id, explicit CodaRunControlModuleLoadContextSuspendedEvent(const QByteArray &id,
const QByteArray &reason, const QByteArray &reason,
quint64 pc, quint64 pc,
const ModuleLoadEventInfo &mi); const ModuleLoadEventInfo &mi);
@@ -306,5 +306,5 @@ private:
const ModuleLoadEventInfo m_mi; const ModuleLoadEventInfo m_mi;
}; };
} // namespace tcftrk } // namespace Coda
#endif // TRCFTRKMESSAGE_H #endif // TRCFTRKMESSAGE_H

4
src/shared/symbianutils/json.cpp
View File

@@ -51,7 +51,7 @@
#define JDEBUG(s) #define JDEBUG(s)
#endif #endif
namespace tcftrk { namespace Coda {
static void skipSpaces(const char *&from, const char *to) static void skipSpaces(const char *&from, const char *to)
{ {
@@ -497,5 +497,5 @@ JsonInputStream &JsonInputStream::operator<<(bool b)
return *this; return *this;
} }
} // namespace tcftrk } // namespace Coda

4
src/shared/symbianutils/json.h
View File

@@ -40,7 +40,7 @@
#include <QtCore/QStringList> #include <QtCore/QStringList>
#include <QtCore/QVector> #include <QtCore/QVector>
namespace tcftrk { namespace Coda {
class SYMBIANUTILS_EXPORT JsonValue class SYMBIANUTILS_EXPORT JsonValue
{ {
@@ -136,6 +136,6 @@ private:
QByteArray &m_target; QByteArray &m_target;
}; };
} // namespace tcftrk } // namespace Coda
#endif // SYMBIANUTILS_JSON_H #endif // SYMBIANUTILS_JSON_H

8
src/shared/symbianutils/symbianutils.pri
View File

@@ -12,8 +12,8 @@ HEADERS += $$PWD/symbianutils_global.h \
$$PWD/bluetoothlistener.h \ $$PWD/bluetoothlistener.h \
$$PWD/communicationstarter.h \ $$PWD/communicationstarter.h \
$$PWD/symbiandevicemanager.h \ $$PWD/symbiandevicemanager.h \
$$PWD/tcftrkdevice.h \ $$PWD/codadevice.h \
$$PWD/tcftrkmessage.h \ $$PWD/codamessage.h \
$$PWD/json.h \ $$PWD/json.h \
$$PWD/virtualserialdevice.h $$PWD/virtualserialdevice.h
@@ -23,8 +23,8 @@ SOURCES += $$PWD/trkutils.cpp \
$$PWD/bluetoothlistener.cpp \ $$PWD/bluetoothlistener.cpp \
$$PWD/communicationstarter.cpp \ $$PWD/communicationstarter.cpp \
$$PWD/symbiandevicemanager.cpp \ $$PWD/symbiandevicemanager.cpp \
$$PWD/tcftrkdevice.cpp \ $$PWD/codadevice.cpp \
$$PWD/tcftrkmessage.cpp \ $$PWD/codamessage.cpp \
$$PWD/json.cpp \ $$PWD/json.cpp \
$$PWD/virtualserialdevice.cpp $$PWD/virtualserialdevice.cpp