qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/generatorvisitor.h

@@ -0,0 +1,119 @@
+/*
+    Copyright (C) 2009  Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef PARSERVISITOR_H
+#define PARSERVISITOR_H
+
+#include <QStringList>
+#include <QStack>
+
+#include <default_visitor.h>
+#include <parsesession.h>
+#include <lexer.h>
+
+#include "type.h"
+
+class NameCompiler;
+class TypeCompiler;
+
+struct QProperty
+{
+    QString type;
+    bool isPtr;
+    QString name;
+    QString read;
+    QString write;
+};
+
+class GeneratorVisitor : public DefaultVisitor
+{
+public:
+    GeneratorVisitor(ParseSession *session, const QString& header = QString());
+    virtual ~GeneratorVisitor();
+    BasicTypeDeclaration* resolveTypeInSuperClasses(const Class* klass, const QString& name);
+    BasicTypeDeclaration* resolveType(const QString& name);
+    BasicTypeDeclaration* resolveType(QString& name);
+    QString resolveEnumMember(const QString& name);
+    QString resolveEnumMember(const QString& parent, const QString& name);
+    QPair<bool, bool> parseCv(const ListNode<std::size_t> *cv);
+
+protected:
+    inline const Token& token(std::size_t token) { return m_session->token_stream->token(token); }
+
+    virtual void visitAccessSpecifier(AccessSpecifierAST* node);
+    virtual void visitBaseSpecifier(BaseSpecifierAST* node);
+    virtual void visitClassSpecifier(ClassSpecifierAST* node);
+    virtual void visitDeclarator(DeclaratorAST* node);
+    virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST* node);
+    virtual void visitEnumSpecifier(EnumSpecifierAST *);
+    virtual void visitEnumerator(EnumeratorAST *);
+    virtual void visitFunctionDefinition(FunctionDefinitionAST* );
+    virtual void visitInitializerClause(InitializerClauseAST *);
+    virtual void visitNamespace(NamespaceAST* node);
+    virtual void visitParameterDeclaration(ParameterDeclarationAST* node);
+    virtual void visitSimpleDeclaration(SimpleDeclarationAST* node);
+    virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST* node);
+    virtual void visitTemplateDeclaration(TemplateDeclarationAST* node);
+    virtual void visitTemplateArgument(TemplateArgumentAST* node);
+    virtual void visitTypedef(TypedefAST* node);
+    virtual void visitUsing(UsingAST* node);
+    virtual void visitUsingDirective(UsingDirectiveAST* node);
+
+private:
+    NameCompiler *nc;
+    TypeCompiler *tc;
+    
+    ParseSession *m_session;
+    QString m_header;
+    
+    bool createType;
+    bool createTypedef;
+    short inClass;
+    
+    bool inTemplate;
+    bool isStatic;
+    bool isVirtual;
+    bool isExplicit;
+    bool hasInitializer;
+    
+    Type currentType;
+    Type* currentTypeRef;
+    
+    bool inMethod;
+    Method currentMethod;
+    
+    Function currentFunction;
+    
+    Enum currentEnum;
+    Enum* currentEnumRef;
+    
+    Class::Kind kind;
+    QStack<Class*> klass;
+    QStack<Access> access;
+    QStack<bool> inSignals;
+    QStack<bool> inSlots;
+    
+    QStack<QStringList> usingTypes;
+    QStack<QStringList> usingNamespaces;
+    
+    QStringList nspace;
+    
+    QStack<QList<QProperty> > q_properties;
+};
+
+#endif // PARSERVISITOR_H

data/ext/generator/main.cpp

@@ -0,0 +1,239 @@
+/*
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <QCoreApplication>
+#include <QList>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QLibrary>
+
+#include <QtXml>
+
+#include <QtDebug>
+
+#include <control.h>
+#include <parsesession.h>
+#include <parser.h>
+#include <ast.h>
+
+#include <iostream>
+
+#include "generatorpreprocessor.h"
+#include "generatorvisitor.h"
+#include "options.h"
+
+typedef int (*GenerateFn)();
+
+static void showUsage()
+{
+    std::cout << 
+    "Usage: smokegen [options] -- <header files>" << std::endl <<
+    "Possible command line options are:" << std::endl <<
+    "    -I <include dir>" << std::endl <<
+    "    -d <path to file containing #defines>" << std::endl <<
+    "    -dm <list of macros that should be ignored>" << std::endl <<
+    "    -g <generator to use>" << std::endl <<
+    "    -qt enables Qt-mode (special treatment of QFlags)" << std::endl <<
+    "    -t resolve typedefs" << std::endl <<
+    "    -o <output dir>" << std::endl <<
+    "    -config <config file>" << std::endl <<
+    "    -h shows this message" << std::endl;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc == 1) {
+        showUsage();
+        return EXIT_SUCCESS;
+    }
+
+    QCoreApplication app(argc, argv);
+    const QStringList& args = app.arguments();
+
+    QFileInfo configFile;
+    QString generator;
+    bool addHeaders = false;
+    bool hasCommandLineGenerator = false;
+    QStringList classes;
+
+    for (int i = 1; i < args.count(); i++) {
+        if ((args[i] == "-I" || args[i] == "-d" || args[i] == "-dm" ||
+             args[i] == "-g" || args[i] == "-config") && i + 1 >= args.count())
+        {
+            qCritical() << "not enough parameters for option" << args[i];
+            return EXIT_FAILURE;
+        }
+        if (args[i] == "-I") {
+            ParserOptions::includeDirs << QDir(args[++i]);
+        } else if (args[i] == "-config") {
+            configFile = QFileInfo(args[++i]);
+        } else if (args[i] == "-d") {
+            ParserOptions::definesList = QFileInfo(args[++i]);
+        } else if (args[i] == "-dm") {
+            ParserOptions::dropMacros += args[++i].split(',');
+        } else if (args[i] == "-g") {
+            generator = args[++i];
+            hasCommandLineGenerator = true;
+        } else if ((args[i] == "-h" || args[i] == "--help") && argc == 2) {
+            showUsage();
+            return EXIT_SUCCESS;
+        } else if (args[i] == "-t") {
+            ParserOptions::resolveTypedefs = true;
+        } else if (args[i] == "-qt") {
+            ParserOptions::qtMode = true;
+        } else if (args[i] == "--") {
+            addHeaders = true;
+        } else if (addHeaders) {
+            ParserOptions::headerList << QFileInfo(args[i]);
+        }
+    }
+        
+    if (configFile.exists()) {
+        QFile file(configFile.filePath());
+        file.open(QIODevice::ReadOnly);
+        QDomDocument doc;
+        doc.setContent(file.readAll());
+        file.close();
+        QDomElement root = doc.documentElement();
+        QDomNode node = root.firstChild();
+        while (!node.isNull()) {
+            QDomElement elem = node.toElement();
+            if (elem.isNull()) {
+                node = node.nextSibling();
+                continue;
+            }
+            if (elem.tagName() == "resolveTypedefs") {
+                ParserOptions::resolveTypedefs = (elem.text() == "true");
+            } else if (elem.tagName() == "qtMode") {
+                ParserOptions::qtMode = (elem.text() == "true");
+            } else if (!hasCommandLineGenerator && elem.tagName() == "generator") {
+                generator = elem.text();
+            } else if (elem.tagName() == "includeDirs") {
+                QDomNode dir = elem.firstChild();
+                while (!dir.isNull()) {
+                    QDomElement elem = dir.toElement();
+                    if (elem.isNull()) {
+                        dir = dir.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "dir") {
+                        ParserOptions::includeDirs << QDir(elem.text());
+                    }
+                    dir = dir.nextSibling();
+                }
+            } else if (elem.tagName() == "definesList") {
+                // reference to an external file, so it can be auto-generated
+                ParserOptions::definesList = QFileInfo(elem.text());
+            } else if (elem.tagName() == "dropMacros") {
+                QDomNode macro = elem.firstChild();
+                while (!macro.isNull()) {
+                    QDomElement elem = macro.toElement();
+                    if (elem.isNull()) {
+                        macro = macro.nextSibling();
+                        continue;
+                    }
+                    if (elem.tagName() == "name") {
+                        ParserOptions::dropMacros << elem.text();
+                    }
+                    macro = macro.nextSibling();
+                }
+            }
+            node = node.nextSibling();
+        }
+    } else {
+        qWarning() << "Couldn't find config file" << configFile.filePath();
+    }
+
+    // first try to load plugins from the executable's directory
+    QLibrary lib(app.applicationDirPath() + "/generator_" + generator);
+    lib.load();
+    if (!lib.isLoaded()) {
+        lib.unload();
+        lib.setFileName(app.applicationDirPath() + "/../lib/smokegen/generator_" + generator);
+        lib.load();
+    }
+    if (!lib.isLoaded()) {
+        lib.unload();
+        lib.setFileName("generator_" + generator);
+        lib.load();
+    }
+    if (!lib.isLoaded()) {
+        qCritical() << lib.errorString();
+        return EXIT_FAILURE;
+    }
+    qDebug() << "using generator" << lib.fileName();
+    GenerateFn generate = (GenerateFn) lib.resolve("generate");
+    if (!generate) {
+        qCritical() << "couldn't resolve symbol 'generate', aborting";
+        return EXIT_FAILURE;
+    }
+    
+    foreach (QDir dir, ParserOptions::includeDirs) {
+        if (!dir.exists()) {
+            qWarning() << "include directory" << dir.path() << "doesn't exist";
+            ParserOptions::includeDirs.removeAll(dir);
+        }
+    }
+    
+    QStringList defines;
+    if (ParserOptions::definesList.exists()) {
+        QFile file(ParserOptions::definesList.filePath());
+        file.open(QIODevice::ReadOnly);
+        while (!file.atEnd()) {
+            QByteArray array = file.readLine();
+            if (!array.isEmpty())
+                defines << array.trimmed();
+        }
+        file.close();
+    } else if (!ParserOptions::definesList.filePath().isEmpty()) {
+        qWarning() << "didn't find file" << ParserOptions::definesList.filePath();
+    }
+    
+    QFile log("generator.log");
+    bool logErrors = log.open(QFile::WriteOnly | QFile::Truncate);
+    QTextStream logOut(&log);
+    
+    foreach (QFileInfo file, ParserOptions::headerList) {
+        qDebug() << "parsing" << file.absoluteFilePath();
+        // this has already been parsed because it was included by some header
+        if (parsedHeaders.contains(file.absoluteFilePath()))
+            continue;
+        Preprocessor pp(ParserOptions::includeDirs, defines, file);
+        Control c;
+        Parser parser(&c);
+        ParseSession session;
+        session.setContentsAndGenerateLocationTable(pp.preprocess());
+        TranslationUnitAST* ast = parser.parse(&session);
+        // TODO: improve 'header => class' association
+        GeneratorVisitor visitor(&session, file.fileName());
+        visitor.visit(ast);
+        
+        if (!logErrors)
+            continue;
+        
+        foreach (const Problem* p, c.problems()) {
+            logOut << file.fileName() << ": " << p->file << "(" << p->position.line << ", " << p->position.column << "): "
+                   << p->description << "\n";
+        }
+    }
+    
+    log.close();
+    
+    return generate();
+}

data/ext/generator/name_compiler.cpp

@@ -0,0 +1,205 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License version 2 as published by the Free Software Foundation.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+//krazy:excludeall=cpp
+
+#include "name_compiler.h"
+#include "type_compiler.h"
+#include <lexer.h>
+#include <symbol.h>
+#include <parsesession.h>
+#include <tokens.h>
+#include "type_compiler.h"
+
+#include <QtCore/qdebug.h>
+
+///@todo this is very expensive
+QString decode(ParseSession* session, AST* ast, bool without_spaces = false)
+{
+  QString ret;
+  if( without_spaces ) {
+    //Decode operator-names without spaces for now, since we rely on it in other places.
+    ///@todo change this, here and in all the places that rely on it. Operators should then by written like "operator [ ]"(space between each token)
+    for( size_t a = ast->start_token; a < ast->end_token; a++ ) {
+      ret += session->token_stream->token(a).symbolString();
+    }
+  } else {
+    for( size_t a = ast->start_token; a < ast->end_token; a++ ) {
+      ret += session->token_stream->token(a).symbolString() + ' ';
+    }
+  }
+  return ret;
+}
+
+/*uint parseConstVolatile(ParseSession* session, const ListNode<std::size_t> *cv)
+{
+  uint ret = AbstractType::NoModifiers;
+
+  if (cv) {
+    const ListNode<std::size_t> *it = cv->toFront();
+    const ListNode<std::size_t> *end = it;
+    do {
+      int kind = session->token_stream->kind(it->element);
+      if (kind == Token_const)
+        ret |= AbstractType::ConstModifier;
+      else if (kind == Token_volatile)
+        ret |= AbstractType::VolatileModifier;
+
+      it = it->next;
+    } while (it != end);
+  }
+
+  return ret;
+}*/
+
+/*IndexedTypeIdentifier typeIdentifierFromTemplateArgument(ParseSession* session, TemplateArgumentAST *node)
+{
+  IndexedTypeIdentifier id;
+  if(node->expression) {
+    id = IndexedTypeIdentifier(decode(session, node), true);
+  }else if(node->type_id) {
+    //Parse the pointer operators
+    TypeCompiler tc(session);
+    tc.run(node->type_id->type_specifier);
+    id = IndexedTypeIdentifier(tc.identifier());
+    //node->type_id->type_specifier->cv
+    
+    if(node->type_id->type_specifier)
+      id.setIsConstant(parseConstVolatile(session, node->type_id->type_specifier->cv) & AbstractType::ConstModifier);
+    
+    if(node->type_id->declarator && node->type_id->declarator->ptr_ops)
+    {
+      const ListNode<PtrOperatorAST*> *it = node->type_id->declarator->ptr_ops->toFront();
+      const ListNode<PtrOperatorAST*> *end = it; ///@todo check ordering, eventually walk the list in reversed order
+      do
+        {
+          if(it->element && it->element->op) { ///@todo What about ptr-to-member?
+            static IndexedString ref('&');
+            if( session->token_stream->token(it->element->op).symbol() == ref) {
+              //We're handling a 'reference'
+              id.setIsReference(true);
+            } else {
+              //We're handling a real pointer
+              id.setPointerDepth(id.pointerDepth()+1);
+
+              if(it->element->cv) {
+                id.setIsConstPointer(id.pointerDepth()-1, parseConstVolatile(session, it->element->cv) & AbstractType::ConstModifier);
+              }
+            }
+          }
+          it = it->next;
+        }
+      while (it != end);
+    }
+  }
+  return id;
+}*/
+
+NameCompiler::NameCompiler(ParseSession* session, GeneratorVisitor* visitor)
+  : m_session(session), m_visitor(visitor)
+{
+}
+
+void NameCompiler::internal_run(AST *node)
+{
+  m_name.clear();
+  m_castType = Type();
+  m_templateArgs.clear();
+  visit(node);
+}
+
+void NameCompiler::visitUnqualifiedName(UnqualifiedNameAST *node)
+{
+  IndexedString tmp_name;
+
+  if (node->id)
+    tmp_name = m_session->token_stream->token(node->id).symbol();
+
+  if (node->tilde)
+    tmp_name = IndexedString('~' + tmp_name.byteArray());
+
+  if (OperatorFunctionIdAST *op_id = node->operator_id)
+    {
+#if defined(__GNUC__)
+#warning "NameCompiler::visitUnqualifiedName() -- implement me"
+#endif
+      static QString operatorString("operator");
+      QString tmp = operatorString;
+
+      if (op_id->op && op_id->op->op) {
+        tmp +=  decode(m_session, op_id->op, true);
+      } else {
+        TypeCompiler tc(m_session, m_visitor);
+        tc.run(op_id->type_specifier);
+        tc.run(op_id->ptr_ops);
+        m_castType = tc.type();
+        tmp += " " + tc.type().toString();
+      }
+
+      tmp_name = IndexedString(tmp);
+      m_typeSpecifier = op_id->type_specifier;
+    }
+
+  m_currentIdentifier = tmp_name.str();
+
+  if (node->template_arguments)
+    {
+      visitNodes(this, node->template_arguments);
+    }/*else if(node->end_token == node->start_token + 3 && node->id == node->start_token && m_session->token_stream->token(node->id+1).symbol() == KDevelop::IndexedString('<')) {
+      ///@todo Represent this nicer in the AST
+      ///It's probably a type-specifier with instantiation of the default-parameter, like "Bla<>".
+      m_currentIdentifier.appendTemplateIdentifier( IndexedTypeIdentifier() );
+    }*/
+
+  m_name.push_back(m_currentIdentifier);
+}
+
+TypeSpecifierAST* NameCompiler::lastTypeSpecifier() const {
+  return m_typeSpecifier;
+}
+
+void NameCompiler::visitTemplateArgument(TemplateArgumentAST *node)
+{
+    if (!node->type_id) {
+        QString ret;
+        for (int i = node->expression->start_token; i < node->expression->end_token; i++) {
+            ret.append(m_session->token_stream->token(i).symbolString());
+        }
+        // TODO: Better use a new struct here - expressions aren't really types.
+        m_templateArgs[m_name.count()] << Type(ret);
+        return;
+    }
+    TypeCompiler tc(m_session, m_visitor);
+    tc.run(node->type_id->type_specifier, node->type_id->declarator ? node->type_id->declarator : 0);
+    m_templateArgs[m_name.count()] << tc.type();
+}
+
+/*const QualifiedIdentifier& NameCompiler::identifier() const
+{
+  return *_M_name;
+}*/
+
+void NameCompiler::run(NameAST *node/*, QualifiedIdentifier* target*/)
+{
+//   if(target)
+//     _M_name = target;
+//   else
+//     _M_name = &m_localName;
+    
+  m_typeSpecifier = 0; internal_run(node); /*if(node && node->global) _M_name->setExplicitlyGlobal( node->global );*/
+}