3 // Copyright by Johannes Sixt
4 // This file is under GPL, the GNU General Public Licence
24 * A type representing an address.
31 DbgAddr(const QString
& aa
);
32 DbgAddr(const DbgAddr
& src
) : a(src
.a
), fnoffs(src
.fnoffs
) { }
33 void operator=(const QString
& aa
);
34 void operator=(const DbgAddr
& src
) { a
= src
.a
; fnoffs
= src
.fnoffs
; }
35 QString
asString() const;
36 bool isEmpty() const { return a
.isEmpty(); }
40 bool operator==(const DbgAddr
& a1
, const DbgAddr
& a2
);
41 bool operator>(const DbgAddr
& a1
, const DbgAddr
& a2
);
60 DCsetoption
, /* debugger options */
70 DCuntil
, /* line number is zero-based! */
73 DCbreakline
, /* line number is zero-based! */
74 DCtbreakline
, /* line number is zero-based! */
96 RDNstdin
= 0x1, /* redirect stdin to /dev/null */
97 RDNstdout
= 0x2, /* redirect stdout to /dev/null */
98 RDNstderr
= 0x4 /* redirect stderr to /dev/null */
102 * How the memory dump is formated. The lowest 4 bits define the size of
103 * the entities. The higher bits define how these are formatted. Note that
104 * not all combinations make sense.
106 enum MemoryDumpType
{
128 * Debugger commands are placed in a queue. Only one command at a time is
129 * sent down to the debugger. All other commands in the queue are retained
130 * until the sent command has been processed by gdb. The debugger tells us
131 * that it's done with the command by sending the prompt. The output of the
132 * debugger is parsed at that time. Then, if more commands are in the
133 * queue, the next one is sent to the debugger.
139 bool m_committed
; /* just a debugging aid */
140 // remember which expression when printing an expression
143 // remember file position
146 // whether command was emitted due to direct user request (only set when relevant)
149 CmdQueueItem(DbgCommand cmd
, const QString
& str
) :
161 * The information about a breakpoint that is parsed from the list of
166 int id
; /* gdb's number */
168 breakpoint
, watchpoint
173 DbgAddr address
; /* exact address of breakpoint */
174 QString condition
; /* condition as printed by gdb */
175 int ignoreCount
; /* ignore next that may hits */
176 int hitCount
; /* as reported by gdb */
177 // the following items repeat the location, but in a better usable way
179 int lineNo
; /* zero-based line number */
183 * Information about a stack frame.
188 int lineNo
; /* zero-based line number */
189 DbgAddr address
; /* exact address of PC */
193 * The information about a stack frame as parsed from the backtrace.
195 struct StackFrame
: FrameInfo
198 VarTree
* var
; /* more information if non-zero */
199 StackFrame() : var(0) { }
204 * The information about a thread as parsed from the threads list.
206 struct ThreadInfo
: FrameInfo
208 int id
; /* gdb's number */
209 QString threadName
; /* the SYSTAG */
210 QString function
; /* where thread is halted */
211 bool hasFocus
; /* the thread whose stack we are watching */
215 * Register information
221 QString cookedValue
; /* may be empty */
222 QString type
; /* of vector register if not empty */
228 struct DisassembledCode
244 * This is an abstract base class for debugger process.
246 * This class represents the debugger program. It provides the low-level
247 * interface to the commandline debugger. As such it implements the
248 * commands and parses the output.
250 class DebuggerDriver
: public KProcess
255 virtual ~DebuggerDriver() = 0;
257 virtual QString
driverName() const = 0;
259 * Returns the default command string to invoke the debugger driver.
261 virtual QString
defaultInvocation() const = 0;
264 * Returns a list of options that can be turned on and off.
266 virtual QStringList
boolOptionList() const = 0;
268 virtual bool startup(QString cmdStr
);
269 void dequeueCmdByVar(VarTree
* var
);
270 void setLogFileName(const QString
& fname
) { m_logFileName
= fname
; }
276 DSidle
, /* gdb waits for input */
277 DSinterrupted
, /* a command was interrupted */
278 DSrunningLow
, /* gdb is running a low-priority command */
279 DSrunning
, /* gdb waits for program */
280 DScommandSent
, /* command has been sent, we wait for wroteStdin signal */
281 DScommandSentLow
/* low-prioritycommand has been sent */
283 DebuggerState m_state
;
286 bool isIdle() const { return m_state
== DSidle
; }
288 * Tells whether a high prority command would be executed immediately.
290 bool canExecuteImmediately() const { return m_hipriCmdQueue
.isEmpty(); }
293 char* m_output
; /* normal gdb output */
294 size_t m_outputLen
; /* amount of data so far accumulated in m_output */
295 size_t m_outputAlloc
; /* space available in m_output */
296 typedef QCString DelayedStr
;
297 QQueue
<DelayedStr
> m_delayedOutput
; /* output colleced while we have receivedOutput */
298 /* but before signal wroteStdin arrived */
302 * Enqueues a high-priority command. High-priority commands are
303 * executed before any low-priority commands. No user interaction is
304 * possible as long as there is a high-priority command in the queue.
306 virtual CmdQueueItem
* executeCmd(DbgCommand
,
307 bool clearLow
= false) = 0;
308 virtual CmdQueueItem
* executeCmd(DbgCommand
, QString strArg
,
309 bool clearLow
= false) = 0;
310 virtual CmdQueueItem
* executeCmd(DbgCommand
, int intArg
,
311 bool clearLow
= false) = 0;
312 virtual CmdQueueItem
* executeCmd(DbgCommand
, QString strArg
, int intArg
,
313 bool clearLow
= false) = 0;
314 virtual CmdQueueItem
* executeCmd(DbgCommand
, QString strArg1
, QString strArg2
,
315 bool clearLow
= false) = 0;
316 virtual CmdQueueItem
* executeCmd(DbgCommand
, int intArg1
, int intArg2
,
317 bool clearLow
= false) = 0;
320 QMnormal
, /* queues the command last */
321 QMoverride
, /* removes an already queued command */
322 QMoverrideMoreEqual
/* ditto, also puts the command first in the queue */
326 * Enqueues a low-priority command. Low-priority commands are executed
327 * after any high-priority commands.
329 virtual CmdQueueItem
* queueCmd(DbgCommand
,
331 virtual CmdQueueItem
* queueCmd(DbgCommand
, QString strArg
,
333 virtual CmdQueueItem
* queueCmd(DbgCommand
, int intArg
,
335 virtual CmdQueueItem
* queueCmd(DbgCommand
, QString strArg
, int intArg
,
337 virtual CmdQueueItem
* queueCmd(DbgCommand
, QString strArg1
, QString strArg2
,
341 * Flushes the command queues.
342 * @param hipriOnly if true, only the high priority queue is flushed.
344 virtual void flushCommands(bool hipriOnly
= false);
347 * Terminates the debugger process.
349 virtual void terminate() = 0;
352 * Terminates the debugger process, but also detaches any program that
353 * it has been attached to.
355 virtual void detachAndTerminate() = 0;
358 * Interrupts the debuggee.
360 virtual void interruptInferior() = 0;
363 * Parses the output as an array of QChars.
365 virtual VarTree
* parseQCharArray(const char* output
, bool wantErrorValue
, bool qt3like
) = 0;
368 * Parses a back-trace (the output of the DCbt command).
370 virtual void parseBackTrace(const char* output
, QList
<StackFrame
>& stack
) = 0;
373 * Parses the output of the DCframe command;
374 * @param frameNo Returns the frame number.
375 * @param file Returns the source file name.
376 * @param lineNo The zero-based line number.
377 * @param address Returns the exact address.
378 * @return false if the frame could not be parsed successfully. The
379 * output values are undefined in this case.
381 virtual bool parseFrameChange(const char* output
, int& frameNo
,
382 QString
& file
, int& lineNo
, DbgAddr
& address
) = 0;
385 * Parses a list of breakpoints.
386 * @param output The output of the debugger.
387 * @param brks The list of new #Breakpoint objects. The list
388 * must initially be empty.
389 * @return False if there was an error before the first breakpoint
390 * was found. Even if true is returned, #brks may be empty.
392 virtual bool parseBreakList(const char* output
, QList
<Breakpoint
>& brks
) = 0;
395 * Parses a list of threads.
396 * @param output The output of the debugger.
397 * @param threads The list of new #ThreadInfo objects. The list
398 * must initially be empty.
399 * @return False if there was an error before the first thread entry
400 * was found. Even if true is returned, #threads may be empty.
402 virtual bool parseThreadList(const char* output
, QList
<ThreadInfo
>& threads
) = 0;
405 * Parses the output when the program stops to see whether this it
406 * stopped due to a breakpoint.
407 * @param output The output of the debugger.
408 * @param id Returns the breakpoint id.
409 * @param file Returns the file name in which the breakpoint is.
410 * @param lineNo Returns he zero-based line number of the breakpoint.
411 * @return False if there was no breakpoint.
413 virtual bool parseBreakpoint(const char* output
, int& id
,
414 QString
& file
, int& lineNo
) = 0;
417 * Parses the output of the DCinfolocals command.
418 * @param output The output of the debugger.
419 * @param newVars Receives the parsed variable values. The values are
420 * simply append()ed to the supplied list.
422 virtual void parseLocals(const char* output
, QList
<VarTree
>& newVars
) = 0;
425 * Parses the output of a DCprint or DCprintStruct command.
426 * @param output The output of the debugger.
427 * @param wantErrorValue Specifies whether the error message should be
428 * provided as the value of a NKplain variable. If this is false,
429 * #var will be 0 if the printed value is an error message.
430 * @param var Returns the variable value. It is set to 0 if there was
431 * a parse error or if the output is an error message and wantErrorValue
432 * is false. If it is not 0, #var->text() will return junk and must be
433 * set using #var->setText().
434 * @return false if the output is an error message. Even if true is
435 * returned, #var might still be 0 (due to a parse error).
437 virtual bool parsePrintExpr(const char* output
, bool wantErrorValue
,
441 * Parses the output of the DCcd command.
442 * @return false if the message is an error message.
444 virtual bool parseChangeWD(const char* output
, QString
& message
) = 0;
447 * Parses the output of the DCexecutable command.
448 * @return false if an error occured.
450 virtual bool parseChangeExecutable(const char* output
, QString
& message
) = 0;
453 * Parses the output of the DCcorefile command.
454 * @return false if the core file was not loaded successfully.
456 virtual bool parseCoreFile(const char* output
) = 0;
459 SFrefreshSource
= 1, /* refresh of source code is needed */
460 SFrefreshBreak
= 2, /* refresh breakpoints */
461 SFrefreshThreads
= 4, /* refresh thread list */
462 SFprogramActive
= 128 /* program remains active */
465 * Parses the output of commands that execute (a piece of) the program.
466 * @return The inclusive OR of zero or more of the StopFlags.
468 virtual uint
parseProgramStopped(const char* output
, QString
& message
) = 0;
471 * Parses the output of the DCsharedlibs command.
473 virtual void parseSharedLibs(const char* output
, QStrList
& shlibs
) = 0;
476 * Parses the output of the DCfindType command.
477 * @return true if a type was found.
479 virtual bool parseFindType(const char* output
, QString
& type
) = 0;
482 * Parses the output of the DCinforegisters command.
484 virtual void parseRegisters(const char* output
, QList
<RegisterInfo
>& regs
) = 0;
487 * Parses the output of the DCinfoline command. Returns false if the
488 * two addresses could not be found.
490 virtual bool parseInfoLine(const char* output
,
491 QString
& addrFrom
, QString
& addrTo
) = 0;
494 * Parses the ouput of the DCdisassemble command.
496 virtual void parseDisassemble(const char* output
, QList
<DisassembledCode
>& code
) = 0;
499 * Parses a memory dump. Returns an empty string if no error was found;
500 * otherwise it contains an error message.
502 virtual QString
parseMemoryDump(const char* output
, QList
<MemoryDump
>& memdump
) = 0;
505 /** Removes all commands from the low-priority queue. */
506 void flushLoPriQueue();
507 /** Removes all commands from the high-priority queue. */
508 void flushHiPriQueue();
510 QQueue
<CmdQueueItem
> m_hipriCmdQueue
;
511 QList
<CmdQueueItem
> m_lopriCmdQueue
;
513 * The active command is kept separately from other pending commands.
515 CmdQueueItem
* m_activeCmd
;
517 * Helper function that queues the given command string in the
518 * low-priority queue.
520 CmdQueueItem
* queueCmdString(DbgCommand cmd
, QString cmdString
,
523 * Helper function that queues the given command string in the
524 * high-priority queue.
526 CmdQueueItem
* executeCmdString(DbgCommand cmd
, QString cmdString
,
529 virtual void commandFinished(CmdQueueItem
* cmd
) = 0;
533 virtual int commSetupDoneC();
536 size_t m_promptMinLen
;
537 char m_promptLastChar
;
541 QString m_logFileName
;
545 virtual void slotReceiveOutput(KProcess
*, char* buffer
, int buflen
);
546 virtual void slotCommandRead(KProcess
*);
547 virtual void slotExited(KProcess
*);
551 * This signal is emitted when the output of a command has been fully
552 * collected and is ready to be interpreted.
554 void commandReceived(CmdQueueItem
* cmd
, const char* output
);
557 * This signal is emitted when the debugger recognizes that a specific
558 * location in a file ought to be displayed.
560 * Gdb's --fullname option supports this for the step, next, frame, and
561 * run commands (and possibly others).
563 * @param file specifies the file; this is not necessarily a full path
564 * name, and if it is relative, you won't know relative to what, you
566 * @param lineNo specifies the line number (0-based!) (this may be
567 * negative, in which case the file should be activated, but the line
568 * should NOT be changed).
569 * @param address specifies the exact address of the PC or is empty.
571 void activateFileLine(const QString
& file
, int lineNo
, const DbgAddr
& address
);
574 * This signal is emitted when a command that starts the inferior has
575 * been submitted to the debugger.
577 void inferiorRunning();
580 * This signal is emitted when all output from the debugger has been
581 * consumed and no more commands are in the queues.
583 void enterIdleState();
586 #endif // DBGDRIVER_H