3 // Copyright by Johannes Sixt, Keith Isdale
4 // This file is under GPL, the GNU General Public Licence
6 #include "xsldbgdriver.h"
8 #include <qstringlist.h>
9 #include <klocale.h> /* i18n */
11 #include <stdlib.h> /* strtol, atoi */
12 #include <string.h> /* strcpy */
13 #include <kmessagebox.h>
22 static VarTree
*parseVar(const char *&s
);
23 static bool parseName(const char *&s
, QString
& name
,
24 VarTree::NameKind
& kind
);
25 static bool parseValue(const char *&s
, VarTree
* variable
);
26 static bool isErrorExpr(const char *output
);
28 #define TERM_IO_ALLOWED 1
30 // TODO: make this cmd info stuff non-static to allow multiple
31 // simultaneous gdbs to run!
33 struct XsldbgCmdInfo
{
35 const char *fmt
; /* format string */
37 argNone
, argString
, argNum
,
38 argStringNum
, argNumString
,
44 * The following array of commands must be sorted by the DC* values,
45 * because they are used as indices.
47 static XsldbgCmdInfo cmds
[] = {
48 {DCinitialize
, "init\n", XsldbgCmdInfo::argNone
},
49 {DCtty
, "tty %s\n", XsldbgCmdInfo::argString
},
50 {DCexecutable
, "source %s\n", XsldbgCmdInfo::argString
}, /* force a restart */
51 {DCtargetremote
, "print 'target remote %s'\n", XsldbgCmdInfo::argString
},
52 {DCcorefile
, "data %s\n", XsldbgCmdInfo::argString
}, /* force a restart */
53 {DCattach
, "print 'attach %s'\n", XsldbgCmdInfo::argString
},
54 {DCinfolinemain
, "print 'info main line'\n", XsldbgCmdInfo::argNone
},
55 {DCinfolocals
, "locals -f\n", XsldbgCmdInfo::argNone
},
56 {DCinforegisters
, "print 'info reg'\n", XsldbgCmdInfo::argNone
},
57 {DCexamine
, "print 'x %s %s'\n", XsldbgCmdInfo::argString2
},
58 {DCinfoline
, "print 'templates %s:%d'\n", XsldbgCmdInfo::argStringNum
},
59 {DCdisassemble
, "print 'disassemble %s %s'\n", XsldbgCmdInfo::argString2
},
60 {DCsetargs
, "data %s\n", XsldbgCmdInfo::argString
},
61 {DCsetenv
, "addparam %s %s\n", XsldbgCmdInfo::argString2
},
62 {DCunsetenv
, "unset env %s\n", XsldbgCmdInfo::argString
},
63 {DCsetoption
, "setoption %s %d\n", XsldbgCmdInfo::argStringNum
},
64 {DCcd
, "chdir %s\n", XsldbgCmdInfo::argString
},
65 {DCbt
, "where\n", XsldbgCmdInfo::argNone
},
66 {DCrun
, "run\nsource\n", XsldbgCmdInfo::argNone
}, /* Ensure that at the start
67 of executing XSLT we show the XSLT file */
68 {DCcont
, "continue\n", XsldbgCmdInfo::argNone
},
69 {DCstep
, "step\n", XsldbgCmdInfo::argNone
},
70 {DCstepi
, "step\n", XsldbgCmdInfo::argNone
},
71 {DCnext
, "next\n", XsldbgCmdInfo::argNone
},
72 {DCnexti
, "next\n", XsldbgCmdInfo::argNone
},
73 {DCfinish
, "stepup\n", XsldbgCmdInfo::argNone
},
74 {DCuntil
, "continue %s:%d\n", XsldbgCmdInfo::argStringNum
},
75 {DCkill
, "quit\n", XsldbgCmdInfo::argNone
},
76 {DCbreaktext
, "break %s\n", XsldbgCmdInfo::argString
},
77 {DCbreakline
, "break -l %s %d\n", XsldbgCmdInfo::argStringNum
},
78 {DCtbreakline
, "break -l %s %d\n", XsldbgCmdInfo::argStringNum
},
79 {DCbreakaddr
, "print `break *%s`\n", XsldbgCmdInfo::argString
},
80 {DCtbreakaddr
, "print `tbreak *%s`\n", XsldbgCmdInfo::argString
},
81 {DCwatchpoint
, "print 'watch %s'\n", XsldbgCmdInfo::argString
},
82 {DCdelete
, "delete %d\n", XsldbgCmdInfo::argNum
},
83 {DCenable
, "enable %d\n", XsldbgCmdInfo::argNum
},
84 {DCdisable
, "disable %d\n", XsldbgCmdInfo::argNum
},
85 {DCprint
, "print %s\n", XsldbgCmdInfo::argString
},
86 {DCprintDeref
, "print 'print (*%s)'\n", XsldbgCmdInfo::argString
},
87 {DCprintStruct
, "print 'print %s'\n", XsldbgCmdInfo::argString
},
88 {DCprintQStringStruct
, "print 'print %s'\n", XsldbgCmdInfo::argString
},
89 {DCframe
, "frame %d\n", XsldbgCmdInfo::argNum
},
90 {DCfindType
, "print 'whatis %s'\n", XsldbgCmdInfo::argString
},
91 {DCinfosharedlib
, "stylesheets\n", XsldbgCmdInfo::argNone
},
92 {DCthread
, "print 'thread %d'\n", XsldbgCmdInfo::argNum
},
93 {DCinfothreads
, "print 'info threads'\n", XsldbgCmdInfo::argNone
},
94 {DCinfobreak
, "show\n", XsldbgCmdInfo::argNone
},
95 {DCcondition
, "print 'condition %d %s'\n", XsldbgCmdInfo::argNumString
},
96 {DCsetpc
, "print 'set variable $pc=%s'\n", XsldbgCmdInfo::argString
},
97 {DCignore
, "print 'ignore %d %d'\n", XsldbgCmdInfo::argNum2
},
98 {DCsetvariable
, "set %s %s\n", XsldbgCmdInfo::argString2
},
101 #define NUM_CMDS (int(sizeof(cmds)/sizeof(cmds[0])))
102 #define MAX_FMTLEN 200
104 XsldbgDriver::XsldbgDriver():
105 DebuggerDriver(), m_gdbMajor(2), m_gdbMinor(0)
107 m_promptRE
.setPattern("\\(xsldbg\\) .*> ");
109 m_promptLastChar
= ' ';
111 m_markerRE
.setPattern("^Breakpoint for file ");
112 m_haveDataFile
= FALSE
;
115 // check command info array
118 for (int i
= 0; i
< NUM_CMDS
; i
++) {
119 // must be indexable by DbgCommand values, i.e. sorted by DbgCommand values
120 assert(i
== cmds
[i
].cmd
);
121 // a format string must be associated
122 assert(cmds
[i
].fmt
!= 0);
123 assert(strlen(cmds
[i
].fmt
) <= MAX_FMTLEN
);
124 // format string must match arg specification
125 switch (cmds
[i
].argsNeeded
) {
126 case XsldbgCmdInfo::argNone
:
127 assert(strchr(cmds
[i
].fmt
, '%') == 0);
129 case XsldbgCmdInfo::argString
:
130 perc
= strchr(cmds
[i
].fmt
, '%');
131 assert(perc
!= 0 && perc
[1] == 's');
132 assert(strchr(perc
+ 2, '%') == 0);
134 case XsldbgCmdInfo::argNum
:
135 perc
= strchr(cmds
[i
].fmt
, '%');
136 assert(perc
!= 0 && perc
[1] == 'd');
137 assert(strchr(perc
+ 2, '%') == 0);
139 case XsldbgCmdInfo::argStringNum
:
140 perc
= strchr(cmds
[i
].fmt
, '%');
141 assert(perc
!= 0 && perc
[1] == 's');
142 perc
= strchr(perc
+ 2, '%');
143 assert(perc
!= 0 && perc
[1] == 'd');
144 assert(strchr(perc
+ 2, '%') == 0);
146 case XsldbgCmdInfo::argNumString
:
147 perc
= strchr(cmds
[i
].fmt
, '%');
148 assert(perc
!= 0 && perc
[1] == 'd');
149 perc
= strchr(perc
+ 2, '%');
150 assert(perc
!= 0 && perc
[1] == 's');
151 assert(strchr(perc
+ 2, '%') == 0);
153 case XsldbgCmdInfo::argString2
:
154 perc
= strchr(cmds
[i
].fmt
, '%');
155 assert(perc
!= 0 && perc
[1] == 's');
156 perc
= strchr(perc
+ 2, '%');
157 assert(perc
!= 0 && perc
[1] == 's');
158 assert(strchr(perc
+ 2, '%') == 0);
160 case XsldbgCmdInfo::argNum2
:
161 perc
= strchr(cmds
[i
].fmt
, '%');
162 assert(perc
!= 0 && perc
[1] == 'd');
163 perc
= strchr(perc
+ 2, '%');
164 assert(perc
!= 0 && perc
[1] == 'd');
165 assert(strchr(perc
+ 2, '%') == 0);
172 XsldbgDriver::~XsldbgDriver()
178 XsldbgDriver::driverName() const
184 XsldbgDriver::defaultXsldbg()
186 return "xsldbg --lang en --shell --gdb";
190 XsldbgDriver::defaultInvocation() const
192 return defaultXsldbg();
195 QStringList
XsldbgDriver::boolOptionList() const
197 QStringList allOptions
;
198 allOptions
.append("verbose");
199 allOptions
.append("repeat");
200 allOptions
.append("debug");
201 allOptions
.append("novalid");
202 allOptions
.append("noout");
203 allOptions
.append("html");
204 allOptions
.append("docbook");
205 allOptions
.append("nonet");
206 allOptions
.append("catalogs");
207 allOptions
.append("xinclude");
208 allOptions
.append("profile");
214 XsldbgDriver::slotReceiveOutput(KProcess
* process
, char *buffer
,
218 if (m_state
!= DSidle
) {
220 DebuggerDriver::slotReceiveOutput(process
, buffer
, buflen
);
222 if (strncmp(buffer
, "quit", 4) == 0) {
223 TRACE("Ignoring text when xsldbg is quiting");
226 ("Stray output received by XsldbgDriver::slotReceiveOutput");
233 XsldbgDriver::startup(QString cmdStr
)
235 if (!DebuggerDriver::startup(cmdStr
))
238 static const char xsldbgInitialize
[] = "pwd\nsetoption gdb 2\n"; /* don't need to do anything else */
240 executeCmdString(DCinitialize
, xsldbgInitialize
, false);
246 XsldbgDriver::commandFinished(CmdQueueItem
* cmd
)
249 TRACE(__PRETTY_FUNCTION__
);
250 // command string must be committed
251 if (!cmd
->m_committed
) {
254 (__PRETTY_FUNCTION__
+
255 (" with uncommited command:\n\t" + cmd
->m_cmdString
)));
259 switch (cmd
->m_cmd
) {
261 // get version number from preamble
264 QRegExp
xsldbgVersion("^XSLDBG [0-9]+\\.[0-9]+\\.[0-9]+");
265 int offset
= xsldbgVersion
.match(m_output
, 0, &len
);
268 char *start
= m_output
+ offset
+ 7; // skip "^XSLDBG "
271 TRACE("Reading version");
273 m_gdbMajor
= strtol(start
, &end
, 10);
274 m_gdbMinor
= strtol(end
+ 1, 0, 10); // skip "."
276 // nothing was parsed
281 // assume some default version (what would make sense?)
285 TRACE(QString("Got version ") +
286 QString::number(m_gdbMajor
) + "." +
287 QString::number(m_gdbMinor
));
292 /* ok, the command is ready */
293 emit
commandReceived(cmd
, m_output
);
295 switch (cmd
->m_cmd
) {
303 if (!::isErrorExpr(m_output
))
306 // This only shows an error for DCinfolocals
307 // need to update KDebugger::handleRunCommand ?
308 KMessageBox::sorry(0L, m_output
);
314 if (!m_xslFile
.isEmpty())
315 emit
activateFileLine(m_xslFile
, 0, DbgAddr());
323 XsldbgDriver::parseMarker()
326 // TRACE("parseMarker : xsldbg");
328 int len
, markerStart
= -1;
331 while (markerStart
== -1) {
332 if ((p
== 0) || (*p
== '\0')) {
336 //TRACE(QString("parseMarker is looking at :") + p);
337 markerStart
= m_markerRE
.match(p
, 0, &len
);
338 if (markerStart
== -1) {
339 // try to marker on next line !
341 if ((p
!= 0) && (*p
!= '\0'))
347 // extract the marker
348 char *startMarker
= p
+ markerStart
+ len
;
350 //TRACE(QString("found marker:") + startMarker);
351 char *endMarker
= strchr(startMarker
, '\n');
358 // extract filename and line number
359 static QRegExp
MarkerRE(" at line [0-9]+");
361 int lineNoStart
= MarkerRE
.match(startMarker
, 0, &len
);
363 if (lineNoStart
>= 0) {
364 int lineNo
= atoi(startMarker
+ lineNoStart
+ 8);
368 // now show the window
369 startMarker
[lineNoStart
-1] = '\0'; /* split off file name */
370 TRACE("Got file and line number");
372 TRACE(QString(startMarker
) + ": " + QString::number(lineNo
));
373 emit
activateFileLine(startMarker
, lineNo
- 1, address
);
379 * Escapes characters that might lead to problems when they appear on gdb's
383 normalizeStringArg(QString
& arg
)
386 * Remove trailing backslashes. This approach is a little simplistic,
387 * but we know that there is at the moment no case where a trailing
388 * backslash would make sense.
390 while (!arg
.isEmpty() && arg
[arg
.length() - 1] == '\\') {
391 arg
= arg
.left(arg
.length() - 1);
397 XsldbgDriver::makeCmdString(DbgCommand cmd
, QString strArg
)
399 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
400 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argString
);
402 normalizeStringArg(strArg
);
405 // need the working directory when parsing the output
406 m_programWD
= strArg
;
407 } else if (cmd
== DCexecutable
) {
408 // want to display the XSL file
413 cmdString
.sprintf(cmds
[cmd
].fmt
, strArg
.latin1());
418 XsldbgDriver::makeCmdString(DbgCommand cmd
, int intArg
)
420 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
421 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argNum
);
424 cmdString
.sprintf(cmds
[cmd
].fmt
, intArg
);
429 XsldbgDriver::makeCmdString(DbgCommand cmd
, QString strArg
, int intArg
)
431 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
432 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argStringNum
||
433 cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argNumString
||
434 cmd
== DCexamine
|| cmd
== DCtty
);
436 normalizeStringArg(strArg
);
442 * intArg specifies which channels should be redirected to
443 * /dev/null. It is a value or'ed together from RDNstdin,
444 * RDNstdout, RDNstderr.
446 static const char *const runRedir
[8] = {
450 " </dev/null >/dev/null",
452 " </dev/null 2>/dev/null",
454 " </dev/null >/dev/null 2>&1"
457 if (strArg
.isEmpty())
458 intArg
= 7; /* failsafe if no tty */
459 m_redirect
= runRedir
[intArg
& 7];
461 return makeCmdString(DCtty
, strArg
); /* note: no problem if strArg empty */
464 if (cmd
== DCexamine
) {
465 // make a format specifier from the intArg
466 static const char size
[16] = {
467 '\0', 'b', 'h', 'w', 'g'
469 static const char format
[16] = {
470 '\0', 'x', 'd', 'u', 'o', 't',
471 'a', 'c', 'f', 's', 'i'
474 assert(MDTsizemask
== 0xf); /* lowest 4 bits */
475 assert(MDTformatmask
== 0xf0); /* next 4 bits */
476 int count
= 16; /* number of entities to print */
477 char sizeSpec
= size
[intArg
& MDTsizemask
];
478 char formatSpec
= format
[(intArg
& MDTformatmask
) >> 4];
480 assert(sizeSpec
!= '\0');
481 assert(formatSpec
!= '\0');
482 // adjust count such that 16 lines are printed
483 switch (intArg
& MDTformatmask
) {
486 break; /* no modification needed */
488 // all cases drop through:
489 switch (intArg
& MDTsizemask
) {
502 spec
.sprintf("/%d%c%c", count
, sizeSpec
, formatSpec
);
504 return makeCmdString(DCexamine
, spec
, strArg
);
507 if (cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argStringNum
) {
508 // line numbers are zero-based
509 if (cmd
== DCuntil
|| cmd
== DCbreakline
||
510 cmd
== DCtbreakline
|| cmd
== DCinfoline
) {
513 if (cmd
== DCinfoline
) {
514 // must split off file name part
515 int slash
= strArg
.findRev('/');
518 strArg
= strArg
.right(strArg
.length() - slash
- 1);
520 cmdString
.sprintf(cmds
[cmd
].fmt
, strArg
.latin1(), intArg
);
522 cmdString
.sprintf(cmds
[cmd
].fmt
, intArg
, strArg
.latin1());
528 XsldbgDriver::makeCmdString(DbgCommand cmd
, QString strArg1
,
531 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
532 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argString2
);
534 normalizeStringArg(strArg1
);
535 normalizeStringArg(strArg2
);
538 cmdString
.sprintf(cmds
[cmd
].fmt
, strArg1
.latin1(), strArg2
.latin1());
543 XsldbgDriver::makeCmdString(DbgCommand cmd
, int intArg1
, int intArg2
)
545 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
546 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argNum2
);
549 cmdString
.sprintf(cmds
[cmd
].fmt
, intArg1
, intArg2
);
554 XsldbgDriver::executeCmd(DbgCommand cmd
, bool clearLow
)
556 assert(cmd
>= 0 && cmd
< NUM_CMDS
);
557 assert(cmds
[cmd
].argsNeeded
== XsldbgCmdInfo::argNone
);
560 m_haveCoreFile
= false;
563 return executeCmdString(cmd
, cmds
[cmd
].fmt
, clearLow
);
567 XsldbgDriver::executeCmd(DbgCommand cmd
, QString strArg
, bool clearLow
)
569 return executeCmdString(cmd
, makeCmdString(cmd
, strArg
), clearLow
);
573 XsldbgDriver::executeCmd(DbgCommand cmd
, int intArg
, bool clearLow
)
576 return executeCmdString(cmd
, makeCmdString(cmd
, intArg
), clearLow
);
580 XsldbgDriver::executeCmd(DbgCommand cmd
, QString strArg
, int intArg
,
583 return executeCmdString(cmd
, makeCmdString(cmd
, strArg
, intArg
),
588 XsldbgDriver::executeCmd(DbgCommand cmd
, QString strArg1
, QString strArg2
,
591 return executeCmdString(cmd
, makeCmdString(cmd
, strArg1
, strArg2
),
596 XsldbgDriver::executeCmd(DbgCommand cmd
, int intArg1
, int intArg2
,
599 return executeCmdString(cmd
, makeCmdString(cmd
, intArg1
, intArg2
),
604 XsldbgDriver::queueCmd(DbgCommand cmd
, QueueMode mode
)
606 return queueCmdString(cmd
, cmds
[cmd
].fmt
, mode
);
610 XsldbgDriver::queueCmd(DbgCommand cmd
, QString strArg
, QueueMode mode
)
612 return queueCmdString(cmd
, makeCmdString(cmd
, strArg
), mode
);
616 XsldbgDriver::queueCmd(DbgCommand cmd
, int intArg
, QueueMode mode
)
618 return queueCmdString(cmd
, makeCmdString(cmd
, intArg
), mode
);
622 XsldbgDriver::queueCmd(DbgCommand cmd
, QString strArg
, int intArg
,
625 return queueCmdString(cmd
, makeCmdString(cmd
, strArg
, intArg
), mode
);
629 XsldbgDriver::queueCmd(DbgCommand cmd
, QString strArg1
, QString strArg2
,
632 return queueCmdString(cmd
, makeCmdString(cmd
, strArg1
, strArg2
), mode
);
636 XsldbgDriver::terminate()
638 qDebug("XsldbgDriver::Terminate");
640 executeCmdString(DCinitialize
, "quit\n", true);
646 XsldbgDriver::detachAndTerminate()
648 qDebug("XsldbgDriver::detachAndTerminate");
650 executeCmdString(DCinitialize
, "quit\n", true);
655 XsldbgDriver::interruptInferior()
657 // remove accidentally queued commands
658 qDebug("interruptInferior");
664 isErrorExpr(const char *output
)
668 #define ERROR_WORD_COUNT 6
669 static const char *errorWords
[ERROR_WORD_COUNT
] = {
671 "error:", // libxslt error
674 "warning:", // libxslt warning
675 "Information:" // xsldbg information
677 static int errorWordLength
[ERROR_WORD_COUNT
] = {
680 15, /* Unknown command*/
686 for (wordIndex
= 0; wordIndex
< ERROR_WORD_COUNT
; wordIndex
++){
688 errorWords
[wordIndex
],
689 errorWordLength
[wordIndex
]) == 0){
691 TRACE(QString("Error/Warning/Information from xsldbg ") + output
);
700 * Returns true if the output is an error message. If wantErrorValue is
701 * true, a new VarTree object is created and filled with the error message.
704 parseErrorMessage(const char *output
,
705 VarTree
* &variable
, bool wantErrorValue
)
707 if (isErrorExpr(output
)) {
708 if (wantErrorValue
) {
709 // put the error message as value in the variable
710 variable
= new VarTree(QString(), VarTree::NKplain
);
711 const char *endMsg
= strchr(output
, '\n');
714 endMsg
= output
+ strlen(output
);
715 variable
->m_value
= QString::fromLatin1(output
, endMsg
- output
);
726 XsldbgDriver::setPrintQStringDataCmd(const char* /*cmd*/)
731 XsldbgDriver::parseQCharArray(const char */
*output*/
, bool /*wantErrorValue*/,
734 VarTree
*variable
= 0;
736 TRACE("XsldbgDriver::parseQCharArray not implmented");
741 parseVar(const char *&s
)
744 bool foundLocalVar
= false;
745 VarTree
*variable
= 0L;
748 VarTree::NameKind kind
;
750 TRACE(__PRETTY_FUNCTION__
);
753 if (parseErrorMessage(p
, variable
, false) == true) {
754 TRACE("Found error message");
758 if (strncmp(p
, " Local", 6) == 0) {
759 foundLocalVar
= true;
762 TRACE("Found local variable");
763 } else if (strncmp(p
, " Global", 7) == 0) {
766 TRACE("Found global variable");
767 } else if (strncmp(p
, "= ", 2) == 0) {
768 /* we're processing the result of a "print command" */
770 char *nextLine
= strchr(p
, '\n');
772 TRACE("Found print expr");
774 p
= p
+ 2; /* skip the "= " */
775 name
= QString::fromLatin1(p
, nextLine
- p
);
776 kind
= VarTree::NKplain
;
778 variable
= new VarTree(name
, kind
);
779 variable
->m_varKind
= VarTree::VKsimple
;
780 variable
->setDeleteChildren(true);
781 parseValue(p
, variable
);
785 return variable
; /* don't know what to do this this data abort!! */
792 // No value provided just a name
793 TRACE(QString("Parse var: name") + p
);
794 if (!parseName(p
, name
, kind
)) {
797 variable
= new VarTree(name
, kind
);
798 if (variable
!= 0L) {
799 variable
->m_varKind
= VarTree::VKsimple
;
800 variable
->setDeleteChildren(true);
807 TRACE(QString("Parse var: name") + p
);
808 if (!parseName(p
, name
, kind
)) {
811 variable
= new VarTree(name
, kind
);
812 if (variable
!= 0L) {
813 variable
->m_varKind
= VarTree::VKsimple
;
814 variable
->setDeleteChildren(true);
818 if (!parseValue(p
, variable
)) {
833 skipName(const char *&p
)
835 // allow : (for enumeration values) and $ and . (for _vtbl.)
836 while (isalnum(*p
) || *p
== '_' || *p
== ':' || *p
== '$' || *p
== '.')
841 parseName(const char *&s
, QString
& name
, VarTree::NameKind
& kind
)
843 /* qDebug(__PRETTY_FUNCTION__); */
844 kind
= VarTree::NKplain
;
849 // examples of names:
852 while ((*p
!= '\n') && (*p
!= '\0')) {
858 name
= QString::fromLatin1(s
, len
);
859 /* XSL variables will have a $ prefix to be evaluated
861 //TRACE(QString("parseName got name" ) + name);
863 // return the new position
869 parseValue(const char *&s
, VarTree
* variable
)
871 const char *start
= s
, *end
= s
;
872 VarTree
* childValue
;
873 #define VALUE_END_MARKER_INDEX 0
875 /* This mark the end of a value */
876 static const char *marker
[] = {
877 "\032\032", /* value end marker*/
879 "Breakpoint at", /* stepped to next location */
880 "Breakpoint in", /* reached a set breakpoint */
881 "Reached ", /* reached template */
889 static char valueBuffer
[2048];
890 int markerIndex
= 0, foundEnd
= 0;
894 return false; /* should never happen but .. */
896 while (start
&& (*start
!= '\0')) {
897 /* look for the next marker */
898 for (markerIndex
= 0; marker
[markerIndex
] != 0; markerIndex
++) {
900 strncmp(start
, marker
[markerIndex
],
901 strlen(marker
[markerIndex
])) == 0;
910 end
= strchr(start
, '\n');
912 copySize
= end
- start
;
914 copySize
= strlen(start
);
915 if (copySize
>= sizeof(valueBuffer
))
916 copySize
= sizeof(valueBuffer
)-1;
918 strncpy(valueBuffer
, start
, copySize
);
919 valueBuffer
[copySize
] = '\0';
920 TRACE("Got value :");
922 if ((variable
->m_varKind
== VarTree::VKsimple
)) {
923 if (!variable
->m_value
.isEmpty()){
924 variable
->m_varKind
= VarTree::VKarray
;
925 childValue
= new VarTree(variable
->m_value
, VarTree::NKplain
);
926 variable
->appendChild(childValue
);
927 childValue
= new VarTree(valueBuffer
, VarTree::NKplain
);
928 variable
->appendChild(childValue
);
929 variable
->m_value
= "";
931 variable
->m_value
= valueBuffer
;
934 childValue
= new VarTree(valueBuffer
, VarTree::NKplain
);
935 variable
->appendChild(childValue
);
947 TRACE(QString("Unable to find end on value near :") + start
);
949 // If we've got something otherthan a end of value marker then
950 // advance to the end of this buffer
951 if (markerIndex
!= VALUE_END_MARKER_INDEX
){
952 while (start
&& *start
!= '\0')
955 start
= start
+ strlen(marker
[0]);
965 * Parses a stack frame.
968 parseFrameInfo(const char *&s
, QString
& func
,
969 QString
& file
, int &lineNo
, DbgAddr
& /*address*/)
971 const char *p
= s
, *endPos
= s
+ strlen(s
);
972 QString lineNoString
;
974 TRACE("parseFrameInfo");
978 /* skip 'template :\" */
982 while ((*p
!= '\"') && (*p
!= '\0')) {
986 while ((*p
!= '\0') && *p
!= '"')
996 /* skip mode :".*" */
997 while ((*p
!= '\0') && *p
!= '"')
1001 while ((*p
!= '\0') && *p
!= '"')
1004 /* skip '" in file ' */
1010 while (!isspace(*p
) && (*p
!= '\"') && (*p
!= '\0')) {
1016 ASSERT(p
<= endPos
);
1023 /* skip ' : line '" */
1026 ASSERT(p
<= endPos
);
1033 /* KDbg uses an offset of +1 for its line numbers */
1034 lineNo
= atoi(p
) - 1;
1035 lineNoString
= QString::number(lineNo
);
1037 /* convert func into format needed */
1038 func
.append(" at ");
1041 func
.append(lineNoString
);
1043 /*advance to next line */
1044 p
= strchr(p
, '\n');
1054 * Parses a stack frame including its frame number
1057 parseFrame(const char *&s
, int &frameNo
, QString
& func
,
1058 QString
& file
, int &lineNo
, DbgAddr
& address
)
1061 // TRACE("XsldbgDriver ::parseFrame");
1062 /* skip leading 'where' or 'frame <frame_no>' */
1063 if ((strncmp(s
, "where", 5) == 0) || (strncmp(s
, "frame", 5) == 0)) {
1064 s
= strchr(s
, '\n');
1065 if ((*s
!= '\0') && (*s
!= '#'))
1071 //#1 template :"/" in file /home/keith/anon_CVS/xsldbg/docs/en/xsldoc.xsl : line 21
1072 // must start with a hash mark followed by number
1073 if (s
[0] != '#' || !isdigit(s
[1]))
1076 //TRACE("XsldbgDriver ::parseFrame got #");
1077 s
++; /* skip the hash mark */
1083 //TRACE(QString("Got frame ").append(QString::number(frameNo)));
1087 parseFrameInfo(s
, func
, file
, lineNo
, address
);
1088 // TRACE("Will next look at ");
1094 XsldbgDriver::parseBackTrace(const char *output
,
1095 QList
< StackFrame
> &stack
)
1098 int lineNo
, frameNo
;
1101 while (::parseFrame(output
, frameNo
, func
, file
, lineNo
, address
)) {
1102 StackFrame
*frm
= new StackFrame
;
1104 frm
->frameNo
= frameNo
;
1105 frm
->fileName
= file
;
1106 frm
->lineNo
= lineNo
;
1107 frm
->address
= address
;
1108 frm
->var
= new VarTree(func
, VarTree::NKplain
);
1114 XsldbgDriver::parseFrameChange(const char *output
, int &frameNo
,
1115 QString
& file
, int &lineNo
,
1120 return::parseFrame(output
, frameNo
, func
, file
, lineNo
, address
);
1125 XsldbgDriver::parseBreakList(const char *output
,
1126 QList
< Breakpoint
> &brks
)
1128 TRACE("parseBreakList");
1129 /* skip the first blank line */
1133 QString location
, file
, lineNo
;
1135 QString templateName
;
1138 uint ignoreCount
= 0;
1141 p
= strchr(output
, '\n');/* skip the first blank line*/
1143 while ((p
!= 0) && (*p
!= '\0')) {
1146 templateName
= QString();
1147 Breakpoint::Type bpType
= Breakpoint::breakpoint
;
1148 //qDebug("Looking at :%s", p);
1149 if (strncmp(p
, " Breakpoint", 11) != 0)
1157 long bpNum
= strtol(p
, &dummy
, 10); /* don't care about overflows */
1160 if ((p
== 0) || (p
[1] == '\0'))
1165 // Get breakpoint state ie enabled/disabled
1166 if (strncmp(p
, "enabled", 7) == 0) {
1170 if (strncmp(p
, "disabled", 8) == 0) {
1174 TRACE("Parse error in breakpoint list");
1180 //TRACE("Looking for template");
1182 if (strncmp(p
, " for template: \"", 16) == 0){
1184 //TRACE("Looking for template name near");
1186 /* get the template name */
1187 while (p
&& (*p
!= '\0') && (*p
!= '\"')){
1188 templateName
.append(*p
);
1194 TRACE("Error missed \" near");
1199 //TRACE("Looking for mode near");
1201 if (strncmp(p
, " mode: \"", 8) == 0){
1203 while (p
&& *p
!= '\"')
1209 if (strncmp(p
, " in file ", 9) != 0){
1210 TRACE("Parse error in breakpoint list");
1216 /* skip ' in file ' */
1222 /* grab file name */
1223 while ((*p
!= '\"') && !isspace(*p
)) {
1232 /* skip ' : line ' */
1234 while (isspace(*p
)) {
1238 while (isdigit(*p
)) {
1245 Breakpoint
*bp
= new Breakpoint
;
1247 // take 1 of line number
1248 lineNo
.setNum(lineNo
.toInt() -1);
1251 bp
->temporary
= false;
1252 bp
->enabled
= enabled
;
1253 location
.append("in ").append(templateName
).append(" at ");
1254 location
.append(file
).append(":").append(lineNo
);
1255 bp
->location
= location
;
1256 bp
->fileName
= file
;
1257 bp
->lineNo
= lineNo
.toInt();
1258 bp
->address
= address
;
1259 bp
->hitCount
= hits
;
1260 bp
->ignoreCount
= ignoreCount
;
1261 bp
->condition
= condition
;
1267 TRACE("Outof memory, breakpoint not created");
1270 p
= strchr(p
, '\n');
1279 XsldbgDriver::parseThreadList(const char */
*output*/
,
1280 QList
< ThreadInfo
> &/*threads*/)
1286 XsldbgDriver::parseBreakpoint(const char *output
, int &id
,
1287 QString
&file
, int &lineNo
, QString
&address
)
1290 if ( strncmp(output
, "Error:", 6) == 0) {
1295 if (strncmp(output
, "Breakpoint ", 11) != 0)
1299 if (!isdigit(*output
))
1303 id
= strtol(output
, &dummy
, 10); /* don't care about overflows */
1304 if (output
== dummy
)
1307 // the file name + lineNo will be filled in later from the breakpoint list
1308 file
= address
= QString();
1314 XsldbgDriver::parseLocals(const char *output
, QList
< VarTree
> &newVars
)
1317 /* keep going until error or xsldbg prompt is found */
1318 while (*output
!= '\0') {
1319 VarTree
*variable
= parseVar(output
);
1321 if (variable
== 0) {
1324 // do not add duplicates
1325 for (VarTree
* o
= newVars
.first(); o
!= 0; o
= newVars
.next()) {
1326 if (o
->getText() == variable
->getText()) {
1332 newVars
.append(variable
);
1339 XsldbgDriver::parsePrintExpr(const char *output
, bool wantErrorValue
,
1342 // check for error conditions
1343 if (parseErrorMessage(output
, var
, wantErrorValue
)) {
1346 // parse the variable
1347 var
= parseVar(output
);
1353 XsldbgDriver::parseChangeWD(const char *output
, QString
& message
)
1355 bool isGood
= false;
1357 if (strncmp(output
, "Change to directory", 20) == 0) {
1358 output
= output
+ 20; /* skip 'Change to directory' */
1359 message
= QString(output
).simplifyWhiteSpace();
1360 if (message
.isEmpty()) {
1361 message
= i18n("New working directory: ") + m_programWD
;
1369 XsldbgDriver::parseChangeExecutable(const char *output
, QString
& message
)
1372 TRACE(QString("XsldbgDriver::parseChangeExecutable :") + output
);
1373 m_haveCoreFile
= false;
1376 * The command is successful if there is no output or the single
1377 * message (no debugging symbols found)...
1379 QRegExp
exp(".*Load of source deferred. Use the run command.*");
1380 int len
, index
= exp
.match(output
, 0, &len
);
1383 TRACE("Parsed stylesheet executable");
1386 return (output
[0] == '\0') || (index
!= -1);
1390 XsldbgDriver::parseCoreFile(const char *output
)
1392 TRACE("XsldbgDriver::parseCoreFile");
1394 QRegExp
exp(".*Load of data file deferred. Use the run command.*");
1395 int len
, index
= exp
.match(output
, 0, &len
);
1398 m_haveCoreFile
= true;
1399 TRACE("Parsed data file name");
1402 return m_haveCoreFile
;
1406 XsldbgDriver::parseProgramStopped(const char *output
, QString
& message
)
1408 /* Not sure about this function leave it here for the moment */
1410 * return DebuggerDriver::SFrefreshBreak & DebuggerDriver::SFprogramActive;
1413 // go through the output, line by line, checking what we have
1414 const char *start
= output
- 1;
1415 uint flags
= SFprogramActive
;
1417 message
= QString();
1419 start
++; /* skip '\n' */
1421 if (strncmp(start
, "Finished stylesheet\n\032\032\n", 21) == 0){
1422 // flags &= ~SFprogramActive;
1426 // next line, please
1427 start
= strchr(start
, '\n');
1428 } while (start
!= 0);
1434 XsldbgDriver::parseSharedLibs(const char */
*output*/
, QStrList
& /*shlibs*/)
1440 XsldbgDriver::parseFindType(const char */
*output*/
, QString
& /*type*/)
1446 XsldbgDriver::parseRegisters(const char */
*output*/
,
1447 QList
< RegisterInfo
> &/*regs*/)
1453 XsldbgDriver::parseInfoLine(const char */
*output*/
, QString
& /*addrFrom*/,
1454 QString
& /*addrTo*/)
1460 XsldbgDriver::parseDisassemble(const char */
*output*/
,
1461 QList
< DisassembledCode
> &/*code*/)
1467 XsldbgDriver::parseMemoryDump(const char */
*output*/
,
1468 QList
< MemoryDump
> &/*memdump*/)
1470 return i18n("No memory dump available");
1474 XsldbgDriver::parseSetVariable(const char */
*output*/
)
1481 #include "xsldbgdriver.moc"