src/scripttools/debugging/qscriptdebuggerscriptedconsolecommand.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 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 "qscriptdebuggerscriptedconsolecommand_p.h"
  43 #include "qscriptdebuggerconsolecommand_p_p.h"
  44 #include "qscriptdebuggerconsolecommandjob_p.h"
  45 #include "qscriptdebuggerconsolecommandjob_p_p.h"
  46 #include "qscriptmessagehandlerinterface_p.h"
  47 #include "qscriptdebuggerconsoleglobalobject_p.h"
  48 #include "qscriptdebuggerresponse_p.h"
  49 #include "qscriptdebuggervalue_p.h"
  50 #include "qscriptdebuggervalueproperty_p.h"
  51 #include "qscriptdebuggercommandschedulerinterface_p.h"
  52
  53 #include <QtCore/qstring.h>
  54 #include <QtCore/qstringlist.h>
  55 #include <QtScript/qscriptengine.h>
  56 #include <QtScript/qscriptvalue.h>
  57 #include <QtScript/qscriptvalueiterator.h>
  58 #include <QtScript/qscriptcontextinfo.h>
  59 #include <QtCore/qdebug.h>
  60
  61 Q_DECLARE_METATYPE(QScriptDebuggerResponse)
  62 Q_DECLARE_METATYPE(QScriptBreakpointData)
  63 Q_DECLARE_METATYPE(QScriptBreakpointMap)
  64 Q_DECLARE_METATYPE(QScriptScriptData)
  65 Q_DECLARE_METATYPE(QScriptScriptMap)
  66 Q_DECLARE_METATYPE(QScriptContextInfo)
  67 Q_DECLARE_METATYPE(QScriptDebuggerValue)
  68 Q_DECLARE_METATYPE(QScriptDebuggerValueProperty)
  69 Q_DECLARE_METATYPE(QScriptDebuggerValuePropertyList)
  70 Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommand*)
  71 Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandList)
  72 Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandGroupData)
  73 Q_DECLARE_METATYPE(QScriptDebuggerConsoleCommandGroupMap)
  74
  75 QT_BEGIN_NAMESPACE
  76
  77 static QScriptValue debuggerResponseToScriptValue(QScriptEngine *eng, const QScriptDebuggerResponse &in)
  78 {
  79     QScriptValue out = eng->newObject();
  80     out.setProperty(QString::fromLatin1("result"), qScriptValueFromValue(eng, in.result()));
  81     out.setProperty(QString::fromLatin1("error"), QScriptValue(eng, in.error()));
  82     out.setProperty(QString::fromLatin1("async"), QScriptValue(eng, in.async()));
  83     return out;
  84 }
  85
  86 static void debuggerResponseFromScriptValue(const QScriptValue &, QScriptDebuggerResponse &)
  87 {
  88     Q_ASSERT(0);
  89 }
  90
  91 static QScriptValue breakpointDataToScriptValue(QScriptEngine *eng, const QScriptBreakpointData &in)
  92 {
  93     QScriptValue out = eng->newObject();
  94     out.setProperty(QString::fromLatin1("scriptId"), QScriptValue(eng, qsreal(in.scriptId())));
  95     out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));
  96     out.setProperty(QString::fromLatin1("lineNumber"), QScriptValue(eng, in.lineNumber()));
  97     out.setProperty(QString::fromLatin1("enabled"), QScriptValue(eng, in.isEnabled()));
  98     out.setProperty(QString::fromLatin1("singleShot"), QScriptValue(eng, in.isSingleShot()));
  99     out.setProperty(QString::fromLatin1("ignoreCount"), QScriptValue(eng, in.ignoreCount()));
 100     out.setProperty(QString::fromLatin1("condition"), QScriptValue(eng, in.condition()));
 101     return out;
 102 }
 103
 104 static void breakpointDataFromScriptValue(const QScriptValue &in, QScriptBreakpointData &out)
 105 {
 106     QScriptValue scriptId = in.property(QString::fromLatin1("scriptId"));
 107     if (scriptId.isValid())
 108         out.setScriptId((qint64)scriptId.toNumber());
 109     out.setFileName(in.property(QString::fromLatin1("fileName")).toString());
 110     out.setLineNumber(in.property(QString::fromLatin1("lineNumber")).toInt32());
 111     QScriptValue enabled = in.property(QString::fromLatin1("enabled"));
 112     if (enabled.isValid())
 113         out.setEnabled(enabled.toBoolean());
 114     QScriptValue singleShot = in.property(QString::fromLatin1("singleShot"));
 115     if (singleShot.isValid())
 116         out.setSingleShot(singleShot.toBoolean());
 117     out.setIgnoreCount(in.property(QString::fromLatin1("ignoreCount")).toInt32());
 118     out.setCondition(in.property(QString::fromLatin1("condition")).toString());
 119 }
 120
 121 static QScriptValue breakpointMapToScriptValue(QScriptEngine *eng, const QScriptBreakpointMap &in)
 122 {
 123     QScriptValue out = eng->newObject();
 124     QScriptBreakpointMap::const_iterator it;
 125     for (it = in.constBegin(); it != in.constEnd(); ++it) {
 126         out.setProperty(QString::number(it.key()), qScriptValueFromValue(eng, it.value()));
 127     }
 128     return out;
 129 }
 130
 131 static void breakpointMapFromScriptValue(const QScriptValue &, QScriptBreakpointMap &)
 132 {
 133     Q_ASSERT(0);
 134 }
 135
 136 static QScriptValue scriptDataToScriptValue(QScriptEngine *eng, const QScriptScriptData &in)
 137 {
 138     QScriptValue out = eng->newObject();
 139     out.setProperty(QString::fromLatin1("contents"), QScriptValue(eng, in.contents()));
 140     out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));
 141     out.setProperty(QString::fromLatin1("baseLineNumber"), QScriptValue(eng, in.baseLineNumber()));
 142     return out;
 143 }
 144
 145 static void scriptDataFromScriptValue(const QScriptValue &in, QScriptScriptData &out)
 146 {
 147     QString contents = in.property(QString::fromLatin1("contents")).toString();
 148     QString fileName = in.property(QString::fromLatin1("fileName")).toString();
 149     int baseLineNumber = in.property(QString::fromLatin1("baseLineNumber")).toInt32();
 150     QScriptScriptData tmp(contents, fileName, baseLineNumber);
 151     out = tmp;
 152 }
 153
 154 static QScriptValue scriptMapToScriptValue(QScriptEngine *eng, const QScriptScriptMap &in)
 155 {
 156     QScriptValue out = eng->newObject();
 157     QScriptScriptMap::const_iterator it;
 158     for (it = in.constBegin(); it != in.constEnd(); ++it) {
 159         out.setProperty(QString::number(it.key()), qScriptValueFromValue(eng, it.value()));
 160     }
 161     return out;
 162 }
 163
 164 static void scriptMapFromScriptValue(const QScriptValue &, QScriptScriptMap &)
 165 {
 166     Q_ASSERT(0);
 167 }
 168
 169 static QScriptValue consoleCommandToScriptValue(
 170     QScriptEngine *eng, QScriptDebuggerConsoleCommand* const &in)
 171 {
 172     if (!in)
 173         return eng->undefinedValue();
 174     QScriptValue out = eng->newObject();
 175     out.setProperty(QString::fromLatin1("name"), QScriptValue(eng, in->name()));
 176     out.setProperty(QString::fromLatin1("group"), QScriptValue(eng, in->group()));
 177     out.setProperty(QString::fromLatin1("shortDescription"), QScriptValue(eng, in->shortDescription()));
 178     out.setProperty(QString::fromLatin1("longDescription"), QScriptValue(eng, in->longDescription()));
 179     out.setProperty(QString::fromLatin1("aliases"), qScriptValueFromValue(eng, in->aliases()));
 180     out.setProperty(QString::fromLatin1("seeAlso"), qScriptValueFromValue(eng, in->seeAlso()));
 181     return out;
 182 }
 183
 184 static void consoleCommandFromScriptValue(
 185     const QScriptValue &, QScriptDebuggerConsoleCommand* &)
 186 {
 187     Q_ASSERT(0);
 188 }
 189
 190 static QScriptValue consoleCommandGroupDataToScriptValue(
 191     QScriptEngine *eng, const QScriptDebuggerConsoleCommandGroupData &in)
 192 {
 193     QScriptValue out = eng->newObject();
 194     out.setProperty(QString::fromLatin1("longDescription"), QScriptValue(eng, in.longDescription()));
 195     out.setProperty(QString::fromLatin1("shortDescription"), QScriptValue(eng, in.shortDescription()));
 196     return out;
 197 }
 198
 199 static void consoleCommandGroupDataFromScriptValue(
 200     const QScriptValue &, QScriptDebuggerConsoleCommandGroupData &)
 201 {
 202     Q_ASSERT(0);
 203 }
 204
 205 static QScriptValue consoleCommandGroupMapToScriptValue(
 206     QScriptEngine *eng, const QScriptDebuggerConsoleCommandGroupMap &in)
 207 {
 208     QScriptValue out = eng->newObject();
 209     QScriptDebuggerConsoleCommandGroupMap::const_iterator it;
 210     for (it = in.constBegin(); it != in.constEnd(); ++it) {
 211         out.setProperty(it.key(), qScriptValueFromValue(eng, it.value()));
 212     }
 213     return out;
 214 }
 215
 216 static void consoleCommandGroupMapFromScriptValue(
 217     const QScriptValue &, QScriptDebuggerConsoleCommandGroupMap &)
 218 {
 219     Q_ASSERT(0);
 220 }
 221
 222 static QScriptValue contextInfoToScriptValue(QScriptEngine *eng, const QScriptContextInfo &in)
 223 {
 224     QScriptValue out = eng->newObject();
 225     out.setProperty(QString::fromLatin1("scriptId"), QScriptValue(eng, qsreal(in.scriptId())));
 226     out.setProperty(QString::fromLatin1("fileName"), QScriptValue(eng, in.fileName()));
 227     out.setProperty(QString::fromLatin1("lineNumber"), QScriptValue(eng, in.lineNumber()));
 228     out.setProperty(QString::fromLatin1("columnNumber"), QScriptValue(eng, in.columnNumber()));
 229     out.setProperty(QString::fromLatin1("functionName"), QScriptValue(eng, in.functionName()));
 230     return out;
 231 }
 232
 233 static void contextInfoFromScriptValue(const QScriptValue &, QScriptContextInfo &)
 234 {
 235     Q_ASSERT(0);
 236 }
 237
 238 static QScriptValue debuggerScriptValuePropertyToScriptValue(QScriptEngine *eng, const QScriptDebuggerValueProperty &in)
 239 {
 240     QScriptValue out = eng->newObject();
 241     out.setProperty(QString::fromLatin1("name"), QScriptValue(eng, in.name()));
 242     out.setProperty(QString::fromLatin1("value"), qScriptValueFromValue(eng, in.value()));
 243     out.setProperty(QString::fromLatin1("valueAsString"), QScriptValue(eng, in.valueAsString()));
 244     out.setProperty(QString::fromLatin1("flags"), QScriptValue(eng, static_cast<int>(in.flags())));
 245     return out;
 246 }
 247
 248 static void debuggerScriptValuePropertyFromScriptValue(const QScriptValue &in, QScriptDebuggerValueProperty &out)
 249 {
 250     QString name = in.property(QString::fromLatin1("name")).toString();
 251     QScriptDebuggerValue value = qscriptvalue_cast<QScriptDebuggerValue>(in.property(QString::fromLatin1("value")));
 252     QString valueAsString = in.property(QString::fromLatin1("valueAsString")).toString();
 253     int flags = in.property(QString::fromLatin1("flags")).toInt32();
 254     QScriptDebuggerValueProperty tmp(name, value, valueAsString, QScriptValue::PropertyFlags(flags));
 255     out = tmp;
 256 }
 257
 258 /*!
 259   \since 4.5
 260   \class QScriptDebuggerScriptedConsoleCommand
 261   \internal
 262
 263   \brief The QScriptDebuggerScriptedConsoleCommand class encapsulates a command defined in a script.
 264 */
 265
 266 class QScriptDebuggerScriptedConsoleCommandPrivate
 267     : public QScriptDebuggerConsoleCommandPrivate
 268 {
 269     Q_DECLARE_PUBLIC(QScriptDebuggerScriptedConsoleCommand)
 270 public:
 271     QScriptDebuggerScriptedConsoleCommandPrivate();
 272     ~QScriptDebuggerScriptedConsoleCommandPrivate();
 273
 274     QString name;
 275     QString group;
 276     QString shortDescription;
 277     QString longDescription;
 278     QStringList aliases;
 279     QStringList seeAlso;
 280     QStringList argumentTypes;
 281     QStringList subCommands;
 282     QScriptEngine *engine;
 283     QScriptValue execFunction;
 284     QScriptValue responseFunction;
 285 };
 286
 287 QScriptDebuggerScriptedConsoleCommandPrivate::QScriptDebuggerScriptedConsoleCommandPrivate()
 288 {
 289     engine = 0;
 290 }
 291
 292 QScriptDebuggerScriptedConsoleCommandPrivate::~QScriptDebuggerScriptedConsoleCommandPrivate()
 293 {
 294     delete engine;
 295 }
 296
 297 QScriptDebuggerScriptedConsoleCommand::QScriptDebuggerScriptedConsoleCommand(
 298     const QString &name, const QString &group,
 299     const QString &shortDescription, const QString &longDescription,
 300     const QStringList &aliases, const QStringList &seeAlso,
 301     const QStringList &argumentTypes, const QStringList &subCommands,
 302     const QScriptValue &execFunction, const QScriptValue &responseFunction)
 303     : QScriptDebuggerConsoleCommand(*new QScriptDebuggerScriptedConsoleCommandPrivate)
 304 {
 305     Q_D(QScriptDebuggerScriptedConsoleCommand);
 306     d->name = name;
 307     d->group = group;
 308     d->shortDescription = shortDescription;
 309     d->longDescription = longDescription;
 310     d->aliases = aliases;
 311     d->seeAlso = seeAlso;
 312     d->argumentTypes = argumentTypes;
 313     d->subCommands = subCommands;
 314     d->execFunction = execFunction;
 315     d->responseFunction = responseFunction;
 316     d->engine = execFunction.engine();
 317
 318     qScriptRegisterMetaType<QScriptBreakpointData>(d->engine, breakpointDataToScriptValue, breakpointDataFromScriptValue);
 319     qScriptRegisterMetaType<QScriptBreakpointMap>(d->engine, breakpointMapToScriptValue, breakpointMapFromScriptValue);
 320     qScriptRegisterMetaType<QScriptScriptData>(d->engine, scriptDataToScriptValue, scriptDataFromScriptValue);
 321     qScriptRegisterMetaType<QScriptScriptMap>(d->engine, scriptMapToScriptValue, scriptMapFromScriptValue);
 322     qScriptRegisterMetaType<QScriptContextInfo>(d->engine, contextInfoToScriptValue, contextInfoFromScriptValue);
 323     qScriptRegisterMetaType<QScriptDebuggerValueProperty>(d->engine, debuggerScriptValuePropertyToScriptValue, debuggerScriptValuePropertyFromScriptValue);
 324     qScriptRegisterSequenceMetaType<QScriptDebuggerValuePropertyList>(d->engine);
 325     qScriptRegisterMetaType<QScriptDebuggerResponse>(d->engine, debuggerResponseToScriptValue, debuggerResponseFromScriptValue);
 326     qScriptRegisterMetaType<QScriptDebuggerConsoleCommand*>(d->engine, consoleCommandToScriptValue, consoleCommandFromScriptValue);
 327     qScriptRegisterSequenceMetaType<QScriptDebuggerConsoleCommandList>(d->engine);
 328     qScriptRegisterMetaType<QScriptDebuggerConsoleCommandGroupData>(d->engine, consoleCommandGroupDataToScriptValue, consoleCommandGroupDataFromScriptValue);
 329     qScriptRegisterMetaType<QScriptDebuggerConsoleCommandGroupMap>(d->engine, consoleCommandGroupMapToScriptValue, consoleCommandGroupMapFromScriptValue);
 330 // ### can't do this, if it's an object ID the conversion will be incorrect since
 331 // ### the object ID refers to an object in a different engine!
 332 //    qScriptRegisterMetaType(d->engine, debuggerScriptValueToScriptValue, debuggerScriptValueFromScriptValue);
 333 }
 334
 335 QScriptDebuggerScriptedConsoleCommand::~QScriptDebuggerScriptedConsoleCommand()
 336 {
 337 }
 338
 339 class QScriptDebuggerScriptedConsoleCommandJobPrivate;
 340 class QScriptDebuggerScriptedConsoleCommandJob
 341     : public QScriptDebuggerConsoleCommandJob,
 342       public QScriptDebuggerCommandSchedulerInterface
 343 {
 344 public:
 345     QScriptDebuggerScriptedConsoleCommandJob(
 346         QScriptDebuggerScriptedConsoleCommandPrivate *command,
 347         const QStringList &arguments,
 348         QScriptDebuggerConsole *console,
 349         QScriptMessageHandlerInterface *messageHandler,
 350         QScriptDebuggerCommandSchedulerInterface *commandScheduler);
 351     ~QScriptDebuggerScriptedConsoleCommandJob();
 352
 353     int scheduleCommand(
 354         const QScriptDebuggerCommand &command,
 355         QScriptDebuggerResponseHandlerInterface *responseHandler);
 356
 357     void start();
 358     void handleResponse(const QScriptDebuggerResponse &response,
 359                         int commandId);
 360
 361 private:
 362     Q_DECLARE_PRIVATE(QScriptDebuggerScriptedConsoleCommandJob)
 363     Q_DISABLE_COPY(QScriptDebuggerScriptedConsoleCommandJob)
 364 };
 365
 366 class QScriptDebuggerScriptedConsoleCommandJobPrivate
 367     : public QScriptDebuggerConsoleCommandJobPrivate
 368 {
 369 public:
 370     QScriptDebuggerScriptedConsoleCommandJobPrivate() : command(0), commandCount(0) {}
 371     ~QScriptDebuggerScriptedConsoleCommandJobPrivate() {}
 372
 373     QScriptDebuggerScriptedConsoleCommandPrivate *command;
 374     QStringList arguments;
 375     int commandCount;
 376 };
 377
 378 QScriptDebuggerScriptedConsoleCommandJob::QScriptDebuggerScriptedConsoleCommandJob(
 379     QScriptDebuggerScriptedConsoleCommandPrivate *command,
 380     const QStringList &arguments,
 381     QScriptDebuggerConsole *console,
 382     QScriptMessageHandlerInterface *messageHandler,
 383     QScriptDebuggerCommandSchedulerInterface *commandScheduler)
 384     : QScriptDebuggerConsoleCommandJob(*new QScriptDebuggerScriptedConsoleCommandJobPrivate,
 385                                        console, messageHandler, commandScheduler)
 386 {
 387     Q_D(QScriptDebuggerScriptedConsoleCommandJob);
 388     d->command = command;
 389     d->arguments = arguments;
 390 }
 391
 392 QScriptDebuggerScriptedConsoleCommandJob::~QScriptDebuggerScriptedConsoleCommandJob()
 393 {
 394 }
 395
 396 int QScriptDebuggerScriptedConsoleCommandJob::scheduleCommand(
 397     const QScriptDebuggerCommand &command,
 398     QScriptDebuggerResponseHandlerInterface *responseHandler)
 399 {
 400     Q_D(QScriptDebuggerScriptedConsoleCommandJob);
 401     ++d->commandCount;
 402     return commandScheduler()->scheduleCommand(command, responseHandler);
 403 }
 404
 405 void QScriptDebuggerScriptedConsoleCommandJob::start()
 406 {
 407     Q_D(QScriptDebuggerScriptedConsoleCommandJob);
 408     QScriptEngine *engine = d->command->engine;
 409     QScriptValueList args;
 410     for (int i = 0; i < d->arguments.size(); ++i)
 411         args.append(QScriptValue(engine, d->arguments.at(i)));
 412     QScriptDebuggerConsoleGlobalObject *global;
 413     global = qobject_cast<QScriptDebuggerConsoleGlobalObject*>(engine->globalObject().toQObject());
 414     Q_ASSERT(global != 0);
 415     global->setScheduler(this);
 416     global->setResponseHandler(this);
 417     global->setMessageHandler(d->messageHandler);
 418     global->setConsole(d->console);
 419     d->commandCount = 0;
 420     QScriptValue ret = d->command->execFunction.call(QScriptValue(), args);
 421     global->setScheduler(0);
 422     global->setResponseHandler(0);
 423     global->setMessageHandler(0);
 424     global->setConsole(0);
 425     if (ret.isError()) {
 426         qWarning("*** internal error: %s", qPrintable(ret.toString()));
 427     }
 428     if (d->commandCount == 0)
 429         finish();
 430 }
 431
 432 void QScriptDebuggerScriptedConsoleCommandJob::handleResponse(
 433     const QScriptDebuggerResponse &response,
 434     int commandId)
 435 {
 436     Q_D(QScriptDebuggerScriptedConsoleCommandJob);
 437     // ### generalize
 438     QScriptEngine *engine = d->command->engine;
 439     QScriptValueList args;
 440     args.append(qScriptValueFromValue(engine, response));
 441     args.append(QScriptValue(engine, commandId));
 442     QScriptDebuggerConsoleGlobalObject *global;
 443     global = qobject_cast<QScriptDebuggerConsoleGlobalObject*>(engine->globalObject().toQObject());
 444     Q_ASSERT(global != 0);
 445     global->setScheduler(this);
 446     global->setResponseHandler(this);
 447     global->setMessageHandler(d->messageHandler);
 448     global->setConsole(d->console);
 449     d->commandCount = 0;
 450     QScriptValue ret = d->command->responseFunction.call(QScriptValue(), args);
 451     global->setScheduler(0);
 452     global->setResponseHandler(0);
 453     global->setMessageHandler(0);
 454     global->setConsole(0);
 455     if (ret.isError()) {
 456         qWarning("*** internal error: %s", qPrintable(ret.toString()));
 457     }
 458     if (d->commandCount == 0)
 459         finish();
 460 }
 461
 462 /*!
 463   \internal
 464 */
 465 QString QScriptDebuggerScriptedConsoleCommand::name() const
 466 {
 467     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 468     return d->name;
 469 }
 470
 471 /*!
 472   \internal
 473 */
 474 QString QScriptDebuggerScriptedConsoleCommand::group() const
 475 {
 476     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 477     return d->group;
 478 }
 479
 480 /*!
 481   \internal
 482 */
 483 QString QScriptDebuggerScriptedConsoleCommand::shortDescription() const
 484 {
 485     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 486     return d->shortDescription;
 487 }
 488
 489 /*!
 490   \internal
 491 */
 492 QString QScriptDebuggerScriptedConsoleCommand::longDescription() const
 493 {
 494     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 495     return d->longDescription;
 496 }
 497
 498 /*!
 499   \internal
 500 */
 501 QStringList QScriptDebuggerScriptedConsoleCommand::aliases() const
 502 {
 503     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 504     return d->aliases;
 505 }
 506
 507 /*!
 508   \internal
 509 */
 510 QStringList QScriptDebuggerScriptedConsoleCommand::seeAlso() const
 511 {
 512     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 513     return d->seeAlso;
 514 }
 515
 516 /*!
 517   \internal
 518 */
 519 QStringList QScriptDebuggerScriptedConsoleCommand::argumentTypes() const
 520 {
 521     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 522     return d->argumentTypes;
 523 }
 524
 525 /*!
 526   \internal
 527 */
 528 QStringList QScriptDebuggerScriptedConsoleCommand::subCommands() const
 529 {
 530     Q_D(const QScriptDebuggerScriptedConsoleCommand);
 531     return d->subCommands;
 532 }
 533
 534 /*!
 535   \internal
 536 */
 537 QScriptDebuggerConsoleCommandJob *QScriptDebuggerScriptedConsoleCommand::createJob(
 538     const QStringList &arguments,
 539     QScriptDebuggerConsole *console,
 540     QScriptMessageHandlerInterface *messageHandler,
 541     QScriptDebuggerCommandSchedulerInterface *commandScheduler)
 542 {
 543     Q_D(QScriptDebuggerScriptedConsoleCommand);
 544     return new QScriptDebuggerScriptedConsoleCommandJob(
 545         d, arguments, console, messageHandler, commandScheduler);
 546 }
 547
 548 /*!
 549   Parses a command defined by the given \a program.
 550   Returns an object that encapsulates the command, or 0 if parsing failed.
 551 */
 552 QScriptDebuggerScriptedConsoleCommand *QScriptDebuggerScriptedConsoleCommand::parse(
 553     const QString &program, const QString &fileName,
 554     QScriptMessageHandlerInterface *messageHandler)
 555 {
 556     QScriptEngine *engine = new QScriptEngine();
 557     // create a custom global object
 558     QScriptDebuggerConsoleGlobalObject *cppGlobal = new QScriptDebuggerConsoleGlobalObject();
 559     QScriptValue global = engine->newQObject(cppGlobal,
 560                                              QScriptEngine::ScriptOwnership,
 561                                              QScriptEngine::ExcludeSuperClassContents);
 562     {
 563         QScriptValueIterator it(engine->globalObject());
 564         while (it.hasNext()) {
 565             it.next();
 566             global.setProperty(it.scriptName(), it.value(), it.flags());
 567         }
 568     }
 569     engine->setGlobalObject(global);
 570
 571     cppGlobal->setMessageHandler(messageHandler);
 572     QScriptValue ret = engine->evaluate(program, fileName);
 573     cppGlobal->setMessageHandler(0);
 574     if (engine->hasUncaughtException()) {
 575         messageHandler->message(QtCriticalMsg, ret.toString(), fileName,
 576                                 engine->uncaughtExceptionLineNumber());
 577         delete engine;
 578         return 0;
 579     }
 580
 581     QScriptValue name = global.property(QLatin1String("name"));
 582     if (!name.isString()) {
 583         messageHandler->message(QtCriticalMsg, QLatin1String("command definition lacks a name"), fileName);
 584         delete engine;
 585         return 0;
 586     }
 587     QString nameStr = name.toString();
 588
 589     QScriptValue group = global.property(QLatin1String("group"));
 590     if (!group.isString()) {
 591         messageHandler->message(QtCriticalMsg, QString::fromLatin1("definition of command \"%0\" lacks a group name")
 592                                 .arg(nameStr), fileName);
 593         delete engine;
 594         return 0;
 595     }
 596     QString groupStr = group.toString();
 597
 598     QScriptValue shortDesc = global.property(QLatin1String("shortDescription"));
 599     if (!shortDesc.isString()) {
 600         messageHandler->message(QtCriticalMsg, QString::fromLatin1("definition of command \"%0\" lacks shortDescription")
 601                                 .arg(nameStr), fileName);
 602         delete engine;
 603         return 0;
 604     }
 605     QString shortDescStr = shortDesc.toString();
 606
 607     QScriptValue longDesc = global.property(QLatin1String("longDescription"));
 608     if (!longDesc.isString()) {
 609         messageHandler->message(QtCriticalMsg, QString::fromLatin1("definition of command \"%0\" lacks longDescription")
 610                                 .arg(nameStr), fileName);
 611         delete engine;
 612         return 0;
 613     }
 614     QString longDescStr = longDesc.toString();
 615
 616     QStringList aliases;
 617     qScriptValueToSequence(global.property(QLatin1String("aliases")), aliases);
 618
 619     QStringList seeAlso;
 620     qScriptValueToSequence(global.property(QLatin1String("seeAlso")), seeAlso);
 621
 622     QStringList argTypes;
 623     qScriptValueToSequence(global.property(QLatin1String("argumentTypes")), argTypes);
 624
 625     QStringList subCommands;
 626     qScriptValueToSequence(global.property(QLatin1String("subCommands")), subCommands);
 627
 628     QScriptValue execFunction = global.property(QLatin1String("execute"));
 629     if (!execFunction.isFunction()) {
 630         messageHandler->message(QtCriticalMsg, QString::fromLatin1("definition of command \"%0\" lacks execute() function")
 631                                 .arg(nameStr), fileName);
 632         delete engine;
 633         return 0;
 634     }
 635
 636     QScriptValue responseFunction = global.property(QLatin1String("handleResponse"));
 637
 638     QScriptDebuggerScriptedConsoleCommand *result = new QScriptDebuggerScriptedConsoleCommand(
 639         nameStr, groupStr,
 640         shortDescStr, longDescStr,
 641         aliases, seeAlso,
 642         argTypes, subCommands,
 643         execFunction, responseFunction);
 644     return result;
 645 }
 646
 647 QT_END_NAMESPACE