qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/parser/stringhelpers.h

@@ -0,0 +1,118 @@
+/*
+   Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
+
+   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.
+*/
+
+#ifndef __DUCHAIN_STRINGHELPERS_H__
+#define __DUCHAIN_STRINGHELPERS_H__
+
+#include "cppparser_export.h"
+
+#include <QtCore/QChar>
+
+class QString;
+class QStringList;
+
+/**
+searches a fitting closing brace from left to right: a ')' for '(', ']' for '[', ...
+*/
+int CPPPARSER_EXPORT findClose( const QString& str , int pos );
+
+/**
+ * Searches in the given string for a ',' or closing brace,
+ * while skipping everything between opened braces.
+ * @param str string to search
+ * @param pos position where to start searching
+ * @param validEnd when this is set differently, the function will stop when it finds a comma or the given character, and not at closing-braces.
+ * @return  On fail, str.length() is returned, else the position of the closing character.
+ * */
+int CPPPARSER_EXPORT findCommaOrEnd( const QString& str , int pos, QChar validEnd = ' ' );
+
+/**
+ * Skips in the string backwards over function-arguments, and stops at the right side of a "("
+ * @param skippedArguments Will contain all skipped arguments
+ * @param argumentsStart Should be set to the position where the seeking should start, will be changed to the right side of a "(" when found. Should be at the right side of a '(', and may be max. str.length()
+ * */
+void CPPPARSER_EXPORT skipFunctionArguments(QString str, QStringList& skippedArguments, int& argumentsStart );
+
+/**
+ * Removes white space at the beginning and end, and replaces contiguous inner white-spaces with single white-spaces. Newlines are treated as whitespaces, the returned text will have no more newlines.
+ * */
+QString CPPPARSER_EXPORT reduceWhiteSpace(QString str);
+
+QString CPPPARSER_EXPORT stripFinalWhitespace(QString str);
+
+/**
+ * Fills all c++-style comments  within the given code with the given 'replacement' character
+ * Newlines are preserved.
+ * */
+QString CPPPARSER_EXPORT clearComments( QString str, QChar replacement = ' ' );
+/**
+ * Fills all c++-strings within the given code with the given 'replacement' character
+ * Comments should have been removed before.
+ * */
+QString CPPPARSER_EXPORT clearStrings( QString str, QChar replacement = ' ' );
+
+/**
+ * Extracts the interesting information out of a comment.
+ * For example it removes all the stars at the beginning, and re-indents the text.
+ * */
+QString CPPPARSER_EXPORT formatComment( const QString& comment );
+
+/**
+ * Extracts the interesting information out of a comment.
+ * For example it removes all the stars at the beginning, and re-indents the text.
+ * */
+QByteArray CPPPARSER_EXPORT formatComment( const QByteArray& comment );
+
+/**
+ * Can be used to iterate through different kinds of parameters, for example template-parameters(By giving it "<>:")
+ * */
+class CPPPARSER_EXPORT ParamIterator
+{
+  public:
+    /**
+     * @param parens should be a string containing the two parens between which the parameters are searched. Example: "<>" or "()" Optionally it can also contain one third end-character. If that end-character is encountered in the prefix, the iteration will be stopped.
+     *
+     * Example: When "<>:" is given, ParamIterator will only parse the first identifier of a c++ scope
+     * */
+    ParamIterator( QString parens, QString source, int start = 0);
+    ~ParamIterator();
+
+    ParamIterator& operator ++();
+
+    /**
+     * Returns current found parameter
+     * */
+    QString operator *();
+
+    /**
+     * Returns whether there is a current found parameter
+     * */
+    operator bool() const;
+
+    /**
+     * Returns the text in front of the first opening-paren(if none found then the whole text)
+     * */
+    QString prefix() const;
+
+    uint position() const;
+
+  private:
+    class ParamIteratorPrivate* const d;
+};
+
+#endif

data/ext/generator/parser/symbol.h

@@ -0,0 +1,140 @@
+/* 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.
+*/
+
+#ifndef SYMBOL_H
+#define SYMBOL_H
+
+#include <QtCore/QString>
+#include <cstring>
+
+#include <QtCore/QHash>
+#include <QtCore/QPair>
+
+/**@file symbol.h Symbol table for the parser.*/
+
+/**
+Symbol in the parser symbol table.
+*/
+struct NameSymbol
+{
+  const char *data;
+  std::size_t count;
+
+  inline QString as_string() const
+  {
+    return QString::fromUtf8(data, count);
+  }
+
+  /**Required to put NameSymbol's into a QHash.*/
+  inline bool operator == (const NameSymbol &other) const
+  {
+    return count == other.count
+      && std::strncmp(data, other.data, count) == 0;
+  }
+
+protected:
+  inline NameSymbol() {}
+  inline NameSymbol(const char *d, std::size_t c)
+    : data(d), count(c) {}
+
+private:
+  void operator = (const NameSymbol &);
+
+  friend class NameTable;
+};
+
+
+/**
+@brief Required to put NameSymbol's into a QHash.
+@see qHash(const QPair<const char*, std::size_t> &r) method for the reference.*/
+inline uint qHash(const NameSymbol &r)
+{
+  uint hash_value = 0;
+
+  for (std::size_t i=0; i<r.count; ++i)
+    hash_value = (hash_value << 5) - hash_value + r.data[i];
+
+  return hash_value;
+}
+
+
+/**
+Required to put pairs of char* and std::size_t into a QHash.
+
+Hash function is: hash = hash*31 + key[i].@n
+It looks like a Bernstein's hash function with a different factor.
+@n Original Bernstein's function is: hash = hash*33 + key[i].
+@n Factor of 31 makes this function return reliably unique values
+for english words with 6 symbols length.
+
+@n More information can be found at @a http://burtleburtle.net/bob/hash/doobs.html.
+*/
+inline uint qHash(const QPair<const char*, std::size_t> &r)
+{
+  uint hash_value = 0;
+
+  for (std::size_t i=0; i<r.second; ++i)
+    hash_value = (hash_value << 5) - hash_value + r.first[i];
+
+  return hash_value;
+}
+
+/**Symbol table for the parser.*/
+class NameTable
+{
+public:
+  typedef QPair<const char *, std::size_t> KeyType;
+  typedef QHash<KeyType, NameSymbol*> ContainerType;
+
+public:
+  NameTable() {}
+
+  ~NameTable()
+  {
+    qDeleteAll(_M_storage);
+  }
+
+  inline const NameSymbol *findOrInsert(const char *str, std::size_t len)
+  {
+    KeyType key(str, len);
+
+    NameSymbol *name = _M_storage.value(key);
+    if (!name)
+      {
+        name = new NameSymbol(str, len);
+        _M_storage.insert(key, name);
+      }
+
+    return name;
+  }
+
+  inline std::size_t count() const
+  {
+    return _M_storage.size();
+  }
+
+private:
+  ContainerType _M_storage;
+
+private:
+  NameTable(const NameTable &other);
+  void operator = (const NameTable &other);
+};
+
+#endif // SYMBOL_H
+

data/ext/generator/parser/tests/CMakeLists.txt

@@ -0,0 +1,30 @@
+
+set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/testconfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/testconfig.h)
+
+
+########### next target ###############
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/../rpp ${QT_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR})
+
+set(parsertest_SRCS test_parser.cpp)
+
+QT4_GENERATE_MOC(${parsertest_SRCS} test_parser.moc)
+add_executable(parsertest ${parsertest_SRCS} test_parser.moc)
+target_link_libraries(parsertest ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} cppparser)
+
+########### next target ###############
+
+set(generatortest_SRCS test_generator.cpp)
+
+QT4_GENERATE_MOC(${generatortest_SRCS} test_generator.moc)
+add_executable(generatortest ${generatortest_SRCS} test_generator.moc)
+target_link_libraries(generatortest ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} cppparser)
+
+########### next target ###############
+
+set(pooltest_SRCS test_pool.cpp)
+
+QT4_GENERATE_MOC(test_pool.h test_pool.moc)
+add_executable(pooltest ${pooltest_SRCS} test_pool.moc)
+target_link_libraries(pooltest ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY} cppparser)

data/ext/generator/parser/tests/test_generator.cpp

@@ -0,0 +1,259 @@
+#include <QtTest/QtTest>
+
+#include "ast.h"
+#include "parser.h"
+#include "rpp/preprocessor.h"
+#include "control.h"
+#include "dumptree.h"
+#include "tokens.h"
+#include "parsesession.h"
+#include "commentformatter.h"
+#include "codegenerator.h"
+
+#include "testconfig.h"
+
+#include <QByteArray>
+#include <QDataStream>
+#include <QFile>
+
+#include <iostream>
+#include <rpp/chartools.h>
+#include <rpp/pp-engine.h>
+
+bool operator==(const Token& t1, const Token& t2)
+{
+  return t1.kind == t2.kind && t1.symbolString() == t2.symbolString();
+}
+
+namespace QTest {
+  template<>
+  char* toString(const Token& t)
+  {
+    return qstrdup(QString("%1 [ %2 ]").arg(token_name(t.kind)).arg(t.symbolString()).toUtf8());
+  }
+}
+
+class TestGenerator : public QObject
+{
+  Q_OBJECT
+
+  Control control;
+  DumpTree dumper;
+
+public:
+  TestGenerator()
+  {
+  }
+
+  enum ParseFlag {
+    FlagNone = 0,
+    DumpAST = 1,
+    PrintCode = 2,
+    FlagAll = 3
+  };
+  Q_DECLARE_FLAGS(ParseFlags, ParseFlag)
+
+  void parse(const QByteArray& unit, ParseFlags flags = static_cast<ParseFlags>(FlagNone))
+  {
+    TranslationUnitAST* ast = parseOriginal(unit);
+    if (flags & DumpAST)
+      dumper.dump(ast, lastSession->token_stream);
+
+    CodeGenerator cg(lastSession);
+    cg.visit(ast);
+    if (flags & PrintCode) {
+      qDebug() << unit;
+      qDebug() << cg.output();
+    }
+
+    parseGenerated( cg.output().toUtf8() );
+
+    compareTokenStreams();
+  }
+
+private slots:
+  void initTestCase()
+  {
+  }
+
+  void testIf()
+  {
+    parse(QByteArray("void test() { if (i == 0) { foo(); } else { foo2(); } }"));
+  }
+
+  void testFor()
+  {
+    QByteArray method("void test() { for (int i = 0; i < 4; ++i) { break; } for (j; j < 4; ) {return;} }");
+    parse(method);
+  }
+
+  void testDo()
+  {
+    QByteArray method("void test() { do { foo(); } while (i < 0); }");
+    parse(method);
+  }
+
+  void testWhile()
+  {
+    QByteArray method("void test() { while (i & 3) { foo(); } }");
+    parse(method);
+  }
+
+  void testSwitch()
+  {
+    QByteArray method("void test() { switch (i) { case 1: break; case 2: return; default: goto foo; } foo: return; }");
+    parse(method);
+  }
+
+  void testClass()
+  {
+    QByteArray method("struct A : public B, virtual private C { int i; A() : i(5) { } virtual void test() = 0; };");
+    parse(method);
+  }
+
+  void testTemplateClass()
+  {
+    QByteArray method("template <typename B> struct A : private C { B i; A() : i(5) { } virtual void test() = 0; };");
+    parse(method);
+  }
+
+  void testMethod()
+  {
+    QByteArray method("int A::test(int primitive, B* pointer) { return primitive; }");
+    parse(method);
+  }
+
+  void testIntegralTypes()
+  {
+    parse(QByteArray("const unsigned int i, k; volatile long double j; int* l; double * const * m; const int& n = l;"));
+  }
+
+  void testArrayType()
+  {
+    parse(QByteArray("const unsigned int ArraySize = 3; int i[ArraySize];"));
+  }
+
+  void testEnum()
+  {
+    parse(QByteArray("enum Enum { Value1 = 5, value2 }; enum Enum2 { Value21, value22 = 2 }; union { int u1; float u2; };"));
+  }
+
+  void testPublicFlags()
+  {
+    parse(QByteArray("class Foo { public: virtual void bar(); private: void baz(); protected: };"));
+  }
+
+  void testDeclareStruct()
+  {
+    parse(QByteArray("struct { short i; } instance;"));
+  }
+
+  void testVariableDeclaration()
+  {
+    parse(QByteArray("int c; A instance(c); A instance(2, 3); A instance(q); bla() {int* i = new A(c); delete i; }"));
+  }
+
+  void testFriendDeclaration()
+  {
+    parse(QByteArray("class A { friend class F; }; "));
+  }
+
+  void testUsingDeclarationInTemplate()
+  {
+    parse(QByteArray("template<class T> class A { T i; }; template<class Q> struct B: private A<Q> { using A<T>::i; };"));
+  }
+
+  void testDeclareUsingNamespace2()
+  {
+    parse(QByteArray("namespace foo2 {int bar2; namespace SubFoo { int subBar2; } } namespace foo { int bar; using namespace foo2; } namespace GFoo{ namespace renamedFoo2 = foo2; using namespace renamedFoo2; using namespace SubFoo; int gf; } using namespace GFoo; int test() { return bar; }"));
+  }
+
+  void testFunctionDefinition3()
+  {
+    parse(QByteArray("class B{template<class T> void test(T t); B(int i); int test(int a); int test(char a); template<class T2, class T3> void test(T2 t, T3 t3); int test(Unknown k); int test(Unknown2 k); }; template<class T> void B::test(T t) {} B::B(int) {} int B::test(int a){} int B::test(char a){} template<class T2, class T3> void B::test(T2 t, T3 t3) {} int B::test(Unknown k){} int B::test( Unknown2 k) {} "));
+  }
+
+  void testTemplateEnums()
+  {
+    parse(QByteArray("template<bool num> struct No {};  No<true> n;"));
+    parse(QByteArray("template<int num=5> struct No {};  No n;"));
+    parse(QByteArray("template<int num> struct No {};  No<9> n;"));
+  }
+
+  void testDynamicArray()
+  {
+    parse(QByteArray("struct Bla { int val; } blaArray[] = { {5} };"));
+  }
+
+  void testSmartPointer()
+  {
+    parse(QByteArray("template<class T> struct SmartPointer { T* operator ->() const {} template<class Target> SmartPointer<Target> cast() {} T& operator*() {}  } ; class B{int i;}; class C{}; SmartPointer<B> bPointer;"));
+  }
+
+  void testSimpleExpression()
+  {
+    parse(QByteArray("struct Cont { int& a; Cont* operator -> () {} double operator*(); }; Cont c; Cont* d = &c; void test() { c.a = 5; d->a = 5; (*d).a = 5; c.a(5, 1, c); c.b<Fulli>(); }"));
+  }
+
+  void testThis()
+  {
+    parse(QByteArray("struct Cont { operator int() {} }; void test( int c = 5 ) { this->test( Cont(), 1, 5.5, 6); }"));
+  }
+
+  void testCasts()
+  {
+    parse(QByteArray("struct Cont2 {}; struct Cont { int& a; Cont* operator -> () {} double operator*(); }; Cont c; Cont* d = &c; void test() { c.a = 5; d->a = 5; (*d).a = 5; c.a(5, 1, c); c(); c.a = dynamic_cast<const Cont2*>(d); }"));
+  }
+
+  void testOperators()
+  {
+    parse(QByteArray("struct Cont2 {int operator[] {} operator()() {}}; struct Cont3{}; struct Cont { Cont3 operator[](int i) {} Cont3 operator()() {} Cont3 operator+(const Cont3& c3 ) {} }; Cont c; Cont2 operator+( const Cont& c, const Cont& c2){} Cont3 c3;"));
+  }
+
+  void testEmptyFor()
+  {
+    parse(QByteArray("void test() { for (;;) {} }"));
+  }
+
+private:
+  ParseSession* lastSession;
+  ParseSession* lastGeneratedSession;
+
+  TranslationUnitAST* parseOriginal(const QByteArray& unit)
+  {
+    Parser parser(&control);
+    lastSession = new ParseSession();
+    lastSession->setContentsAndGenerateLocationTable(tokenizeFromByteArray(unit));
+    return  parser.parse(lastSession);
+  }
+
+  TranslationUnitAST* parseGenerated(const QByteArray& unit)
+  {
+    Parser parser(&control);
+    lastGeneratedSession = new ParseSession();
+    lastGeneratedSession->setContentsAndGenerateLocationTable(tokenizeFromByteArray(unit));
+    return  parser.parse(lastGeneratedSession);
+  }
+
+  void compareTokenStreams()
+  {
+    std::size_t cursor = 1;
+    forever {
+      QVERIFY(cursor < lastSession->token_stream->size());
+      QVERIFY(cursor < lastGeneratedSession->token_stream->size());
+
+      const Token& t1 = lastSession->token_stream->token( cursor );
+      const Token& t2 = lastGeneratedSession->token_stream->token( cursor );
+
+      QCOMPARE(t1, t2);
+      if (t1.kind == Token_EOF)
+        break;
+
+      ++cursor;
+    }
+  }
+};
+
+#include "test_generator.moc"
+
+QTEST_MAIN(TestGenerator)