main.cpp Example File
script/qscript/main.cpp

 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <qscriptengine.h>

 #include <QtCore/QFile>
 #include <QtCore/QTextStream>
 #include <QtCore/QStringList>
 #include <QtGui/QApplication>

 #include <stdlib.h>

 #include "bytearrayclass.h"

 static bool wantsToQuit;

 static QScriptValue qtscript_quit(QScriptContext *ctx, QScriptEngine *eng)
 {
     Q_UNUSED(ctx);
     wantsToQuit = true;
     return eng->undefinedValue();
 }

 static void interactive(QScriptEngine *eng)
 {
     QScriptValue global = eng->globalObject();
     QScriptValue quitFunction = eng->newFunction(qtscript_quit);
     if (!global.property(QLatin1String("exit")).isValid())
         global.setProperty(QLatin1String("exit"), quitFunction);
     if (!global.property(QLatin1String("quit")).isValid())
         global.setProperty(QLatin1String("quit"), quitFunction);
     wantsToQuit = false;

     QTextStream qin(stdin, QFile::ReadOnly);

     const char *qscript_prompt = "qs> ";
     const char *dot_prompt = ".... ";
     const char *prompt = qscript_prompt;

     QString code;

     forever {
         QString line;

         printf("%s", prompt);
         fflush(stdout);

         line = qin.readLine();
         if (line.isNull())
             break;

         code += line;
         code += QLatin1Char('\n');

         if (line.trimmed().isEmpty()) {
             continue;

         } else if (! eng->canEvaluate(code)) {
             prompt = dot_prompt;

         } else {
             QScriptValue result = eng->evaluate(code, QLatin1String("typein"));

             code.clear();
             prompt = qscript_prompt;

             if (! result.isUndefined())
                 fprintf(stderr, "%s\n", qPrintable(result.toString()));

             if (wantsToQuit)
                 break;
         }
     }
 }

 static QScriptValue importExtension(QScriptContext *context, QScriptEngine *engine)
 {
     return engine->importExtension(context->argument(0).toString());
 }

 static QScriptValue loadScripts(QScriptContext *context, QScriptEngine *engine)
 {
     for (int i = 0; i < context->argumentCount(); ++i) {
         QString fileName = context->argument(0).toString();
         QFile file(fileName);
         if (!file.open(QIODevice::ReadOnly))
             return context->throwError(QString::fromLatin1("could not open %0 for reading").arg(fileName));
         QTextStream ts(&file);
         QString contents = ts.readAll();
         file.close();
         QScriptContext *pc = context->parentContext();
         context->setActivationObject(pc->activationObject());
         context->setThisObject(pc->thisObject());
         QScriptValue ret = engine->evaluate(contents);
         if (engine->hasUncaughtException())
             return ret;
     }
     return engine->undefinedValue();
 }

 int main(int argc, char *argv[])
 {
     QApplication *app;
     if (argc >= 2 && !qstrcmp(argv[1], "-tty")) {
         ++argv;
        --argc;
         app = new QApplication(argc, argv, QApplication::Tty);
     } else {
         app = new QApplication(argc, argv);
     }

     QScriptEngine *eng = new QScriptEngine();

     QScriptValue globalObject = eng->globalObject();

     globalObject.setProperty("load", eng->newFunction(loadScripts, /*length=*/1));

     {
         if (!globalObject.property("qt").isObject())
             globalObject.setProperty("qt", eng->newObject());
         QScriptValue qscript = eng->newObject();
         qscript.setProperty("importExtension", eng->newFunction(importExtension));
         globalObject.property("qt").setProperty("script", qscript);
     }

     ByteArrayClass *byteArrayClass = new ByteArrayClass(eng);
     globalObject.setProperty("ByteArray", byteArrayClass->constructor());

     if (! *++argv) {
         interactive(eng);
         return EXIT_SUCCESS;
     }

     while (const char *arg = *argv++) {
         QString fn = QString::fromLocal8Bit(arg);

         if (fn == QLatin1String("-i")) {
             interactive(eng);
             break;
         }

         QString contents;
         int lineNumber = 1;

         if (fn == QLatin1String("-")) {
             QTextStream stream(stdin, QFile::ReadOnly);
             contents = stream.readAll();
         }

         else {
             QFile file(fn);

             if (file.open(QFile::ReadOnly)) {
                 QTextStream stream(&file);
                 contents = stream.readAll();
                 file.close();

                 // strip off #!/usr/bin/env qscript line
                 if (contents.startsWith("#!")) {
                     contents.remove(0, contents.indexOf("\n"));
                     ++lineNumber;
                 }
             }
         }

         if (contents.isEmpty())
             continue;

         QScriptValue r = eng->evaluate(contents, fn, lineNumber);
         if (eng->hasUncaughtException()) {
             QStringList backtrace = eng->uncaughtExceptionBacktrace();
             fprintf (stderr, "    %s\n%s\n\n", qPrintable(r.toString()),
                      qPrintable(backtrace.join("\n")));
             return EXIT_FAILURE;
         }
     }

     delete eng;
     delete app;

     return EXIT_SUCCESS;
 }