GIT_REPOSITORIES/LPP/PythonQt Commit - r162:1182b71738ca

merged contributions from https://github.com/commontk/PythonQt/compare/svn-mirror...patched...

florianlink -

r162:1182b71738ca

parent child

Context file:

r162:1182b71738ca

Collapse all files

generator/main.cpp +14 -8

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $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 "main.h"
             #include "asttoxml.h"
             #include "reporthandler.h"
             #include "typesystem.h"
             #include "generatorset.h"
             #include "fileout.h"
             #include <QDir>
             void displayHelp(GeneratorSet *generatorSet);
             #include <QDebug>
             int main(int argc, char *argv[])
+            {
                 GeneratorSet *gs = GeneratorSet::getInstance();
                 QString default_file = ":/trolltech/generator/qtscript_masterinclude.h";
                 QString default_system = ":/trolltech/generator/build_all.txt";
                 QString fileName;
                 QString typesystemFileName;
                 QString pp_file = ".preprocessed.tmp";
                 QStringList rebuild_classes;
                 QMap<QString, QString> args;
                 int argNum = 0;
                 for (int i=1; i<argc; ++i) {
                     QString arg(argv[i]);
                     arg = arg.trimmed();
                     if( arg.startsWith("--") ) {
                         int split = arg.indexOf("=");
                         if( split > 0 )
                             args[arg.mid(2).left(split-2)] = arg.mid(split + 1).trimmed();
                         else
                             args[arg.mid(2)] = QString();
                     } else if( arg.startsWith("-")) {
                         args[arg.mid(1)] = QString();
                     } else {
                         argNum++;
                         args[QString("arg-%1").arg(argNum)] = arg;
                     }
                 }
                 if (args.contains("no-suppress-warnings")) {
                     TypeDatabase *db = TypeDatabase::instance();
                     db->setSuppressWarnings(false);
                 }
                 if (args.contains("debug-level")) {
                     QString level = args.value("debug-level");
                     if (level == "sparse")
                         ReportHandler::setDebugLevel(ReportHandler::SparseDebug);
                     else if (level == "medium")
                         ReportHandler::setDebugLevel(ReportHandler::MediumDebug);
                     else if (level == "full")
                         ReportHandler::setDebugLevel(ReportHandler::FullDebug);
+                }
                 if (args.contains("dummy")) {
                     FileOut::dummy = true;
                 }
                 if (args.contains("diff")) {
                     FileOut::diff = true;
                 }
                 if (args.contains("license"))
                     FileOut::license = true;
                 if (args.contains("rebuild-only")) {
                     QStringList classes = args.value("rebuild-only").split(",", QString::SkipEmptyParts);
                     TypeDatabase::instance()->setRebuildClasses(classes);
                 }
                 fileName = args.value("arg-1");
                 typesystemFileName = args.value("arg-2");
                 if (args.contains("arg-3"))
                     displayHelp(gs);
                 if (fileName.isEmpty())
                     fileName = default_file;
                 if (typesystemFileName.isEmpty())
                     typesystemFileName = default_system;
                 if (fileName.isEmpty() || typesystemFileName.isEmpty() )
                     displayHelp(gs);
                 if (!gs->readParameters(args))
                     displayHelp(gs);
                 printf("Please wait while source files are being generated...\n");
+                printf("Parsing typesystem file [%s]\n", qPrintable(typesystemFileName));
                 if (!TypeDatabase::instance()->parseFile(typesystemFileName))
                     qFatal("Cannot parse file: '%s'", qPrintable(typesystemFileName));
+                printf("PreProcessing - Generate [%s] using [%s] and include-paths [%s]\n",
+                  qPrintable(pp_file), qPrintable(fileName), qPrintable(args.value("include-paths")));
                 if (!Preprocess::preprocess(fileName, pp_file, args.value("include-paths"))) {
                     fprintf(stderr, "Preprocessor failed on file: '%s'\n", qPrintable(fileName));
                     return 1;
                 }
                 if (args.contains("ast-to-xml")) {
-            	astToXML(pp_file);
+                  printf("Running ast-to-xml on file [%s] using pp_file [%s] and include-paths [%s]\n",
-            	return 0;
+                    qPrintable(fileName), qPrintable(pp_file), qPrintable(args.value("include-paths")));
+                  astToXML(pp_file);
+                  return 0;
                 }
+                printf("Building model using [%s]\n", qPrintable(pp_file));
                 gs->buildModel(pp_file);
                 if (args.contains("dump-object-tree")) {
                     gs->dumpObjectTree();
                     return 0;
                 }
                 printf("%s\n", qPrintable(gs->generate()));
                 printf("Done, %d warnings (%d known issues)\n", ReportHandler::warningCount(),
                        ReportHandler::suppressedCount());
             }
             void displayHelp(GeneratorSet* generatorSet) {
             #if defined(Q_OS_WIN32)
                 char path_splitter = ';';
             #else
                 char path_splitter = ':';
             #endif
                 printf("Usage:\n  generator [options] header-file typesystem-file\n\n");
                 printf("Available options:\n\n");
                 printf("General:\n");
                 printf("  --debug-level=[sparse|medium|full]        \n"
                        "  --dump-object-tree                        \n"
                        "  --help, -h or -?                          \n"
                        "  --no-suppress-warnings                    \n"
                        "  --output-directory=[dir]                  \n"
                        "  --include-paths=<path>[%c<path>%c...]     \n"
                        "  --print-stdout                            \n",
                        path_splitter, path_splitter);
                 printf("%s", qPrintable( generatorSet->usage()));
                 exit(0);
             }

generator/reporthandler.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $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 "reporthandler.h"
             #include "typesystem.h"
             int ReportHandler::m_warning_count = 0;
             int ReportHandler::m_suppressed_count = 0;
             QString ReportHandler::m_context;
             ReportHandler::DebugLevel ReportHandler::m_debug_level = NoDebug;
             QSet<QString> ReportHandler::m_reported_warnings;
             void ReportHandler::warning(const QString &text)
             {
                 QString warningText = QString("WARNING(%1) :: %2").arg(m_context).arg(text);
                 TypeDatabase *db = TypeDatabase::instance();
                 if (db && db->isSuppressedWarning(warningText)) {
                     ++m_suppressed_count;
                 } else if (!m_reported_warnings.contains(warningText)) {
-                    qDebug(qPrintable(warningText));
+                    qDebug("%s", qPrintable(warningText));
                     ++m_warning_count;
                     m_reported_warnings.insert(warningText);
                 }
             }
             void ReportHandler::debug(DebugLevel level, const QString &text)
             {
                 if (m_debug_level == NoDebug)
                     return;
                 if (level <= m_debug_level)
                     qDebug(" - DEBUG(%s) :: %s", qPrintable(m_context), qPrintable(text));
             }

generator/setupgenerator.cpp +4 -2

             /****************************************************************************
             **
             ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
             ** All rights reserved.
             ** Contact: Nokia Corporation (qt-info@nokia.com)
             **
             ** This file is part of the Qt Script Generator project on Qt Labs.
             **
             ** $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 "setupgenerator.h"
             #include "shellgenerator.h"
             #include "reporthandler.h"
             #include "fileout.h"
             //#define Q_SCRIPT_LAZY_GENERATOR
             void SetupGenerator::addClass(const QString& package, const AbstractMetaClass *cls)
             {
               packHash[package].append(cls);
             }
             void maybeDeclareMetaType(QTextStream &stream, const QString &typeName,
                                       QSet<QString> &registeredTypeNames);
             bool hasDefaultConstructor(const AbstractMetaClass *meta_class);
             static QStringList getOperatorCodes(const AbstractMetaClass* cls) {
               QSet<QString> operatorCodes;
               AbstractMetaFunctionList returned;
               AbstractMetaFunctionList functions = cls->functions();
               foreach (AbstractMetaFunction *function, functions) {
                 if (function->originalName().startsWith("operator")) {
                   QString op = function->originalName().mid(8);
                   operatorCodes.insert(op);
                 }
               }
               QSet<QString> r;
               foreach(QString op, operatorCodes.toList()) {
                 if (op == ">" || op == "<" || op == ">=" || op == "<=" || op == "==" || op == "!=") {
                   r.insert("PythonQt::Type_RichCompare");
                 } else if (op == "+") {
                   r.insert("PythonQt::Type_Add");
                 } else if (op == "-") {
                   r.insert("PythonQt::Type_Subtract");
                 } else if (op == "/") {
                   r.insert("PythonQt::Type_Divide");
                 } else if (op == "*") {
                   r.insert("PythonQt::Type_Multiply");
                 } else if (op == "%") {
                   r.insert("PythonQt::Type_Mod");
                 } else if (op == "&") {
                   r.insert("PythonQt::Type_And");
                 } else if (op == "|") {
                   r.insert("PythonQt::Type_Or");
                 } else if (op == "^") {
                   r.insert("PythonQt::Type_Xor");
                 } else if (op == "~") {
                   r.insert("PythonQt::Type_Invert");
                 } else if (op == "+=") {
                   r.insert("PythonQt::Type_InplaceAdd");
                 } else if (op == "-=") {
                   r.insert("PythonQt::Type_InplaceSubtract");
                 } else if (op == "/=") {
                   r.insert("PythonQt::Type_InplaceDivide");
                 } else if (op == "*=") {
                   r.insert("PythonQt::Type_InplaceMultiply");
                 } else if (op == "%=") {
                   r.insert("PythonQt::Type_InplaceMod");
                 } else if (op == "&=") {
                   r.insert("PythonQt::Type_InplaceAnd");
                 } else if (op == "|=") {
                   r.insert("PythonQt::Type_InplaceOr");
                 } else if (op == "^=") {
                   r.insert("PythonQt::Type_InplaceXor");
                 }
               }
               if (cls->hasDefaultIsNull()) {
                 r.insert("PythonQt::Type_NonZero");
               }
               QStringList result = r.toList();
               return result;
             }
             static bool class_less_than(const AbstractMetaClass *a, const AbstractMetaClass *b)
             {
               return a->name() < b->name();
             }
             void SetupGenerator::generate()
             {
               AbstractMetaClassList classes_with_polymorphic_id;
               {
                 QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
                 while (pack.hasNext()) {
                   pack.next();
                   QList<const AbstractMetaClass*> list = pack.value();
                   foreach (const AbstractMetaClass *cls, list) {
                     if (cls->typeEntry()->isPolymorphicBase()) {
                       classes_with_polymorphic_id.append((AbstractMetaClass*)cls);
                     }
                   }
                 }
               }
               qSort(classes_with_polymorphic_id.begin(), classes_with_polymorphic_id.end(), class_less_than);
               QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
               while (pack.hasNext()) {
                 pack.next();
                 QList<const AbstractMetaClass*> list = pack.value();
                 if (list.isEmpty())
                   continue;
                 qSort(list.begin(), list.end(), class_less_than);
                 QString packKey = pack.key();
                 QString packName = pack.key();
                 QStringList components = packName.split("_");
                 if ((components.size() > 2) && (components.at(0) == "com")
                   && (components.at(1) == "trolltech")) {
                     // kill com.trolltech in key
                     components.removeAt(0);
                     components.removeAt(0);
                 }
                 QString shortPackName;
                 foreach (QString comp, components) {
                   comp[0] = comp[0].toUpper();
                   shortPackName += comp;
                 }
                 // add missing camel case (workaround..)
                 if (shortPackName == "QtWebkit") {
                   shortPackName = "QtWebKit";
                 } else if (shortPackName == "QtXmlpatterns") {
                   shortPackName = "QtXmlPatterns";
                 } else if (shortPackName == "QtOpengl") {
                   shortPackName = "QtOpenGL";
                 } else if (shortPackName == "QtUitools") {
                   shortPackName = "QtUiTools";
                 }
                 {
-                  FileOut initFile(m_out_dir + "/generated_cpp/" + packName + "/" + packKey + "_init.cpp");
+                  QString fileName(packName + "/" + packKey + "_init.cpp");
+                  FileOut initFile(m_out_dir + "/generated_cpp/" + fileName);
+                  ReportHandler::debugSparse(QString("generating: %1").arg(fileName));
                   QTextStream &s = initFile.stream;
                   s << "#include <PythonQt.h>" << endl;
                   for (int i=0; i<(list.count()+MAX_CLASSES_PER_FILE-1) / MAX_CLASSES_PER_FILE; i++) {
                     s << "#include \"" << packKey << QString::number(i) << ".h\"" << endl;
                   }
                   s << endl;
                   QStringList polymorphicHandlers;
                   if (!packName.endsWith("_builtin")) {
                     polymorphicHandlers = writePolymorphicHandler(s, list.at(0)->package(), classes_with_polymorphic_id, list);
                     s << endl;
                   }
                   // declare individual class creation functions
                   s << "void PythonQt_init_" << shortPackName << "(PyObject* module) {" << endl;
                   if (shortPackName.endsWith("Builtin")) {
                     shortPackName = shortPackName.mid(0, shortPackName.length()-strlen("builtin"));
                   }
                   QStringList cppClassNames;
                   foreach (const AbstractMetaClass *cls, list) {
                     QString shellCreator;
                     if (cls->generateShellClass()) {
                       shellCreator = ", PythonQtSetInstanceWrapperOnShell<" + ShellGenerator::shellClassName(cls) + ">";
                     } else {
                       shellCreator = ", NULL";
                     }
                     QString operatorCodes = getOperatorCodes(cls).join("|");
                     if (operatorCodes.isEmpty()) {
                       operatorCodes = "0";
                     }
                     if (cls->isQObject()) {
                       s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
                     } else {
                       QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";
                       s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
                     }
                     foreach(AbstractMetaClass* interface, cls->interfaces()) {
                       // the interface might be our own class... (e.g. QPaintDevice)
                       if (interface->qualifiedCppName() != cls->qualifiedCppName()) {
                         s << "PythonQt::self()->addParentClass(\""<< cls->qualifiedCppName() << "\", \"" << interface->qualifiedCppName() << "\",PythonQtUpcastingOffset<" << cls->qualifiedCppName() <<","<<interface->qualifiedCppName()<<">());" << endl;
                       }
                     }
                   }
                   s << endl;
                   foreach (QString handler, polymorphicHandlers) {
                     s << "PythonQt::self()->addPolymorphicHandler(\""<< handler << "\", polymorphichandler_" << handler << ");" << endl;
                   }
                   s << "}";
                   s << endl;
                 }
               }
             }
             QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QString &package,
                                                                 const AbstractMetaClassList &polybase, QList<const AbstractMetaClass*>& allClasses)
             {
               QStringList handlers;
               foreach (AbstractMetaClass *cls, polybase) {
                 const ComplexTypeEntry *centry = cls->typeEntry();
                 if (!centry->isPolymorphicBase())
                   continue;
                 bool isGraphicsItem = (cls->qualifiedCppName()=="QGraphicsItem");
                 bool first = true;
                 foreach (const AbstractMetaClass *clazz, allClasses) {
                   bool inherits = false;
                   if (isGraphicsItem) {
                     foreach(AbstractMetaClass* interfaze, clazz->interfaces()) {
                       if (interfaze->qualifiedCppName()=="QGraphicsItem") {
                         inherits = true;
                         break;
                       }
                     }
                   } else {
                     inherits = clazz->inheritsFrom(cls);
                   }
                   if (clazz->package() == package && inherits) {
                     if (!clazz->typeEntry()->polymorphicIdValue().isEmpty() || isGraphicsItem) {
                       // On first find, open the function
                       if (first) {
                         first = false;
                         QString handler = cls->name();
                         handlers.append(handler);
                         s << "static void* polymorphichandler_" << handler
-                          << "(const void *ptr, char **class_name)" << endl
+                          << "(const void *ptr, const char **class_name)" << endl
                           << "{" << endl
                           << "    Q_ASSERT(ptr != 0);" << endl
                           << "    " << cls->qualifiedCppName() << " *object = ("
                           << cls->qualifiedCppName() << " *)ptr;" << endl;
                       }
                       // For each, add case label
                       QString polyId = clazz->typeEntry()->polymorphicIdValue();
                       if (isGraphicsItem) {
                         polyId = "%1->type() == " + clazz->qualifiedCppName() + "::Type";
                       }
                       s << "    if ("
                         << polyId.replace("%1", "object")
                         << ") {" << endl
                         << "        *class_name = \"" << clazz->name() << "\";" << endl
                         << "        return (" << clazz->qualifiedCppName() << "*)object;" << endl
                         << "    }" << endl;
                     } else {
                       QString warning = QString("class '%1' inherits from polymorphic class '%2', but has no polymorphic id set")
                         .arg(clazz->name())
                         .arg(cls->name());
                       ReportHandler::warning(warning);
                     }
                   }
                 }
                 // Close the function if it has been opened
                 if (!first) {
                   s << "    return NULL;" << endl
                     << "}" << endl;
                 }
               }
               return handlers;
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages