kdbg/gdbdriver.cpp

   1 // $Id$
   2
   3 // Copyright by Johannes Sixt
   4 // This file is under GPL, the GNU General Public Licence
   5
   6 #include "gdbdriver.h"
   7 #include "exprwnd.h"
   8 #include <qregexp.h>
   9 #include <qstringlist.h>
  10 #include <klocale.h>                    /* i18n */
  11 #include <ctype.h>
  12 #include <stdlib.h>                     /* strtol, atoi */
  13 #include <string.h>                     /* strcpy */
  14
  15 #include "assert.h"
  16 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif
  19 #include "mydebug.h"
  20
  21 static void skipString(const char*& p);
  22 static void skipNested(const char*& s, char opening, char closing);
  23 static ExprValue* parseVar(const char*& s);
  24 static bool parseName(const char*& s, QString& name, VarTree::NameKind& kind);
  25 static bool parseValue(const char*& s, ExprValue* variable);
  26 static bool parseNested(const char*& s, ExprValue* variable);
  27 static bool parseVarSeq(const char*& s, ExprValue* variable);
  28 static bool parseValueSeq(const char*& s, ExprValue* variable);
  29
  30 #define PROMPT "(kdbg)"
  31 #define PROMPT_LEN 6
  32 #define PROMPT_LAST_CHAR ')'            /* needed when searching for prompt string */
  33
  34
  35 // TODO: make this cmd info stuff non-static to allow multiple
  36 // simultaneous gdbs to run!
  37
  38 struct GdbCmdInfo {
  39     DbgCommand cmd;
  40     const char* fmt;                    /* format string */
  41     enum Args {
  42         argNone, argString, argNum,
  43         argStringNum, argNumString,
  44         argString2, argNum2
  45     } argsNeeded;
  46 };
  47
  48 #if 0
  49 // This is  how the QString data print statement generally looks like.
  50 // It is set by KDebugger via setPrintQStringDataCmd().
  51
  52 static const char printQStringStructFmt[] =
  53                 // if the string data is junk, fail early
  54                 "print ($qstrunicode=($qstrdata=(%s))->unicode)?"
  55                 // print an array of shorts
  56                 "(*(unsigned short*)$qstrunicode)@"
  57                 // limit the length
  58                 "(($qstrlen=(unsigned int)($qstrdata->len))>100?100:$qstrlen)"
  59                 // if unicode data is 0, report a special value
  60                 ":1==0\n";
  61 #endif
  62 static const char printQStringStructFmt[] = "print (0?\"%s\":$kdbgundef)\n";
  63
  64 /*
  65  * The following array of commands must be sorted by the DC* values,
  66  * because they are used as indices.
  67  */
  68 static GdbCmdInfo cmds[] = {
  69     { DCinitialize, "", GdbCmdInfo::argNone },
  70     { DCtty, "tty %s\n", GdbCmdInfo::argString },
  71     { DCexecutable, "file \"%s\"\n", GdbCmdInfo::argString },
  72     { DCtargetremote, "target remote %s\n", GdbCmdInfo::argString },
  73     { DCcorefile, "core-file %s\n", GdbCmdInfo::argString },
  74     { DCattach, "attach %s\n", GdbCmdInfo::argString },
  75     { DCinfolinemain, "kdbg_infolinemain\n", GdbCmdInfo::argNone },
  76     { DCinfolocals, "kdbg__alllocals\n", GdbCmdInfo::argNone },
  77     { DCinforegisters, "info all-registers\n", GdbCmdInfo::argNone},
  78     { DCexamine, "x %s %s\n", GdbCmdInfo::argString2 },
  79     { DCinfoline, "info line %s:%d\n", GdbCmdInfo::argStringNum },
  80     { DCdisassemble, "disassemble %s %s\n", GdbCmdInfo::argString2 },
  81     { DCsetargs, "set args %s\n", GdbCmdInfo::argString },
  82     { DCsetenv, "set env %s %s\n", GdbCmdInfo::argString2 },
  83     { DCunsetenv, "unset env %s\n", GdbCmdInfo::argString },
  84     { DCsetoption, "setoption %s %d\n", GdbCmdInfo::argStringNum},
  85     { DCcd, "cd %s\n", GdbCmdInfo::argString },
  86     { DCbt, "bt\n", GdbCmdInfo::argNone },
  87     { DCrun, "run\n", GdbCmdInfo::argNone },
  88     { DCcont, "cont\n", GdbCmdInfo::argNone },
  89     { DCstep, "step\n", GdbCmdInfo::argNone },
  90     { DCstepi, "stepi\n", GdbCmdInfo::argNone },
  91     { DCnext, "next\n", GdbCmdInfo::argNone },
  92     { DCnexti, "nexti\n", GdbCmdInfo::argNone },
  93     { DCfinish, "finish\n", GdbCmdInfo::argNone },
  94     { DCuntil, "until %s:%d\n", GdbCmdInfo::argStringNum },
  95     { DCkill, "kill\n", GdbCmdInfo::argNone },
  96     { DCbreaktext, "break %s\n", GdbCmdInfo::argString },
  97     { DCbreakline, "break %s:%d\n", GdbCmdInfo::argStringNum },
  98     { DCtbreakline, "tbreak %s:%d\n", GdbCmdInfo::argStringNum },
  99     { DCbreakaddr, "break *%s\n", GdbCmdInfo::argString },
 100     { DCtbreakaddr, "tbreak *%s\n", GdbCmdInfo::argString },
 101     { DCwatchpoint, "watch %s\n", GdbCmdInfo::argString },
 102     { DCdelete, "delete %d\n", GdbCmdInfo::argNum },
 103     { DCenable, "enable %d\n", GdbCmdInfo::argNum },
 104     { DCdisable, "disable %d\n", GdbCmdInfo::argNum },
 105     { DCprint, "print %s\n", GdbCmdInfo::argString },
 106     { DCprintDeref, "print *(%s)\n", GdbCmdInfo::argString },
 107     { DCprintStruct, "print %s\n", GdbCmdInfo::argString },
 108     { DCprintQStringStruct, printQStringStructFmt, GdbCmdInfo::argString},
 109     { DCframe, "frame %d\n", GdbCmdInfo::argNum },
 110     { DCfindType, "whatis %s\n", GdbCmdInfo::argString },
 111     { DCinfosharedlib, "info sharedlibrary\n", GdbCmdInfo::argNone },
 112     { DCthread, "thread %d\n", GdbCmdInfo::argNum },
 113     { DCinfothreads, "info threads\n", GdbCmdInfo::argNone },
 114     { DCinfobreak, "info breakpoints\n", GdbCmdInfo::argNone },
 115     { DCcondition, "condition %d %s\n", GdbCmdInfo::argNumString},
 116     { DCsetpc, "set variable $pc=%s\n", GdbCmdInfo::argString },
 117     { DCignore, "ignore %d %d\n", GdbCmdInfo::argNum2},
 118     { DCprintWChar, "print ($s=%s)?*$s@wcslen($s):0x0\n", GdbCmdInfo::argString },
 119     { DCsetvariable, "set variable %s=%s\n", GdbCmdInfo::argString2 },
 120 };
 121
 122 #define NUM_CMDS (int(sizeof(cmds)/sizeof(cmds[0])))
 123 #define MAX_FMTLEN 200
 124
 125 GdbDriver::GdbDriver() :
 126         DebuggerDriver(),
 127         m_gdbMajor(4), m_gdbMinor(16)
 128 {
 129     strcpy(m_prompt, PROMPT);
 130     m_promptMinLen = PROMPT_LEN;
 131     m_promptLastChar = PROMPT_LAST_CHAR;
 132
 133 #ifndef NDEBUG
 134     // check command info array
 135     char* perc;
 136     for (int i = 0; i < NUM_CMDS; i++) {
 137         // must be indexable by DbgCommand values, i.e. sorted by DbgCommand values
 138         assert(i == cmds[i].cmd);
 139         // a format string must be associated
 140         assert(cmds[i].fmt != 0);
 141         assert(strlen(cmds[i].fmt) <= MAX_FMTLEN);
 142         // format string must match arg specification
 143         switch (cmds[i].argsNeeded) {
 144         case GdbCmdInfo::argNone:
 145             assert(strchr(cmds[i].fmt, '%') == 0);
 146             break;
 147         case GdbCmdInfo::argString:
 148             perc = strchr(cmds[i].fmt, '%');
 149             assert(perc != 0 && perc[1] == 's');
 150             assert(strchr(perc+2, '%') == 0);
 151             break;
 152         case GdbCmdInfo::argNum:
 153             perc = strchr(cmds[i].fmt, '%');
 154             assert(perc != 0 && perc[1] == 'd');
 155             assert(strchr(perc+2, '%') == 0);
 156             break;
 157         case GdbCmdInfo::argStringNum:
 158             perc = strchr(cmds[i].fmt, '%');
 159             assert(perc != 0 && perc[1] == 's');
 160             perc = strchr(perc+2, '%');
 161             assert(perc != 0 && perc[1] == 'd');
 162             assert(strchr(perc+2, '%') == 0);
 163             break;
 164         case GdbCmdInfo::argNumString:
 165             perc = strchr(cmds[i].fmt, '%');
 166             assert(perc != 0 && perc[1] == 'd');
 167             perc = strchr(perc+2, '%');
 168             assert(perc != 0 && perc[1] == 's');
 169             assert(strchr(perc+2, '%') == 0);
 170             break;
 171         case GdbCmdInfo::argString2:
 172             perc = strchr(cmds[i].fmt, '%');
 173             assert(perc != 0 && perc[1] == 's');
 174             perc = strchr(perc+2, '%');
 175             assert(perc != 0 && perc[1] == 's');
 176             assert(strchr(perc+2, '%') == 0);
 177             break;
 178         case GdbCmdInfo::argNum2:
 179             perc = strchr(cmds[i].fmt, '%');
 180             assert(perc != 0 && perc[1] == 'd');
 181             perc = strchr(perc+2, '%');
 182             assert(perc != 0 && perc[1] == 'd');
 183             assert(strchr(perc+2, '%') == 0);
 184             break;
 185         }
 186     }
 187     assert(strlen(printQStringStructFmt) <= MAX_FMTLEN);
 188 #endif
 189 }
 190
 191 GdbDriver::~GdbDriver()
 192 {
 193 }
 194
 195
 196 QString GdbDriver::driverName() const
 197 {
 198     return "GDB";
 199 }
 200
 201 QString GdbDriver::defaultGdb()
 202 {
 203     return
 204         "gdb"
 205         " --fullname"   /* to get standard file names each time the prog stops */
 206         " --nx";        /* do not execute initialization files */
 207 }
 208
 209 QString GdbDriver::defaultInvocation() const
 210 {
 211     if (m_defaultCmd.isEmpty()) {
 212         return defaultGdb();
 213     } else {
 214         return m_defaultCmd;
 215     }
 216 }
 217
 218 QStringList GdbDriver::boolOptionList() const
 219 {
 220     // no options
 221     return QStringList();
 222 }
 223
 224 bool GdbDriver::startup(QString cmdStr)
 225 {
 226     if (!DebuggerDriver::startup(cmdStr))
 227         return false;
 228
 229     static const char gdbInitialize[] =
 230         /*
 231          * Work around buggy gdbs that do command line editing even if they
 232          * are not on a tty. The readline library echos every command back
 233          * in this case, which is confusing for us.
 234          */
 235         "set editing off\n"
 236         "set confirm off\n"
 237         "set print static-members off\n"
 238         "set print asm-demangle on\n"
 239         /*
 240          * Don't assume that program functions invoked from a watch expression
 241          * always succeed.
 242          */
 243         "set unwindonsignal on\n"
 244         /*
 245          * Write a short macro that prints all locals: local variables and
 246          * function arguments.
 247          */
 248         "define kdbg__alllocals\n"
 249         "info locals\n"                 /* local vars supersede args with same name */
 250         "info args\n"                   /* therefore, arguments must come last */
 251         "end\n"
 252         /*
 253          * Work around a bug in gdb-6.3: "info line main" crashes gdb.
 254          */
 255         "define kdbg_infolinemain\n"
 256         "list\n"
 257         "info line\n"
 258         "end\n"
 259         // change prompt string and synchronize with gdb
 260         "set prompt " PROMPT "\n"
 261         ;
 262
 263     executeCmdString(DCinitialize, gdbInitialize, false);
 264
 265     // assume that QString::null is ok
 266     cmds[DCprintQStringStruct].fmt = printQStringStructFmt;
 267
 268     return true;
 269 }
 270
 271 void GdbDriver::commandFinished(CmdQueueItem* cmd)
 272 {
 273     // command string must be committed
 274     if (!cmd->m_committed) {
 275         // not commited!
 276         TRACE("calling " + (__PRETTY_FUNCTION__ + (" with uncommited command:\n\t" +
 277               cmd->m_cmdString)));
 278         return;
 279     }
 280
 281     switch (cmd->m_cmd) {
 282     case DCinitialize:
 283         // get version number from preamble
 284         {
 285             int len;
 286             QRegExp GDBVersion("\\nGDB [0-9]+\\.[0-9]+");
 287             int offset = GDBVersion.match(m_output, 0, &len);
 288             if (offset >= 0) {
 289                 char* start = m_output + offset + 5;    // skip "\nGDB "
 290                 char* end;
 291                 m_gdbMajor = strtol(start, &end, 10);
 292                 m_gdbMinor = strtol(end + 1, 0, 10);    // skip "."
 293                 if (start == end) {
 294                     // nothing was parsed
 295                     m_gdbMajor = 4;
 296                     m_gdbMinor = 16;
 297                 }
 298             } else {
 299                 // assume some default version (what would make sense?)
 300                 m_gdbMajor = 4;
 301                 m_gdbMinor = 16;
 302             }
 303             // use a feasible core-file command
 304             if (m_gdbMajor > 4 || (m_gdbMajor == 4 && m_gdbMinor >= 16)) {
 305                 cmds[DCcorefile].fmt = "target core %s\n";
 306             } else {
 307                 cmds[DCcorefile].fmt = "core-file %s\n";
 308             }
 309         }
 310         break;
 311     default:;
 312     }
 313
 314     /* ok, the command is ready */
 315     emit commandReceived(cmd, m_output);
 316
 317     switch (cmd->m_cmd) {
 318     case DCcorefile:
 319     case DCinfolinemain:
 320     case DCframe:
 321     case DCattach:
 322     case DCrun:
 323     case DCcont:
 324     case DCstep:
 325     case DCstepi:
 326     case DCnext:
 327     case DCnexti:
 328     case DCfinish:
 329     case DCuntil:
 330         parseMarker();
 331     default:;
 332     }
 333 }
 334
 335 /*
 336  * The --fullname option makes gdb send a special normalized sequence print
 337  * each time the program stops and at some other points. The sequence has
 338  * the form "\032\032filename:lineno:charoffset:(beg|middle):address".
 339  */
 340 void GdbDriver::parseMarker()
 341 {
 342     char* startMarker = strstr(m_output, "\032\032");
 343     if (startMarker == 0)
 344         return;
 345
 346     // extract the marker
 347     startMarker += 2;
 348     TRACE(QString("found marker: ") + startMarker);
 349     char* endMarker = strchr(startMarker, '\n');
 350     if (endMarker == 0)
 351         return;
 352
 353     *endMarker = '\0';
 354
 355     // extract filename and line number
 356     static QRegExp MarkerRE(":[0-9]+:[0-9]+:[begmidl]+:0x");
 357
 358     int len;
 359     int lineNoStart = MarkerRE.match(startMarker, 0, &len);
 360     if (lineNoStart >= 0) {
 361         int lineNo = atoi(startMarker + lineNoStart+1);
 362
 363         // get address
 364         const char* addrStart = startMarker + lineNoStart + len - 2;
 365         DbgAddr address = QString(addrStart).stripWhiteSpace();
 366
 367         // now show the window
 368         startMarker[lineNoStart] = '\0';   /* split off file name */
 369         emit activateFileLine(startMarker, lineNo-1, address);
 370     }
 371 }
 372
 373
 374 /*
 375  * Escapes characters that might lead to problems when they appear on gdb's
 376  * command line.
 377  */
 378 static void normalizeStringArg(QString& arg)
 379 {
 380     /*
 381      * Remove trailing backslashes. This approach is a little simplistic,
 382      * but we know that there is at the moment no case where a trailing
 383      * backslash would make sense.
 384      */
 385     while (!arg.isEmpty() && arg[arg.length()-1] == '\\') {
 386         arg = arg.left(arg.length()-1);
 387     }
 388 }
 389
 390
 391 QString GdbDriver::makeCmdString(DbgCommand cmd, QString strArg)
 392 {
 393     assert(cmd >= 0 && cmd < NUM_CMDS);
 394     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argString);
 395
 396     normalizeStringArg(strArg);
 397
 398     if (cmd == DCcd) {
 399         // need the working directory when parsing the output
 400         m_programWD = strArg;
 401     } else if (cmd == DCsetargs && !m_redirect.isEmpty()) {
 402         /*
 403          * Use saved redirection. We prepend it in front of the user's
 404          * arguments so that the user can override the redirections.
 405         */
 406         strArg = m_redirect + " " + strArg;
 407     }
 408
 409     QString cmdString;
 410     cmdString.sprintf(cmds[cmd].fmt, strArg.latin1());
 411     return cmdString;
 412 }
 413
 414 QString GdbDriver::makeCmdString(DbgCommand cmd, int intArg)
 415 {
 416     assert(cmd >= 0 && cmd < NUM_CMDS);
 417     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argNum);
 418
 419     QString cmdString;
 420     cmdString.sprintf(cmds[cmd].fmt, intArg);
 421     return cmdString;
 422 }
 423
 424 QString GdbDriver::makeCmdString(DbgCommand cmd, QString strArg, int intArg)
 425 {
 426     assert(cmd >= 0 && cmd < NUM_CMDS);
 427     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argStringNum ||
 428            cmds[cmd].argsNeeded == GdbCmdInfo::argNumString ||
 429            cmd == DCexamine ||
 430            cmd == DCtty);
 431
 432     normalizeStringArg(strArg);
 433
 434     QString cmdString;
 435
 436     if (cmd == DCtty)
 437     {
 438         /*
 439          * intArg specifies which channels should be redirected to
 440          * /dev/null. It is a value or'ed together from RDNstdin,
 441          * RDNstdout, RDNstderr. We store the value for a later DCsetargs
 442          * command.
 443          *
 444          * Note: We rely on that after the DCtty a DCsetargs will follow,
 445          * which will ultimately apply the redirection.
 446          */
 447         static const char* const runRedir[8] = {
 448             "",
 449             "</dev/null",
 450             ">/dev/null",
 451             "</dev/null >/dev/null",
 452             "2>/dev/null",
 453             "</dev/null 2>/dev/null",
 454             ">/dev/null 2>&1",
 455             "</dev/null >/dev/null 2>&1"
 456         };
 457         if (strArg.isEmpty())
 458             intArg = 7;                 /* failsafe if no tty */
 459         m_redirect = runRedir[intArg & 7];
 460
 461         return makeCmdString(DCtty, strArg);   /* note: no problem if strArg empty */
 462     }
 463
 464     if (cmd == DCexamine) {
 465         // make a format specifier from the intArg
 466         static const char size[16] = {
 467             '\0', 'b', 'h', 'w', 'g'
 468         };
 469         static const char format[16] = {
 470             '\0', 'x', 'd', 'u', 'o', 't',
 471             'a',  'c', 'f', 's', 'i'
 472         };
 473         assert(MDTsizemask == 0xf);     /* lowest 4 bits */
 474         assert(MDTformatmask == 0xf0);  /* next 4 bits */
 475         int count = 16;                 /* number of entities to print */
 476         char sizeSpec = size[intArg & MDTsizemask];
 477         char formatSpec = format[(intArg & MDTformatmask) >> 4];
 478         assert(sizeSpec != '\0');
 479         assert(formatSpec != '\0');
 480         // adjust count such that 16 lines are printed
 481         switch (intArg & MDTformatmask) {
 482         case MDTstring: case MDTinsn:
 483             break;                      /* no modification needed */
 484         default:
 485             // all cases drop through:
 486             switch (intArg & MDTsizemask) {
 487             case MDTbyte:
 488             case MDThalfword:
 489                 count *= 2;
 490             case MDTword:
 491                 count *= 2;
 492             case MDTgiantword:
 493                 count *= 2;
 494             }
 495             break;
 496         }
 497         QString spec;
 498         spec.sprintf("/%d%c%c", count, sizeSpec, formatSpec);
 499
 500         return makeCmdString(DCexamine, spec, strArg);
 501     }
 502
 503     if (cmds[cmd].argsNeeded == GdbCmdInfo::argStringNum)
 504     {
 505         // line numbers are zero-based
 506         if (cmd == DCuntil || cmd == DCbreakline ||
 507             cmd == DCtbreakline || cmd == DCinfoline)
 508         {
 509             intArg++;
 510         }
 511         if (cmd == DCinfoline)
 512         {
 513             // must split off file name part
 514             int slash = strArg.findRev('/');
 515             if (slash >= 0)
 516                 strArg = strArg.right(strArg.length()-slash-1);
 517         }
 518         cmdString.sprintf(cmds[cmd].fmt, strArg.latin1(), intArg);
 519     }
 520     else
 521     {
 522         cmdString.sprintf(cmds[cmd].fmt, intArg, strArg.latin1());
 523     }
 524     return cmdString;
 525 }
 526
 527 QString GdbDriver::makeCmdString(DbgCommand cmd, QString strArg1, QString strArg2)
 528 {
 529     assert(cmd >= 0 && cmd < NUM_CMDS);
 530     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argString2);
 531
 532     normalizeStringArg(strArg1);
 533     normalizeStringArg(strArg2);
 534
 535     QString cmdString;
 536     cmdString.sprintf(cmds[cmd].fmt, strArg1.latin1(), strArg2.latin1());
 537     return cmdString;
 538 }
 539
 540 QString GdbDriver::makeCmdString(DbgCommand cmd, int intArg1, int intArg2)
 541 {
 542     assert(cmd >= 0 && cmd < NUM_CMDS);
 543     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argNum2);
 544
 545     QString cmdString;
 546     cmdString.sprintf(cmds[cmd].fmt, intArg1, intArg2);
 547     return cmdString;
 548 }
 549
 550 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, bool clearLow)
 551 {
 552     assert(cmd >= 0 && cmd < NUM_CMDS);
 553     assert(cmds[cmd].argsNeeded == GdbCmdInfo::argNone);
 554
 555     if (cmd == DCrun) {
 556         m_haveCoreFile = false;
 557     }
 558
 559     return executeCmdString(cmd, cmds[cmd].fmt, clearLow);
 560 }
 561
 562 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, QString strArg,
 563                                     bool clearLow)
 564 {
 565     return executeCmdString(cmd, makeCmdString(cmd, strArg), clearLow);
 566 }
 567
 568 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, int intArg,
 569                                     bool clearLow)
 570 {
 571
 572     return executeCmdString(cmd, makeCmdString(cmd, intArg), clearLow);
 573 }
 574
 575 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, QString strArg, int intArg,
 576                                     bool clearLow)
 577 {
 578     return executeCmdString(cmd, makeCmdString(cmd, strArg, intArg), clearLow);
 579 }
 580
 581 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, QString strArg1, QString strArg2,
 582                                     bool clearLow)
 583 {
 584     return executeCmdString(cmd, makeCmdString(cmd, strArg1, strArg2), clearLow);
 585 }
 586
 587 CmdQueueItem* GdbDriver::executeCmd(DbgCommand cmd, int intArg1, int intArg2,
 588                                     bool clearLow)
 589 {
 590     return executeCmdString(cmd, makeCmdString(cmd, intArg1, intArg2), clearLow);
 591 }
 592
 593 CmdQueueItem* GdbDriver::queueCmd(DbgCommand cmd, QueueMode mode)
 594 {
 595     return queueCmdString(cmd, cmds[cmd].fmt, mode);
 596 }
 597
 598 CmdQueueItem* GdbDriver::queueCmd(DbgCommand cmd, QString strArg,
 599                                   QueueMode mode)
 600 {
 601     return queueCmdString(cmd, makeCmdString(cmd, strArg), mode);
 602 }
 603
 604 CmdQueueItem* GdbDriver::queueCmd(DbgCommand cmd, int intArg,
 605                                   QueueMode mode)
 606 {
 607     return queueCmdString(cmd, makeCmdString(cmd, intArg), mode);
 608 }
 609
 610 CmdQueueItem* GdbDriver::queueCmd(DbgCommand cmd, QString strArg, int intArg,
 611                                   QueueMode mode)
 612 {
 613     return queueCmdString(cmd, makeCmdString(cmd, strArg, intArg), mode);
 614 }
 615
 616 CmdQueueItem* GdbDriver::queueCmd(DbgCommand cmd, QString strArg1, QString strArg2,
 617                                   QueueMode mode)
 618 {
 619     return queueCmdString(cmd, makeCmdString(cmd, strArg1, strArg2), mode);
 620 }
 621
 622 void GdbDriver::terminate()
 623 {
 624     kill(SIGTERM);
 625     m_state = DSidle;
 626 }
 627
 628 void GdbDriver::detachAndTerminate()
 629 {
 630     kill(SIGINT);
 631     flushCommands();
 632     executeCmdString(DCinitialize, "detach\nquit\n", true);
 633 }
 634
 635 void GdbDriver::interruptInferior()
 636 {
 637     kill(SIGINT);
 638     // remove accidentally queued commands
 639     flushHiPriQueue();
 640 }
 641
 642 static bool isErrorExpr(const char* output)
 643 {
 644     return
 645         strncmp(output, "Cannot access memory at", 23) == 0 ||
 646         strncmp(output, "Attempt to dereference a generic pointer", 40) == 0 ||
 647         strncmp(output, "Attempt to take contents of ", 28) == 0 ||
 648         strncmp(output, "Attempt to use a type name as an expression", 43) == 0 ||
 649         strncmp(output, "There is no member or method named", 34) == 0 ||
 650         strncmp(output, "A parse error in expression", 27) == 0 ||
 651         strncmp(output, "No symbol \"", 11) == 0 ||
 652         strncmp(output, "Internal error: ", 16) == 0;
 653 }
 654
 655 /**
 656  * Returns true if the output is an error message. If wantErrorValue is
 657  * true, a new ExprValue object is created and filled with the error message.
 658  * If there are warnings, they are skipped and output points past the warnings
 659  * on return (even if there \e are errors).
 660  */
 661 static bool parseErrorMessage(const char*& output,
 662                               ExprValue*& variable, bool wantErrorValue)
 663 {
 664     // skip warnings
 665     while (strncmp(output, "warning:", 8) == 0)
 666     {
 667         char* end = strchr(output+8, '\n');
 668         if (end == 0)
 669             output += strlen(output);
 670         else
 671             output = end+1;
 672     }
 673
 674     if (isErrorExpr(output))
 675     {
 676         if (wantErrorValue) {
 677             // put the error message as value in the variable
 678             variable = new ExprValue(QString(), VarTree::NKplain);
 679             const char* endMsg = strchr(output, '\n');
 680             if (endMsg == 0)
 681                 endMsg = output + strlen(output);
 682             variable->m_value = QString::fromLatin1(output, endMsg-output);
 683         } else {
 684             variable = 0;
 685         }
 686         return true;
 687     }
 688     return false;
 689 }
 690
 691 #if QT_VERSION >= 300
 692 union Qt2QChar {
 693     short s;
 694     struct {
 695         uchar row;
 696         uchar cell;
 697     } qch;
 698 };
 699 #endif
 700
 701 void GdbDriver::setPrintQStringDataCmd(const char* cmd)
 702 {
 703     // don't accept the command if it is empty
 704     if (cmd == 0 || *cmd == '\0')
 705         return;
 706     assert(strlen(cmd) <= MAX_FMTLEN);
 707     cmds[DCprintQStringStruct].fmt = cmd;
 708 }
 709
 710 ExprValue* GdbDriver::parseQCharArray(const char* output, bool wantErrorValue, bool qt3like)
 711 {
 712     ExprValue* variable = 0;
 713
 714     /*
 715      * Parse off white space. gdb sometimes prints white space first if the
 716      * printed array leaded to an error.
 717      */
 718     while (isspace(*output))
 719         output++;
 720
 721     // special case: empty string (0 repetitions)
 722     if (strncmp(output, "Invalid number 0 of repetitions", 31) == 0)
 723     {
 724         variable = new ExprValue(QString(), VarTree::NKplain);
 725         variable->m_value = "\"\"";
 726         return variable;
 727     }
 728
 729     // check for error conditions
 730     if (parseErrorMessage(output, variable, wantErrorValue))
 731         return variable;
 732
 733     // parse the array
 734
 735     // find '='
 736     const char* p = output;
 737     p = strchr(p, '=');
 738     if (p == 0) {
 739         goto error;
 740     }
 741     // skip white space
 742     do {
 743         p++;
 744     } while (isspace(*p));
 745
 746     if (*p == '{')
 747     {
 748         // this is the real data
 749         p++;                            /* skip '{' */
 750
 751         // parse the array
 752         QString result;
 753         QString repeatCount;
 754         enum { wasNothing, wasChar, wasRepeat } lastThing = wasNothing;
 755         /*
 756          * A matrix for separators between the individual "things"
 757          * that are added to the string. The first index is a bool,
 758          * the second index is from the enum above.
 759          */
 760         static const char* separator[2][3] = {
 761             { "\"", 0,       ", \"" },  /* normal char is added */
 762             { "'",  "\", '", ", '" }    /* repeated char is added */
 763         };
 764
 765         while (isdigit(*p)) {
 766             // parse a number
 767             char* end;
 768             unsigned short value = (unsigned short) strtoul(p, &end, 0);
 769             if (end == p)
 770                 goto error;             /* huh? no valid digits */
 771             // skip separator and search for a repeat count
 772             p = end;
 773             while (isspace(*p) || *p == ',')
 774                 p++;
 775             bool repeats = strncmp(p, "<repeats ", 9) == 0;
 776             if (repeats) {
 777                 const char* start = p;
 778                 p = strchr(p+9, '>');   /* search end and advance */
 779                 if (p == 0)
 780                     goto error;
 781                 p++;                    /* skip '>' */
 782                 repeatCount = QString::fromLatin1(start, p-start);
 783                 while (isspace(*p) || *p == ',')
 784                     p++;
 785             }
 786             // p is now at the next char (or the end)
 787
 788             // interpret the value as a QChar
 789             // TODO: make cross-architecture compatible
 790             QChar ch;
 791             if (qt3like) {
 792                 ch = QChar(value);
 793             } else {
 794 #if QT_VERSION < 300
 795                 (unsigned short&)ch = value;
 796 #else
 797                 Qt2QChar c;
 798                 c.s = value;
 799                 ch.setRow(c.qch.row);
 800                 ch.setCell(c.qch.cell);
 801 #endif
 802             }
 803
 804             // escape a few frequently used characters
 805             char escapeCode = '\0';
 806             switch (ch.latin1()) {
 807             case '\n': escapeCode = 'n'; break;
 808             case '\r': escapeCode = 'r'; break;
 809             case '\t': escapeCode = 't'; break;
 810             case '\b': escapeCode = 'b'; break;
 811             case '\"': escapeCode = '\"'; break;
 812             case '\\': escapeCode = '\\'; break;
 813             case '\0': if (value == 0) { escapeCode = '0'; } break;
 814             }
 815
 816             // add separator
 817             result += separator[repeats][lastThing];
 818             // add char
 819             if (escapeCode != '\0') {
 820                 result += '\\';
 821                 ch = escapeCode;
 822             }
 823             result += ch;
 824
 825             // fixup repeat count and lastThing
 826             if (repeats) {
 827                 result += "' ";
 828                 result += repeatCount;
 829                 lastThing = wasRepeat;
 830             } else {
 831                 lastThing = wasChar;
 832             }
 833         }
 834         if (*p != '}')
 835             goto error;
 836
 837         // closing quote
 838         if (lastThing == wasChar)
 839             result += "\"";
 840
 841         // assign the value
 842         variable = new ExprValue(QString(), VarTree::NKplain);
 843         variable->m_value = result;
 844     }
 845     else if (strncmp(p, "true", 4) == 0)
 846     {
 847         variable = new ExprValue(QString(), VarTree::NKplain);
 848         variable->m_value = "QString::null";
 849     }
 850     else if (strncmp(p, "false", 5) == 0)
 851     {
 852         variable = new ExprValue(QString(), VarTree::NKplain);
 853         variable->m_value = "(null)";
 854     }
 855     else
 856         goto error;
 857     return variable;
 858
 859 error:
 860     if (wantErrorValue) {
 861         variable = new ExprValue(QString(), VarTree::NKplain);
 862         variable->m_value = "internal parse error";
 863     }
 864     return variable;
 865 }
 866
 867 static ExprValue* parseVar(const char*& s)
 868 {
 869     const char* p = s;
 870
 871     // skip whitespace
 872     while (isspace(*p))
 873         p++;
 874
 875     QString name;
 876     VarTree::NameKind kind;
 877     if (!parseName(p, name, kind)) {
 878         return 0;
 879     }
 880
 881     // go for '='
 882     while (isspace(*p))
 883         p++;
 884     if (*p != '=') {
 885         TRACE(QString().sprintf("parse error: = not found after %s", (const char*)name));
 886         return 0;
 887     }
 888     // skip the '=' and more whitespace
 889     p++;
 890     while (isspace(*p))
 891         p++;
 892
 893     ExprValue* variable = new ExprValue(name, kind);
 894
 895     if (!parseValue(p, variable)) {
 896         delete variable;
 897         return 0;
 898     }
 899     s = p;
 900     return variable;
 901 }
 902
 903 static void skipNested(const char*& s, char opening, char closing)
 904 {
 905     const char* p = s;
 906
 907     // parse a nested type
 908     int nest = 1;
 909     p++;
 910     /*
 911      * Search for next matching `closing' char, skipping nested pairs of
 912      * `opening' and `closing'.
 913      */
 914     while (*p && nest > 0) {
 915         if (*p == opening) {
 916             nest++;
 917         } else if (*p == closing) {
 918             nest--;
 919         }
 920         p++;
 921     }
 922     if (nest != 0) {
 923         TRACE(QString().sprintf("parse error: mismatching %c%c at %-20.20s", opening, closing, s));
 924     }
 925     s = p;
 926 }
 927
 928 /**
 929  * This function skips text that is delimited by nested angle bracktes, '<>'.
 930  * A complication arises because the delimited text can contain the names of
 931  * operator<<, operator>>, operator<, and operator>, which have to be treated
 932  * specially so that they do not count towards the nesting of '<>'.
 933  * This function assumes that the delimited text does not contain strings.
 934  */
 935 static void skipNestedAngles(const char*& s)
 936 {
 937     const char* p = s;
 938
 939     int nest = 1;
 940     p++;                // skip the initial '<'
 941     while (*p && nest > 0)
 942     {
 943         // Below we can check for p-s >= 9 instead of 8 because
 944         // *s is '<' and cannot be part of "operator".
 945         if (*p == '<')
 946         {
 947             if (p-s >= 9 && strncmp(p-8, "operator", 8) == 0) {
 948                 if (p[1] == '<')
 949                     p++;
 950             } else {
 951                 nest++;
 952             }
 953         }
 954         else if (*p == '>')
 955         {
 956             if (p-s >= 9 && strncmp(p-8, "operator", 8) == 0) {
 957                 if (p[1] == '>')
 958                     p++;
 959             } else {
 960                 nest--;
 961             }
 962         }
 963         p++;
 964     }
 965     if (nest != 0) {
 966         TRACE(QString().sprintf("parse error: mismatching <> at %-20.20s", s));
 967     }
 968     s = p;
 969 }
 970
 971 /**
 972  * Find the end of line that is not inside braces
 973  */
 974 static void findEnd(const char*& s)
 975 {
 976     const char* p = s;
 977     while (*p && *p!='\n') {
 978         while (*p && *p!='\n' && *p!='{')
 979             p++;
 980         if (*p=='{') {
 981             p++;
 982             skipNested(p, '{', '}'); p--;
 983         }
 984     }
 985     s = p;
 986 }
 987
 988 static bool isNumberish(const char ch)
 989 {
 990     return (ch>='0' && ch<='9') || ch=='.' || ch=='x';
 991 }
 992
 993 void skipString(const char*& p)
 994 {
 995 moreStrings:
 996     // opening quote
 997     char quote = *p++;
 998     while (*p != quote) {
 999         if (*p == '\\') {
1000             // skip escaped character
1001             // no special treatment for octal values necessary
1002             p++;
1003         }
1004         // simply return if no more characters
1005         if (*p == '\0')
1006             return;
1007         p++;
1008     }
1009     // closing quote
1010     p++;
1011     /*
1012      * Strings can consist of several parts, some of which contain repeated
1013      * characters.
1014      */
1015     if (quote == '\'') {
1016         // look ahaead for <repeats 123 times>
1017         const char* q = p+1;
1018         while (isspace(*q))
1019             q++;
1020         if (strncmp(q, "<repeats ", 9) == 0) {
1021             p = q+9;
1022             while (*p != '\0' && *p != '>')
1023                 p++;
1024             if (*p != '\0') {
1025                 p++;                    /* skip the '>' */
1026             }
1027         }
1028     }
1029     // is the string continued?
1030     if (*p == ',') {
1031         // look ahead for another quote
1032         const char* q = p+1;
1033         while (isspace(*q))
1034             q++;
1035         if (*q == '"' || *q == '\'') {
1036             // yes!
1037             p = q;
1038             goto moreStrings;
1039         }
1040     }
1041     /* very long strings are followed by `...' */
1042     if (*p == '.' && p[1] == '.' && p[2] == '.') {
1043         p += 3;
1044     }
1045 }
1046
1047 static void skipNestedWithString(const char*& s, char opening, char closing)
1048 {
1049     const char* p = s;
1050
1051     // parse a nested expression
1052     int nest = 1;
1053     p++;
1054     /*
1055      * Search for next matching `closing' char, skipping nested pairs of
1056      * `opening' and `closing' as well as strings.
1057      */
1058     while (*p && nest > 0) {
1059         if (*p == opening) {
1060             nest++;
1061         } else if (*p == closing) {
1062             nest--;
1063         } else if (*p == '\'' || *p == '\"') {
1064             skipString(p);
1065             continue;
1066         }
1067         p++;
1068     }
1069     if (nest > 0) {
1070         TRACE(QString().sprintf("parse error: mismatching %c%c at %-20.20s", opening, closing, s));
1071     }
1072     s = p;
1073 }
1074
1075 inline void skipName(const char*& p)
1076 {
1077     // allow : (for enumeration values) and $ and . (for _vtbl.)
1078     while (isalnum(*p) || *p == '_' || *p == ':' || *p == '$' || *p == '.')
1079         p++;
1080 }
1081
1082 static bool parseName(const char*& s, QString& name, VarTree::NameKind& kind)
1083 {
1084     kind = VarTree::NKplain;
1085
1086     const char* p = s;
1087     // examples of names:
1088     //  name
1089     //  <Object>
1090     //  <string<a,b<c>,7> >
1091
1092     if (*p == '<') {
1093         skipNestedAngles(p);
1094         name = QString::fromLatin1(s, p - s);
1095         kind = VarTree::NKtype;
1096     }
1097     else
1098     {
1099         // name, which might be "static"; allow dot for "_vtbl."
1100         skipName(p);
1101         if (p == s) {
1102             TRACE(QString().sprintf("parse error: not a name %-20.20s", s));
1103             return false;
1104         }
1105         int len = p - s;
1106         if (len == 6 && strncmp(s, "static", 6) == 0) {
1107             kind = VarTree::NKstatic;
1108
1109             // its a static variable, name comes now
1110             while (isspace(*p))
1111                 p++;
1112             s = p;
1113             skipName(p);
1114             if (p == s) {
1115                 TRACE(QString().sprintf("parse error: not a name after static %-20.20s", s));
1116                 return false;
1117             }
1118             len = p - s;
1119         }
1120         name = QString::fromLatin1(s, len);
1121     }
1122     // return the new position
1123     s = p;
1124     return true;
1125 }
1126
1127 static bool parseValue(const char*& s, ExprValue* variable)
1128 {
1129     variable->m_value = "";
1130
1131 repeat:
1132     if (*s == '{') {
1133         // Sometimes we find the following output:
1134         //  {<text variable, no debug info>} 0x40012000 <access>
1135         //  {<data variable, no debug info>}
1136         //  {<variable (not text or data), no debug info>}
1137         if (strncmp(s, "{<text variable, ", 17) == 0 ||
1138             strncmp(s, "{<data variable, ", 17) == 0 ||
1139             strncmp(s, "{<variable (not text or data), ", 31) == 0)
1140         {
1141             const char* start = s;
1142             skipNested(s, '{', '}');
1143             variable->m_value = QString::fromLatin1(start, s-start);
1144             variable->m_value += ' ';   // add only a single space
1145             while (isspace(*s))
1146                 s++;
1147             goto repeat;
1148         }
1149         else
1150         {
1151             s++;
1152             if (!parseNested(s, variable)) {
1153                 return false;
1154             }
1155             // must be the closing brace
1156             if (*s != '}') {
1157                 TRACE("parse error: missing } of " +  variable->m_name);
1158                 return false;
1159             }
1160             s++;
1161             // final white space
1162             while (isspace(*s))
1163                 s++;
1164         }
1165     } else {
1166         // examples of leaf values (cannot be the empty string):
1167         //  123
1168         //  -123
1169         //  23.575e+37
1170         //  0x32a45
1171         //  @0x012ab4
1172         //  (DwContentType&) @0x8123456: {...}
1173         //  0x32a45 "text"
1174         //  10 '\n'
1175         //  <optimized out>
1176         //  0x823abc <Array<int> virtual table>
1177         //  (void (*)()) 0x8048480 <f(E *, char)>
1178         //  (E *) 0xbffff450
1179         //  red
1180         //  &parseP (HTMLClueV *, char *)
1181         //  Variable "x" is not available.
1182         //  The value of variable 'x' is distributed...
1183         //  -nan(0xfffff081defa0)
1184
1185         const char*p = s;
1186
1187         // check for type
1188         QString type;
1189         if (*p == '(') {
1190             skipNested(p, '(', ')');
1191
1192             while (isspace(*p))
1193                 p++;
1194             variable->m_value = QString::fromLatin1(s, p - s);
1195         }
1196
1197         bool reference = false;
1198         if (*p == '@') {
1199             // skip reference marker
1200             p++;
1201             reference = true;
1202         }
1203         const char* start = p;
1204         if (*p == '-')
1205             p++;
1206
1207         // some values consist of more than one token
1208         bool checkMultiPart = false;
1209
1210         if (p[0] == '0' && p[1] == 'x') {
1211             // parse hex number
1212             p += 2;
1213             while (isxdigit(*p))
1214                 p++;
1215
1216             /*
1217              * Assume this is a pointer, but only if it's not a reference, since
1218              * references can't be expanded.
1219              */
1220             if (!reference) {
1221                 variable->m_varKind = VarTree::VKpointer;
1222             } else {
1223                 /*
1224                  * References are followed by a colon, in which case we'll
1225                  * find the value following the reference address.
1226                  */
1227                 if (*p == ':') {
1228                     p++;
1229                 } else {
1230                     // Paranoia. (Can this happen, i.e. reference not followed by ':'?)
1231                     reference = false;
1232                 }
1233             }
1234             checkMultiPart = true;
1235         } else if (isdigit(*p)) {
1236             // parse decimal number, possibly a float
1237             while (isdigit(*p))
1238                 p++;
1239             if (*p == '.') {            /* TODO: obey i18n? */
1240                 // In long arrays an integer may be followed by '...'.
1241                 // We test for this situation and don't gobble the '...'.
1242                 if (p[1] != '.' || p[0] != '.') {
1243                     // fractional part
1244                     p++;
1245                     while (isdigit(*p))
1246                         p++;
1247                 }
1248             }
1249             if (*p == 'e' || *p == 'E') {
1250                 p++;
1251                 // exponent
1252                 if (*p == '-' || *p == '+')
1253                     p++;
1254                 while (isdigit(*p))
1255                     p++;
1256             }
1257
1258             // for char variables there is the char, eg. 10 '\n'
1259             checkMultiPart = true;
1260         } else if (*p == '<') {
1261             // e.g. <optimized out>
1262             skipNestedAngles(p);
1263         } else if (*p == '"' || *p == '\'') {
1264             // character may have multipart: '\000' <repeats 11 times>
1265             checkMultiPart = *p == '\'';
1266             // found a string
1267             skipString(p);
1268         } else if (*p == '&') {
1269             // function pointer
1270             p++;
1271             skipName(p);
1272             while (isspace(*p)) {
1273                 p++;
1274             }
1275             if (*p == '(') {
1276                 skipNested(p, '(', ')');
1277             }
1278         } else if (strncmp(p, "Variable \"", 10) == 0) {
1279             // Variable "x" is not available.
1280             p += 10;            // skip to "
1281             skipName(p);
1282             if (strncmp(p, "\" is not available.", 19) == 0) {
1283                 p += 19;
1284             }
1285         } else if (strncmp(p, "The value of variable '", 23) == 0) {
1286             p += 23;
1287             skipName(p);
1288             const char* e = strchr(p, '.');
1289             if (e == 0) {
1290                 p += strlen(p);
1291             } else {
1292                 p = e+1;
1293             }
1294         } else {
1295             // must be an enumeration value
1296             skipName(p);
1297             // hmm, not necessarily: nan (floating point Not a Number)
1298             // is followed by a number in ()
1299             if (*p == '(')
1300                 skipNested(p, '(', ')');
1301         }
1302         variable->m_value += QString::fromLatin1(start, p - start);
1303
1304         // remove line breaks from the value; this is ok since
1305         // string values never contain a literal line break
1306         variable->m_value.replace('\n', ' ');
1307
1308         if (checkMultiPart) {
1309             // white space
1310             while (isspace(*p))
1311                 p++;
1312             // may be followed by a string or <...>
1313             start = p;
1314
1315             if (*p == '"' || *p == '\'') {
1316                 skipString(p);
1317             } else if (*p == '<') {
1318                 // if this value is part of an array, it might be followed
1319                 // by <repeats 15 times>, which we don't skip here
1320                 if (strncmp(p, "<repeats ", 9) != 0)
1321                     skipNestedAngles(p);
1322             }
1323             if (p != start) {
1324                 // there is always a blank before the string,
1325                 // which we will include in the final string value
1326                 variable->m_value += QString::fromLatin1(start-1, (p - start)+1);
1327                 // if this was a pointer, reset that flag since we
1328                 // now got the value
1329                 variable->m_varKind = VarTree::VKsimple;
1330             }
1331         }
1332
1333         if (variable->m_value.length() == 0) {
1334             TRACE("parse error: no value for " + variable->m_name);
1335             return false;
1336         }
1337
1338         // final white space
1339         while (isspace(*p))
1340             p++;
1341         s = p;
1342
1343         /*
1344          * If this was a reference, the value follows. It might even be a
1345          * composite variable!
1346          */
1347         if (reference) {
1348             goto repeat;
1349         }
1350     }
1351
1352     return true;
1353 }
1354
1355 static bool parseNested(const char*& s, ExprValue* variable)
1356 {
1357     // could be a structure or an array
1358     while (isspace(*s))
1359         s++;
1360
1361     const char* p = s;
1362     bool isStruct = false;
1363     /*
1364      * If there is a name followed by an = or an < -- which starts a type
1365      * name -- or "static", it is a structure
1366      */
1367     if (*p == '<' || *p == '}') {
1368         isStruct = true;
1369     } else if (strncmp(p, "static ", 7) == 0) {
1370         isStruct = true;
1371     } else if (isalpha(*p) || *p == '_' || *p == '$') {
1372         // look ahead for a comma after the name
1373         skipName(p);
1374         while (isspace(*p))
1375             p++;
1376         if (*p == '=') {
1377             isStruct = true;
1378         }
1379         p = s;                          /* rescan the name */
1380     }
1381     if (isStruct) {
1382         if (!parseVarSeq(p, variable)) {
1383             return false;
1384         }
1385         variable->m_varKind = VarTree::VKstruct;
1386     } else {
1387         if (!parseValueSeq(p, variable)) {
1388             return false;
1389         }
1390         variable->m_varKind = VarTree::VKarray;
1391     }
1392     s = p;
1393     return true;
1394 }
1395
1396 static bool parseVarSeq(const char*& s, ExprValue* variable)
1397 {
1398     // parse a comma-separated sequence of variables
1399     ExprValue* var = variable;          /* var != 0 to indicate success if empty seq */
1400     for (;;) {
1401         if (*s == '}')
1402             break;
1403         if (strncmp(s, "<No data fields>}", 17) == 0)
1404         {
1405             // no member variables, so break out immediately
1406             s += 16;                    /* go to the closing brace */
1407             break;
1408         }
1409         var = parseVar(s);
1410         if (var == 0)
1411             break;                      /* syntax error */
1412         variable->appendChild(var);
1413         if (*s != ',')
1414             break;
1415         // skip the comma and whitespace
1416         s++;
1417         while (isspace(*s))
1418             s++;
1419     }
1420     return var != 0;
1421 }
1422
1423 static bool parseValueSeq(const char*& s, ExprValue* variable)
1424 {
1425     // parse a comma-separated sequence of variables
1426     int index = 0;
1427     bool good;
1428     for (;;) {
1429         QString name;
1430         name.sprintf("[%d]", index);
1431         ExprValue* var = new ExprValue(name, VarTree::NKplain);
1432         good = parseValue(s, var);
1433         if (!good) {
1434             delete var;
1435             return false;
1436         }
1437         // a value may be followed by "<repeats 45 times>"
1438         if (strncmp(s, "<repeats ", 9) == 0) {
1439             s += 9;
1440             char* end;
1441             int l = strtol(s, &end, 10);
1442             if (end == s || strncmp(end, " times>", 7) != 0) {
1443                 // should not happen
1444                 delete var;
1445                 return false;
1446             }
1447             TRACE(QString().sprintf("found <repeats %d times> in array", l));
1448             // replace name and advance index
1449             name.sprintf("[%d .. %d]", index, index+l-1);
1450             var->m_name = name;
1451             index += l;
1452             // skip " times>" and space
1453             s = end+7;
1454             // possible final space
1455             while (isspace(*s))
1456                 s++;
1457         } else {
1458             index++;
1459         }
1460         variable->appendChild(var);
1461         // long arrays may be terminated by '...'
1462         if (strncmp(s, "...", 3) == 0) {
1463             s += 3;
1464             ExprValue* var = new ExprValue("...", VarTree::NKplain);
1465             var->m_value = i18n("<additional entries of the array suppressed>");
1466             variable->appendChild(var);
1467             break;
1468         }
1469         if (*s != ',') {
1470             break;
1471         }
1472         // skip the comma and whitespace
1473         s++;
1474         while (isspace(*s))
1475             s++;
1476         // sometimes there is a closing brace after a comma
1477 //      if (*s == '}')
1478 //          break;
1479     }
1480     return true;
1481 }
1482
1483 /**
1484  * Parses a stack frame.
1485  */
1486 static void parseFrameInfo(const char*& s, QString& func,
1487                            QString& file, int& lineNo, DbgAddr& address)
1488 {
1489     const char* p = s;
1490
1491     // next may be a hexadecimal address
1492     if (*p == '0') {
1493         const char* start = p;
1494         p++;
1495         if (*p == 'x')
1496             p++;
1497         while (isxdigit(*p))
1498             p++;
1499         address = QString::fromLatin1(start, p-start);
1500         if (strncmp(p, " in ", 4) == 0)
1501             p += 4;
1502     } else {
1503         address = DbgAddr();
1504     }
1505     const char* start = p;
1506     // check for special signal handler frame
1507     if (strncmp(p, "<signal handler called>", 23) == 0) {
1508         func = QString::fromLatin1(start, 23);
1509         file = QString();
1510         lineNo = -1;
1511         s = p+23;
1512         if (*s == '\n')
1513             s++;
1514         return;
1515     }
1516
1517     /*
1518      * Skip the function name. It is terminated by a left parenthesis
1519      * which does not delimit "(anonymous namespace)" and which is
1520      * outside the angle brackets <> of template parameter lists.
1521      */
1522     while (*p != '\0')
1523     {
1524         if (*p == '<') {
1525             // check for operator<< and operator<
1526             if (p-start >= 8 && strncmp(p-8, "operator", 8) == 0)
1527             {
1528                 p++;
1529                 if (*p == '<')
1530                     p++;
1531             }
1532             else
1533             {
1534                 // skip template parameter list
1535                 skipNestedAngles(p);
1536             }
1537         } else if (*p == '(') {
1538             if (strncmp(p, "(anonymous namespace)", 21) != 0)
1539                 break;  // parameter list found
1540             p += 21;
1541         } else {
1542             p++;
1543         }
1544     }
1545
1546     if (*p == '\0') {
1547         func = start;
1548         file = QString();
1549         lineNo = -1;
1550         s = p;
1551         return;
1552     }
1553     /*
1554      * Skip parameters. But notice that for complicated conversion
1555      * functions (eg. "operator int(**)()()", ie. convert to pointer to
1556      * pointer to function) as well as operator()(...) we have to skip
1557      * additional pairs of parentheses. Furthermore, recent gdbs write the
1558      * demangled name followed by the arguments in a pair of parentheses,
1559      * where the demangled name can end in "const".
1560      */
1561     do {
1562         skipNestedWithString(p, '(', ')');
1563         while (isspace(*p))
1564             p++;
1565         // skip "const"
1566         if (strncmp(p, "const", 5) == 0) {
1567             p += 5;
1568             while (isspace(*p))
1569                 p++;
1570         }
1571     } while (*p == '(');
1572
1573     // check for file position
1574     if (strncmp(p, "at ", 3) == 0) {
1575         p += 3;
1576         const char* fileStart = p;
1577         // go for the end of the line
1578         while (*p != '\0' && *p != '\n')
1579             p++;
1580         // search back for colon
1581         const char* colon = p;
1582         do {
1583             --colon;
1584         } while (*colon != ':');
1585         file = QString::fromLatin1(fileStart, colon-fileStart);
1586         lineNo = atoi(colon+1)-1;
1587         // skip new-line
1588         if (*p != '\0')
1589             p++;
1590     } else {
1591         // check for "from shared lib"
1592         if (strncmp(p, "from ", 5) == 0) {
1593             p += 5;
1594             // go for the end of the line
1595             while (*p != '\0' && *p != '\n')
1596                 p++;
1597             // skip new-line
1598             if (*p != '\0')
1599                 p++;
1600         }
1601         file = "";
1602         lineNo = -1;
1603     }
1604     // construct the function name (including file info)
1605     if (*p == '\0') {
1606         func = start;
1607     } else {
1608         func = QString::fromLatin1(start, p-start-1);   /* don't include \n */
1609     }
1610     s = p;
1611
1612     /*
1613      * Replace \n (and whitespace around it) in func by a blank. We cannot
1614      * use QString::simplifyWhiteSpace() for this because this would also
1615      * simplify space that belongs to a string arguments that gdb sometimes
1616      * prints in the argument lists of the function.
1617      */
1618     ASSERT(!isspace(func[0].latin1()));         /* there must be non-white before first \n */
1619     int nl = 0;
1620     while ((nl = func.find('\n', nl)) >= 0) {
1621         // search back to the beginning of the whitespace
1622         int startWhite = nl;
1623         do {
1624             --startWhite;
1625         } while (isspace(func[startWhite].latin1()));
1626         startWhite++;
1627         // search forward to the end of the whitespace
1628         do {
1629             nl++;
1630         } while (isspace(func[nl].latin1()));
1631         // replace
1632         func.replace(startWhite, nl-startWhite, " ");
1633         /* continue searching for more \n's at this place: */
1634         nl = startWhite+1;
1635     }
1636 }
1637
1638
1639 /**
1640  * Parses a stack frame including its frame number
1641  */
1642 static bool parseFrame(const char*& s, int& frameNo, QString& func,
1643                        QString& file, int& lineNo, DbgAddr& address)
1644 {
1645     // Example:
1646     //  #1  0x8048881 in Dl::Dl (this=0xbffff418, r=3214) at testfile.cpp:72
1647     //  Breakpoint 3, Cl::f(int) const (this=0xbffff3c0, x=17) at testfile.cpp:155
1648
1649     // must start with a hash mark followed by number
1650     // or with "Breakpoint " followed by number and comma
1651     if (s[0] == '#') {
1652         if (!isdigit(s[1]))
1653             return false;
1654         s++;                            /* skip the hash mark */
1655     } else if (strncmp(s, "Breakpoint ", 11) == 0) {
1656         if (!isdigit(s[11]))
1657             return false;
1658         s += 11;                        /* skip "Breakpoint" */
1659     } else
1660         return false;
1661
1662     // frame number
1663     frameNo = atoi(s);
1664     while (isdigit(*s))
1665         s++;
1666     // space and comma
1667     while (isspace(*s) || *s == ',')
1668         s++;
1669     parseFrameInfo(s, func, file, lineNo, address);
1670     return true;
1671 }
1672
1673 void GdbDriver::parseBackTrace(const char* output, QList<StackFrame>& stack)
1674 {
1675     QString func, file;
1676     int lineNo, frameNo;
1677     DbgAddr address;
1678
1679     while (::parseFrame(output, frameNo, func, file, lineNo, address)) {
1680         StackFrame* frm = new StackFrame;
1681         frm->frameNo = frameNo;
1682         frm->fileName = file;
1683         frm->lineNo = lineNo;
1684         frm->address = address;
1685         frm->var = new ExprValue(func, VarTree::NKplain);
1686         stack.append(frm);
1687     }
1688 }
1689
1690 bool GdbDriver::parseFrameChange(const char* output, int& frameNo,
1691                                  QString& file, int& lineNo, DbgAddr& address)
1692 {
1693     QString func;
1694     return ::parseFrame(output, frameNo, func, file, lineNo, address);
1695 }
1696
1697
1698 bool GdbDriver::parseBreakList(const char* output, QList<Breakpoint>& brks)
1699 {
1700     // skip first line, which is the headline
1701     const char* p = strchr(output, '\n');
1702     if (p == 0)
1703         return false;
1704     p++;
1705     if (*p == '\0')
1706         return false;
1707
1708     // split up a line
1709     QString location;
1710     QString address;
1711     int hits = 0;
1712     uint ignoreCount = 0;
1713     QString condition;
1714     const char* end;
1715     char* dummy;
1716     while (*p != '\0') {
1717         // get Num
1718         long bpNum = strtol(p, &dummy, 10);     /* don't care about overflows */
1719         p = dummy;
1720         // get Type
1721         while (isspace(*p))
1722             p++;
1723         Breakpoint::Type bpType = Breakpoint::breakpoint;
1724         if (strncmp(p, "breakpoint", 10) == 0) {
1725             p += 10;
1726         } else if (strncmp(p, "hw watchpoint", 13) == 0) {
1727             bpType = Breakpoint::watchpoint;
1728             p += 13;
1729         } else if (strncmp(p, "watchpoint", 10) == 0) {
1730             bpType = Breakpoint::watchpoint;
1731             p += 10;
1732         }
1733         while (isspace(*p))
1734             p++;
1735         if (*p == '\0')
1736             break;
1737         // get Disp
1738         char disp = *p++;
1739         while (*p != '\0' && !isspace(*p))      /* "keep" or "del" */
1740             p++;
1741         while (isspace(*p))
1742             p++;
1743         if (*p == '\0')
1744             break;
1745         // get Enb
1746         char enable = *p++;
1747         while (*p != '\0' && !isspace(*p))      /* "y" or "n" */
1748             p++;
1749         while (isspace(*p))
1750             p++;
1751         if (*p == '\0')
1752             break;
1753         // the address, if present
1754         if (bpType == Breakpoint::breakpoint &&
1755             strncmp(p, "0x", 2) == 0)
1756         {
1757             const char* start = p;
1758             while (*p != '\0' && !isspace(*p))
1759                 p++;
1760             address = QString::fromLatin1(start, p-start);
1761             while (isspace(*p) && *p != '\n')
1762                 p++;
1763             if (*p == '\0')
1764                 break;
1765         } else {
1766             address = QString();
1767         }
1768         // remainder is location, hit and ignore count, condition
1769         hits = 0;
1770         ignoreCount = 0;
1771         condition = QString();
1772         end = strchr(p, '\n');
1773         if (end == 0) {
1774             location = p;
1775             p += location.length();
1776         } else {
1777             location = QString::fromLatin1(p, end-p).stripWhiteSpace();
1778             p = end+1;                  /* skip over \n */
1779         }
1780
1781         // may be continued in next line
1782         while (isspace(*p)) {   /* p points to beginning of line */
1783             // skip white space at beginning of line
1784             while (isspace(*p))
1785                 p++;
1786
1787             // seek end of line
1788             end = strchr(p, '\n');
1789             if (end == 0)
1790                 end = p+strlen(p);
1791
1792             if (strncmp(p, "breakpoint already hit", 22) == 0) {
1793                 // extract the hit count
1794                 p += 22;
1795                 hits = strtol(p, &dummy, 10);
1796                 TRACE(QString().sprintf("hit count %d", hits));
1797             } else if (strncmp(p, "stop only if ", 13) == 0) {
1798                 // extract condition
1799                 p += 13;
1800                 condition = QString::fromLatin1(p, end-p).stripWhiteSpace();
1801                 TRACE("condition: "+condition);
1802             } else if (strncmp(p, "ignore next ", 12) == 0) {
1803                 // extract ignore count
1804                 p += 12;
1805                 ignoreCount = strtol(p, &dummy, 10);
1806                 TRACE(QString().sprintf("ignore count %d", ignoreCount));
1807             } else {
1808                 // indeed a continuation
1809                 location += " " + QString::fromLatin1(p, end-p).stripWhiteSpace();
1810             }
1811             p = end;
1812             if (*p != '\0')
1813                 p++;                    /* skip '\n' */
1814         }
1815         Breakpoint* bp = new Breakpoint;
1816         bp->id = bpNum;
1817         bp->type = bpType;
1818         bp->temporary = disp == 'd';
1819         bp->enabled = enable == 'y';
1820         bp->location = location;
1821         bp->address = address;
1822         bp->hitCount = hits;
1823         bp->ignoreCount = ignoreCount;
1824         bp->condition = condition;
1825         brks.append(bp);
1826     }
1827     return true;
1828 }
1829
1830 bool GdbDriver::parseThreadList(const char* output, QList<ThreadInfo>& threads)
1831 {
1832     if (strcmp(output, "\n") == 0 || strncmp(output, "No stack.", 9) == 0) {
1833         // no threads
1834         return true;
1835     }
1836
1837     int id;
1838     QString systag;
1839     QString func, file;
1840     int lineNo;
1841     DbgAddr address;
1842
1843     const char* p = output;
1844     while (*p != '\0') {
1845         // seach look for thread id, watching out for  the focus indicator
1846         bool hasFocus = false;
1847         while (isspace(*p))             /* may be \n from prev line: see "No stack" below */
1848             p++;
1849         if (*p == '*') {
1850             hasFocus = true;
1851             p++;
1852             // there follows only whitespace
1853         }
1854         char* end;
1855         id = strtol(p, &end, 10);
1856         if (p == end) {
1857             // syntax error: no number found; bail out
1858             return true;
1859         }
1860         p = end;
1861
1862         // skip space
1863         while (isspace(*p))
1864             p++;
1865
1866         /*
1867          * Now follows the thread's SYSTAG. It is terminated by two blanks.
1868          */
1869         end = strstr(p, "  ");
1870         if (end == 0) {
1871             // syntax error; bail out
1872             return true;
1873         }
1874         systag = QString::fromLatin1(p, end-p);
1875         p = end+2;
1876
1877         /*
1878          * Now follows a standard stack frame. Sometimes, however, gdb
1879          * catches a thread at an instant where it doesn't have a stack.
1880          */
1881         if (strncmp(p, "[No stack.]", 11) != 0) {
1882             ::parseFrameInfo(p, func, file, lineNo, address);
1883         } else {
1884             func = "[No stack]";
1885             file = QString();
1886             lineNo = -1;
1887             address = QString();
1888             p += 11;                    /* \n is skipped above */
1889         }
1890
1891         ThreadInfo* thr = new ThreadInfo;
1892         thr->id = id;
1893         thr->threadName = systag;
1894         thr->hasFocus = hasFocus;
1895         thr->function = func;
1896         thr->fileName = file;
1897         thr->lineNo = lineNo;
1898         thr->address = address;
1899         threads.append(thr);
1900     }
1901     return true;
1902 }
1903
1904 static bool parseNewBreakpoint(const char* o, int& id,
1905                                QString& file, int& lineNo, QString& address);
1906 static bool parseNewWatchpoint(const char* o, int& id,
1907                                QString& expr);
1908
1909 bool GdbDriver::parseBreakpoint(const char* output, int& id,
1910                                 QString& file, int& lineNo, QString& address)
1911 {
1912     const char* o = output;
1913     // skip lines of that begin with "(Cannot find"
1914     while (strncmp(o, "(Cannot find", 12) == 0) {
1915         o = strchr(o, '\n');
1916         if (o == 0)
1917             return false;
1918         o++;                            /* skip newline */
1919     }
1920
1921     if (strncmp(o, "Breakpoint ", 11) == 0) {
1922         output += 11;                   /* skip "Breakpoint " */
1923         return ::parseNewBreakpoint(output, id, file, lineNo, address);
1924     } else if (strncmp(o, "Hardware watchpoint ", 20) == 0) {
1925         output += 20;
1926         return ::parseNewWatchpoint(output, id, address);
1927     } else if (strncmp(o, "Watchpoint ", 11) == 0) {
1928         output += 11;
1929         return ::parseNewWatchpoint(output, id, address);
1930     }
1931     return false;
1932 }
1933
1934 static bool parseNewBreakpoint(const char* o, int& id,
1935                                QString& file, int& lineNo, QString& address)
1936 {
1937     // breakpoint id
1938     char* p;
1939     id = strtoul(o, &p, 10);
1940     if (p == o)
1941         return false;
1942
1943     // check for the address
1944     if (strncmp(p, " at 0x", 6) == 0) {
1945         char* start = p+4;             /* skip " at ", but not 0x */
1946         p += 6;
1947         while (isxdigit(*p))
1948             ++p;
1949         address = QString::fromLatin1(start, p-start);
1950     }
1951
1952     // file name
1953     char* fileStart = strstr(p, "file ");
1954     if (fileStart == 0)
1955         return !address.isEmpty();     /* parse error only if there's no address */
1956     fileStart += 5;
1957
1958     // line number
1959     char* numStart = strstr(fileStart, ", line ");
1960     QString fileName = QString::fromLatin1(fileStart, numStart-fileStart);
1961     numStart += 7;
1962     int line = strtoul(numStart, &p, 10);
1963     if (numStart == p)
1964         return false;
1965
1966     file = fileName;
1967     lineNo = line-1;                    /* zero-based! */
1968     return true;
1969 }
1970
1971 static bool parseNewWatchpoint(const char* o, int& id,
1972                                QString& expr)
1973 {
1974     // watchpoint id
1975     char* p;
1976     id = strtoul(o, &p, 10);
1977     if (p == o)
1978         return false;
1979
1980     if (strncmp(p, ": ", 2) != 0)
1981         return false;
1982     p += 2;
1983
1984     // all the rest on the line is the expression
1985     expr = QString::fromLatin1(p, strlen(p)).stripWhiteSpace();
1986     return true;
1987 }
1988
1989 void GdbDriver::parseLocals(const char* output, QList<ExprValue>& newVars)
1990 {
1991     // check for possible error conditions
1992     if (strncmp(output, "No symbol table", 15) == 0)
1993     {
1994         return;
1995     }
1996
1997     while (*output != '\0') {
1998         while (isspace(*output))
1999             output++;
2000         if (*output == '\0')
2001             break;
2002         // skip occurrences of "No locals" and "No args"
2003         if (strncmp(output, "No locals", 9) == 0 ||
2004             strncmp(output, "No arguments", 12) == 0)
2005         {
2006             output = strchr(output, '\n');
2007             if (output == 0) {
2008                 break;
2009             }
2010             continue;
2011         }
2012
2013         ExprValue* variable = parseVar(output);
2014         if (variable == 0) {
2015             break;
2016         }
2017         // do not add duplicates
2018         for (ExprValue* o = newVars.first(); o != 0; o = newVars.next()) {
2019             if (o->m_name == variable->m_name) {
2020                 delete variable;
2021                 goto skipDuplicate;
2022             }
2023         }
2024         newVars.append(variable);
2025     skipDuplicate:;
2026     }
2027 }
2028
2029 ExprValue* GdbDriver::parsePrintExpr(const char* output, bool wantErrorValue)
2030 {
2031     ExprValue* var = 0;
2032     // check for error conditions
2033     if (!parseErrorMessage(output, var, wantErrorValue))
2034     {
2035         // parse the variable
2036         var = parseVar(output);
2037     }
2038     return var;
2039 }
2040
2041 bool GdbDriver::parseChangeWD(const char* output, QString& message)
2042 {
2043     bool isGood = false;
2044     message = QString(output).simplifyWhiteSpace();
2045     if (message.isEmpty()) {
2046         message = i18n("New working directory: ") + m_programWD;
2047         isGood = true;
2048     }
2049     return isGood;
2050 }
2051
2052 bool GdbDriver::parseChangeExecutable(const char* output, QString& message)
2053 {
2054     message = output;
2055
2056     m_haveCoreFile = false;
2057
2058     /*
2059      * Lines starting with the following do not indicate errors:
2060      *     Using host libthread_db
2061      *     (no debugging symbols found)
2062      */
2063     while (strncmp(output, "Using host libthread_db", 23) == 0 ||
2064            strncmp(output, "(no debugging symbols found)", 28) == 0)
2065     {
2066         // this line is good, go to the next one
2067         const char* end = strchr(output, '\n');
2068         if (end == 0)
2069             output += strlen(output);
2070         else
2071             output = end+1;
2072     }
2073
2074     /*
2075      * If we've parsed all lines, there was no error.
2076      */
2077     return output[0] == '\0';
2078 }
2079
2080 bool GdbDriver::parseCoreFile(const char* output)
2081 {
2082     // if command succeeded, gdb emits a line starting with "#0 "
2083     m_haveCoreFile = strstr(output, "\n#0 ") != 0;
2084     return m_haveCoreFile;
2085 }
2086
2087 uint GdbDriver::parseProgramStopped(const char* output, QString& message)
2088 {
2089     // optionally: "program changed, rereading symbols",
2090     // followed by:
2091     // "Program exited normally"
2092     // "Program terminated with wignal SIGSEGV"
2093     // "Program received signal SIGINT" or other signal
2094     // "Breakpoint..."
2095
2096     // go through the output, line by line, checking what we have
2097     const char* start = output - 1;
2098     uint flags = SFprogramActive;
2099     message = QString();
2100     do {
2101         start++;                        /* skip '\n' */
2102
2103         if (strncmp(start, "Program ", 8) == 0 ||
2104             strncmp(start, "ptrace: ", 8) == 0) {
2105             /*
2106              * When we receive a signal, the program remains active.
2107              *
2108              * Special: If we "stopped" in a corefile, the string "Program
2109              * terminated with signal"... is displayed. (Normally, we see
2110              * "Program received signal"... when a signal happens.)
2111              */
2112             if (strncmp(start, "Program exited", 14) == 0 ||
2113                 (strncmp(start, "Program terminated", 18) == 0 && !m_haveCoreFile) ||
2114                 strncmp(start, "ptrace: ", 8) == 0)
2115             {
2116                 flags &= ~SFprogramActive;
2117             }
2118
2119             // set message
2120             const char* endOfMessage = strchr(start, '\n');
2121             if (endOfMessage == 0)
2122                 endOfMessage = start + strlen(start);
2123             message = QString::fromLatin1(start, endOfMessage-start);
2124         } else if (strncmp(start, "Breakpoint ", 11) == 0) {
2125             /*
2126              * We stopped at a (permanent) breakpoint (gdb doesn't tell us
2127              * that it stopped at a temporary breakpoint).
2128              */
2129             flags |= SFrefreshBreak;
2130         } else if (strstr(start, "re-reading symbols.") != 0) {
2131             flags |= SFrefreshSource;
2132         }
2133
2134         // next line, please
2135         start = strchr(start, '\n');
2136     } while (start != 0);
2137
2138     /*
2139      * Gdb only notices when new threads have appeared, but not when a
2140      * thread finishes. So we always have to assume that the list of
2141      * threads has changed.
2142      */
2143     flags |= SFrefreshThreads;
2144
2145     return flags;
2146 }
2147
2148 void GdbDriver::parseSharedLibs(const char* output, QStrList& shlibs)
2149 {
2150     if (strncmp(output, "No shared libraries loaded", 26) == 0)
2151         return;
2152
2153     // parse the table of shared libraries
2154
2155     // strip off head line
2156     output = strchr(output, '\n');
2157     if (output == 0)
2158         return;
2159     output++;                           /* skip '\n' */
2160     QString shlibName;
2161     while (*output != '\0') {
2162         // format of a line is
2163         // 0x404c5000  0x40580d90  Yes         /lib/libc.so.5
2164         // 3 blocks of non-space followed by space
2165         for (int i = 0; *output != '\0' && i < 3; i++) {
2166             while (*output != '\0' && !isspace(*output)) {      /* non-space */
2167                 output++;
2168             }
2169             while (isspace(*output)) {  /* space */
2170                 output++;
2171             }
2172         }
2173         if (*output == '\0')
2174             return;
2175         const char* start = output;
2176         output = strchr(output, '\n');
2177         if (output == 0)
2178             output = start + strlen(start);
2179         shlibName = QString::fromLatin1(start, output-start);
2180         if (*output != '\0')
2181             output++;
2182         shlibs.append(shlibName);
2183         TRACE("found shared lib " + shlibName);
2184     }
2185 }
2186
2187 bool GdbDriver::parseFindType(const char* output, QString& type)
2188 {
2189     if (strncmp(output, "type = ", 7) != 0)
2190         return false;
2191
2192     /*
2193      * Everything else is the type. We strip off any leading "const" and any
2194      * trailing "&" on the grounds that neither affects the decoding of the
2195      * object. We also strip off all white-space from the type.
2196      */
2197     output += 7;
2198     if (strncmp(output, "const ", 6) == 0)
2199         output += 6;
2200     type = output;
2201     type.replace(QRegExp("\\s+"), "");
2202     if (type.endsWith("&"))
2203         type.truncate(type.length() - 1);
2204     return true;
2205 }
2206
2207 void GdbDriver::parseRegisters(const char* output, QList<RegisterInfo>& regs)
2208 {
2209     if (strncmp(output, "The program has no registers now", 32) == 0) {
2210         return;
2211     }
2212
2213     QString regName;
2214     QString value;
2215
2216     // parse register values
2217     while (*output != '\0')
2218     {
2219         // skip space at the start of the line
2220         while (isspace(*output))
2221             output++;
2222
2223         // register name
2224         const char* start = output;
2225         while (*output != '\0' && !isspace(*output))
2226             output++;
2227         if (*output == '\0')
2228             break;
2229         regName = QString::fromLatin1(start, output-start);
2230
2231         // skip space
2232         while (isspace(*output))
2233             output++;
2234
2235         RegisterInfo* reg = new RegisterInfo;
2236         reg->regName = regName;
2237
2238         /*
2239          * If we find a brace now, this is a vector register. We look for
2240          * the closing brace and treat the result as cooked value.
2241          */
2242         if (*output == '{')
2243         {
2244             start = output;
2245             skipNested(output, '{', '}');
2246             value = QString::fromLatin1(start, output-start).simplifyWhiteSpace();
2247             // skip space, but not the end of line
2248             while (isspace(*output) && *output != '\n')
2249                 output++;
2250             // get rid of the braces at the begining and the end
2251             value.remove(0, 1);
2252             if (value[value.length()-1] == '}') {
2253                 value = value.left(value.length()-1);
2254             }
2255             // gdb 5.3 doesn't print a separate set of raw values
2256             if (*output == '{') {
2257                 // another set of vector follows
2258                 // what we have so far is the raw value
2259                 reg->rawValue = value;
2260
2261                 start = output;
2262                 skipNested(output, '{', '}');
2263                 value = QString::fromLatin1(start, output-start).simplifyWhiteSpace();
2264             } else {
2265                 // for gdb 5.3
2266                 // find first type that does not have an array, this is the RAW value
2267                 const char* end=start;
2268                 findEnd(end);
2269                 const char* cur=start;
2270                 while (cur<end) {
2271                     while (*cur != '=' && cur<end)
2272                         cur++;
2273                     cur++;
2274                     while (isspace(*cur) && cur<end)
2275                         cur++;
2276                     if (isNumberish(*cur)) {
2277                         end=cur;
2278                         while (*end && (*end!='}') && (*end!=',') && (*end!='\n'))
2279                             end++;
2280                         QString rawValue = QString::fromLatin1(cur, end-cur).simplifyWhiteSpace();
2281                         reg->rawValue = rawValue;
2282
2283                         if (rawValue.left(2)=="0x") {
2284                             // ok we have a raw value, now get it's type
2285                             end=cur-1;
2286                             while (isspace(*end) || *end=='=') end--;
2287                             end++;
2288                             cur=end-1;
2289                             while (*cur!='{' && *cur!=' ')
2290                                 cur--;
2291                             cur++;
2292                             reg->type=QString::fromLatin1(cur, end-cur);
2293                         }
2294
2295                         // end while loop
2296                         cur=end;
2297                     }
2298                 }
2299                 // skip to the end of line
2300                 while (*output != '\0' && *output != '\n')
2301                     output++;
2302                 // get rid of the braces at the begining and the end
2303                 value.remove(0, 1);
2304                 if (value[value.length()-1] == '}') {
2305                     value = value.left(value.length()-1);
2306                 }
2307             }
2308             reg->cookedValue = value;
2309         }
2310         else
2311         {
2312             // the rest of the line is the register value
2313             start = output;
2314             output = strchr(output,'\n');
2315             if (output == 0)
2316                 output = start + strlen(start);
2317             value = QString::fromLatin1(start, output-start).simplifyWhiteSpace();
2318
2319             /*
2320              * We split the raw from the cooked values.
2321              * Some modern gdbs explicitly say: "0.1234 (raw 0x3e4567...)".
2322              * Here, the cooked value comes first, and the raw value is in
2323              * the second part.
2324              */
2325             int pos = value.find(" (raw ");
2326             if (pos >= 0)
2327             {
2328                 reg->cookedValue = value.left(pos);
2329                 reg->rawValue = value.mid(pos+6);
2330                 if (reg->rawValue.right(1) == ")")      // remove closing bracket
2331                     reg->rawValue.truncate(reg->rawValue.length()-1);
2332             }
2333             else
2334             {
2335                 /*
2336                 * In other cases we split off the first token (separated by
2337                 * whitespace). It is the raw value. The remainder of the line
2338                 * is the cooked value.
2339                 */
2340                 int pos = value.find(' ');
2341                 if (pos < 0) {
2342                     reg->rawValue = value;
2343                     reg->cookedValue = QString();
2344                 } else {
2345                     reg->rawValue = value.left(pos);
2346                     reg->cookedValue = value.mid(pos+1);
2347                 }
2348             }
2349         }
2350         if (*output != '\0')
2351             output++;                   /* skip '\n' */
2352
2353         regs.append(reg);
2354     }
2355 }
2356
2357 bool GdbDriver::parseInfoLine(const char* output, QString& addrFrom, QString& addrTo)
2358 {
2359     // "is at address" or "starts at address"
2360     const char* start = strstr(output, "s at address ");
2361     if (start == 0)
2362         return false;
2363
2364     start += 13;
2365     const char* p = start;
2366     while (*p != '\0' && !isspace(*p))
2367         p++;
2368     addrFrom = QString::fromLatin1(start, p-start);
2369
2370     start = strstr(p, "and ends at ");
2371     if (start == 0) {
2372         addrTo = addrFrom;
2373         return true;
2374     }
2375
2376     start += 12;
2377     p = start;
2378     while (*p != '\0' && !isspace(*p))
2379         p++;
2380     addrTo = QString::fromLatin1(start, p-start);
2381
2382     return true;
2383 }
2384
2385 void GdbDriver::parseDisassemble(const char* output, QList<DisassembledCode>& code)
2386 {
2387     code.clear();
2388
2389     if (strncmp(output, "Dump of assembler", 17) != 0) {
2390         // error message?
2391         DisassembledCode c;
2392         c.code = output;
2393         code.append(new DisassembledCode(c));
2394         return;
2395     }
2396
2397     // remove first line
2398     const char* p = strchr(output, '\n');
2399     if (p == 0)
2400         return;                         /* not a regular output */
2401
2402     p++;
2403
2404     // remove last line
2405     const char* end = strstr(output, "End of assembler");
2406     if (end == 0)
2407         end = p + strlen(p);
2408
2409     DbgAddr address;
2410
2411     // remove function offsets from the lines
2412     while (p != end)
2413     {
2414         const char* start = p;
2415         // address
2416         while (p != end && !isspace(*p))
2417             p++;
2418         address = QString::fromLatin1(start, p-start);
2419
2420         // function name (enclosed in '<>', followed by ':')
2421         while (p != end && *p != '<')
2422             p++;
2423         if (*p == '<')
2424             skipNestedAngles(p);
2425         if (*p == ':')
2426             p++;
2427
2428         // space until code
2429         while (p != end && isspace(*p))
2430             p++;
2431
2432         // code until end of line
2433         start = p;
2434         while (p != end && *p != '\n')
2435             p++;
2436         if (p != end)                   /* include '\n' */
2437             p++;
2438
2439         DisassembledCode* c = new DisassembledCode;
2440         c->address = address;
2441         c->code = QString::fromLatin1(start, p-start);
2442         code.append(c);
2443     }
2444 }
2445
2446 QString GdbDriver::parseMemoryDump(const char* output, QList<MemoryDump>& memdump)
2447 {
2448     if (isErrorExpr(output)) {
2449         // error; strip space
2450         QString msg = output;
2451         return msg.stripWhiteSpace();
2452     }
2453
2454     const char* p = output;             /* save typing */
2455     DbgAddr addr;
2456     QString dump;
2457
2458     // the address
2459     while (*p != 0) {
2460         const char* start = p;
2461         while (*p != '\0' && *p != ':' && !isspace(*p))
2462             p++;
2463         addr = QString::fromLatin1(start, p-start);
2464         if (*p != ':') {
2465             // parse function offset
2466             while (isspace(*p))
2467                 p++;
2468             start = p;
2469             while (*p != '\0' && !(*p == ':' && isspace(p[1])))
2470                 p++;
2471             addr.fnoffs = QString::fromLatin1(start, p-start);
2472         }
2473         if (*p == ':')
2474             p++;
2475         // skip space; this may skip a new-line char!
2476         while (isspace(*p))
2477             p++;
2478         // everything to the end of the line is the memory dump
2479         const char* end = strchr(p, '\n');
2480         if (end != 0) {
2481             dump = QString::fromLatin1(p, end-p);
2482             p = end+1;
2483         } else {
2484             dump = QString::fromLatin1(p, strlen(p));
2485             p += strlen(p);
2486         }
2487         MemoryDump* md = new MemoryDump;
2488         md->address = addr;
2489         md->dump = dump;
2490         memdump.append(md);
2491     }
2492
2493     return QString();
2494 }
2495
2496 QString GdbDriver::editableValue(VarTree* value)
2497 {
2498     const char* s = value->m_value.latin1();
2499
2500     // if the variable is a pointer value that contains a cast,
2501     // remove the cast
2502     if (*s == '(') {
2503         skipNested(s, '(', ')');
2504         // skip space
2505         while (isspace(*s))
2506             ++s;
2507     }
2508
2509 repeat:
2510     const char* start = s;
2511
2512     if (strncmp(s, "0x", 2) == 0)
2513     {
2514         s += 2;
2515         while (isxdigit(*s))
2516             ++s;
2517
2518         /*
2519          * What we saw so far might have been a reference. If so, edit the
2520          * referenced value. Otherwise, edit the pointer.
2521          */
2522         if (*s == ':') {
2523             // a reference
2524             ++s;
2525             goto repeat;
2526         }
2527         // a pointer
2528         // if it's a pointer to a string, remove the string
2529         const char* end = s;
2530         while (isspace(*s))
2531             ++s;
2532         if (*s == '"') {
2533             // a string
2534             return QString::fromLatin1(start, end-start);
2535         } else {
2536             // other pointer
2537             return QString::fromLatin1(start, strlen(start));
2538         }
2539     }
2540
2541     // else leave it unchanged (or stripped of the reference preamble)
2542     return s;
2543 }
2544
2545 QString GdbDriver::parseSetVariable(const char* output)
2546 {
2547     // if there is any output, it is an error message
2548     QString msg = output;
2549     return msg.stripWhiteSpace();
2550 }
2551
2552
2553 #include "gdbdriver.moc"