qtbindings 4.6.3.0

data/ext/generator/parser/rpp/test/t010.cpp

@@ -0,0 +1,15 @@
+#include "test.h"
+
+#define TEST_H
+
+#if defined(TEST_H)
+OK
+#else
+ERROR
+#endif
+
+#if !defined(TEST_H)
+ERROR
+#else
+OK
+#endif

data/ext/generator/parser/rpp/test/t011.cpp

@@ -0,0 +1,9 @@
+#define BLANK_MACRO
+
+class BLANK_MACRO Blah
+{
+public:
+  void BLANK_MACRO testFoo() const;
+
+  void testMe();
+};

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

@@ -0,0 +1,13 @@
+set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
+include_directories( ${CMAKE_SOURCE_DIR}/languages/cpp/parser ${CMAKE_CURRENT_SOURCE_DIR}/..  )
+
+
+########### next target ###############
+
+set(pp_SRCS
+    main.cpp
+)
+
+kde4_add_executable(pp TEST ${pp_SRCS})
+target_link_libraries(pp ${KDE4_KDECORE_LIBS} kdev4cpprpp)
+

data/ext/generator/parser/rpp/tests/main.cpp

@@ -0,0 +1,69 @@
+/*
+  Copyright 2005 Roberto Raggi <roberto@kdevelop.org>
+
+  Permission to use, copy, modify, distribute, and sell this software and its
+  documentation for any purpose is hereby granted without fee, provided that
+  the above copyright notice appear in all copies and that both that
+  copyright notice and this permission notice appear in supporting
+  documentation.
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "pp-engine.h"
+
+#include <QtDebug>
+
+#include "preprocessor.h"
+#include "pp-environment.h"
+#include "pp-location.h"
+#include "chartools.h"
+
+using namespace rpp;
+
+int main (int /*argc*/, char *argv[])
+{
+  bool no_stdinc = false;
+  bool no_stdincpp = false;
+
+  char const *filename = *++argv;
+  if (!filename)
+    {
+      qDebug() << "usage: pp file.cpp";
+      return EXIT_FAILURE;
+    }
+
+  Preprocessor p;
+
+  QStringList ip;
+
+  pp preprocess(&p);
+
+  preprocess.processFile(QString("pp-configuration")); // ### put your macros here!
+
+  preprocess.environment()->enterBlock(0, PreprocessedContents());
+
+  QString result = QString::fromUtf8(stringFromContents(preprocess.processFile(QString(filename))));
+
+  preprocess.environment()->cleanup();
+
+  QStringList resultLines = result.split('\n');
+  for (int i = 0; i < resultLines.count(); ++i)
+    qDebug() << i << ":" << resultLines[i];
+
+  preprocess.environment()->locationTable()->dump();
+  
+  /*foreach (const Preprocessor::MacroItem& macro, p.macros())
+    kDebug(9007) << "Macro '" << macro.name << "' param (" << macro.parameters << ") def (" << macro.definition << ") isFnLike (" << macro.isFunctionLike << ") filename (" << macro.fileName << ")";*/
+
+  return EXIT_SUCCESS;
+}
+

data/ext/generator/parser/rxx.pri

@@ -0,0 +1,50 @@
+
+isEmpty(RXXPATH):RXXPATH = $$PWD
+
+INCLUDEPATH += $$RXXPATH
+
+DEFINES += RXX_ALLOCATOR_INIT_0
+
+HEADERS += $$RXXPATH/ast.h \
+           $$RXXPATH/lexer.h \
+           $$RXXPATH/listnode.h \
+           $$RXXPATH/parser.h \
+           $$RXXPATH/rxx_allocator.h \
+           $$RXXPATH/memorypool.h \
+           $$RXXPATH/tokens.h \
+           $$RXXPATH/symbol.h \
+           $$RXXPATH/control.h \
+           $$RXXPATH/visitor.h \
+           $$RXXPATH/default_visitor.h \
+           $$RXXPATH/dumptree.h \
+           $$RXXPATH/binder.h \
+           $$RXXPATH/codemodel.h \
+           $$RXXPATH/codemodel_fwd.h \
+           $$RXXPATH/type_compiler.h \
+           $$RXXPATH/name_compiler.h \
+           $$RXXPATH/declarator_compiler.h \
+           $$RXXPATH/class_compiler.h \
+           $$RXXPATH/codemodel_finder.h \
+           $$RXXPATH/compiler_utils.h \
+           $$RXXPATH/kdevsharedptr.h \
+           $$RXXPATH/problem.h
+
+SOURCES += $$RXXPATH/ast.cpp \
+           $$RXXPATH/lexer.cpp \
+           $$RXXPATH/listnode.cpp \
+           $$RXXPATH/parser.cpp \
+           $$RXXPATH/memorypool.cpp \
+           $$RXXPATH/control.cpp \
+           $$RXXPATH/visitor.cpp \
+           $$RXXPATH/default_visitor.cpp \
+           $$RXXPATH/dumptree.cpp \
+           $$RXXPATH/tokens.cpp \
+           $$RXXPATH/binder.cpp \
+           $$RXXPATH/codemodel.cpp \
+           $$RXXPATH/type_compiler.cpp \
+           $$RXXPATH/name_compiler.cpp \
+           $$RXXPATH/declarator_compiler.cpp \
+           $$RXXPATH/class_compiler.cpp \
+           $$RXXPATH/codemodel_finder.cpp \
+           $$RXXPATH/compiler_utils.cpp \
+           $$RXXPATH/problem.cpp

data/ext/generator/parser/rxx_allocator.h

@@ -0,0 +1,128 @@
+/* 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 RXX_ALLOCATOR_H
+#define RXX_ALLOCATOR_H
+
+#include <cstddef>
+#include <cstdlib>
+#include <string.h>
+#include <memory>
+
+/**The allocator which uses fixed size blocks for allocation of its elements.
+Block size is currently 64k, allocated space is not reclaimed,
+if the size of the element being allocated extends the amount of free
+memory in the block then a new block is allocated.
+
+The allocator supports standard c++ library interface but does not
+make use of allocation hints.
+*/
+template <class _Tp> class rxx_allocator {
+public:
+  typedef _Tp value_type;
+  typedef _Tp* pointer;
+  typedef const _Tp* const_pointer;
+  typedef _Tp& reference;
+  typedef const _Tp& const_reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  static const size_type max_block_count = size_type(-1);
+  static const size_type _S_block_size = 1 << 16; // 64K
+
+  rxx_allocator() {
+    init();
+  }
+
+  rxx_allocator(const rxx_allocator &/*__o*/) {
+    init();
+  }
+
+  ~rxx_allocator() {
+    for (size_type index = 0; index < _M_block_index + 1; ++index)
+      delete[] _M_storage[index];
+
+    ::free(_M_storage);
+  }
+
+  pointer address(reference __val) { return &__val; }
+  const_pointer address(const_reference __val) const { return &__val; }
+
+  /**Allocates @p __n elements continuosly in the pool. Warning! no
+  check is done to check if the size of those @p __n elements
+  fit into the block. You should assure you do not allocate more
+  than the size of a block.*/
+  pointer allocate(size_type __n, const void* = 0) {
+    const size_type bytes = __n * sizeof(_Tp);
+
+    if (_M_current_block == 0
+	|| _S_block_size < _M_current_index + bytes)
+      {
+	++_M_block_index;
+
+	_M_storage = reinterpret_cast<char**>
+	  (::realloc(_M_storage, sizeof(char*) * (1 + _M_block_index)));
+
+	_M_current_block = _M_storage[_M_block_index] = reinterpret_cast<char*>
+	  (new char[_S_block_size]);
+
+	::memset(_M_current_block, 0, _S_block_size);
+	_M_current_index = 0;
+      }
+
+    pointer p = reinterpret_cast<pointer>
+      (_M_current_block + _M_current_index);
+
+    _M_current_index += bytes;
+
+    return p;
+  }
+
+  /**Deallocate does nothing in this implementation.*/
+  void deallocate(pointer /*__p*/, size_type /*__n*/) {}
+
+  size_type max_size() const { return size_type(-1) / sizeof(_Tp); }
+
+  void construct(pointer __p, const_reference __val) { new (__p) _Tp(__val); }
+  void destroy(pointer __p) { __p->~_Tp(); }
+
+  template <class _Tp1> struct rebind {
+    typedef rxx_allocator<_Tp1> other;
+  };
+
+private:
+
+  void init()
+  {
+    _M_block_index = max_block_count;
+    _M_current_index = 0;
+    _M_storage = 0;
+    _M_current_block = 0;
+  }
+
+  template <class _Tp1> rxx_allocator(const rxx_allocator<_Tp1> &__o) {}
+
+private:
+  size_type _M_block_index;
+  size_type _M_current_index;
+  char *_M_current_block;
+  char **_M_storage;
+};
+
+#endif // RXX_ALLOCATOR_H
+

data/ext/generator/parser/safetycounter.h

@@ -0,0 +1,57 @@
+
+/***************************************************************************
+   Copyright 2006 David Nolden <david.nolden.kdevelop@art-master.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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef __SAFETYCOUNTER_H__
+#define __SAFETYCOUNTER_H__
+
+#include <QtCore/QtDebug>
+
+struct SafetyCounter {
+  int safetyCounter;
+  const int maxSafetyCounter;
+  
+  SafetyCounter( int max = 40000 ) : safetyCounter(0), maxSafetyCounter(max) {
+  }
+  
+  void init() {
+    safetyCounter = 0;
+  }
+  
+  SafetyCounter& operator ++() {
+    safetyCounter++;
+    return *this;
+  }
+
+  ///Returns whether the counter is ok, but without increasing it
+  bool ok() const {
+    return safetyCounter < maxSafetyCounter;
+  }
+  
+  operator bool() {
+    safetyCounter++;
+    bool ret = safetyCounter < maxSafetyCounter;
+	  if( !ret ) {
+			if( safetyCounter == maxSafetyCounter ) {
+#ifdef DEPTHBACKTRACE
+      	qDebug() << "WARNING: Safety-counter reached count > " << maxSafetyCounter << ", operation stopped";
+#endif
+			}
+	  }
+    
+    return ret;
+  }
+  
+};
+
+#endif

data/ext/generator/parser/simplecursor.h

@@ -0,0 +1,74 @@
+/* This file is part of KDevelop
+    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 SIMPLECURSOR_H
+#define SIMPLECURSOR_H
+
+#include "cppparser_export.h"
+
+struct CPPPARSER_EXPORT SimpleCursor {
+
+ int line, column;
+
+ SimpleCursor() : line(0), column(0) {
+ }
+
+ SimpleCursor(int _line, int _column) : line(_line), column(_column) {
+ }
+
+ static SimpleCursor invalid() {
+     return SimpleCursor(-1, -1);
+ }
+
+ bool isValid() const {
+     return line != -1 || column != -1;
+ }
+
+ bool operator<(const SimpleCursor& rhs) const {
+     return line < rhs.line || (line == rhs.line && column < rhs.column);
+ }
+ 
+ bool operator<=(const SimpleCursor& rhs) const {
+     return line < rhs.line || (line == rhs.line && column <= rhs.column);
+ }
+
+ bool operator>(const SimpleCursor& rhs) const {
+     return line > rhs.line || (line == rhs.line && column > rhs.column);
+ }
+ 
+ bool operator>=(const SimpleCursor& rhs) const {
+     return line > rhs.line || (line == rhs.line && column >= rhs.column);
+ }
+
+ bool operator ==(const SimpleCursor& rhs) const {
+     return line == rhs.line && column == rhs.column;
+ }
+ 
+ bool operator !=(const SimpleCursor& rhs) const {
+     return !(*this == rhs);
+ }
+
+ SimpleCursor operator +(const SimpleCursor& rhs) const {
+     return SimpleCursor(line + rhs.line, column + rhs.column);
+ }
+};
+
+inline uint qHash(const SimpleCursor& cursor) {
+    return cursor.line * 53 + cursor.column * 47;
+}
+
+#endif

data/ext/generator/parser/stringhelpers.cpp

@@ -0,0 +1,577 @@
+/*
+   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.
+*/
+
+#include "stringhelpers.h"
+#include "safetycounter.h"
+
+#include <QString>
+#include <QStringList>
+
+class ParamIteratorPrivate
+{
+public:
+  QString m_prefix;
+  QString m_source;
+  QString m_parens;
+  int m_cur;
+  int m_curEnd;
+  int m_end;
+  
+  int next() const
+  {
+    return findCommaOrEnd( m_source, m_cur, m_parens[ 1 ] );
+  }
+};
+
+
+bool parenFits( QChar c1, QChar c2 )
+{
+  if( c1 == '<' && c2 == '>' ) return true;
+  else if( c1 == '(' && c2 == ')' ) return true;
+  else if( c1 == '[' && c2 == ']' ) return true;
+  else if( c1 == '{' && c2 == '}' ) return true;
+  else
+    return false;
+}
+
+int findClose( const QString& str , int pos )
+{
+  int depth = 0;
+  QList<QChar> st;
+  QChar last = ' ';
+
+  for( int a = pos; a < (int)str.length(); a++)
+  {
+    switch(str[a].unicode()) {
+    case '<':
+    case '(':
+      case '[':
+        case '{':
+        st.push_front( str[a] );
+      depth++;
+      break;
+    case '>':
+      if( last == '-' ) break;
+    case ')':
+      case ']':
+        case '}':
+        if( !st.isEmpty() && parenFits(st.front(), str[a]) )
+        {
+          depth--;
+          st.pop_front();
+        }
+      break;
+    case '"':
+      last = str[a];
+      a++;
+      while( a < (int)str.length() && (str[a] != '"' || last == '\\'))
+      {
+        last = str[a];
+        a++;
+      }
+      continue;
+      break;
+    case '\'':
+      last = str[a];
+      a++;
+      while( a < (int)str.length() && (str[a] != '\'' || last == '\\'))
+      {
+        last = str[a];
+        a++;
+      }
+      continue;
+      break;
+    }
+
+    last = str[a];
+
+    if( depth == 0 )
+    {
+      return a;
+    }
+  }
+
+  return -1;
+}
+
+int findCommaOrEnd( const QString& str , int pos, QChar validEnd)
+{
+
+  for( int a = pos; a < (int)str.length(); a++)
+  {
+    switch(str[a].unicode())
+    {
+    case '"':
+    case '(':
+      case '[':
+        case '{':
+        case '<':
+        a = findClose( str, a );
+      if( a == -1 ) return str.length();
+      break;
+    case ')':
+      case ']':
+        case '}':
+        case '>':
+        if( validEnd != ' ' && validEnd != str[a] )
+          continue;
+    case ',':
+      return a;
+    }
+  }
+
+  return str.length();
+}
+
+
+QString reverse( const QString& str ) {
+  QString ret;
+  int len = str.length();
+  for( int a = len-1; a >= 0; --a ) {
+    switch(str[a].toAscii()) {
+    case '(':
+      ret += ')';
+      continue;
+    case '[':
+      ret += ']';
+      continue;
+    case '{':
+      ret += '}';
+      continue;
+    case '<':
+      ret += '>';
+      continue;
+    case ')':
+      ret += '(';
+      continue;
+    case ']':
+      ret += '[';
+      continue;
+    case '}':
+      ret += '{';
+      continue;
+    case '>':
+      ret += '<';
+      continue;
+    default:
+      ret += str[a];
+      continue;
+    }
+  }
+  return ret;
+}
+
+///@todo this hackery sucks
+QString escapeForBracketMatching(QString str) {
+  str.replace("<<", "$&");
+  str.replace(">>", "$$");
+  str.replace("\\\"", "$!");
+  str.replace("->", "$?");
+  return str;
+}
+
+QString escapeFromBracketMatching(QString str) {
+  str.replace("$&", "<<");
+  str.replace("$$", ">>");
+  str.replace("$!", "\\\"");
+  str.replace("$?", "->");
+  return str;
+}
+
+void skipFunctionArguments(QString str, QStringList& skippedArguments, int& argumentsStart ) {
+  QString withStrings = escapeForBracketMatching(str);
+  str = escapeForBracketMatching(clearStrings(str));
+  
+  //Blank out everything that can confuse the bracket-matching algorithm
+  QString reversed = reverse( str.left(argumentsStart) );
+  QString withStringsReversed = reverse( withStrings.left(argumentsStart) );
+  //Now we should decrease argumentStart at the end by the count of steps we go right until we find the beginning of the function
+  SafetyCounter s( 1000 );
+
+  int pos = 0;
+  int len = reversed.length();
+  //we are searching for an opening-brace, but the reversion has also reversed the brace
+  while( pos < len && s ) {
+    int lastPos = pos;
+    pos = findCommaOrEnd( reversed, pos )  ;
+    if( pos > lastPos ) {
+      QString arg = reverse( withStringsReversed.mid(lastPos, pos-lastPos) ).trimmed();
+      if( !arg.isEmpty() )
+        skippedArguments.push_front( escapeFromBracketMatching(arg) ); //We are processing the reversed reverseding, so push to front
+    }
+    if( reversed[pos] == ')' || reversed[pos] == '>' )
+      break;
+    else
+      ++pos;
+  }
+
+  if( !s ) {
+    qDebug() << "skipFunctionArguments: Safety-counter triggered";
+  }
+
+  argumentsStart -= pos;
+}
+
+QString reduceWhiteSpace(QString str) {
+  str = str.trimmed();
+  QString ret;
+
+  QChar spaceChar = ' ';
+
+  bool hadSpace = false;
+  for( int a = 0; a < str.length(); a++ ) {
+    if( str[a].isSpace() ) {
+      hadSpace = true;
+    } else {
+      if( hadSpace ) {
+        hadSpace = false;
+        ret += spaceChar;
+      }
+      ret += str[a];
+    }
+  }
+
+  return ret;
+}
+
+void fillString( QString& str, int start, int end, QChar replacement ) {
+  for( int a = start; a < end; a++) str[a] = replacement;
+}
+
+QString stripFinalWhitespace(QString str) {
+
+  for( int a = str.length() - 1; a >= 0; --a ) {
+    if( !str[a].isSpace() )
+      return str.left( a+1 );
+    }
+
+  return QString();
+}
+
+QString clearComments( QString str, QChar replacement ) {
+
+  QString withoutStrings = clearStrings(str, '$');
+  
+  SafetyCounter s( 1000 );
+  int lastPos = 0;
+  int pos;
+  int len = str.length();
+  while( (pos = withoutStrings.indexOf( "/*", lastPos )) != -1 ) {
+    if( !s ) return str;
+    int i = withoutStrings.indexOf( "*/", pos );
+    int iNewline = withoutStrings.indexOf( '\n', pos );
+    
+    while(iNewline != -1 && iNewline < i && pos < len) {
+      //Preserve newlines
+      iNewline = withoutStrings.indexOf( '\n', pos );
+      fillString( str, pos, iNewline, replacement );
+      pos = iNewline+1;
+    }
+    if( i != -1 && i <= len - 2 ) {
+      fillString( str, pos, i+2, replacement );
+      lastPos = i+2;
+      if( lastPos == len ) break;
+    } else {
+      break;
+    }
+  }
+
+  lastPos = 0;
+  while( (pos = withoutStrings.indexOf( "//", lastPos )) != -1 ) {
+    if( !s ) return str;
+    int i = withoutStrings.indexOf( '\n', pos );
+    if( i != -1 && i <= len - 1 ) {
+      fillString( str, pos, i, replacement );
+      lastPos = i+1;
+    } else {
+      fillString( str, pos, len, replacement );
+      break;
+    }
+  }
+
+  return str;
+}
+
+QString clearStrings( QString str, QChar replacement ) {
+  bool inString = false;
+  for(int pos = 0; pos < str.length(); ++pos) {
+    bool intoString = false;
+    if(str[pos] == '"' && !inString)
+      intoString = true;
+    
+    if(inString || intoString) {
+      if(inString) {
+        if(str[pos] == '"')
+          inString = false;
+      }else{
+        inString = true;
+      }
+      
+      bool skip = false;
+      if(str[pos] == '\\')
+        skip = true;
+        
+      str[pos] = replacement;
+      if(skip) {
+        ++pos;
+        if(pos < str.length())
+          str[pos] = replacement;
+      }
+    }
+  }
+  return str;
+}
+
+
+static inline bool isWhite( QChar c ) {
+  return c.isSpace();
+}
+
+static inline bool isWhite( char c ) {
+  return QChar(c).isSpace();
+}
+
+void rStrip( const QString& str, QString& from ) {
+  if( str.isEmpty() ) return;
+
+  int i = 0;
+  int ip = from.length();
+  int s = from.length();
+
+  for( int a = s-1; a >= 0; a-- ) {
+      if( isWhite( from[a] ) ) {
+          continue;
+      } else {
+          if( from[a] == str[i] ) {
+              i++;
+              ip = a;
+              if( i == (int)str.length() ) break;
+          } else {
+              break;
+          }
+      }
+  }
+
+  if( ip != (int)from.length() ) from = from.left( ip );
+}
+
+void strip( const QString& str, QString& from ) {
+  if( str.isEmpty() ) return;
+
+  int i = 0;
+  int ip = 0;
+  int s = from.length();
+
+  for( int a = 0; a < s; a++ ) {
+      if( isWhite( from[a] ) ) {
+          continue;
+      } else {
+          if( from[a] == str[i] ) {
+              i++;
+              ip = a+1;
+              if( i == (int)str.length() ) break;
+          } else {
+              break;
+          }
+      }
+  }
+
+  if( ip ) from = from.mid( ip );
+}
+
+void rStrip( const QByteArray& str, QByteArray& from ) {
+  if( str.isEmpty() ) return;
+
+  int i = 0;
+  int ip = from.length();
+  int s = from.length();
+
+  for( int a = s-1; a >= 0; a-- ) {
+      if( isWhite( from[a] ) ) { ///@todo Check whether this can cause problems in utf-8, as only one real character is treated!
+          continue;
+      } else {
+          if( from[a] == str[i] ) {
+              i++;
+              ip = a;
+              if( i == (int)str.length() ) break;
+          } else {
+              break;
+          }
+      }
+  }
+
+  if( ip != (int)from.length() ) from = from.left( ip );
+}
+
+void strip( const QByteArray& str, QByteArray& from ) {
+  if( str.isEmpty() ) return;
+
+  int i = 0;
+  int ip = 0;
+  int s = from.length();
+
+  for( int a = 0; a < s; a++ ) {
+      if( isWhite( from[a] ) ) { ///@todo Check whether this can cause problems in utf-8, as only one real character is treated!
+          continue;
+      } else {
+          if( from[a] == str[i] ) {
+              i++;
+              ip = a+1;
+              if( i == (int)str.length() ) break;
+          } else {
+              break;
+          }
+      }
+  }
+
+  if( ip ) from = from.mid( ip );
+}
+QString formatComment( const QString& comment ) {
+  QString ret;
+
+  QStringList lines = comment.split( '\n', QString::KeepEmptyParts );
+
+  if ( !lines.isEmpty() ) {
+
+    QStringList::iterator it = lines.begin();
+    QStringList::iterator eit = lines.end();
+
+    // remove common leading chars from the beginning of lines
+    for( ; it != eit; ++it ) {
+        strip( "///", *it );
+        strip( "//", *it );
+        strip( "**", *it );
+        rStrip( "/**", *it );
+    }
+
+    ret = lines.join( "\n" );
+  }
+
+  return ret.trimmed();
+}
+
+QByteArray formatComment( const QByteArray& comment ) {
+  QByteArray ret;
+
+  QList<QByteArray> lines = comment.split( '\n' );
+
+  if ( !lines.isEmpty() ) {
+
+    QList<QByteArray>::iterator it = lines.begin();
+    QList<QByteArray>::iterator eit = lines.end();
+
+    // remove common leading chars from the beginning of lines
+    for( ; it != eit; ++it ) {
+        strip( "///", *it );
+        strip( "//", *it );
+        strip( "**", *it );
+        rStrip( "/**", *it );
+    }
+
+    foreach(const QByteArray& line, lines) {
+      if(!ret.isEmpty())
+        ret += "\n";
+      ret += line;
+    }
+  }
+
+  return ret.trimmed();
+}
+ParamIterator::~ParamIterator()
+{
+  delete d;
+}
+
+ParamIterator::ParamIterator( QString parens, QString source, int offset ) : d(new ParamIteratorPrivate)
+{
+  d->m_source = source;
+  d->m_parens = parens;
+  
+  d->m_cur = offset;
+  d->m_curEnd = offset;
+  d->m_end = d->m_source.length();
+
+  ///The whole search should be stopped when: A) The end-sign is found on the top-level B) A closing-brace of parameters was found
+  int parenBegin = d->m_source.indexOf( parens[ 0 ], offset );
+  
+  //Search for an interrupting end-sign that comes before the found paren-begin
+  int foundEnd = -1;
+  if( parens.length() > 2 ) {
+    foundEnd = d->m_source.indexOf( parens[2], offset );
+    if( foundEnd > parenBegin && parenBegin != -1 )
+      foundEnd = -1;
+  }
+  
+  if( foundEnd != -1 ) {
+    //We have to stop the search, because we found an interrupting end-sign before the opening-paren
+    d->m_prefix = d->m_source.mid( offset, foundEnd - offset );
+    
+    d->m_curEnd = d->m_end = d->m_cur = foundEnd;
+  } else {
+    if( parenBegin != -1 ) {
+      //We have a valid prefix before an opening-paren. Take the prefix, and start iterating parameters.
+      d->m_prefix = d->m_source.mid( offset, parenBegin - offset );
+      d->m_cur = parenBegin + 1;
+      d->m_curEnd = d->next();
+      if( d->m_curEnd == d->m_source.length() ) {
+        //The paren was not closed. It might be an identifier like "operator<", so count everything as prefix.
+        d->m_prefix = d->m_source.mid(offset);
+        d->m_curEnd = d->m_end = d->m_cur = d->m_source.length();
+      }
+    } else {
+      //We have neither found an ending-character, nor an opening-paren, so take the whole input and end
+      d->m_prefix = d->m_source.mid(offset);
+      d->m_curEnd = d->m_end = d->m_cur = d->m_source.length();
+    }
+  }
+}
+
+ParamIterator& ParamIterator::operator ++()
+{
+  if( d->m_source[d->m_curEnd] == d->m_parens[1] ) {
+    //We have reached the end-paren. Stop iterating.
+    d->m_cur = d->m_end = d->m_curEnd + 1;
+  } else {
+    //Iterate on through parameters
+    d->m_cur = d->m_curEnd + 1;
+    if ( d->m_cur < ( int ) d->m_source.length() )
+    {
+      d->m_curEnd = d->next();
+    }
+  }
+  return *this;
+}
+
+QString ParamIterator::operator *()
+{
+  return d->m_source.mid( d->m_cur, d->m_curEnd - d->m_cur ).trimmed();
+}
+
+ParamIterator::operator bool() const
+{
+  return d->m_cur < ( int ) d->m_end;
+}
+
+QString ParamIterator::prefix() const
+{
+  return d->m_prefix;
+}
+
+uint ParamIterator::position() const {
+  return (uint)d->m_cur;
+}