kdbg/debugger.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include "debugger.h"
   7 #include "dbgdriver.h"
   8 #include "pgmargs.h"
   9 #include "typetable.h"
  10 #include "exprwnd.h"
  11 #include "pgmsettings.h"
  12 #include "programconfig.h"
  13 #include "valarray.h"
  14 #include <qregexp.h>
  15 #include <qfileinfo.h>
  16 #include <qlistbox.h>
  17 #include <qstringlist.h>
  18 #include <kapp.h>
  19 #include <kconfig.h>
  20 #include <klocale.h>                    /* i18n */
  21 #include <kmessagebox.h>
  22 #include <ctype.h>
  23 #include <stdlib.h>                     /* strtol, atoi */
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>                     /* sleep(3) */
  26 #endif
  27 #include "mydebug.h"
  28
  29
  30 KDebugger::KDebugger(QWidget* parent,
  31                      ExprWnd* localVars,
  32                      ExprWnd* watchVars,
  33                      QListBox* backtrace) :
  34         QObject(parent, "debugger"),
  35         m_ttyLevel(ttyFull),
  36         m_memoryFormat(MDTword | MDThex),
  37         m_haveExecutable(false),
  38         m_programActive(false),
  39         m_programRunning(false),
  40         m_sharedLibsListed(false),
  41         m_typeTable(0),
  42         m_programConfig(0),
  43         m_d(0),
  44         m_localVariables(*localVars),
  45         m_watchVariables(*watchVars),
  46         m_btWindow(*backtrace)
  47 {
  48     m_envVars.setAutoDelete(true);
  49     m_brkpts.setAutoDelete(true);
  50
  51     connect(&m_localVariables, SIGNAL(expanding(KTreeViewItem*,bool&)),
  52             SLOT(slotLocalsExpanding(KTreeViewItem*,bool&)));
  53     connect(&m_watchVariables, SIGNAL(expanding(KTreeViewItem*,bool&)),
  54             SLOT(slotWatchExpanding(KTreeViewItem*,bool&)));
  55     connect(&m_localVariables, SIGNAL(editValueCommitted(int, const QString&)),
  56             SLOT(slotValueEdited(int, const QString&)));
  57     connect(&m_watchVariables, SIGNAL(editValueCommitted(int, const QString&)),
  58             SLOT(slotValueEdited(int, const QString&)));
  59
  60     connect(&m_btWindow, SIGNAL(highlighted(int)), SLOT(gotoFrame(int)));
  61
  62     emit updateUI();
  63 }
  64
  65 KDebugger::~KDebugger()
  66 {
  67     if (m_programConfig != 0) {
  68         saveProgramSettings();
  69         m_programConfig->sync();
  70         delete m_programConfig;
  71     }
  72
  73     delete m_typeTable;
  74 }
  75
  76
  77 void KDebugger::saveSettings(KConfig* /*config*/)
  78 {
  79 }
  80
  81 void KDebugger::restoreSettings(KConfig* /*config*/)
  82 {
  83 }
  84
  85
  86 //////////////////////////////////////////////////////////////////////
  87 // external interface
  88
  89 const char GeneralGroup[] = "General";
  90 const char DebuggerCmdStr[] = "DebuggerCmdStr";
  91 const char TTYLevelEntry[] = "TTYLevel";
  92 const char KDebugger::DriverNameEntry[] = "DriverName";
  93
  94 bool KDebugger::debugProgram(const QString& name,
  95                              DebuggerDriver* driver)
  96 {
  97     if (m_d != 0 && m_d->isRunning())
  98     {
  99         QApplication::setOverrideCursor(waitCursor);
 100
 101         stopDriver();
 102
 103         QApplication::restoreOverrideCursor();
 104
 105         if (m_d->isRunning() || m_haveExecutable) {
 106             /* timed out! We can't really do anything useful now */
 107             TRACE("timed out while waiting for gdb to die!");
 108             return false;
 109         }
 110         delete m_d;
 111         m_d = 0;
 112     }
 113
 114     // wire up the driver
 115     connect(driver, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)),
 116             this, SIGNAL(activateFileLine(const QString&,int,const DbgAddr&)));
 117     connect(driver, SIGNAL(processExited(KProcess*)), SLOT(gdbExited(KProcess*)));
 118     connect(driver, SIGNAL(commandReceived(CmdQueueItem*,const char*)),
 119             SLOT(parse(CmdQueueItem*,const char*)));
 120     connect(driver, SIGNAL(wroteStdin(KProcess*)), SIGNAL(updateUI()));
 121     connect(driver, SIGNAL(inferiorRunning()), SLOT(slotInferiorRunning()));
 122     connect(driver, SIGNAL(enterIdleState()), SLOT(backgroundUpdate()));
 123     connect(driver, SIGNAL(enterIdleState()), SIGNAL(updateUI()));
 124     connect(&m_localVariables, SIGNAL(removingItem(VarTree*)),
 125             driver, SLOT(dequeueCmdByVar(VarTree*)));
 126     connect(&m_watchVariables, SIGNAL(removingItem(VarTree*)),
 127             driver, SLOT(dequeueCmdByVar(VarTree*)));
 128
 129     // create the program settings object
 130     openProgramConfig(name);
 131
 132     // get debugger command from per-program settings
 133     if (m_programConfig != 0) {
 134         m_programConfig->setGroup(GeneralGroup);
 135         m_debuggerCmd = readDebuggerCmd();
 136         // get terminal emulation level
 137         m_ttyLevel = TTYLevel(m_programConfig->readNumEntry(TTYLevelEntry, ttyFull));
 138     }
 139     // the rest is read in later in the handler of DCexecutable
 140
 141     m_d = driver;
 142
 143     if (!startDriver()) {
 144         TRACE("startDriver failed");
 145         m_d = 0;
 146         return false;
 147     }
 148
 149     TRACE("before file cmd");
 150     m_d->executeCmd(DCexecutable, name);
 151     m_executable = name;
 152
 153     // set remote target
 154     if (!m_remoteDevice.isEmpty()) {
 155         m_d->executeCmd(DCtargetremote, m_remoteDevice);
 156         m_d->queueCmd(DCbt, DebuggerDriver::QMoverride);
 157         m_d->queueCmd(DCframe, 0, DebuggerDriver::QMnormal);
 158         m_programActive = true;
 159         m_haveExecutable = true;
 160     }
 161
 162     // create a type table
 163     m_typeTable = new ProgramTypeTable;
 164     m_sharedLibsListed = false;
 165
 166     emit updateUI();
 167
 168     return true;
 169 }
 170
 171 void KDebugger::shutdown()
 172 {
 173     // shut down debugger driver
 174     if (m_d != 0 && m_d->isRunning())
 175     {
 176         stopDriver();
 177     }
 178 }
 179
 180 void KDebugger::useCoreFile(QString corefile, bool batch)
 181 {
 182     m_corefile = corefile;
 183     if (!batch) {
 184         CmdQueueItem* cmd = loadCoreFile();
 185         cmd->m_byUser = true;
 186     }
 187 }
 188
 189 void KDebugger::setAttachPid(const QString& pid)
 190 {
 191     m_attachedPid = pid;
 192 }
 193
 194 void KDebugger::programRun()
 195 {
 196     if (!isReady())
 197         return;
 198
 199     // when program is active, but not a core file, continue
 200     // otherwise run the program
 201     if (m_programActive && m_corefile.isEmpty()) {
 202         // gdb command: continue
 203         m_d->executeCmd(DCcont, true);
 204     } else {
 205         // gdb command: run
 206         m_d->executeCmd(DCrun, true);
 207         m_corefile = QString();
 208         m_programActive = true;
 209     }
 210     m_programRunning = true;
 211 }
 212
 213 void KDebugger::attachProgram(const QString& pid)
 214 {
 215     if (!isReady())
 216         return;
 217
 218     m_attachedPid = pid;
 219     TRACE("Attaching to " + m_attachedPid);
 220     m_d->executeCmd(DCattach, m_attachedPid);
 221     m_programActive = true;
 222     m_programRunning = true;
 223 }
 224
 225 void KDebugger::programRunAgain()
 226 {
 227     if (canSingleStep()) {
 228         m_d->executeCmd(DCrun, true);
 229         m_corefile = QString();
 230         m_programRunning = true;
 231     }
 232 }
 233
 234 void KDebugger::programStep()
 235 {
 236     if (canSingleStep()) {
 237         m_d->executeCmd(DCstep, true);
 238         m_programRunning = true;
 239     }
 240 }
 241
 242 void KDebugger::programNext()
 243 {
 244     if (canSingleStep()) {
 245         m_d->executeCmd(DCnext, true);
 246         m_programRunning = true;
 247     }
 248 }
 249
 250 void KDebugger::programStepi()
 251 {
 252     if (canSingleStep()) {
 253         m_d->executeCmd(DCstepi, true);
 254         m_programRunning = true;
 255     }
 256 }
 257
 258 void KDebugger::programNexti()
 259 {
 260     if (canSingleStep()) {
 261         m_d->executeCmd(DCnexti, true);
 262         m_programRunning = true;
 263     }
 264 }
 265
 266 void KDebugger::programFinish()
 267 {
 268     if (canSingleStep()) {
 269         m_d->executeCmd(DCfinish, true);
 270         m_programRunning = true;
 271     }
 272 }
 273
 274 void KDebugger::programKill()
 275 {
 276     if (haveExecutable() && isProgramActive()) {
 277         if (m_programRunning) {
 278             m_d->interruptInferior();
 279         }
 280         // this is an emergency command; flush queues
 281         m_d->flushCommands(true);
 282         m_d->executeCmd(DCkill, true);
 283     }
 284 }
 285
 286 bool KDebugger::runUntil(const QString& fileName, int lineNo)
 287 {
 288     if (isReady() && m_programActive && !m_programRunning) {
 289         // strip off directory part of file name
 290         QString file = fileName;
 291         int offset = file.findRev("/");
 292         if (offset >= 0) {
 293             file.remove(0, offset+1);
 294         }
 295         m_d->executeCmd(DCuntil, file, lineNo, true);
 296         m_programRunning = true;
 297         return true;
 298     } else {
 299         return false;
 300     }
 301 }
 302
 303 void KDebugger::programBreak()
 304 {
 305     if (m_haveExecutable && m_programRunning) {
 306         m_d->interruptInferior();
 307     }
 308 }
 309
 310 void KDebugger::programArgs(QWidget* parent)
 311 {
 312     if (m_haveExecutable) {
 313         QStringList allOptions = m_d->boolOptionList();
 314         PgmArgs dlg(parent, m_executable, m_envVars, allOptions);
 315         dlg.setArgs(m_programArgs);
 316         dlg.setWd(m_programWD);
 317         dlg.setOptions(m_boolOptions);
 318         if (dlg.exec()) {
 319             updateProgEnvironment(dlg.args(), dlg.wd(),
 320                                   dlg.envVars(), dlg.options());
 321         }
 322     }
 323 }
 324
 325 void KDebugger::programSettings(QWidget* parent)
 326 {
 327     if (!m_haveExecutable)
 328         return;
 329
 330     ProgramSettings dlg(parent, m_executable);
 331
 332     dlg.m_chooseDriver.setDebuggerCmd(m_debuggerCmd);
 333     dlg.m_output.setTTYLevel(m_ttyLevel);
 334
 335     if (dlg.exec() == QDialog::Accepted)
 336     {
 337         m_debuggerCmd = dlg.m_chooseDriver.debuggerCmd();
 338         m_ttyLevel = TTYLevel(dlg.m_output.ttyLevel());
 339     }
 340 }
 341
 342 bool KDebugger::setBreakpoint(QString file, int lineNo,
 343                               const DbgAddr& address, bool temporary)
 344 {
 345     if (!isReady()) {
 346         return false;
 347     }
 348
 349     Breakpoint* bp = breakpointByFilePos(file, lineNo, address);
 350     if (bp == 0)
 351     {
 352         /*
 353          * No such breakpoint, so set a new one. If we have an address, we
 354          * set the breakpoint exactly there. Otherwise we use the file name
 355          * plus line no.
 356          */
 357         Breakpoint* bp = new Breakpoint;
 358         bp->temporary = temporary;
 359
 360         if (address.isEmpty())
 361         {
 362             bp->fileName = file;
 363             bp->lineNo = lineNo;
 364         }
 365         else
 366         {
 367             bp->address = address;
 368         }
 369         setBreakpoint(bp, false);
 370     }
 371     else
 372     {
 373         /*
 374          * If the breakpoint is disabled, enable it; if it's enabled,
 375          * delete that breakpoint.
 376          */
 377         if (bp->enabled) {
 378             deleteBreakpoint(bp);
 379         } else {
 380             enableDisableBreakpoint(bp);
 381         }
 382     }
 383     return true;
 384 }
 385
 386 void KDebugger::setBreakpoint(Breakpoint* bp, bool queueOnly)
 387 {
 388     CmdQueueItem* cmd;
 389     if (!bp->text.isEmpty())
 390     {
 391         /*
 392          * The breakpoint was set using the text box in the breakpoint
 393          * list. This is the only way in which watchpoints are set.
 394          */
 395         if (bp->type == Breakpoint::watchpoint) {
 396             cmd = m_d->executeCmd(DCwatchpoint, bp->text);
 397         } else {
 398             cmd = m_d->executeCmd(DCbreaktext, bp->text);
 399         }
 400     }
 401     else if (bp->address.isEmpty())
 402     {
 403         // strip off directory part of file name
 404         QString file = bp->fileName;
 405         int offset = file.findRev("/");
 406         if (offset >= 0) {
 407             file.remove(0, offset+1);
 408         }
 409         if (queueOnly) {
 410             cmd = m_d->queueCmd(bp->temporary ? DCtbreakline : DCbreakline,
 411                                 file, bp->lineNo, DebuggerDriver::QMoverride);
 412         } else {
 413             cmd = m_d->executeCmd(bp->temporary ? DCtbreakline : DCbreakline,
 414                                   file, bp->lineNo);
 415         }
 416     }
 417     else
 418     {
 419         if (queueOnly) {
 420             cmd = m_d->queueCmd(bp->temporary ? DCtbreakaddr : DCbreakaddr,
 421                                 bp->address.asString(), DebuggerDriver::QMoverride);
 422         } else {
 423             cmd = m_d->executeCmd(bp->temporary ? DCtbreakaddr : DCbreakaddr,
 424                                   bp->address.asString());
 425         }
 426     }
 427     cmd->m_brkpt = bp;  // used in newBreakpoint()
 428 }
 429
 430 bool KDebugger::enableDisableBreakpoint(QString file, int lineNo,
 431                                         const DbgAddr& address)
 432 {
 433     Breakpoint* bp = breakpointByFilePos(file, lineNo, address);
 434     return bp == 0 || enableDisableBreakpoint(bp);
 435 }
 436
 437 bool KDebugger::enableDisableBreakpoint(Breakpoint* bp)
 438 {
 439     /*
 440      * Toggle enabled/disabled state.
 441      *
 442      * The driver is not bothered if we are modifying an orphaned
 443      * breakpoint.
 444      */
 445     if (!bp->isOrphaned()) {
 446         if (!canChangeBreakpoints()) {
 447             return false;
 448         }
 449         m_d->executeCmd(bp->enabled ? DCdisable : DCenable, bp->id);
 450     } else {
 451         bp->enabled = !bp->enabled;
 452         emit breakpointsChanged();
 453     }
 454     return true;
 455 }
 456
 457 bool KDebugger::conditionalBreakpoint(Breakpoint* bp,
 458                                       const QString& condition,
 459                                       int ignoreCount)
 460 {
 461     /*
 462      * Change the condition and ignore count.
 463      *
 464      * The driver is not bothered if we are removing an orphaned
 465      * breakpoint.
 466      */
 467
 468     if (!bp->isOrphaned()) {
 469         if (!canChangeBreakpoints()) {
 470             return false;
 471         }
 472
 473         bool changed = false;
 474
 475         if (bp->condition != condition) {
 476             // change condition
 477             m_d->executeCmd(DCcondition, condition, bp->id);
 478             changed = true;
 479         }
 480         if (bp->ignoreCount != ignoreCount) {
 481             // change ignore count
 482             m_d->executeCmd(DCignore, bp->id, ignoreCount);
 483             changed = true;
 484         }
 485         if (changed) {
 486             // get the changes
 487             m_d->queueCmd(DCinfobreak, DebuggerDriver::QMoverride);
 488         }
 489     } else {
 490         bp->condition = condition;
 491         bp->ignoreCount = ignoreCount;
 492         emit breakpointsChanged();
 493     }
 494     return true;
 495 }
 496
 497 bool KDebugger::deleteBreakpoint(Breakpoint* bp)
 498 {
 499     /*
 500      * Remove the breakpoint.
 501      *
 502      * The driver is not bothered if we are removing an orphaned
 503      * breakpoint.
 504      */
 505     if (!bp->isOrphaned()) {
 506         if (!canChangeBreakpoints()) {
 507             return false;
 508         }
 509         m_d->executeCmd(DCdelete, bp->id);
 510     } else {
 511         // move the last entry to bp's slot and shorten the list
 512         int i = m_brkpts.findRef(bp);
 513         m_brkpts.insert(i, m_brkpts.take(m_brkpts.size()-1));
 514         m_brkpts.resize(m_brkpts.size()-1);
 515         emit breakpointsChanged();
 516     }
 517     return false;
 518 }
 519
 520 bool KDebugger::canSingleStep()
 521 {
 522     return isReady() && m_programActive && !m_programRunning;
 523 }
 524
 525 bool KDebugger::canChangeBreakpoints()
 526 {
 527     return isReady() && !m_programRunning;
 528 }
 529
 530 bool KDebugger::canStart()
 531 {
 532     return isReady() && !m_programActive;
 533 }
 534
 535 bool KDebugger::isReady() const
 536 {
 537     return m_haveExecutable &&
 538         m_d != 0 && m_d->canExecuteImmediately();
 539 }
 540
 541 bool KDebugger::isIdle() const
 542 {
 543     return m_d == 0 || m_d->isIdle();
 544 }
 545
 546
 547 //////////////////////////////////////////////////////////
 548 // debugger driver
 549
 550 bool KDebugger::startDriver()
 551 {
 552     emit debuggerStarting();            /* must set m_inferiorTerminal */
 553
 554     /*
 555      * If the per-program command string is empty, use the global setting
 556      * (which might also be empty, in which case the driver uses its
 557      * default).
 558      */
 559     m_explicitKill = false;
 560     if (!m_d->startup(m_debuggerCmd)) {
 561         return false;
 562     }
 563
 564     /*
 565      * If we have an output terminal, we use it. Otherwise we will run the
 566      * program with input and output redirected to /dev/null. Other
 567      * redirections are also necessary depending on the tty emulation
 568      * level.
 569      */
 570     int redirect = RDNstdin|RDNstdout|RDNstderr;        /* redirect everything */
 571     if (!m_inferiorTerminal.isEmpty()) {
 572         switch (m_ttyLevel) {
 573         default:
 574         case ttyNone:
 575             // redirect everything
 576             break;
 577         case ttySimpleOutputOnly:
 578             redirect = RDNstdin;
 579             break;
 580         case ttyFull:
 581             redirect = 0;
 582             break;
 583         }
 584     }
 585     m_d->executeCmd(DCtty, m_inferiorTerminal, redirect);
 586
 587     return true;
 588 }
 589
 590 void KDebugger::stopDriver()
 591 {
 592     m_explicitKill = true;
 593
 594     if (m_attachedPid.isEmpty()) {
 595         m_d->terminate();
 596     } else {
 597         m_d->detachAndTerminate();
 598     }
 599
 600     /*
 601      * We MUST wait until the slot gdbExited() has been called. But to
 602      * avoid a deadlock, we wait only for some certain maximum time. Should
 603      * this timeout be reached, the only reasonable thing one could do then
 604      * is exiting kdbg.
 605      */
 606     kapp->processEvents(1000);          /* ideally, this will already shut it down */
 607     int maxTime = 20;                   /* about 20 seconds */
 608     while (m_haveExecutable && maxTime > 0) {
 609         // give gdb time to die (and send a SIGCLD)
 610         ::sleep(1);
 611         --maxTime;
 612         kapp->processEvents(1000);
 613     }
 614 }
 615
 616 void KDebugger::gdbExited(KProcess*)
 617 {
 618     /*
 619      * Save settings, but only if gdb has already processed "info line
 620      * main", otherwise we would save an empty config file, because it
 621      * isn't read in until then!
 622      */
 623     if (m_programConfig != 0) {
 624         if (m_haveExecutable) {
 625             saveProgramSettings();
 626             m_programConfig->sync();
 627         }
 628         delete m_programConfig;
 629         m_programConfig = 0;
 630     }
 631
 632     // erase types
 633     delete m_typeTable;
 634     m_typeTable = 0;
 635
 636     if (m_explicitKill) {
 637         TRACE(m_d->driverName() + " exited normally");
 638     } else {
 639         QString msg = i18n("%1 exited unexpectedly.\n"
 640                            "Restart the session (e.g. with File|Executable).");
 641         KMessageBox::error(parentWidget(), msg.arg(m_d->driverName()));
 642     }
 643
 644     // reset state
 645     m_haveExecutable = false;
 646     m_executable = "";
 647     m_programActive = false;
 648     m_programRunning = false;
 649     m_explicitKill = false;
 650     m_debuggerCmd = QString();          /* use global setting at next start! */
 651     m_attachedPid = QString();          /* we are no longer attached to a process */
 652     m_ttyLevel = ttyFull;
 653     m_brkpts.clear();
 654
 655     // erase PC
 656     emit updatePC(QString(), -1, DbgAddr(), 0);
 657 }
 658
 659 QString KDebugger::getConfigForExe(const QString& name)
 660 {
 661     QFileInfo fi(name);
 662     QString pgmConfigFile = fi.dirPath(true);
 663     if (!pgmConfigFile.isEmpty()) {
 664         pgmConfigFile += '/';
 665     }
 666     pgmConfigFile += ".kdbgrc." + fi.fileName();
 667     TRACE("program config file = " + pgmConfigFile);
 668     return pgmConfigFile;
 669 }
 670
 671 void KDebugger::openProgramConfig(const QString& name)
 672 {
 673     ASSERT(m_programConfig == 0);
 674
 675     QString pgmConfigFile = getConfigForExe(name);
 676
 677     m_programConfig = new ProgramConfig(pgmConfigFile);
 678 }
 679
 680 const char EnvironmentGroup[] = "Environment";
 681 const char WatchGroup[] = "Watches";
 682 const char FileVersion[] = "FileVersion";
 683 const char ProgramArgs[] = "ProgramArgs";
 684 const char WorkingDirectory[] = "WorkingDirectory";
 685 const char OptionsSelected[] = "OptionsSelected";
 686 const char Variable[] = "Var%d";
 687 const char Value[] = "Value%d";
 688 const char ExprFmt[] = "Expr%d";
 689
 690 void KDebugger::saveProgramSettings()
 691 {
 692     ASSERT(m_programConfig != 0);
 693     m_programConfig->setGroup(GeneralGroup);
 694     m_programConfig->writeEntry(FileVersion, 1);
 695     m_programConfig->writeEntry(ProgramArgs, m_programArgs);
 696     m_programConfig->writeEntry(WorkingDirectory, m_programWD);
 697     m_programConfig->writeEntry(OptionsSelected, m_boolOptions);
 698     m_programConfig->writeEntry(DebuggerCmdStr, m_debuggerCmd);
 699     m_programConfig->writeEntry(TTYLevelEntry, int(m_ttyLevel));
 700     QString driverName;
 701     if (m_d != 0)
 702         driverName = m_d->driverName();
 703     m_programConfig->writeEntry(DriverNameEntry, driverName);
 704
 705     // write environment variables
 706     m_programConfig->deleteGroup(EnvironmentGroup);
 707     m_programConfig->setGroup(EnvironmentGroup);
 708     QDictIterator<EnvVar> it = m_envVars;
 709     EnvVar* var;
 710     QString varName;
 711     QString varValue;
 712     for (int i = 0; (var = it) != 0; ++it, ++i) {
 713         varName.sprintf(Variable, i);
 714         varValue.sprintf(Value, i);
 715         m_programConfig->writeEntry(varName, it.currentKey());
 716         m_programConfig->writeEntry(varValue, var->value);
 717     }
 718
 719     saveBreakpoints(m_programConfig);
 720
 721     // watch expressions
 722     // first get rid of whatever was in this group
 723     m_programConfig->deleteGroup(WatchGroup);
 724     // then start a new group
 725     m_programConfig->setGroup(WatchGroup);
 726     KTreeViewItem* item = m_watchVariables.itemAt(0);
 727     int watchNum = 0;
 728     for (; item != 0; item = item->getSibling(), ++watchNum) {
 729         varName.sprintf(ExprFmt, watchNum);
 730         m_programConfig->writeEntry(varName, item->getText());
 731     }
 732
 733     // give others a chance
 734     emit saveProgramSpecific(m_programConfig);
 735 }
 736
 737 void KDebugger::restoreProgramSettings()
 738 {
 739     ASSERT(m_programConfig != 0);
 740     m_programConfig->setGroup(GeneralGroup);
 741     /*
 742      * We ignore file version for now we will use it in the future to
 743      * distinguish different versions of this configuration file.
 744      */
 745     // m_debuggerCmd has been read in already
 746     // m_ttyLevel has been read in already
 747     QString pgmArgs = m_programConfig->readEntry(ProgramArgs);
 748     QString pgmWd = m_programConfig->readEntry(WorkingDirectory);
 749     QStringList boolOptions = m_programConfig->readListEntry(OptionsSelected);
 750     m_boolOptions = QStringList();
 751
 752     // read environment variables
 753     m_programConfig->setGroup(EnvironmentGroup);
 754     m_envVars.clear();
 755     QDict<EnvVar> pgmVars;
 756     EnvVar* var;
 757     QString varName;
 758     QString varValue;
 759     for (int i = 0;; ++i) {
 760         varName.sprintf(Variable, i);
 761         varValue.sprintf(Value, i);
 762         if (!m_programConfig->hasKey(varName)) {
 763             /* entry not present, assume that we've hit them all */
 764             break;
 765         }
 766         QString name = m_programConfig->readEntry(varName);
 767         if (name.isEmpty()) {
 768             // skip empty names
 769             continue;
 770         }
 771         var = new EnvVar;
 772         var->value = m_programConfig->readEntry(varValue);
 773         var->status = EnvVar::EVnew;
 774         pgmVars.insert(name, var);
 775     }
 776
 777     updateProgEnvironment(pgmArgs, pgmWd, pgmVars, boolOptions);
 778
 779     restoreBreakpoints(m_programConfig);
 780
 781     // watch expressions
 782     m_programConfig->setGroup(WatchGroup);
 783     m_watchVariables.clear();
 784     for (int i = 0;; ++i) {
 785         varName.sprintf(ExprFmt, i);
 786         if (!m_programConfig->hasKey(varName)) {
 787             /* entry not present, assume that we've hit them all */
 788             break;
 789         }
 790         QString expr = m_programConfig->readEntry(varName);
 791         if (expr.isEmpty()) {
 792             // skip empty expressions
 793             continue;
 794         }
 795         addWatch(expr);
 796     }
 797
 798     // give others a chance
 799     emit restoreProgramSpecific(m_programConfig);
 800 }
 801
 802 /**
 803  * Reads the debugger command line from the program settings. The config
 804  * group must have been set by the caller.
 805  */
 806 QString KDebugger::readDebuggerCmd()
 807 {
 808     QString debuggerCmd = m_programConfig->readEntry(DebuggerCmdStr);
 809
 810     // always let the user confirm the debugger cmd if we are root
 811     if (::geteuid() == 0)
 812     {
 813         if (!debuggerCmd.isEmpty()) {
 814             QString msg = i18n(
 815                 "The settings for this program specify "
 816                 "the following debugger command:\n%1\n"
 817                 "Shall this command be used?");
 818             if (KMessageBox::warningYesNo(parentWidget(), msg.arg(debuggerCmd))
 819                 != KMessageBox::Yes)
 820             {
 821                 // don't use it
 822                 debuggerCmd = QString();
 823             }
 824         }
 825     }
 826     return debuggerCmd;
 827 }
 828
 829 /*
 830  * Breakpoints are saved one per group.
 831  */
 832 const char BPGroup[] = "Breakpoint %d";
 833 const char File[] = "File";
 834 const char Line[] = "Line";
 835 const char Text[] = "Text";
 836 const char Address[] = "Address";
 837 const char Temporary[] = "Temporary";
 838 const char Enabled[] = "Enabled";
 839 const char Condition[] = "Condition";
 840
 841 void KDebugger::saveBreakpoints(ProgramConfig* config)
 842 {
 843     QString groupName;
 844     int i = 0;
 845     for (uint j = 0; j < m_brkpts.size(); j++) {
 846         Breakpoint* bp = m_brkpts[j];
 847         if (bp->type == Breakpoint::watchpoint)
 848             continue;                   /* don't save watchpoints */
 849         groupName.sprintf(BPGroup, i++);
 850
 851         /* remove remmants */
 852         config->deleteGroup(groupName);
 853
 854         config->setGroup(groupName);
 855         if (!bp->text.isEmpty()) {
 856             /*
 857              * The breakpoint was set using the text box in the breakpoint
 858              * list. We do not save the location by filename+line number,
 859              * but instead honor what the user typed (a function name, for
 860              * example, which could move between sessions).
 861              */
 862             config->writeEntry(Text, bp->text);
 863         } else if (!bp->fileName.isEmpty()) {
 864             config->writeEntry(File, bp->fileName);
 865             config->writeEntry(Line, bp->lineNo);
 866             /*
 867              * Addresses are hardly correct across sessions, so we don't
 868              * save it.
 869              */
 870         } else {
 871             config->writeEntry(Address, bp->address.asString());
 872         }
 873         config->writeEntry(Temporary, bp->temporary);
 874         config->writeEntry(Enabled, bp->enabled);
 875         if (!bp->condition.isEmpty())
 876             config->writeEntry(Condition, bp->condition);
 877         // we do not save the ignore count
 878     }
 879     // delete remaining groups
 880     // we recognize that a group is present if there is an Enabled entry
 881     for (;; i++) {
 882         groupName.sprintf(BPGroup, i);
 883         config->setGroup(groupName);
 884         if (!config->hasKey(Enabled)) {
 885             /* group not present, assume that we've hit them all */
 886             break;
 887         }
 888         config->deleteGroup(groupName);
 889     }
 890 }
 891
 892 void KDebugger::restoreBreakpoints(ProgramConfig* config)
 893 {
 894     QString groupName;
 895     /*
 896      * We recognize the end of the list if there is no Enabled entry
 897      * present.
 898      */
 899     for (int i = 0;; i++) {
 900         groupName.sprintf(BPGroup, i);
 901         config->setGroup(groupName);
 902         if (!config->hasKey(Enabled)) {
 903             /* group not present, assume that we've hit them all */
 904             break;
 905         }
 906         Breakpoint* bp = new Breakpoint;
 907         bp->fileName = config->readEntry(File);
 908         bp->lineNo = config->readNumEntry(Line, -1);
 909         bp->text = config->readEntry(Text);
 910         bp->address = config->readEntry(Address);
 911         // check consistency
 912         if ((bp->fileName.isEmpty() || bp->lineNo < 0) &&
 913             bp->text.isEmpty() &&
 914             bp->address.isEmpty())
 915         {
 916             delete bp;
 917             continue;
 918         }
 919         bp->enabled = config->readBoolEntry(Enabled, true);
 920         bp->temporary = config->readBoolEntry(Temporary, false);
 921         bp->condition = config->readEntry(Condition);
 922
 923         /*
 924          * Add the breakpoint.
 925          */
 926         setBreakpoint(bp, false);
 927         // the new breakpoint is disabled or conditionalized later
 928         // in newBreakpoint()
 929     }
 930     m_d->queueCmd(DCinfobreak, DebuggerDriver::QMoverride);
 931 }
 932
 933
 934 // parse output of command cmd
 935 void KDebugger::parse(CmdQueueItem* cmd, const char* output)
 936 {
 937     ASSERT(cmd != 0);                   /* queue mustn't be empty */
 938
 939     TRACE(QString(__PRETTY_FUNCTION__) + " parsing " + output);
 940
 941     switch (cmd->m_cmd) {
 942     case DCtargetremote:
 943         // the output (if any) is uninteresting
 944     case DCsetargs:
 945     case DCtty:
 946         // there is no output
 947     case DCsetenv:
 948     case DCunsetenv:
 949     case DCsetoption:
 950         /* if value is empty, we see output, but we don't care */
 951         break;
 952     case DCcd:
 953         /* display gdb's message in the status bar */
 954         m_d->parseChangeWD(output, m_statusMessage);
 955         emit updateStatusMessage();
 956         break;
 957     case DCinitialize:
 958         break;
 959     case DCexecutable:
 960         if (m_d->parseChangeExecutable(output, m_statusMessage))
 961         {
 962             // success; restore breakpoints etc.
 963             if (m_programConfig != 0) {
 964                 restoreProgramSettings();
 965             }
 966             // load file containing main() or core file
 967             if (!m_corefile.isEmpty())
 968             {
 969                 // load core file
 970                 loadCoreFile();
 971             }
 972             else if (!m_attachedPid.isEmpty())
 973             {
 974                 m_d->queueCmd(DCattach, m_attachedPid, DebuggerDriver::QMoverride);
 975                 m_programActive = true;
 976                 m_programRunning = true;
 977             }
 978             else if (!m_remoteDevice.isEmpty())
 979             {
 980                 // handled elsewhere
 981             }
 982             else
 983             {
 984                 m_d->queueCmd(DCinfolinemain, DebuggerDriver::QMnormal);
 985             }
 986             if (!m_statusMessage.isEmpty())
 987                 emit updateStatusMessage();
 988         } else {
 989             QString msg = m_d->driverName() + ": " + m_statusMessage;
 990             KMessageBox::sorry(parentWidget(), msg);
 991             m_executable = "";
 992             m_corefile = "";            /* don't process core file */
 993             m_haveExecutable = false;
 994         }
 995         break;
 996     case DCcorefile:
 997         // in any event we have an executable at this point
 998         m_haveExecutable = true;
 999         if (m_d->parseCoreFile(output)) {
1000             // loading a core is like stopping at a breakpoint
1001             m_programActive = true;
1002             handleRunCommands(output);
1003             // do not reset m_corefile
1004         } else {
1005             // report error
1006             QString msg = m_d->driverName() + ": " + QString(output);
1007             KMessageBox::sorry(parentWidget(), msg);
1008
1009             // if core file was loaded from command line, revert to info line main
1010             if (!cmd->m_byUser) {
1011                 m_d->queueCmd(DCinfolinemain, DebuggerDriver::QMnormal);
1012             }
1013             m_corefile = QString();     /* core file not available any more */
1014         }
1015         break;
1016     case DCinfolinemain:
1017         // ignore the output, marked file info follows
1018         m_haveExecutable = true;
1019         break;
1020     case DCinfolocals:
1021         // parse local variables
1022         if (output[0] != '\0') {
1023             handleLocals(output);
1024         }
1025         break;
1026     case DCinforegisters:
1027         handleRegisters(output);
1028         break;
1029     case DCexamine:
1030         handleMemoryDump(output);
1031         break;
1032     case DCinfoline:
1033         handleInfoLine(cmd, output);
1034         break;
1035     case DCdisassemble:
1036         handleDisassemble(cmd, output);
1037         break;
1038     case DCframe:
1039         handleFrameChange(output);
1040         updateAllExprs();
1041         break;
1042     case DCbt:
1043         handleBacktrace(output);
1044         updateAllExprs();
1045         break;
1046     case DCprint:
1047         handlePrint(cmd, output);
1048         break;
1049     case DCprintDeref:
1050         handlePrintDeref(cmd, output);
1051         break;
1052     case DCattach:
1053         m_haveExecutable = true;
1054         // fall through
1055     case DCrun:
1056     case DCcont:
1057     case DCstep:
1058     case DCstepi:
1059     case DCnext:
1060     case DCnexti:
1061     case DCfinish:
1062     case DCuntil:
1063     case DCthread:
1064         handleRunCommands(output);
1065         break;
1066     case DCkill:
1067         m_programRunning = m_programActive = false;
1068         // erase PC
1069         emit updatePC(QString(), -1, DbgAddr(), 0);
1070         break;
1071     case DCbreaktext:
1072     case DCbreakline:
1073     case DCtbreakline:
1074     case DCbreakaddr:
1075     case DCtbreakaddr:
1076     case DCwatchpoint:
1077         newBreakpoint(cmd, output);
1078         // fall through
1079     case DCdelete:
1080     case DCenable:
1081     case DCdisable:
1082         // these commands need immediate response
1083         m_d->queueCmd(DCinfobreak, DebuggerDriver::QMoverrideMoreEqual);
1084         break;
1085     case DCinfobreak:
1086         // note: this handler must not enqueue a command, since
1087         // DCinfobreak is used at various different places.
1088         updateBreakList(output);
1089         break;
1090     case DCfindType:
1091         handleFindType(cmd, output);
1092         break;
1093     case DCprintStruct:
1094     case DCprintQStringStruct:
1095         handlePrintStruct(cmd, output);
1096         break;
1097     case DCinfosharedlib:
1098         handleSharedLibs(output);
1099         break;
1100     case DCcondition:
1101     case DCignore:
1102         // we are not interested in the output
1103         break;
1104     case DCinfothreads:
1105         handleThreadList(output);
1106         break;
1107     case DCsetpc:
1108         handleSetPC(output);
1109         break;
1110     case DCsetvariable:
1111         handleSetVariable(cmd, output);
1112         break;
1113     }
1114 }
1115
1116 void KDebugger::backgroundUpdate()
1117 {
1118     /*
1119      * If there are still expressions that need to be updated, then do so.
1120      */
1121     if (m_programActive)
1122         evalExpressions();
1123 }
1124
1125 void KDebugger::handleRunCommands(const char* output)
1126 {
1127     uint flags = m_d->parseProgramStopped(output, m_statusMessage);
1128     emit updateStatusMessage();
1129
1130     m_programActive = flags & DebuggerDriver::SFprogramActive;
1131
1132     // refresh files if necessary
1133     if (flags & DebuggerDriver::SFrefreshSource) {
1134         TRACE("re-reading files");
1135         emit executableUpdated();
1136     }
1137
1138     /*
1139      * Try to set any orphaned breakpoints now.
1140      */
1141     for (int i = m_brkpts.size()-1; i >= 0; i--) {
1142         if (m_brkpts[i]->isOrphaned()) {
1143             TRACE("re-trying brkpt loc: "+m_brkpts[i]->location+
1144                   " file: "+m_brkpts[i]->fileName+
1145                   QString().sprintf(" line: %d", m_brkpts[i]->lineNo));
1146             setBreakpoint(m_brkpts[i], true);
1147             flags |= DebuggerDriver::SFrefreshBreak;
1148         }
1149     }
1150
1151     /*
1152      * If we stopped at a breakpoint, we must update the breakpoint list
1153      * because the hit count changes. Also, if the breakpoint was temporary
1154      * it would go away now.
1155      */
1156     if ((flags & (DebuggerDriver::SFrefreshBreak|DebuggerDriver::SFrefreshSource)) ||
1157         stopMayChangeBreakList())
1158     {
1159         m_d->queueCmd(DCinfobreak, DebuggerDriver::QMoverride);
1160     }
1161
1162     /*
1163      * If we haven't listed the shared libraries yet, do so. We must do
1164      * this before we emit any commands that list variables, since the type
1165      * libraries depend on the shared libraries.
1166      */
1167     if (!m_sharedLibsListed) {
1168         // must be a high-priority command!
1169         m_d->executeCmd(DCinfosharedlib);
1170     }
1171
1172     // get the backtrace if the program is running
1173     if (m_programActive) {
1174         m_d->queueCmd(DCbt, DebuggerDriver::QMoverride);
1175     } else {
1176         // program finished: erase PC
1177         emit updatePC(QString(), -1, DbgAddr(), 0);
1178         // dequeue any commands in the queues
1179         m_d->flushCommands();
1180     }
1181
1182     /* Update threads list */
1183     if (m_programActive && (flags & DebuggerDriver::SFrefreshThreads)) {
1184         m_d->queueCmd(DCinfothreads, DebuggerDriver::QMoverride);
1185     }
1186
1187     m_programRunning = false;
1188     emit programStopped();
1189 }
1190
1191 void KDebugger::slotInferiorRunning()
1192 {
1193     m_programRunning = true;
1194 }
1195
1196 void KDebugger::updateAllExprs()
1197 {
1198     if (!m_programActive)
1199         return;
1200
1201     // retrieve local variables
1202     m_d->queueCmd(DCinfolocals, DebuggerDriver::QMoverride);
1203
1204     // retrieve registers
1205     m_d->queueCmd(DCinforegisters, DebuggerDriver::QMoverride);
1206
1207     // get new memory dump
1208     if (!m_memoryExpression.isEmpty()) {
1209         queueMemoryDump(false);
1210     }
1211
1212     // update watch expressions
1213     KTreeViewItem* item = m_watchVariables.itemAt(0);
1214     for (; item != 0; item = item->getSibling()) {
1215         m_watchEvalExpr.append(static_cast<VarTree*>(item));
1216     }
1217 }
1218
1219 void KDebugger::updateProgEnvironment(const QString& args, const QString& wd,
1220                                       const QDict<EnvVar>& newVars,
1221                                       const QStringList& newOptions)
1222 {
1223     m_programArgs = args;
1224     m_d->executeCmd(DCsetargs, m_programArgs);
1225     TRACE("new pgm args: " + m_programArgs + "\n");
1226
1227     m_programWD = wd.stripWhiteSpace();
1228     if (!m_programWD.isEmpty()) {
1229         m_d->executeCmd(DCcd, m_programWD);
1230         TRACE("new wd: " + m_programWD + "\n");
1231     }
1232
1233     // update environment variables
1234     QDictIterator<EnvVar> it = newVars;
1235     EnvVar* val;
1236     for (; (val = it) != 0; ++it) {
1237         QString var = it.currentKey();
1238         switch (val->status) {
1239         case EnvVar::EVnew:
1240             m_envVars.insert(var, val);
1241             // fall thru
1242         case EnvVar::EVdirty:
1243             // the value must be in our list
1244             ASSERT(m_envVars[var] == val);
1245             // update value
1246             m_d->executeCmd(DCsetenv, var, val->value);
1247             break;
1248         case EnvVar::EVdeleted:
1249             // must be in our list
1250             ASSERT(m_envVars[var] == val);
1251             // delete value
1252             m_d->executeCmd(DCunsetenv, var);
1253             m_envVars.remove(var);
1254             break;
1255         default:
1256             ASSERT(false);
1257         case EnvVar::EVclean:
1258             // variable not changed
1259             break;
1260         }
1261     }
1262
1263     // update options
1264     QStringList::ConstIterator oi;
1265     for (oi = newOptions.begin(); oi != newOptions.end(); ++oi)
1266     {
1267         if (m_boolOptions.findIndex(*oi) < 0) {
1268             // the options is currently not set, so set it
1269             m_d->executeCmd(DCsetoption, *oi, 1);
1270         } else {
1271             // option is set, no action required, but move it to the end
1272             m_boolOptions.remove(*oi);
1273         }
1274         m_boolOptions.append(*oi);
1275     }
1276     /*
1277      * Now all options that should be set are at the end of m_boolOptions.
1278      * If some options need to be unset, they are at the front of the list.
1279      * Here we unset and remove them.
1280      */
1281     while (m_boolOptions.count() > newOptions.count()) {
1282         m_d->executeCmd(DCsetoption, m_boolOptions.first(), 0);
1283         m_boolOptions.remove(m_boolOptions.begin());
1284     }
1285 }
1286
1287 void KDebugger::handleLocals(const char* output)
1288 {
1289     // retrieve old list of local variables
1290     QStrList oldVars;
1291     m_localVariables.exprList(oldVars);
1292
1293     /*
1294      *  Get local variables.
1295      */
1296     QList<VarTree> newVars;
1297     parseLocals(output, newVars);
1298
1299     /*
1300      * Clear any old VarTree item pointers, so that later we don't access
1301      * dangling pointers.
1302      */
1303     m_localVariables.clearPendingUpdates();
1304
1305     // reduce flicker
1306     bool autoU = m_localVariables.autoUpdate();
1307     m_localVariables.setAutoUpdate(false);
1308     bool repaintNeeded = false;
1309
1310     /*
1311      * Match old variables against new ones.
1312      */
1313     for (const char* n = oldVars.first(); n != 0; n = oldVars.next()) {
1314         // lookup this variable in the list of new variables
1315         VarTree* v = newVars.first();
1316         while (v != 0 && strcmp(v->getText(), n) != 0) {
1317             v = newVars.next();
1318         }
1319         if (v == 0) {
1320             // old variable not in the new variables
1321             TRACE(QString("old var deleted: ") + n);
1322             v = m_localVariables.topLevelExprByName(n);
1323             if (v != 0) {
1324                 m_localVariables.removeExpr(v);
1325                 repaintNeeded = true;
1326             }
1327         } else {
1328             // variable in both old and new lists: update
1329             TRACE(QString("update var: ") + n);
1330             m_localVariables.updateExpr(newVars.current());
1331             // remove the new variable from the list
1332             newVars.remove();
1333             delete v;
1334             repaintNeeded = true;
1335         }
1336     }
1337     // insert all remaining new variables
1338     for (VarTree* v = newVars.first(); v != 0; v = newVars.next()) {
1339         TRACE("new var: " + v->getText());
1340         m_localVariables.insertExpr(v);
1341         repaintNeeded = true;
1342     }
1343
1344     // repaint
1345     m_localVariables.setAutoUpdate(autoU);
1346     if (repaintNeeded && autoU && m_localVariables.isVisible())
1347         m_localVariables.repaint();
1348 }
1349
1350 void KDebugger::parseLocals(const char* output, QList<VarTree>& newVars)
1351 {
1352     QList<VarTree> vars;
1353     m_d->parseLocals(output, vars);
1354
1355     QString origName;                   /* used in renaming variables */
1356     while (vars.count() > 0)
1357     {
1358         VarTree* variable = vars.take(0);
1359         // get some types
1360         variable->inferTypesOfChildren(*m_typeTable);
1361         /*
1362          * When gdb prints local variables, those from the innermost block
1363          * come first. We run through the list of already parsed variables
1364          * to find duplicates (ie. variables that hide local variables from
1365          * a surrounding block). We keep the name of the inner variable, but
1366          * rename those from the outer block so that, when the value is
1367          * updated in the window, the value of the variable that is
1368          * _visible_ changes the color!
1369          */
1370         int block = 0;
1371         origName = variable->getText();
1372         for (VarTree* v = newVars.first(); v != 0; v = newVars.next()) {
1373             if (variable->getText() == v->getText()) {
1374                 // we found a duplicate, change name
1375                 block++;
1376                 QString newName = origName + " (" + QString().setNum(block) + ")";
1377                 variable->setText(newName);
1378             }
1379         }
1380         newVars.append(variable);
1381     }
1382 }
1383
1384 bool KDebugger::handlePrint(CmdQueueItem* cmd, const char* output)
1385 {
1386     ASSERT(cmd->m_expr != 0);
1387
1388     VarTree* variable = parseExpr(output, true);
1389     if (variable == 0)
1390         return false;
1391
1392     // set expression "name"
1393     variable->setText(cmd->m_expr->getText());
1394
1395     {
1396         TRACE("update expr: " + cmd->m_expr->getText());
1397         cmd->m_exprWnd->updateExpr(cmd->m_expr, variable);
1398         delete variable;
1399     }
1400
1401     evalExpressions();                  /* enqueue dereferenced pointers */
1402
1403     return true;
1404 }
1405
1406 bool KDebugger::handlePrintDeref(CmdQueueItem* cmd, const char* output)
1407 {
1408     ASSERT(cmd->m_expr != 0);
1409
1410     VarTree* variable = parseExpr(output, true);
1411     if (variable == 0)
1412         return false;
1413
1414     // set expression "name"
1415     variable->setText(cmd->m_expr->getText());
1416
1417     {
1418         /*
1419          * We must insert a dummy parent, because otherwise variable's value
1420          * would overwrite cmd->m_expr's value.
1421          */
1422         VarTree* dummyParent = new VarTree(variable->getText(), VarTree::NKplain);
1423         dummyParent->m_varKind = VarTree::VKdummy;
1424         // the name of the parsed variable is the address of the pointer
1425         QString addr = "*" + cmd->m_expr->m_value;
1426         variable->setText(addr);
1427         variable->m_nameKind = VarTree::NKaddress;
1428
1429         dummyParent->appendChild(variable);
1430         dummyParent->setDeleteChildren(true);
1431         // expand the first level for convenience
1432         variable->setExpanded(true);
1433         TRACE("update ptr: " + cmd->m_expr->getText());
1434         cmd->m_exprWnd->updateExpr(cmd->m_expr, dummyParent);
1435         delete dummyParent;
1436     }
1437
1438     evalExpressions();                  /* enqueue dereferenced pointers */
1439
1440     return true;
1441 }
1442
1443 VarTree* KDebugger::parseExpr(const char* output, bool wantErrorValue)
1444 {
1445     VarTree* variable;
1446
1447     // check for error conditions
1448     bool goodValue = m_d->parsePrintExpr(output, wantErrorValue, variable);
1449
1450     if (variable != 0 && goodValue)
1451     {
1452         // get some types
1453         variable->inferTypesOfChildren(*m_typeTable);
1454     }
1455     return variable;
1456 }
1457
1458 // parse the output of bt
1459 void KDebugger::handleBacktrace(const char* output)
1460 {
1461     // reduce flicker
1462     m_btWindow.setAutoUpdate(false);
1463
1464     m_btWindow.clear();
1465
1466     QList<StackFrame> stack;
1467     m_d->parseBackTrace(output, stack);
1468
1469     if (stack.count() > 0) {
1470         StackFrame* frm = stack.take(0);
1471         // first frame must set PC
1472         // note: frm->lineNo is zero-based
1473         emit updatePC(frm->fileName, frm->lineNo, frm->address, frm->frameNo);
1474
1475         do {
1476             QString func;
1477             if (frm->var != 0)
1478                 func = frm->var->getText();
1479             else
1480                 func = frm->fileName + ":" + QString().setNum(frm->lineNo+1);
1481             m_btWindow.insertItem(func);
1482             TRACE("frame " + func + " (" + frm->fileName + ":" +
1483                   QString().setNum(frm->lineNo+1) + ")");
1484             delete frm;
1485         }
1486         while ((frm = stack.take()) != 0);
1487     }
1488
1489     m_btWindow.setAutoUpdate(true);
1490     m_btWindow.repaint();
1491 }
1492
1493 void KDebugger::gotoFrame(int frame)
1494 {
1495     m_d->executeCmd(DCframe, frame);
1496 }
1497
1498 void KDebugger::handleFrameChange(const char* output)
1499 {
1500     QString fileName;
1501     int frameNo;
1502     int lineNo;
1503     DbgAddr address;
1504     if (m_d->parseFrameChange(output, frameNo, fileName, lineNo, address)) {
1505         /* lineNo can be negative here if we can't find a file name */
1506         emit updatePC(fileName, lineNo, address, frameNo);
1507     } else {
1508         emit updatePC(fileName, -1, address, frameNo);
1509     }
1510 }
1511
1512 void KDebugger::evalExpressions()
1513 {
1514     // evaluate expressions in the following order:
1515     //   watch expressions
1516     //   pointers in local variables
1517     //   pointers in watch expressions
1518     //   types in local variables
1519     //   types in watch expressions
1520     //   pointers in 'this'
1521     //   types in 'this'
1522
1523     VarTree* exprItem = m_watchEvalExpr.first();
1524     if (exprItem != 0) {
1525         m_watchEvalExpr.remove();
1526         QString expr = exprItem->computeExpr();
1527         TRACE("watch expr: " + expr);
1528         CmdQueueItem* cmd = m_d->queueCmd(DCprint, expr, DebuggerDriver::QMoverride);
1529         // remember which expr this was
1530         cmd->m_expr = exprItem;
1531         cmd->m_exprWnd = &m_watchVariables;
1532     } else {
1533         ExprWnd* wnd;
1534         VarTree* exprItem;
1535 #define POINTER(widget) \
1536                 wnd = &widget; \
1537                 exprItem = widget.nextUpdatePtr(); \
1538                 if (exprItem != 0) goto pointer
1539 #define STRUCT(widget) \
1540                 wnd = &widget; \
1541                 exprItem = widget.nextUpdateStruct(); \
1542                 if (exprItem != 0) goto ustruct
1543 #define TYPE(widget) \
1544                 wnd = &widget; \
1545                 exprItem = widget.nextUpdateType(); \
1546                 if (exprItem != 0) goto type
1547     repeat:
1548         POINTER(m_localVariables);
1549         POINTER(m_watchVariables);
1550         STRUCT(m_localVariables);
1551         STRUCT(m_watchVariables);
1552         TYPE(m_localVariables);
1553         TYPE(m_watchVariables);
1554 #undef POINTER
1555 #undef STRUCT
1556 #undef TYPE
1557         return;
1558
1559         pointer:
1560         // we have an expression to send
1561         dereferencePointer(wnd, exprItem, false);
1562         return;
1563
1564         ustruct:
1565         // paranoia
1566         if (exprItem->m_type == 0 || exprItem->m_type == TypeInfo::unknownType())
1567             goto repeat;
1568         evalInitialStructExpression(exprItem, wnd, false);
1569         return;
1570
1571         type:
1572         /*
1573          * Sometimes a VarTree gets registered twice for a type update. So
1574          * it may happen that it has already been updated. Hence, we ignore
1575          * it here and go on to the next task.
1576          */
1577         if (exprItem->m_type != 0)
1578             goto repeat;
1579         determineType(wnd, exprItem);
1580     }
1581 }
1582
1583 void KDebugger::dereferencePointer(ExprWnd* wnd, VarTree* exprItem,
1584                                    bool immediate)
1585 {
1586     ASSERT(exprItem->m_varKind == VarTree::VKpointer);
1587
1588     QString expr = exprItem->computeExpr();
1589     TRACE("dereferencing pointer: " + expr);
1590     CmdQueueItem* cmd;
1591     if (immediate) {
1592         cmd = m_d->queueCmd(DCprintDeref, expr, DebuggerDriver::QMoverrideMoreEqual);
1593     } else {
1594         cmd = m_d->queueCmd(DCprintDeref, expr, DebuggerDriver::QMoverride);
1595     }
1596     // remember which expr this was
1597     cmd->m_expr = exprItem;
1598     cmd->m_exprWnd = wnd;
1599 }
1600
1601 void KDebugger::determineType(ExprWnd* wnd, VarTree* exprItem)
1602 {
1603     ASSERT(exprItem->m_varKind == VarTree::VKstruct);
1604
1605     QString expr = exprItem->computeExpr();
1606     TRACE("get type of: " + expr);
1607     CmdQueueItem* cmd;
1608     cmd = m_d->queueCmd(DCfindType, expr, DebuggerDriver::QMoverride);
1609
1610     // remember which expr this was
1611     cmd->m_expr = exprItem;
1612     cmd->m_exprWnd = wnd;
1613 }
1614
1615 void KDebugger::handleFindType(CmdQueueItem* cmd, const char* output)
1616 {
1617     QString type;
1618     if (m_d->parseFindType(output, type))
1619     {
1620         ASSERT(cmd != 0 && cmd->m_expr != 0);
1621
1622         TypeInfo* info = m_typeTable->lookup(type);
1623
1624         if (info == 0) {
1625             /*
1626              * We've asked gdb for the type of the expression in
1627              * cmd->m_expr, but it returned a name we don't know. The base
1628              * class (and member) types have been checked already (at the
1629              * time when we parsed that particular expression). Now it's
1630              * time to derive the type from the base classes as a last
1631              * resort.
1632              */
1633             info = cmd->m_expr->inferTypeFromBaseClass();
1634             // if we found a type through this method, register an alias
1635             if (info != 0) {
1636                 TRACE("infered alias: " + type);
1637                 m_typeTable->registerAlias(type, info);
1638             }
1639         }
1640         if (info == 0) {
1641             TRACE("unknown type");
1642             cmd->m_expr->m_type = TypeInfo::unknownType();
1643         } else {
1644             cmd->m_expr->m_type = info;
1645             /* since this node has a new type, we get its value immediately */
1646             evalInitialStructExpression(cmd->m_expr, cmd->m_exprWnd, false);
1647             return;
1648         }
1649     }
1650
1651     evalExpressions();                  /* queue more of them */
1652 }
1653
1654 void KDebugger::handlePrintStruct(CmdQueueItem* cmd, const char* output)
1655 {
1656     VarTree* var = cmd->m_expr;
1657     ASSERT(var != 0);
1658     ASSERT(var->m_varKind == VarTree::VKstruct);
1659
1660     VarTree* partExpr;
1661     if (cmd->m_cmd != DCprintQStringStruct) {
1662         partExpr = parseExpr(output, false);
1663     } else {
1664         partExpr = m_d->parseQCharArray(output, false, m_typeTable->qCharIsShort());
1665     }
1666     bool errorValue =
1667         partExpr == 0 ||
1668         /* we only allow simple values at the moment */
1669         partExpr->childCount() != 0;
1670
1671     QString partValue;
1672     if (errorValue)
1673     {
1674         partValue = "?""?""?";  // 2 question marks in a row would be a trigraph
1675     } else {
1676         partValue = partExpr->m_value;
1677     }
1678     delete partExpr;
1679     partExpr = 0;
1680
1681     /*
1682      * Updating a struct value works like this: var->m_partialValue holds
1683      * the value that we have gathered so far (it's been initialized with
1684      * var->m_type->m_displayString[0] earlier). Each time we arrive here,
1685      * we append the printed result followed by the next
1686      * var->m_type->m_displayString to var->m_partialValue.
1687      *
1688      * If the expression we just evaluated was a guard expression, and it
1689      * resulted in an error, we must not evaluate the real expression, but
1690      * go on to the next index. (We must still add the question marks to
1691      * the value).
1692      *
1693      * Next, if this was the length expression, we still have not seen the
1694      * real expression, but the length of a QString.
1695      */
1696     ASSERT(var->m_exprIndex >= 0 && var->m_exprIndex <= typeInfoMaxExpr);
1697
1698     if (errorValue || !var->m_exprIndexUseGuard)
1699     {
1700         // add current partValue (which might be the question marks)
1701         var->m_partialValue += partValue;
1702         var->m_exprIndex++;             /* next part */
1703         var->m_exprIndexUseGuard = true;
1704         var->m_partialValue += var->m_type->m_displayString[var->m_exprIndex];
1705     }
1706     else
1707     {
1708         // this was a guard expression that succeeded
1709         // go for the real expression
1710         var->m_exprIndexUseGuard = false;
1711     }
1712
1713     /* go for more sub-expressions if needed */
1714     if (var->m_exprIndex < var->m_type->m_numExprs) {
1715         /* queue a new print command with quite high priority */
1716         evalStructExpression(var, cmd->m_exprWnd, true);
1717         return;
1718     }
1719
1720     cmd->m_exprWnd->updateStructValue(var);
1721
1722     evalExpressions();                  /* enqueue dereferenced pointers */
1723 }
1724
1725 /* queues the first printStruct command for a struct */
1726 void KDebugger::evalInitialStructExpression(VarTree* var, ExprWnd* wnd, bool immediate)
1727 {
1728     var->m_exprIndex = 0;
1729     var->m_exprIndexUseGuard = true;
1730     var->m_partialValue = var->m_type->m_displayString[0];
1731     evalStructExpression(var, wnd, immediate);
1732 }
1733
1734 /* queues a printStruct command; var must have been initialized correctly */
1735 void KDebugger::evalStructExpression(VarTree* var, ExprWnd* wnd, bool immediate)
1736 {
1737     QString base = var->computeExpr();
1738     QString exprFmt;
1739     if (var->m_exprIndexUseGuard) {
1740         exprFmt = var->m_type->m_guardStrings[var->m_exprIndex];
1741         if (exprFmt.isEmpty()) {
1742             // no guard, omit it and go to expression
1743             var->m_exprIndexUseGuard = false;
1744         }
1745     }
1746     if (!var->m_exprIndexUseGuard) {
1747         exprFmt = var->m_type->m_exprStrings[var->m_exprIndex];
1748     }
1749
1750     SIZED_QString(expr, exprFmt.length() + base.length() + 10);
1751     expr.sprintf(exprFmt, base.data());
1752
1753     DbgCommand dbgCmd = DCprintStruct;
1754     // check if this is a QString::Data
1755     if (strncmp(expr, "/QString::Data ", 15) == 0)
1756     {
1757         if (m_typeTable->parseQt2QStrings())
1758         {
1759             expr = expr.mid(15, expr.length()); /* strip off /QString::Data */
1760             dbgCmd = DCprintQStringStruct;
1761         } else {
1762             /*
1763              * This should not happen: the type libraries should be set up
1764              * in a way that this can't happen. If this happens
1765              * nevertheless it means that, eg., kdecore was loaded but qt2
1766              * was not (only qt2 enables the QString feature).
1767              */
1768             // TODO: remove this "print"; queue the next printStruct instead
1769             expr = "*0";
1770         }
1771     } else {
1772         expr = expr;
1773     }
1774     TRACE("evalStruct: " + expr + (var->m_exprIndexUseGuard ? " // guard" : " // real"));
1775     CmdQueueItem* cmd = m_d->queueCmd(dbgCmd, expr,
1776                                       immediate  ?  DebuggerDriver::QMoverrideMoreEqual
1777                                       : DebuggerDriver::QMnormal);
1778
1779     // remember which expression this was
1780     cmd->m_expr = var;
1781     cmd->m_exprWnd = wnd;
1782 }
1783
1784 void KDebugger::handleSharedLibs(const char* output)
1785 {
1786     // delete all known libraries
1787     m_sharedLibs.clear();
1788
1789     // parse the table of shared libraries
1790     m_d->parseSharedLibs(output, m_sharedLibs);
1791     m_sharedLibsListed = true;
1792
1793     // get type libraries
1794     m_typeTable->loadLibTypes(m_sharedLibs);
1795
1796     // hand over the QString data cmd
1797     m_d->setPrintQStringDataCmd(m_typeTable->printQStringDataCmd());
1798 }
1799
1800 CmdQueueItem* KDebugger::loadCoreFile()
1801 {
1802     return m_d->queueCmd(DCcorefile, m_corefile, DebuggerDriver::QMoverride);
1803 }
1804
1805 void KDebugger::slotLocalsExpanding(KTreeViewItem* item, bool& allow)
1806 {
1807     exprExpandingHelper(&m_localVariables, item, allow);
1808 }
1809
1810 void KDebugger::slotWatchExpanding(KTreeViewItem* item, bool& allow)
1811 {
1812     exprExpandingHelper(&m_watchVariables, item, allow);
1813 }
1814
1815 void KDebugger::exprExpandingHelper(ExprWnd* wnd, KTreeViewItem* item, bool&)
1816 {
1817     VarTree* exprItem = static_cast<VarTree*>(item);
1818     if (exprItem->m_varKind != VarTree::VKpointer) {
1819         return;
1820     }
1821     dereferencePointer(wnd, exprItem, true);
1822 }
1823
1824 // add the expression in the edit field to the watch expressions
1825 void KDebugger::addWatch(const QString& t)
1826 {
1827     QString expr = t.stripWhiteSpace();
1828     if (expr.isEmpty())
1829         return;
1830     VarTree* exprItem = new VarTree(expr, VarTree::NKplain);
1831     m_watchVariables.insertExpr(exprItem);
1832
1833     // if we are boring ourselves, send down the command
1834     if (m_programActive) {
1835         m_watchEvalExpr.append(exprItem);
1836         if (m_d->isIdle()) {
1837             evalExpressions();
1838         }
1839     }
1840 }
1841
1842 // delete a toplevel watch expression
1843 void KDebugger::slotDeleteWatch()
1844 {
1845     // delete only allowed while debugger is idle; or else we might delete
1846     // the very expression the debugger is currently working on...
1847     if (!m_d->isIdle())
1848         return;
1849
1850     int index = m_watchVariables.currentItem();
1851     if (index < 0)
1852         return;
1853
1854     VarTree* item = static_cast<VarTree*>(m_watchVariables.itemAt(index));
1855     if (!item->isToplevelExpr())
1856         return;
1857
1858     // remove the variable from the list to evaluate
1859     if (m_watchEvalExpr.findRef(item) >= 0) {
1860         m_watchEvalExpr.remove();
1861     }
1862     m_watchVariables.removeExpr(item);
1863     // item is invalid at this point!
1864 }
1865
1866 void KDebugger::handleRegisters(const char* output)
1867 {
1868     QList<RegisterInfo> regs;
1869     m_d->parseRegisters(output, regs);
1870
1871     emit registersChanged(regs);
1872
1873     // delete them all
1874     regs.setAutoDelete(true);
1875 }
1876
1877 /*
1878  * The output of the DCbreak* commands has more accurate information about
1879  * the file and the line number.
1880  *
1881  * All newly set breakpoints are inserted in the m_brkpts, even those that
1882  * were not set sucessfully. The unsuccessful breakpoints ("orphaned
1883  * breakpoints") are assigned negative ids, and they are tried to set later
1884  * when the program stops again at a breakpoint.
1885  */
1886 void KDebugger::newBreakpoint(CmdQueueItem* cmd, const char* output)
1887 {
1888     Breakpoint* bp = cmd->m_brkpt;
1889     assert(bp != 0);
1890     if (bp == 0)
1891         return;
1892
1893     // if this is a new breakpoint, put it in the list
1894     bool isNew = !m_brkpts.contains(bp);
1895     if (isNew) {
1896         assert(bp->id == 0);
1897         int n = m_brkpts.size();
1898         m_brkpts.resize(n+1);
1899         m_brkpts.insert(n, bp);
1900     }
1901
1902     // parse the output to determine success or failure
1903     int id;
1904     QString file;
1905     int lineNo;
1906     QString address;
1907     if (!m_d->parseBreakpoint(output, id, file, lineNo, address))
1908     {
1909         /*
1910          * Failure, the breakpoint could not be set. If this is a new
1911          * breakpoint, assign it a negative id. We look for the minimal id
1912          * of all breakpoints (that are already in the list) to get the new
1913          * id.
1914          */
1915         if (isNew)
1916         {
1917             assert(bp->id == 0);
1918             for (int i = m_brkpts.size()-2; i >= 0; i--) {
1919                 if (m_brkpts[i]->id < bp->id) {
1920                     bp->id = m_brkpts[i]->id;
1921                     break;
1922                 }
1923             }
1924             --bp->id;
1925         }
1926         return;
1927     }
1928
1929     // The breakpoint was successfully set.
1930     if (bp->id <= 0)
1931     {
1932         // this is a new or orphaned breakpoint:
1933         // set the remaining properties
1934         if (!cmd->m_brkpt->enabled) {
1935             m_d->executeCmd(DCdisable, id);
1936         }
1937         if (!cmd->m_brkpt->condition.isEmpty()) {
1938             m_d->executeCmd(DCcondition, cmd->m_brkpt->condition, id);
1939         }
1940     }
1941
1942     bp->id = id;
1943     bp->fileName = file;
1944     bp->lineNo = lineNo;
1945     if (!address.isEmpty())
1946         bp->address = address;
1947 }
1948
1949 void KDebugger::updateBreakList(const char* output)
1950 {
1951     // get the new list
1952     QList<Breakpoint> brks;
1953     brks.setAutoDelete(false);
1954     m_d->parseBreakList(output, brks);
1955
1956     // merge new information into existing breakpoints
1957
1958     for (int i = m_brkpts.size()-1; i >= 0; i--)        // decrement!
1959     {
1960         // skip orphaned breakpoints
1961         if (m_brkpts[i]->id < 0)
1962             continue;
1963
1964         for (Breakpoint* bp = brks.first(); bp != 0; bp = brks.next())
1965         {
1966             if (bp->id == m_brkpts[i]->id) {
1967                 // keep accurate location
1968                 // except that xsldbg doesn't have a location in
1969                 // the old breakpoint if it's just been set
1970                 bp->text = m_brkpts[i]->text;
1971                 if (!m_brkpts[i]->fileName.isEmpty()) {
1972                     bp->fileName = m_brkpts[i]->fileName;
1973                     bp->lineNo = m_brkpts[i]->lineNo;
1974                 }
1975                 m_brkpts.insert(i, bp); // old object is deleted
1976                 goto stillAlive;
1977             }
1978         }
1979         /*
1980          * If we get here, this breakpoint is no longer present.
1981          *
1982          * To delete the breakpoint at i, we place the last breakpoint in
1983          * the list into the slot i. This will delete the old object at i.
1984          * Then we shorten the list by one.
1985          */
1986         m_brkpts.insert(i, m_brkpts.take(m_brkpts.size()-1));
1987         m_brkpts.resize(m_brkpts.size()-1);
1988         TRACE(QString().sprintf("deleted brkpt %d, have now %d brkpts", i, m_brkpts.size()));
1989
1990         stillAlive:;
1991     }
1992
1993     // brks may contain new breakpoints not already in m_brkpts
1994     for (const Breakpoint* bp = brks.first(); bp != 0; bp = brks.next())
1995     {
1996         bool found = false;
1997         for (uint i = 0; i < m_brkpts.size(); i++)      {
1998             if (bp->id == m_brkpts[i]->id) {
1999                 found = true;
2000                 break;
2001             }
2002         }
2003         if (!found){
2004             int n = m_brkpts.size();
2005             m_brkpts.resize(n+1);
2006             m_brkpts.insert(n, bp);
2007         }
2008     }
2009
2010     emit breakpointsChanged();
2011 }
2012
2013 // look if there is at least one temporary breakpoint
2014 // or a watchpoint
2015 bool KDebugger::stopMayChangeBreakList() const
2016 {
2017     for (int i = m_brkpts.size()-1; i >= 0; i--) {
2018         Breakpoint* bp = m_brkpts[i];
2019         if (bp->temporary || bp->type == Breakpoint::watchpoint)
2020             return true;
2021     }
2022     return false;
2023 }
2024
2025 Breakpoint* KDebugger::breakpointByFilePos(QString file, int lineNo,
2026                                            const DbgAddr& address)
2027 {
2028     // look for exact file name match
2029     int i;
2030     for (i = m_brkpts.size()-1; i >= 0; i--) {
2031         if (m_brkpts[i]->lineNo == lineNo &&
2032             m_brkpts[i]->fileName == file &&
2033             (address.isEmpty() || m_brkpts[i]->address == address))
2034         {
2035             return m_brkpts[i];
2036         }
2037     }
2038     // not found, so try basename
2039     // strip off directory part of file name
2040     int offset = file.findRev("/");
2041     file.remove(0, offset+1);
2042
2043     for (i = m_brkpts.size()-1; i >= 0; i--) {
2044         // get base name of breakpoint's file
2045         QString basename = m_brkpts[i]->fileName;
2046         int offset = basename.findRev("/");
2047         if (offset >= 0) {
2048             basename.remove(0, offset+1);
2049         }
2050
2051         if (m_brkpts[i]->lineNo == lineNo &&
2052             basename == file &&
2053             (address.isEmpty() || m_brkpts[i]->address == address))
2054         {
2055             return m_brkpts[i];
2056         }
2057     }
2058
2059     // not found
2060     return 0;
2061 }
2062
2063 Breakpoint* KDebugger::breakpointById(int id)
2064 {
2065     for (int i = m_brkpts.size()-1; i >= 0; i--)
2066     {
2067         if (m_brkpts[i]->id == id) {
2068             return m_brkpts[i];
2069         }
2070     }
2071     // not found
2072     return 0;
2073 }
2074
2075 void KDebugger::slotValuePopup(const QString& expr)
2076 {
2077     // search the local variables for a match
2078     VarTree* v = m_localVariables.topLevelExprByName(expr);
2079     if (v == 0) {
2080         // not found, check watch expressions
2081         v = m_watchVariables.topLevelExprByName(expr);
2082         if (v == 0) {
2083             // try a member of 'this'
2084             v = m_localVariables.topLevelExprByName("this");
2085             if (v != 0)
2086                 v = ExprWnd::ptrMemberByName(v, expr);
2087             if (v == 0) {
2088                 // nothing found; do nothing
2089                 return;
2090             }
2091         }
2092     }
2093
2094     // construct the tip
2095     QString tip = v->getText() + " = ";
2096     if (!v->m_value.isEmpty())
2097     {
2098         tip += v->m_value;
2099     }
2100     else
2101     {
2102         // no value: we use some hint
2103         switch (v->m_varKind) {
2104         case VarTree::VKstruct:
2105             tip += "{...}";
2106             break;
2107         case VarTree::VKarray:
2108             tip += "[...]";
2109             break;
2110         default:
2111             tip += "?""?""?";   // 2 question marks in a row would be a trigraph
2112             break;
2113         }
2114     }
2115     emit valuePopup(tip);
2116 }
2117
2118 void KDebugger::slotDisassemble(const QString& fileName, int lineNo)
2119 {
2120     CmdQueueItem* cmd = m_d->queueCmd(DCinfoline, fileName, lineNo,
2121                                       DebuggerDriver::QMoverrideMoreEqual);
2122     cmd->m_fileName = fileName;
2123     cmd->m_lineNo = lineNo;
2124 }
2125
2126 void KDebugger::handleInfoLine(CmdQueueItem* cmd, const char* output)
2127 {
2128     QString addrFrom, addrTo;
2129     if (cmd->m_lineNo >= 0) {
2130         // disassemble
2131         if (m_d->parseInfoLine(output, addrFrom, addrTo)) {
2132             // got the address range, now get the real code
2133             CmdQueueItem* c = m_d->queueCmd(DCdisassemble, addrFrom, addrTo,
2134                                             DebuggerDriver::QMoverrideMoreEqual);
2135             c->m_fileName = cmd->m_fileName;
2136             c->m_lineNo = cmd->m_lineNo;
2137         } else {
2138             // no code
2139             QList<DisassembledCode> empty;
2140             emit disassembled(cmd->m_fileName, cmd->m_lineNo, empty);
2141         }
2142     } else {
2143         // set program counter
2144         if (m_d->parseInfoLine(output, addrFrom, addrTo)) {
2145             // move the program counter to the start address
2146             m_d->executeCmd(DCsetpc, addrFrom);
2147         }
2148     }
2149 }
2150
2151 void KDebugger::handleDisassemble(CmdQueueItem* cmd, const char* output)
2152 {
2153     QList<DisassembledCode> code;
2154     code.setAutoDelete(true);
2155     m_d->parseDisassemble(output, code);
2156     emit disassembled(cmd->m_fileName, cmd->m_lineNo, code);
2157 }
2158
2159 void KDebugger::handleThreadList(const char* output)
2160 {
2161     QList<ThreadInfo> threads;
2162     threads.setAutoDelete(true);
2163     m_d->parseThreadList(output, threads);
2164     emit threadsChanged(threads);
2165 }
2166
2167 void KDebugger::setThread(int id)
2168 {
2169     m_d->queueCmd(DCthread, id, DebuggerDriver::QMoverrideMoreEqual);
2170 }
2171
2172 void KDebugger::setMemoryExpression(const QString& memexpr)
2173 {
2174     m_memoryExpression = memexpr;
2175
2176     // queue the new expression
2177     if (!m_memoryExpression.isEmpty() &&
2178         isProgramActive() &&
2179         !isProgramRunning())
2180     {
2181         queueMemoryDump(true);
2182     }
2183 }
2184
2185 void KDebugger::queueMemoryDump(bool immediate)
2186 {
2187     m_d->queueCmd(DCexamine, m_memoryExpression, m_memoryFormat,
2188                   immediate ? DebuggerDriver::QMoverrideMoreEqual :
2189                               DebuggerDriver::QMoverride);
2190 }
2191
2192 void KDebugger::handleMemoryDump(const char* output)
2193 {
2194     QList<MemoryDump> memdump;
2195     memdump.setAutoDelete(true);
2196     QString msg = m_d->parseMemoryDump(output, memdump);
2197     emit memoryDumpChanged(msg, memdump);
2198 }
2199
2200 void KDebugger::setProgramCounter(const QString& file, int line, const DbgAddr& addr)
2201 {
2202     if (addr.isEmpty()) {
2203         // find address of the specified line
2204         CmdQueueItem* cmd = m_d->executeCmd(DCinfoline, file, line);
2205         cmd->m_lineNo = -1;             /* indicates "Set PC" UI command */
2206     } else {
2207         // move the program counter to that address
2208         m_d->executeCmd(DCsetpc, addr.asString());
2209     }
2210 }
2211
2212 void KDebugger::handleSetPC(const char* /*output*/)
2213 {
2214     // TODO: handle errors
2215
2216     // now go to the top-most frame
2217     // this also modifies the program counter indicator in the UI
2218     gotoFrame(0);
2219 }
2220
2221 void KDebugger::slotValueEdited(int row, const QString& text)
2222 {
2223     if (text.simplifyWhiteSpace().isEmpty())
2224         return;                        /* no text entered: ignore request */
2225
2226     ASSERT(sender()->inherits("ExprWnd"));
2227     ExprWnd* wnd = const_cast<ExprWnd*>(static_cast<const ExprWnd*>(sender()));
2228     TRACE(QString().sprintf("Changing %s at row %d to ",
2229                             wnd->name(), row) + text);
2230
2231     // determine the lvalue to edit
2232     VarTree* expr = static_cast<VarTree*>(wnd->itemAt(row));
2233     QString lvalue = expr->computeExpr();
2234     CmdQueueItem* cmd = m_d->executeCmd(DCsetvariable, lvalue, text);
2235     cmd->m_expr = expr;
2236     cmd->m_exprWnd = wnd;
2237 }
2238
2239 void KDebugger::handleSetVariable(CmdQueueItem* cmd, const char* output)
2240 {
2241     QString msg = m_d->parseSetVariable(output);
2242     if (!msg.isEmpty())
2243     {
2244         // there was an error; display it in the status bar
2245         m_statusMessage = msg;
2246         emit updateStatusMessage();
2247         return;
2248     }
2249
2250     // get the new value
2251     QString expr = cmd->m_expr->computeExpr();
2252     CmdQueueItem* printCmd =
2253         m_d->queueCmd(DCprint, expr, DebuggerDriver::QMoverrideMoreEqual);
2254     printCmd->m_expr = cmd->m_expr;
2255     printCmd->m_exprWnd = cmd->m_exprWnd;
2256 }
2257
2258
2259 #include "debugger.moc"