1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtSCriptTools module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qscriptdebugger_p.h"

    43 #include "qscriptdebuggerconsole_p.h"

    44 #include "qscriptdebuggerconsolecommandmanager_p.h"

    45 #include "qscriptdebuggerconsolecommandjob_p.h"

    46 #include "qscriptstdmessagehandler_p.h"

    47 #include "qscriptdebuggerfrontend_p.h"

    48 #include "qscriptdebuggereventhandlerinterface_p.h"

    49 #include "qscriptdebuggerresponsehandlerinterface_p.h"

    50 #include "qscriptdebuggerjobschedulerinterface_p.h"

    51 #include "qscriptdebuggerconsolewidgetinterface_p.h"

    52 #include "qscriptcompletionproviderinterface_p.h"

    53 #include "qscriptcompletiontask_p.h"

    54 #include "qscripttooltipproviderinterface_p.h"

    55 #include "qscriptdebuggerstackwidgetinterface_p.h"

    56 #include "qscriptdebuggerstackmodel_p.h"

    57 #include "qscriptdebuggerscriptswidgetinterface_p.h"

    58 #include "qscriptdebuggerscriptsmodel_p.h"

    59 #include "qscriptdebuggerlocalswidgetinterface_p.h"

    60 #include "qscriptdebuggerlocalsmodel_p.h"

    61 #include "qscriptdebuggercodewidgetinterface_p.h"

    62 #include "qscriptdebuggercodeviewinterface_p.h"

    63 #include "qscriptdebuggercodefinderwidgetinterface_p.h"

    64 #include "qscriptbreakpointswidgetinterface_p.h"

    65 #include "qscriptbreakpointsmodel_p.h"

    66 #include "qscriptdebugoutputwidgetinterface_p.h"

    67 #include "qscripterrorlogwidgetinterface_p.h"

    68 #include "qscriptdebuggerwidgetfactoryinterface_p.h"

    69 #include "qscriptdebuggerevent_p.h"

    70 #include "qscriptdebuggervalue_p.h"

    71 #include "qscriptdebuggerresponse_p.h"

    72 #include "qscriptdebuggercommand_p.h"

    73 #include "qscriptdebuggercommandschedulerfrontend_p.h"

    74 #include "qscriptdebuggercommandschedulerjob_p.h"

    75 #include "qscriptdebuggerjob_p_p.h"

    76 #include "qscriptxmlparser_p.h"

    77 

    78 #include "private/qobject_p.h"

    79 

    80 #include <QtScript/qscriptcontext.h>

    81 #include <QtScript/qscriptcontextinfo.h>

    82 

    83 #include <QtCore/qcoreapplication.h>

    84 #include <QtCore/qdir.h>

    85 #include <QtCore/qfileinfo.h>

    86 #include <QtCore/qstringlist.h>

    87 #include <QtCore/qdebug.h>

    88 

    89 #include <QtGui/qaction.h>

    90 #include <QtGui/qevent.h>

    91 #include <QtGui/qicon.h>

    92 #include <QtGui/qinputdialog.h>

    93 #include <QtGui/qmenu.h>

    94 #include <QtGui/qtoolbar.h>

    95 #include <QtGui/qtooltip.h>

    96 

    97 QT_BEGIN_NAMESPACE

    98 typedef QPair<QList<qint64>, QList<qint64> > QScriptScriptsDelta;

    99 typedef QPair<QList<qint64>, QList<qint64> > QScriptContextsDelta;

   100 QT_END_NAMESPACE

   101 

   102 Q_DECLARE_METATYPE(QScriptScriptsDelta)

   103 

   104 QT_BEGIN_NAMESPACE

   105 

   106 Q_SCRIPT_EXPORT QString qt_scriptToXml(const QString &program, int lineNumber = 1);

   107 

   108 namespace {

   109 

   110 static int scriptDebuggerCount = 0;

   111 static bool eventCallbackRegistered = false;

   112 static bool widgetInPaintEvent = false;

   113 

   114 static bool scriptDebuggerEventCallback(void **data)

   115 {

   116     QEvent *event = reinterpret_cast<QEvent*>(data[1]);

   117     if (event->type() == QEvent::Paint) {

   118         QObject *receiver = reinterpret_cast<QObject*>(data[0]);

   119         bool was = widgetInPaintEvent;

   120         widgetInPaintEvent = true;

   121         QCoreApplication::instance()->notify(receiver, event);

   122         widgetInPaintEvent = was;

   123         bool *result = reinterpret_cast<bool*>(data[2]);

   124         *result = true;

   125         return true;

   126     }

   127     return false;

   128 }

   129 

   130 }

   131 

   132 /*!

   133   \since 4.5

   134   \class QScriptDebugger

   135   \internal

   136 

   137   \brief The QScriptDebugger class provides a Qt Script debugger.

   138 

   139   \ingroup script

   140 

   141 */

   142 

   143 class QScriptDebuggerPrivate

   144     : public QObjectPrivate,

   145       public QScriptDebuggerCommandSchedulerInterface,

   146       public QScriptDebuggerJobSchedulerInterface,

   147       public QScriptDebuggerEventHandlerInterface,

   148       public QScriptDebuggerResponseHandlerInterface,

   149       public QScriptCompletionProviderInterface,

   150       public QScriptToolTipProviderInterface

   151 {

   152     Q_DECLARE_PUBLIC(QScriptDebugger)

   153 public:

   154     QScriptDebuggerPrivate();

   155     ~QScriptDebuggerPrivate();

   156 

   157     int scheduleJob(QScriptDebuggerJob *job);

   158     void finishJob(QScriptDebuggerJob *job);

   159     void hibernateUntilEvaluateFinished(QScriptDebuggerJob *job);

   160 

   161     void maybeStartNewJob();

   162 

   163     int scheduleCommand(const QScriptDebuggerCommand &command,

   164                         QScriptDebuggerResponseHandlerInterface *responseHandler);

   165 

   166     void handleResponse(

   167         const QScriptDebuggerResponse &response, int commandId);

   168     bool debuggerEvent(const QScriptDebuggerEvent &event);

   169 

   170     QScriptCompletionTaskInterface *createCompletionTask(

   171         const QString &contents, int cursorPosition, int frameIndex, int options);

   172 

   173     void showToolTip(const QPoint &pos, int frameIndex,

   174                      int lineNumber, const QStringList &path);

   175 

   176     static QPixmap pixmap(const QString &path);

   177 

   178     void startInteraction(QScriptDebuggerEvent::Type type,

   179                           qint64 scriptId, int lineNumber);

   180     void sync();

   181     void loadLocals(int frameIndex);

   182     QScriptDebuggerLocalsModel *createLocalsModel();

   183     void selectScriptForFrame(int frameIndex);

   184     void emitStoppedSignal();

   185 

   186     void maybeDelete(QWidget *widget);

   187 

   188     // private slots

   189     void _q_onLineEntered(const QString &contents);

   190     void _q_onCurrentFrameChanged(int frameIndex);

   191     void _q_onCurrentScriptChanged(qint64 scriptId);

   192     void _q_onScriptLocationSelected(int lineNumber);

   193     void _q_interrupt();

   194     void _q_continue();

   195     void _q_stepInto();

   196     void _q_stepOver();

   197     void _q_stepOut();

   198     void _q_runToCursor();

   199     void _q_runToNewScript();

   200     void _q_toggleBreakpoint();

   201     void _q_clearDebugOutput();

   202     void _q_clearErrorLog();

   203     void _q_clearConsole();

   204     void _q_findInScript();

   205     void _q_findNextInScript();

   206     void _q_findPreviousInScript();

   207     void _q_onFindCodeRequest(const QString &, int);

   208     void _q_goToLine();

   209 

   210     void executeConsoleCommand(const QString &command);

   211     void findCode(const QString &exp, int options);

   212 

   213     QScriptDebuggerFrontend *frontend;

   214 

   215     bool interactive;

   216     QScriptDebuggerConsole *console;

   217 

   218     int nextJobId;

   219     QList<QScriptDebuggerJob*> pendingJobs;

   220     QList<int> pendingJobIds;

   221     QScriptDebuggerJob *activeJob;

   222     bool activeJobHibernating;

   223     QHash<int, QScriptDebuggerCommand> watchedCommands;

   224     QHash<int, QScriptDebuggerResponseHandlerInterface*> responseHandlers;

   225 

   226     QScriptDebuggerConsoleWidgetInterface *consoleWidget;

   227     QScriptDebuggerStackWidgetInterface *stackWidget;

   228     QScriptDebuggerStackModel *stackModel;

   229     QScriptDebuggerScriptsWidgetInterface *scriptsWidget;

   230     QScriptDebuggerScriptsModel *scriptsModel;

   231     QScriptDebuggerLocalsWidgetInterface *localsWidget;

   232     QHash<int, QScriptDebuggerLocalsModel*> localsModels;

   233     QScriptDebuggerCodeWidgetInterface *codeWidget;

   234     QScriptDebuggerCodeFinderWidgetInterface *codeFinderWidget;

   235     QScriptBreakpointsWidgetInterface *breakpointsWidget;

   236     QScriptBreakpointsModel *breakpointsModel;

   237     QScriptDebugOutputWidgetInterface *debugOutputWidget;

   238     QScriptErrorLogWidgetInterface *errorLogWidget;

   239     QScriptDebuggerWidgetFactoryInterface *widgetFactory;

   240 

   241     QAction *interruptAction;

   242     QAction *continueAction;

   243     QAction *stepIntoAction;

   244     QAction *stepOverAction;

   245     QAction *stepOutAction;

   246     QAction *runToCursorAction;

   247     QAction *runToNewScriptAction;

   248 

   249     QAction *toggleBreakpointAction;

   250 

   251     QAction *clearDebugOutputAction;

   252     QAction *clearErrorLogAction;

   253     QAction *clearConsoleAction;

   254 

   255     QAction *findInScriptAction;

   256     QAction *findNextInScriptAction;

   257     QAction *findPreviousInScriptAction;

   258     QAction *goToLineAction;

   259 

   260     int updatesEnabledTimerId;

   261 };

   262 

   263 QScriptDebuggerPrivate::QScriptDebuggerPrivate()

   264 {

   265     frontend = 0;

   266     activeJob = 0;

   267     activeJobHibernating = false;

   268     nextJobId = 0;

   269     interactive = false;

   270 

   271     console = new QScriptDebuggerConsole();

   272     QString scriptsPath = QLatin1String(":/qt/scripttools/debugging/scripts/commands");

   273     QScriptStdMessageHandler tmp;

   274     console->loadScriptedCommands(scriptsPath, &tmp);

   275 

   276     consoleWidget = 0;

   277     stackWidget = 0;

   278     stackModel = 0;

   279     scriptsWidget = 0;

   280     scriptsModel = 0;

   281     localsWidget = 0;

   282     codeWidget = 0;

   283     codeFinderWidget = 0;

   284     breakpointsWidget = 0;

   285     breakpointsModel = 0;

   286     debugOutputWidget = 0;

   287     errorLogWidget = 0;

   288     widgetFactory = 0;

   289 

   290     interruptAction = 0;

   291     continueAction = 0;

   292     stepIntoAction = 0;

   293     stepOverAction = 0;

   294     stepOutAction = 0;

   295     runToCursorAction = 0;

   296     runToNewScriptAction = 0;

   297 

   298     toggleBreakpointAction = 0;

   299 

   300     clearErrorLogAction = 0;

   301     clearDebugOutputAction = 0;

   302     clearConsoleAction = 0;

   303 

   304     findInScriptAction = 0;

   305     findNextInScriptAction = 0;

   306     findPreviousInScriptAction = 0;

   307     goToLineAction = 0;

   308 

   309     updatesEnabledTimerId = -1;

   310 }

   311 

   312 QScriptDebuggerPrivate::~QScriptDebuggerPrivate()

   313 {

   314     delete console;

   315     qDeleteAll(pendingJobs);

   316     delete activeJob;

   317     maybeDelete(consoleWidget);

   318     maybeDelete(stackWidget);

   319     maybeDelete(scriptsWidget);

   320     maybeDelete(localsWidget);

   321     maybeDelete(codeWidget);

   322     maybeDelete(codeFinderWidget);

   323     maybeDelete(breakpointsWidget);

   324     maybeDelete(debugOutputWidget);

   325     maybeDelete(errorLogWidget);

   326 }

   327 

   328 void QScriptDebuggerPrivate::maybeDelete(QWidget *widget)

   329 {

   330     if (widget && !widget->parent())

   331         delete widget;

   332 }

   333 

   334 QPixmap QScriptDebuggerPrivate::pixmap(const QString &path)

   335 {

   336     static QString prefix = QString::fromLatin1(":/qt/scripttools/debugging/images/");

   337     return QPixmap(prefix + path);

   338 }

   339 

   340 /*!

   341   \reimp

   342 */

   343 int QScriptDebuggerPrivate::scheduleJob(QScriptDebuggerJob *job)

   344 {

   345     QScriptDebuggerJobPrivate *priv = QScriptDebuggerJobPrivate::get(job);

   346     Q_ASSERT(priv->jobScheduler == 0);

   347     priv->jobScheduler = this;

   348     int id = nextJobId;

   349     pendingJobs.append(job);

   350     pendingJobIds.append(id);

   351     maybeStartNewJob();

   352     return id;

   353 }

   354 

   355 /*!

   356   \reimp

   357 */

   358 void QScriptDebuggerPrivate::finishJob(QScriptDebuggerJob *job)

   359 {

   360     Q_UNUSED(job);

   361     Q_ASSERT(activeJob == job);

   362     delete activeJob;

   363     activeJob = 0;

   364     activeJobHibernating = false;

   365     maybeStartNewJob();

   366 }

   367 

   368 /*!

   369   \reimp

   370 */

   371 void QScriptDebuggerPrivate::hibernateUntilEvaluateFinished(QScriptDebuggerJob *job)

   372 {

   373     Q_UNUSED(job);

   374     Q_ASSERT(activeJob == job);

   375     activeJobHibernating = true;

   376 }

   377 

   378 /*!

   379   Starts a new job if appropriate.

   380 */

   381 void QScriptDebuggerPrivate::maybeStartNewJob()

   382 {

   383     if (activeJob || pendingJobs.isEmpty())

   384         return;

   385     activeJob = pendingJobs.takeFirst();

   386     activeJob->start();

   387 }

   388 

   389 /*!

   390   \reimp

   391 */

   392 int QScriptDebuggerPrivate::scheduleCommand(

   393     const QScriptDebuggerCommand &command,

   394     QScriptDebuggerResponseHandlerInterface *responseHandler)

   395 {

   396     if (!frontend)

   397         return -1;

   398     int id = frontend->scheduleCommand(command, this);

   399     if (responseHandler && (responseHandler != this))

   400         responseHandlers.insert(id, responseHandler);

   401     if ((command.type() == QScriptDebuggerCommand::SetBreakpoint)

   402         || (command.type() == QScriptDebuggerCommand::SetBreakpointData)

   403         || (command.type() == QScriptDebuggerCommand::DeleteBreakpoint)) {

   404         // need to watch this command and update the breakpoints model afterwards

   405         watchedCommands.insert(id, command);

   406     }

   407     return id;

   408 }

   409 

   410 /*!

   411   \reimp

   412 */

   413 void QScriptDebuggerPrivate::handleResponse(

   414     const QScriptDebuggerResponse &response, int commandId)

   415 {

   416     Q_Q(QScriptDebugger);

   417     if (watchedCommands.contains(commandId)) {

   418         QScriptDebuggerCommand command = watchedCommands.take(commandId);

   419         if (response.error() == QScriptDebuggerResponse::NoError) {

   420             if (!breakpointsModel)

   421                 breakpointsModel = new QScriptBreakpointsModel(this, this, q);

   422             switch (command.type()) {

   423             case QScriptDebuggerCommand::SetBreakpoint: {

   424                 int breakpointId = response.resultAsInt();

   425                 QScriptBreakpointData data = command.breakpointData();

   426                 breakpointsModel->addBreakpoint(breakpointId, data);

   427             }   break;

   428             case QScriptDebuggerCommand::SetBreakpointData: {

   429                 int breakpointId = command.breakpointId();

   430                 QScriptBreakpointData data = command.breakpointData();

   431                 breakpointsModel->modifyBreakpoint(breakpointId, data);

   432             }   break;

   433             case QScriptDebuggerCommand::DeleteBreakpoint: {

   434                 int breakpointId = command.breakpointId();

   435                 breakpointsModel->removeBreakpoint(breakpointId);

   436             }   break;

   437             default:

   438                 Q_ASSERT(false);

   439             }

   440         }

   441     } else if (response.async()) {

   442         interactive = false;

   443         // disable/invalidate/enable stuff

   444         if (continueAction)

   445             continueAction->setEnabled(false);

   446         if (stepIntoAction)

   447             stepIntoAction->setEnabled(false);

   448         if (stepOverAction)

   449             stepOverAction->setEnabled(false);

   450         if (stepOutAction)

   451             stepOutAction->setEnabled(false);

   452         if (runToCursorAction)

   453             runToCursorAction->setEnabled(false);

   454         if (runToNewScriptAction)

   455             runToNewScriptAction->setEnabled(false);

   456         if (interruptAction)

   457             interruptAction->setEnabled(true);

   458 

   459         // the timer is to avoid flicker when stepping

   460         if (stackWidget) {

   461             stackWidget->setUpdatesEnabled(false);

   462             stackWidget->setEnabled(false);

   463             if (updatesEnabledTimerId == -1)

   464                 updatesEnabledTimerId = q->startTimer(75);

   465         }

   466         if (localsWidget) {

   467             localsWidget->setUpdatesEnabled(false);

   468             localsWidget->setEnabled(false);

   469             if (updatesEnabledTimerId == -1)

   470                 updatesEnabledTimerId = q->startTimer(75);

   471         }

   472         if (codeWidget)

   473             codeWidget->invalidateExecutionLineNumbers();

   474 

   475         emit q->started();

   476     }

   477 

   478     QScriptDebuggerResponseHandlerInterface *realHandler = responseHandlers.take(commandId);

   479     if (realHandler)

   480         realHandler->handleResponse(response, commandId);

   481 }

   482 

   483 /*!

   484   \reimp

   485 

   486   Handles a debugger event from the frontend.

   487 */

   488 bool QScriptDebuggerPrivate::debuggerEvent(const QScriptDebuggerEvent &event)

   489 {

   490     Q_Q(QScriptDebugger);

   491     switch (event.type()) {

   492     case QScriptDebuggerEvent::None:

   493     case QScriptDebuggerEvent::UserEvent:

   494     case QScriptDebuggerEvent::MaxUserEvent:

   495         Q_ASSERT(false);

   496         break;

   497 

   498     case QScriptDebuggerEvent::Trace:

   499         if (!debugOutputWidget && widgetFactory)

   500             q->setDebugOutputWidget(widgetFactory->createDebugOutputWidget());

   501         if (debugOutputWidget)

   502             debugOutputWidget->message(QtDebugMsg, event.message());

   503         return true; // trace doesn't stall execution

   504 

   505     case QScriptDebuggerEvent::SteppingFinished: {

   506         if (!consoleWidget && widgetFactory)

   507             q->setConsoleWidget(widgetFactory->createConsoleWidget());

   508         if (consoleWidget) {

   509             QString msg = event.message();

   510             if (!msg.isEmpty())

   511                 consoleWidget->message(QtDebugMsg, msg);

   512         }

   513     }   break;

   514 

   515     case QScriptDebuggerEvent::Interrupted:

   516     case QScriptDebuggerEvent::LocationReached:

   517         break;

   518 

   519     case QScriptDebuggerEvent::Breakpoint: {

   520         int bpId = event.breakpointId();

   521         if (!consoleWidget && widgetFactory)

   522             q->setConsoleWidget(widgetFactory->createConsoleWidget());

   523         if (consoleWidget) {

   524             consoleWidget->message(QtDebugMsg,

   525                                    QString::fromLatin1("Breakpoint %0 at %1, line %2.")

   526                                    .arg(bpId).arg(event.fileName())

   527                                    .arg(event.lineNumber()));

   528         }

   529         if (breakpointsModel->breakpointData(bpId).isSingleShot())

   530             breakpointsModel->removeBreakpoint(bpId);

   531     }   break;

   532 

   533     case QScriptDebuggerEvent::Exception: {

   534         if (event.hasExceptionHandler()) {

   535             // Let the exception be handled like normal.

   536             // We may want to add a "Break on all exceptions" option

   537             // to be able to customize this behavior.

   538             return true;

   539         }

   540         if (!consoleWidget && widgetFactory)

   541             q->setConsoleWidget(widgetFactory->createConsoleWidget());

   542         if (!errorLogWidget && widgetFactory)

   543             q->setErrorLogWidget(widgetFactory->createErrorLogWidget());

   544         if (consoleWidget || errorLogWidget) {

   545             QString fn = event.fileName();

   546             if (fn.isEmpty()) {

   547                 if (event.scriptId() != -1)

   548                     fn = QString::fromLatin1("<anonymous script, id=%0>").arg(event.scriptId());

   549                 else

   550                     fn = QString::fromLatin1("<native>");

   551             }

   552             QString msg = QString::fromLatin1("Uncaught exception at %0:%1: %2").arg(fn)

   553                           .arg(event.lineNumber()).arg(event.message());

   554             if (consoleWidget)

   555                 consoleWidget->message(QtCriticalMsg, msg);

   556             if (errorLogWidget)

   557                 errorLogWidget->message(QtCriticalMsg, msg);

   558         }

   559     }   break;

   560 

   561     case QScriptDebuggerEvent::InlineEvalFinished: {

   562         QScriptDebuggerValue result = event.scriptValue();

   563         Q_ASSERT(console != 0);

   564         int action = console->evaluateAction();

   565         console->setEvaluateAction(0);

   566         switch (action) {

   567         case 0: { // eval command

   568             if (activeJob) {

   569                 if (activeJobHibernating) {

   570                     activeJobHibernating = false;

   571                     activeJob->evaluateFinished(result);

   572                 }

   573             } else if (consoleWidget) {

   574                 // ### if the result is an object, need to do a tostring job on it

   575 //          messageHandler->message(QtDebugMsg, result.toString());

   576                 if (result.type() != QScriptDebuggerValue::UndefinedValue)

   577                     consoleWidget->message(QtDebugMsg, event.message());

   578             }

   579         }   break;

   580         case 1: { // return command

   581             QScriptDebuggerCommandSchedulerFrontend frontend(this, this);

   582             frontend.scheduleForceReturn(console->currentFrameIndex(), result);

   583         }   return false;

   584         }

   585         if (!event.isNestedEvaluate()) {

   586             // in the case when evaluate() was called while the

   587             // engine was not running, we don't want to enter interactive mode

   588             return true;

   589         }

   590     }   break;

   591 

   592     case QScriptDebuggerEvent::DebuggerInvocationRequest: {

   593         if (!consoleWidget && widgetFactory)

   594             q->setConsoleWidget(widgetFactory->createConsoleWidget());

   595         if (consoleWidget) {

   596             QString fn = event.fileName();

   597             if (fn.isEmpty())

   598                 fn = QString::fromLatin1("<anonymous script, id=%0>").arg(event.scriptId());

   599             consoleWidget->message(QtDebugMsg,

   600                                    QString::fromLatin1("Debugger invoked from %1, line %2.")

   601                                    .arg(fn).arg(event.lineNumber()));

   602         }

   603     }   break;

   604 

   605     case QScriptDebuggerEvent::ForcedReturn: {

   606     }   break;

   607 

   608     }

   609 

   610     if (widgetInPaintEvent) {

   611         QString msg = QString::fromLatin1("Suspending evaluation in paintEvent() is not supported; resuming.");

   612         if (!consoleWidget && widgetFactory)

   613             q->setConsoleWidget(widgetFactory->createConsoleWidget());

   614         if (!errorLogWidget && widgetFactory)

   615             q->setErrorLogWidget(widgetFactory->createErrorLogWidget());

   616         if (consoleWidget)

   617             consoleWidget->message(QtWarningMsg, msg);

   618         if (errorLogWidget)

   619             errorLogWidget->message(QtCriticalMsg, msg);

   620         return true;

   621     }

   622 

   623     if (activeJobHibernating) {

   624         // evaluate() did not finish normally (e.g. due to a breakpoint),

   625         // so cancel the job that's waiting for it

   626         delete activeJob;

   627         activeJob = 0;

   628         activeJobHibernating = false;

   629     }

   630 

   631     startInteraction(event.type(), event.scriptId(), event.lineNumber());

   632     return !interactive;

   633 }

   634 

   635 class QScriptToolTipJob : public QScriptDebuggerCommandSchedulerJob

   636 {

   637 public:

   638     QScriptToolTipJob(const QPoint &pos, int frameIndex,

   639                       int lineNumber, const QStringList &path,

   640                       QScriptDebuggerCommandSchedulerInterface *scheduler)

   641         : QScriptDebuggerCommandSchedulerJob(scheduler), m_pos(pos),

   642           m_frameIndex(frameIndex), m_lineNumber(lineNumber), m_path(path)

   643         {}

   644 

   645     void start()

   646     {

   647         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   648         frontend.scheduleGetPropertyExpressionValue(m_frameIndex, m_lineNumber, m_path);

   649     }

   650     void handleResponse(const QScriptDebuggerResponse &response, int /*commandId*/)

   651     {

   652         QString tip = response.result().toString();

   653         if (tip.indexOf(QLatin1Char('\n')) != -1) {

   654             QStringList lines = tip.split(QLatin1Char('\n'));

   655             int lineCount = lines.size();

   656             if (lineCount > 5) {

   657                 lines = lines.mid(0, 5);

   658                 lines.append(QString::fromLatin1("(... %0 more lines ...)").arg(lineCount - 5));

   659             }

   660             tip = lines.join(QLatin1String("\n"));

   661         }

   662         QToolTip::showText(m_pos, tip);

   663         finish();

   664     }

   665 

   666 private:

   667     QPoint m_pos;

   668     int m_frameIndex;

   669     int m_lineNumber;

   670     QStringList m_path;

   671 };

   672 

   673 /*!

   674   \reimp

   675 */

   676 void QScriptDebuggerPrivate::showToolTip(const QPoint &pos, int frameIndex,

   677                                          int lineNumber, const QStringList &path)

   678 {

   679     if (frameIndex == -1) {

   680         if (stackWidget)

   681             frameIndex = stackWidget->currentFrameIndex();

   682         else

   683             frameIndex = console->currentFrameIndex();

   684     }

   685     QScriptDebuggerJob *job = new QScriptToolTipJob(pos, frameIndex, lineNumber, path, this);

   686     scheduleJob(job);

   687 }

   688 

   689 /*!

   690   \reimp

   691 */

   692 QScriptCompletionTaskInterface *QScriptDebuggerPrivate::createCompletionTask(

   693     const QString &contents, int cursorPosition, int frameIndex, int options)

   694 {

   695     return new QScriptCompletionTask(

   696         contents, cursorPosition, frameIndex, this, this,

   697         (options & QScriptCompletionProviderInterface::ConsoleCommandCompletion) ? console : 0);

   698 }

   699 

   700 /*!

   701   Slot called when a line has been entered in the console widget.

   702 */

   703 void QScriptDebuggerPrivate::_q_onLineEntered(const QString &contents)

   704 {

   705     QScriptDebuggerConsoleCommandJob *commandJob;

   706     commandJob = console->consumeInput(contents, consoleWidget, this);

   707     if (commandJob != 0) {

   708         scheduleJob(commandJob);

   709         consoleWidget->setLineContinuationMode(false);

   710     } else if (console->hasIncompleteInput()) {

   711         consoleWidget->setLineContinuationMode(true);

   712     }

   713 }

   714 

   715 /*!

   716   Slot called when the current index has changed in the stack widget.

   717 */

   718 void QScriptDebuggerPrivate::_q_onCurrentFrameChanged(int frameIndex)

   719 {

   720     loadLocals(frameIndex);

   721     selectScriptForFrame(frameIndex);

   722 }

   723 

   724 /*!

   725   Slot called when the current script has changed in the scripts widget.

   726 */

   727 void QScriptDebuggerPrivate::_q_onCurrentScriptChanged(qint64 scriptId)

   728 {

   729     if (codeWidget && (codeWidget->currentScriptId() != scriptId)) {

   730         codeWidget->setCurrentScript(scriptId);

   731         QScriptDebuggerCodeViewInterface *view = codeWidget->currentView();

   732         if (view)

   733             view->setExecutionLineNumber(-1, /*error=*/false);

   734     }

   735 }

   736 

   737 void QScriptDebuggerPrivate::_q_onScriptLocationSelected(int lineNumber)

   738 {

   739     QScriptDebuggerCodeViewInterface *view = codeWidget->currentView();

   740     if (!view)

   741         return;

   742     view->gotoLine(lineNumber);

   743 }

   744 

   745 void QScriptDebuggerPrivate::_q_interrupt()

   746 {

   747     executeConsoleCommand(QString::fromLatin1("interrupt"));

   748 }

   749 

   750 void QScriptDebuggerPrivate::_q_continue()

   751 {

   752     executeConsoleCommand(QString::fromLatin1("continue"));

   753 }

   754 

   755 void QScriptDebuggerPrivate::_q_stepInto()

   756 {

   757     executeConsoleCommand(QString::fromLatin1("step"));

   758 }

   759 

   760 void QScriptDebuggerPrivate::_q_stepOver()

   761 {

   762     executeConsoleCommand(QString::fromLatin1("next"));

   763 }

   764 

   765 void QScriptDebuggerPrivate::_q_stepOut()

   766 {

   767     executeConsoleCommand(QString::fromLatin1("finish"));

   768 }

   769 

   770 void QScriptDebuggerPrivate::_q_runToCursor()

   771 {

   772     qint64 scriptId = codeWidget->currentScriptId();

   773     int lineNumber = codeWidget->currentView()->cursorLineNumber();

   774     QScriptDebuggerCommandSchedulerFrontend frontend(this, this);

   775     frontend.scheduleRunToLocation(scriptId, lineNumber);

   776 }

   777 

   778 void QScriptDebuggerPrivate::_q_runToNewScript()

   779 {

   780     QScriptDebuggerCommandSchedulerFrontend frontend(this, this);

   781     frontend.scheduleRunToLocation(QString(), -1);

   782 }

   783 

   784 void QScriptDebuggerPrivate::_q_toggleBreakpoint()

   785 {

   786     Q_ASSERT(codeWidget != 0);

   787     QScriptDebuggerCodeViewInterface *view = codeWidget->currentView();

   788     if (!view)

   789         return;

   790     qint64 scriptId = codeWidget->currentScriptId();

   791     int lineNumber = view->cursorLineNumber();

   792     Q_ASSERT(breakpointsModel != 0);

   793     int bpId = breakpointsModel->resolveBreakpoint(scriptId, lineNumber);

   794     if (bpId != -1) {

   795         breakpointsModel->deleteBreakpoint(bpId);

   796     } else {

   797         QScriptBreakpointData data(scriptId, lineNumber);

   798         if (scriptsModel)

   799             data.setFileName(scriptsModel->scriptData(scriptId).fileName());

   800         breakpointsModel->setBreakpoint(data);

   801     }

   802 }

   803 

   804 void QScriptDebuggerPrivate::_q_clearDebugOutput()

   805 {

   806     if (debugOutputWidget)

   807         debugOutputWidget->clear();

   808 }

   809 

   810 void QScriptDebuggerPrivate::_q_clearErrorLog()

   811 {

   812     if (errorLogWidget)

   813         errorLogWidget->clear();

   814 }

   815 

   816 void QScriptDebuggerPrivate::_q_clearConsole()

   817 {

   818     if (consoleWidget)

   819         consoleWidget->clear();

   820 }

   821 

   822 void QScriptDebuggerPrivate::executeConsoleCommand(const QString &command)

   823 {

   824     QString tmp = console->incompleteInput();

   825     console->setIncompleteInput(QString());

   826     QScriptDebuggerJob *job = console->consumeInput(console->commandPrefix() + command, debugOutputWidget, this);

   827     console->setIncompleteInput(tmp);

   828     if (job != 0) {

   829         scheduleJob(job);

   830         // once to send the command...

   831         QCoreApplication::processEvents();

   832         // ... and once to receive the response

   833         QCoreApplication::processEvents();

   834     }

   835 }

   836 

   837 void QScriptDebuggerPrivate::_q_findInScript()

   838 {

   839     if (!codeFinderWidget && widgetFactory)

   840         q_func()->setCodeFinderWidget(widgetFactory->createCodeFinderWidget());

   841     if (codeFinderWidget) {

   842         codeFinderWidget->show();

   843         codeFinderWidget->setFocus(Qt::OtherFocusReason);

   844     }

   845 }

   846 

   847 void QScriptDebuggerPrivate::_q_findNextInScript()

   848 {

   849     findCode(codeFinderWidget->text(), codeFinderWidget->findOptions());

   850 }

   851 

   852 void QScriptDebuggerPrivate::_q_findPreviousInScript()

   853 {

   854     int options = codeFinderWidget->findOptions();

   855     options |= QTextDocument::FindBackward;

   856     findCode(codeFinderWidget->text(), options);

   857 }

   858 

   859 void QScriptDebuggerPrivate::_q_onFindCodeRequest(

   860     const QString &exp, int options)

   861 {

   862     findCode(exp, options);

   863     if (findNextInScriptAction)

   864         findNextInScriptAction->setEnabled(!exp.isEmpty());

   865     if (findPreviousInScriptAction)

   866         findPreviousInScriptAction->setEnabled(!exp.isEmpty());

   867 }

   868 

   869 void QScriptDebuggerPrivate::findCode(const QString &exp, int options)

   870 {

   871     QScriptDebuggerCodeViewInterface *view = codeWidget->currentView();

   872     if (!view)

   873         return;

   874     int result = view->find(exp, options);

   875     codeFinderWidget->setOK(((result & 0x1) != 0) || exp.isEmpty());

   876     codeFinderWidget->setWrapped((result & 0x2) != 0);

   877 }

   878 

   879 void QScriptDebuggerPrivate::_q_goToLine()

   880 {

   881     QScriptDebuggerCodeViewInterface *view = codeWidget->currentView();

   882     if (!view)

   883         return;

   884     bool ok = false;

   885     int lineNumber = QInputDialog::getInteger(0, QScriptDebugger::tr("Go to Line"),

   886                                               QScriptDebugger::tr("Line:"),

   887                                               view->cursorLineNumber(),

   888                                               1, INT_MAX, 1, &ok);

   889     if (ok)

   890         view->gotoLine(lineNumber);

   891 }

   892 

   893 class QScriptDebuggerShowLineJob : public QScriptDebuggerCommandSchedulerJob

   894 {

   895 public:

   896     QScriptDebuggerShowLineJob(qint64 scriptId, int lineNumber,

   897                                QScriptMessageHandlerInterface *messageHandler,

   898                                QScriptDebuggerCommandSchedulerInterface *scheduler)

   899         : QScriptDebuggerCommandSchedulerJob(scheduler),

   900           m_scriptId(scriptId), m_lineNumber(lineNumber),

   901         m_messageHandler(messageHandler) {}

   902 

   903     void start()

   904     {

   905         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   906         frontend.scheduleGetScriptData(m_scriptId);

   907     }

   908     void handleResponse(const QScriptDebuggerResponse &response, int /*commandId*/)

   909     {

   910         QScriptScriptData data = response.resultAsScriptData();

   911         QString line = data.lines(m_lineNumber, 1).value(0);

   912         m_messageHandler->message(QtDebugMsg, QString::fromLatin1("%0\t%1")

   913                                   .arg(m_lineNumber).arg(line));

   914         finish();

   915     }

   916 

   917 private:

   918     qint64 m_scriptId;

   919     int m_lineNumber;

   920     QScriptMessageHandlerInterface *m_messageHandler;

   921 };

   922 

   923 namespace {

   924 

   925 class SyncStackJob : public QScriptDebuggerCommandSchedulerJob

   926 {

   927 public:

   928     SyncStackJob(QScriptDebuggerPrivate *debugger)

   929         : QScriptDebuggerCommandSchedulerJob(debugger),

   930           m_debugger(debugger), m_index(0) {}

   931     void start()

   932     {

   933         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   934         frontend.scheduleGetContextInfo(m_index); // ### getContextInfos()

   935     }

   936     void handleResponse(const QScriptDebuggerResponse &response,

   937                         int)

   938     {

   939         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   940         if (response.error() != QScriptDebuggerResponse::InvalidContextIndex) {

   941             m_infos.append(response.resultAsContextInfo());

   942             frontend.scheduleGetContextInfo(++m_index);

   943         } else {

   944             m_debugger->stackModel->setContextInfos(m_infos);

   945             if (m_debugger->stackWidget->currentFrameIndex() == -1)

   946                 m_debugger->stackWidget->setCurrentFrameIndex(0);

   947             m_debugger->stackWidget->setUpdatesEnabled(true);

   948             m_debugger->stackWidget->setEnabled(true);

   949             finish();

   950         }

   951     }

   952 

   953 private:

   954     QScriptDebuggerPrivate *m_debugger;

   955     int m_index;

   956     QList<QScriptContextInfo> m_infos;

   957 };

   958 

   959 class SyncScriptsJob : public QScriptDebuggerCommandSchedulerJob

   960 {

   961 public:

   962     SyncScriptsJob(QScriptDebuggerPrivate *debugger)

   963         : QScriptDebuggerCommandSchedulerJob(debugger),

   964           m_debugger(debugger), m_index(-1) {}

   965 

   966     void start()

   967     {

   968         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   969         frontend.scheduleScriptsCheckpoint();

   970     }

   971     void handleResponse(const QScriptDebuggerResponse &response,

   972                         int)

   973     {

   974         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

   975         if (m_index == -1) {

   976             QScriptScriptsDelta delta;

   977             delta = qvariant_cast<QScriptScriptsDelta>(response.result());

   978 

   979             const QList<qint64> &removed = delta.second;

   980             for (int i = 0; i < removed.size(); ++i)

   981                 m_debugger->scriptsModel->removeScript(removed.at(i));

   982 

   983             m_added = delta.first;

   984             if (!m_added.isEmpty()) {

   985                 frontend.scheduleGetScriptData(m_added.at(++m_index));

   986             } else {

   987                 m_debugger->scriptsModel->commit();

   988                 finish();

   989             }

   990         } else {

   991             QScriptScriptData data = response.resultAsScriptData();

   992             qint64 scriptId = m_added.at(m_index);

   993             m_debugger->scriptsModel->addScript(scriptId, data);

   994 

   995             // ### could be slow, might want to do this in a separate thread

   996 //            Q_ASSERT_X(false, Q_FUNC_INFO, "implement me");

   997             QString xml; // = qt_scriptToXml(data.contents(), data.baseLineNumber());

   998             QScriptXmlParser::Result extraInfo = QScriptXmlParser::parse(xml);

   999             m_debugger->scriptsModel->addExtraScriptInfo(

  1000                 scriptId, extraInfo.functionsInfo, extraInfo.executableLineNumbers);

  1001 

  1002             if (++m_index < m_added.size())

  1003                 frontend.scheduleGetScriptData(m_added.at(m_index));

  1004             else {

  1005                 m_debugger->scriptsModel->commit();

  1006                 finish();

  1007             }

  1008         }

  1009     }

  1010 

  1011 private:

  1012     QScriptDebuggerPrivate *m_debugger;

  1013     int m_index;

  1014     QList<qint64> m_added;

  1015 };

  1016 

  1017 class SyncBreakpointsJob : public QScriptDebuggerCommandSchedulerJob

  1018 {

  1019 public:

  1020     SyncBreakpointsJob(QScriptDebuggerPrivate *debugger)

  1021         : QScriptDebuggerCommandSchedulerJob(debugger),

  1022           m_debugger(debugger), m_index(-1) {}

  1023     void start()

  1024     {

  1025         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

  1026         frontend.scheduleGetBreakpoints();

  1027     }

  1028     void handleResponse(const QScriptDebuggerResponse &response,

  1029                         int)

  1030     {

  1031         QScriptBreakpointMap breakpoints = response.resultAsBreakpoints();

  1032         QScriptBreakpointMap::const_iterator it;

  1033         for (it = breakpoints.constBegin(); it != breakpoints.constEnd(); ++it) {

  1034             int id = it.key();

  1035             QScriptBreakpointData newData = it.value();

  1036             QScriptBreakpointData existingData = m_debugger->breakpointsModel->breakpointData(id);

  1037             if (existingData.isValid() && (existingData != newData))

  1038                 m_debugger->breakpointsModel->modifyBreakpoint(id, newData);

  1039         }

  1040         finish();

  1041     }

  1042 

  1043 private:

  1044     QScriptDebuggerPrivate *m_debugger;

  1045     int m_index;

  1046     QList<QScriptContextInfo> m_infos;

  1047 };

  1048 

  1049 class SyncLocalsJob : public QScriptDebuggerCommandSchedulerJob

  1050 {

  1051 public:

  1052     SyncLocalsJob(QScriptDebuggerPrivate *debugger)

  1053         : QScriptDebuggerCommandSchedulerJob(debugger),

  1054           m_debugger(debugger) {}

  1055 

  1056     void start()

  1057     {

  1058         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

  1059         frontend.scheduleContextsCheckpoint();

  1060     }

  1061     void handleResponse(const QScriptDebuggerResponse &response,

  1062                         int)

  1063     {

  1064         QScriptContextsDelta delta = qvariant_cast<QScriptContextsDelta>(response.result());

  1065         for (int i = 0; i < delta.first.size(); ++i) {

  1066             QScriptDebuggerLocalsModel *model = m_debugger->localsModels.take(delta.first.at(i));

  1067             delete model;

  1068         }

  1069         finish();

  1070     }

  1071 

  1072 private:

  1073     QScriptDebuggerPrivate *m_debugger;

  1074 };

  1075 

  1076 class LoadLocalsJob : public QScriptDebuggerCommandSchedulerJob

  1077 {

  1078 public:

  1079     LoadLocalsJob(QScriptDebuggerPrivate *debugger, int frameIndex)

  1080         : QScriptDebuggerCommandSchedulerJob(debugger),

  1081           m_debugger(debugger), m_frameIndex(frameIndex) {}

  1082 

  1083     void start()

  1084     {

  1085         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

  1086         frontend.scheduleGetContextId(m_frameIndex);

  1087     }

  1088     void handleResponse(const QScriptDebuggerResponse &response,

  1089                         int)

  1090     {

  1091         QScriptDebuggerCommandSchedulerFrontend frontend(commandScheduler(), this);

  1092         qint64 contextId = response.resultAsLongLong();

  1093         QScriptDebuggerLocalsModel *model = m_debugger->localsModels.value(contextId);

  1094         if (model) {

  1095             model->sync(m_frameIndex);

  1096         } else {

  1097             model = m_debugger->createLocalsModel();

  1098             m_debugger->localsModels.insert(contextId, model);

  1099             model->init(m_frameIndex);

  1100         }

  1101         if (m_debugger->localsWidget) {

  1102             if (m_debugger->localsWidget->localsModel() != model) // ### bug in qtreeview

  1103                 m_debugger->localsWidget->setLocalsModel(model);

  1104             m_debugger->localsWidget->setUpdatesEnabled(true);

  1105             m_debugger->localsWidget->setEnabled(true);

  1106         }

  1107         finish();

  1108     }

  1109 

  1110 private:

  1111     QScriptDebuggerPrivate *m_debugger;

  1112     int m_frameIndex;

  1113 };

  1114 

  1115 class EmitStoppedSignalJob : public QScriptDebuggerJob

  1116 {

  1117 public:

  1118     EmitStoppedSignalJob(QScriptDebuggerPrivate *debugger)

  1119         : m_debugger(debugger) {}

  1120 

  1121     void start()

  1122     {

  1123         m_debugger->emitStoppedSignal();

  1124         finish();

  1125     }

  1126 

  1127 private:

  1128     QScriptDebuggerPrivate *m_debugger;

  1129 };

  1130 

  1131 } // namespace

  1132 

  1133 void QScriptDebuggerPrivate::startInteraction(QScriptDebuggerEvent::Type type,

  1134                                               qint64 scriptId, int lineNumber)