qtbindings 4.8.6.3 → 4.8.6.4

data/ext/generator/parser/indexedstring.h

@@ -1,147 +1,147 @@
-/***************************************************************************
-   Copyright 2008 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 INDEXED_STRING_H
-#define INDEXED_STRING_H
-
-//krazy:excludeall=dpointer,inline
-
-#include "cppparser_export.h"
-#include <QtCore/QString>
-
-class QDataStream;
-class QUrl;
-
-class IndexedString;
-
-///This string does "disk reference-counting", which means that reference-counts are maintainted, but
-///only when the string is in a disk-stored location. The file referencecounting.h is used to manage this condition.
-///Whenever reference-counting is enabled for a range that contains the IndexedString, it will manipulate the reference-counts.
-///The duchain storage mechanisms automatically are about correctly managing that condition, so you don't need to care, and can
-///just use this class in every duchain data type without restrictions.
-///
-///@warning Do not use IndexedString after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point
-///
-///Empty strings have an index of zero.
-///Strings of length one are not put into the repository, but are encoded directly within the index:
-///They are encoded like 0xffff00bb where bb is the byte of the character.
-class CPPPARSER_EXPORT IndexedString {
- public:
-  IndexedString();
-  ///@param str must be a utf8 encoded string, does not need to be 0-terminated.
-  ///@param length must be its length in bytes.
-  ///@param hash must be a hash as constructed with the here defined hash functions. If it is zero, it will be computed.
-  explicit IndexedString( const char* str, unsigned short length, unsigned int hash = 0 );
-
-  ///Needs a zero terminated string. When the information is already available, try using the other constructor.
-  explicit IndexedString( const char* str );
-
-  explicit IndexedString( char c );
-  
-  ///When the information is already available, try using the other constructor. This is expensive.
-  explicit IndexedString( const QString& str );
-
-  ///When the information is already available, try using the other constructor. This is expensive.
-  explicit IndexedString( const QByteArray& str );
-
-  ///Returns a not reference-counted IndexedString that represents the given index
-  ///@warning It is dangerous dealing with indices directly, because it may break the reference counting logic
-  ///         never stay pure indices to disk
-  static IndexedString fromIndex( unsigned int index ) {
-    IndexedString ret;
-    ret.m_index = index;
-    return ret;
-  }
-
-  IndexedString( const IndexedString& );
-
-  ~IndexedString();
-
-  ///Creates an indexed string from a KUrl, this is expensive.
-  explicit IndexedString( const QUrl& url );
-
-  ///Re-construct a KUrl from this indexed string, the result can be used with the
-  ///KUrl-using constructor. This is expensive.
-  QUrl toUrl() const;
-
-  inline unsigned int hash() const {
-    return m_index;
-  }
-
-  ///The string is uniquely identified by this index. You can use it for comparison.
-  ///@warning It is dangerous dealing with indices directly, because it may break the reference counting logic
-  ///         never stay pure indices to disk
-  inline unsigned int index() const {
-    return m_index;
-  }
-
-  bool isEmpty() const {
-    return m_index == 0;
-  }
-
-  //This is relatively expensive(needs a mutex lock, hash lookups, and eventual loading), so avoid it when possible.
-  int length() const;
-
-  ///Convenience function, avoid using it, it's relatively expensive
-  QString str() const;
-
-  ///Convenience function, avoid using it, it's relatively expensive(les expensive then str() though)
-  QByteArray byteArray() const;
-
-  IndexedString& operator=(const IndexedString&);
-  
-  bool operator == ( const IndexedString& rhs ) const {
-    return m_index == rhs.m_index;
-  }
-
-  bool operator != ( const IndexedString& rhs ) const {
-    return m_index != rhs.m_index;
-  }
-
-  ///Does not compare alphabetically, uses the index  for ordering.
-  bool operator < ( const IndexedString& rhs ) const {
-    return m_index < rhs.m_index;
-  }
-
-  //Use this to construct a hash-value on-the-fly
-  //To read it, just use the hash member, and when a new string is started, call clear(.
-  //This needs very fast performance(per character operation), so it must stay inlined.
-  struct RunningHash {
-    enum {
-      HashInitialValue = 5381
-    };
-
-    RunningHash() : hash(HashInitialValue) { //We initialize the hash with zero, because we want empty strings to create a zero hash(invalid)
-    }
-    inline void append(const char c) {
-      hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
-    }
-    inline void clear() {
-      hash = HashInitialValue;
-    }
-    unsigned int hash;
-  };
-
-  static unsigned int hashString(const char* str, unsigned short length);
-
- private:
-   explicit IndexedString(bool);
-   uint m_index;
-};
-
-CPPPARSER_EXPORT inline uint qHash( const IndexedString& str ) {
-  return str.index();
-}
-
-
-#endif
+/***************************************************************************
+   Copyright 2008 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 INDEXED_STRING_H
+#define INDEXED_STRING_H
+
+//krazy:excludeall=dpointer,inline
+
+#include "cppparser_export.h"
+#include <QtCore/QString>
+
+class QDataStream;
+class QUrl;
+
+class IndexedString;
+
+///This string does "disk reference-counting", which means that reference-counts are maintainted, but
+///only when the string is in a disk-stored location. The file referencecounting.h is used to manage this condition.
+///Whenever reference-counting is enabled for a range that contains the IndexedString, it will manipulate the reference-counts.
+///The duchain storage mechanisms automatically are about correctly managing that condition, so you don't need to care, and can
+///just use this class in every duchain data type without restrictions.
+///
+///@warning Do not use IndexedString after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point
+///
+///Empty strings have an index of zero.
+///Strings of length one are not put into the repository, but are encoded directly within the index:
+///They are encoded like 0xffff00bb where bb is the byte of the character.
+class CPPPARSER_EXPORT IndexedString {
+ public:
+  IndexedString();
+  ///@param str must be a utf8 encoded string, does not need to be 0-terminated.
+  ///@param length must be its length in bytes.
+  ///@param hash must be a hash as constructed with the here defined hash functions. If it is zero, it will be computed.
+  explicit IndexedString( const char* str, unsigned short length, unsigned int hash = 0 );
+
+  ///Needs a zero terminated string. When the information is already available, try using the other constructor.
+  explicit IndexedString( const char* str );
+
+  explicit IndexedString( char c );
+  
+  ///When the information is already available, try using the other constructor. This is expensive.
+  explicit IndexedString( const QString& str );
+
+  ///When the information is already available, try using the other constructor. This is expensive.
+  explicit IndexedString( const QByteArray& str );
+
+  ///Returns a not reference-counted IndexedString that represents the given index
+  ///@warning It is dangerous dealing with indices directly, because it may break the reference counting logic
+  ///         never stay pure indices to disk
+  static IndexedString fromIndex( unsigned int index ) {
+    IndexedString ret;
+    ret.m_index = index;
+    return ret;
+  }
+
+  IndexedString( const IndexedString& );
+
+  ~IndexedString();
+
+  ///Creates an indexed string from a KUrl, this is expensive.
+  explicit IndexedString( const QUrl& url );
+
+  ///Re-construct a KUrl from this indexed string, the result can be used with the
+  ///KUrl-using constructor. This is expensive.
+  QUrl toUrl() const;
+
+  inline unsigned int hash() const {
+    return m_index;
+  }
+
+  ///The string is uniquely identified by this index. You can use it for comparison.
+  ///@warning It is dangerous dealing with indices directly, because it may break the reference counting logic
+  ///         never stay pure indices to disk
+  inline unsigned int index() const {
+    return m_index;
+  }
+
+  bool isEmpty() const {
+    return m_index == 0;
+  }
+
+  //This is relatively expensive(needs a mutex lock, hash lookups, and eventual loading), so avoid it when possible.
+  int length() const;
+
+  ///Convenience function, avoid using it, it's relatively expensive
+  QString str() const;
+
+  ///Convenience function, avoid using it, it's relatively expensive(les expensive then str() though)
+  QByteArray byteArray() const;
+
+  IndexedString& operator=(const IndexedString&);
+  
+  bool operator == ( const IndexedString& rhs ) const {
+    return m_index == rhs.m_index;
+  }
+
+  bool operator != ( const IndexedString& rhs ) const {
+    return m_index != rhs.m_index;
+  }
+
+  ///Does not compare alphabetically, uses the index  for ordering.
+  bool operator < ( const IndexedString& rhs ) const {
+    return m_index < rhs.m_index;
+  }
+
+  //Use this to construct a hash-value on-the-fly
+  //To read it, just use the hash member, and when a new string is started, call clear(.
+  //This needs very fast performance(per character operation), so it must stay inlined.
+  struct RunningHash {
+    enum {
+      HashInitialValue = 5381
+    };
+
+    RunningHash() : hash(HashInitialValue) { //We initialize the hash with zero, because we want empty strings to create a zero hash(invalid)
+    }
+    inline void append(const char c) {
+      hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+    }
+    inline void clear() {
+      hash = HashInitialValue;
+    }
+    unsigned int hash;
+  };
+
+  static unsigned int hashString(const char* str, unsigned short length);
+
+ private:
+   explicit IndexedString(bool);
+   uint m_index;
+};
+
+CPPPARSER_EXPORT inline uint qHash( const IndexedString& str ) {
+  return str.index();
+}
+
+
+#endif

data/ext/generator/parser/kdevelop-parser-rev

@@ -1 +1 @@
-1010222
+1010222

data/ext/generator/parser/kdevvarlengtharray.h

@@ -1,346 +1,346 @@
-/****************************************************************************
-**
-** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
-**
-** This file is part of the QtCore module of the Qt Toolkit.
-**
-** This file may be used under the terms of the GNU General Public
-** License versions 2.0 or 3.0 as published by the Free Software
-** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file.  Alternatively you may (at
-** your option) use any later version of the GNU General Public
-** License if such license has been publicly approved by Trolltech ASA
-** (or its successors, if any) and the KDE Free Qt Foundation. In
-** addition, as a special exception, Trolltech gives you certain
-** additional rights. These rights are described in the Trolltech GPL
-** Exception version 1.2, which can be found at
-** http://www.trolltech.com/products/qt/gplexception/ and in the file
-** GPL_EXCEPTION.txt in this package.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
-** you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** In addition, as a special exception, Trolltech, as the sole
-** copyright holder for Qt Designer, grants users of the Qt/Eclipse
-** Integration plug-in the right for the Qt/Eclipse Integration to
-** link to functionality provided by Qt Designer and its related
-** libraries.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
-** granted herein.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-****************************************************************************/
-
-#ifndef KDEVVARLENGTHARRAY_H
-#define KDEVVARLENGTHARRAY_H
-
-//#include <QtCore/qcontainerfwd.h>
-#include <QtCore/QtGlobal>
-#include <QtCore/QVector>
-#include <new>
-
-///Foreach macro that also works with QVarLengthArray or KDevVarLengthArray
-///@warning Unlike the Qt foreach macro, this does not temporarily copy the array, which its size must not be changed while the iteration.
-#define FOREACH_ARRAY(item, container) for(int a = 0, mustDo = 1; a < container.size(); ++a) if((mustDo == 0 || mustDo == 1) && (mustDo = 2)) for(item(container[a]); mustDo; mustDo = 0)
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Core)
-
-//When this is uncommented, a QVector will be used instead of a variable-length array. This is useful for debugging, to find problems in KDevVarLengthArray
-// #define FAKE_KDEVVARLENGTH_ARRAY
-
-#ifdef FAKE_KDEVVARLENGTH_ARRAY
-template<class T, int Prealloc = 256>
-class KDevVarLengthArray : public QVector<T> {
-    public:
-    ///Inserts the given item at the given position, moving all items behind the position back
-    void insert(const T& item, int position) {
-    QVector<T>::insert(position, item);
-    }
-
-    // Removes exactly one occurrence of the given value from the array. Returns false if none was found.
-    bool removeOne(const T& value) {
-    int i = this->indexOf(value);
-    if(i == -1)
-    return false;
-    erase(i);
-    return true;
-    }
-    void erase(int pos) {
-    this->remove(pos);
-    }
-    void append(const T& item) {
-        QVector<T>::append(item);
-    }
-    
-    void pop_back() {
-        Q_ASSERT(!this->isEmpty());
-        QVector<T>::pop_back();
-    }
-    
-    void append(const T *buf, int size) {
-    for(int a = 0; a < size; ++a)
-        append(buf[a]);
-    }
-};
-#else
-
-template<class T, int Prealloc = 256>
-class KDevVarLengthArray
-{
-public:
-    inline explicit KDevVarLengthArray(int size = 0);
-
-    inline KDevVarLengthArray(const KDevVarLengthArray<T, Prealloc> &other)
-        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
-    {
-        append(other.constData(), other.size());
-    }
-
-    inline ~KDevVarLengthArray() {
-        if (QTypeInfo<T>::isComplex) {
-            T *i = ptr + s;
-            while (i-- > ptr)
-                i->~T();
-        }
-        if (ptr != reinterpret_cast<T *>(array))
-            qFree(ptr);
-    }
-    inline KDevVarLengthArray<T, Prealloc> &operator=(const KDevVarLengthArray<T, Prealloc> &other)
-    {
-        if (this != &other) {
-            clear();
-            append(other.constData(), other.size());
-        }
-        return *this;
-    }
-
-    inline int size() const { return s; }
-    inline int count() const { return s; }
-    inline bool isEmpty() const { return (s == 0); }
-    inline void resize(int size);
-    inline void clear() { resize(0); }
-
-    inline int capacity() const { return a; }
-    inline void reserve(int size);
-
-    inline T &operator[](int idx) {
-        Q_ASSERT(idx >= 0 && idx < s);
-        return ptr[idx];
-    }
-    inline const T &operator[](int idx) const {
-        Q_ASSERT(idx >= 0 && idx < s);
-        return ptr[idx];
-    }
-
-    ///Returns the index of the given item in this array, or -1
-    int indexOf(const T& t) const {
-        for(int a = 0; a < s; ++a)
-            if(t == ptr[a])
-                return a;
-        return -1;
-    }
-    
-    inline KDevVarLengthArray& operator<<(const T &t) {
-        append(t);
-        return *this;
-    }
-
-    inline void append(const T &t) {
-        const int idx = s++;
-        ///This is currently the difference to KDevVarLengthArray(which uses s == a), and it prevents a crash.
-        if (s >= a)
-            realloc(s, s<<1);
-        if (QTypeInfo<T>::isComplex) {
-            new (ptr + idx) T(t);
-        } else {
-            ptr[idx] = t;
-        }
-    }
-    void append(const T *buf, int size);
-
-    inline T *data() { return ptr; }
-    inline const T *data() const { return ptr; }
-    inline const T * constData() const { return ptr; }
-
-    ///Returns whether the given item is contained in this array
-    bool contains(const T& value) const {
-      for(int a = 0; a < s; ++a)
-          if(ptr[a] == value)
-          return true;
-
-      return false;
-    }
-
-    ///Inserts the given item at the given position, moving all items behind the position back
-    void insert(const T& item, int position) {
-        Q_ASSERT(position >= 0 && position <= size());
-        resize(s+1);
-        for(int a = s-1; a > position; --a) {
-            ptr[a] = ptr[a-1];
-        }
-        ptr[position] = item;
-    }
-
-    ///Removes the given position from the array, moving all items behind it one back.
-    void erase(int position) {
-        Q_ASSERT(position >= 0 && position < s);
-        for(int a = position; a < s-1; ++a) {
-            ptr[a] = ptr[a+1];
-        }
-        resize(s-1);
-    }
-
-    // Removes exactly one occurrence of the given value from the array. Returns false if none was found.
-    bool removeOne(const T& value) {
-    for(int a = 0; a < s; ++a) {
-        if(ptr[a] == value) {
-        erase(a);
-        return true;
-        }
-    }
-    return false;
-    }
-
-    T& back() {
-        return ptr[s-1];
-    }
-
-    const T& back() const {
-        return ptr[s-1];
-    }
-
-    void pop_back() {
-        Q_ASSERT(s > 0);
-        resize(s-1);
-    }
-
-private:
-    void realloc(int size, int alloc);
-
-    int a;
-    int s;
-    T *ptr;
-    union {
-        // ### Qt 5: Use 'Prealloc * sizeof(T)' as array size
-        char array[sizeof(qint64) * (((Prealloc * sizeof(T)) / sizeof(qint64)) + 1)];
-        qint64 q_for_alignment_1;
-        double q_for_alignment_2;
-    };
-};
-
-template <class T, int Prealloc>
-Q_INLINE_TEMPLATE KDevVarLengthArray<T, Prealloc>::KDevVarLengthArray(int asize)
-    : s(asize) {
-    if (s > Prealloc) {
-        ptr = reinterpret_cast<T *>(qMalloc(s * sizeof(T)));
-        a = s;
-    } else {
-        ptr = reinterpret_cast<T *>(array);
-        a = Prealloc;
-    }
-    if (QTypeInfo<T>::isComplex) {
-        T *i = ptr + s;
-        while (i != ptr)
-            new (--i) T;
-    }
-}
-
-template <class T, int Prealloc>
-Q_INLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::resize(int asize)
-{ Q_ASSERT(asize >= 0 && asize < 100000); realloc(asize, qMax(asize, a)); }
-
-template <class T, int Prealloc>
-Q_INLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::reserve(int asize)
-{ if (asize > a) realloc(s, asize); }
-
-template <class T, int Prealloc>
-Q_OUTOFLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::append(const T *abuf, int asize)
-{
-    Q_ASSERT(abuf);
-    if (asize <= 0)
-        return;
-
-    const int idx = s;
-    const int news = s + asize;
-    if (news >= a)
-        realloc(news, news<<1);
-    else
-        s = news;
-
-    if (QTypeInfo<T>::isComplex) {
-        T *i = ptr + idx;
-        T *j = i + asize;
-        while (i < j)
-            new (i++) T(*abuf++);
-    } else {
-        qMemCopy(&ptr[idx], abuf, asize * sizeof(T));
-    }
-}
-
-template <class T, int Prealloc>
-Q_OUTOFLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
-{
-    Q_ASSERT(aalloc >= asize);
-    T *oldPtr = ptr;
-    int osize = s;
-    s = asize;
-
-    if (aalloc != a) {
-        ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T)));
-        if (ptr) {
-            a = aalloc;
-
-            if (QTypeInfo<T>::isStatic) {
-                T *i = ptr + osize;
-                T *j = oldPtr + osize;
-                while (i != ptr) {
-                    new (--i) T(*--j);
-                    j->~T();
-                }
-            } else {
-                qMemCopy(ptr, oldPtr, osize * sizeof(T));
-            }
-        } else {
-            ptr = oldPtr;
-            s = 0;
-            asize = 0;
-        }
-    }
-
-    if (QTypeInfo<T>::isComplex) {
-        if (asize < osize) {
-            T *i = oldPtr + osize;
-            T *j = oldPtr + asize;
-            while (i-- != j)
-                i->~T();
-        } else {
-            T *i = ptr + asize;
-            T *j = ptr + osize;
-            while (i != j)
-                new (--i) T;
-        }
-    }
-
-    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
-        qFree(oldPtr);
-}
-#endif
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif // QVARLENGTHARRAY_H
+/****************************************************************************
+**
+** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License versions 2.0 or 3.0 as published by the Free Software
+** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file.  Alternatively you may (at
+** your option) use any later version of the GNU General Public
+** License if such license has been publicly approved by Trolltech ASA
+** (or its successors, if any) and the KDE Free Qt Foundation. In
+** addition, as a special exception, Trolltech gives you certain
+** additional rights. These rights are described in the Trolltech GPL
+** Exception version 1.2, which can be found at
+** http://www.trolltech.com/products/qt/gplexception/ and in the file
+** GPL_EXCEPTION.txt in this package.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
+** you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** In addition, as a special exception, Trolltech, as the sole
+** copyright holder for Qt Designer, grants users of the Qt/Eclipse
+** Integration plug-in the right for the Qt/Eclipse Integration to
+** link to functionality provided by Qt Designer and its related
+** libraries.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
+** granted herein.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#ifndef KDEVVARLENGTHARRAY_H
+#define KDEVVARLENGTHARRAY_H
+
+//#include <QtCore/qcontainerfwd.h>
+#include <QtCore/QtGlobal>
+#include <QtCore/QVector>
+#include <new>
+
+///Foreach macro that also works with QVarLengthArray or KDevVarLengthArray
+///@warning Unlike the Qt foreach macro, this does not temporarily copy the array, which its size must not be changed while the iteration.
+#define FOREACH_ARRAY(item, container) for(int a = 0, mustDo = 1; a < container.size(); ++a) if((mustDo == 0 || mustDo == 1) && (mustDo = 2)) for(item(container[a]); mustDo; mustDo = 0)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+//When this is uncommented, a QVector will be used instead of a variable-length array. This is useful for debugging, to find problems in KDevVarLengthArray
+// #define FAKE_KDEVVARLENGTH_ARRAY
+
+#ifdef FAKE_KDEVVARLENGTH_ARRAY
+template<class T, int Prealloc = 256>
+class KDevVarLengthArray : public QVector<T> {
+    public:
+    ///Inserts the given item at the given position, moving all items behind the position back
+    void insert(const T& item, int position) {
+    QVector<T>::insert(position, item);
+    }
+
+    // Removes exactly one occurrence of the given value from the array. Returns false if none was found.
+    bool removeOne(const T& value) {
+    int i = this->indexOf(value);
+    if(i == -1)
+    return false;
+    erase(i);
+    return true;
+    }
+    void erase(int pos) {
+    this->remove(pos);
+    }
+    void append(const T& item) {
+        QVector<T>::append(item);
+    }
+    
+    void pop_back() {
+        Q_ASSERT(!this->isEmpty());
+        QVector<T>::pop_back();
+    }
+    
+    void append(const T *buf, int size) {
+    for(int a = 0; a < size; ++a)
+        append(buf[a]);
+    }
+};
+#else
+
+template<class T, int Prealloc = 256>
+class KDevVarLengthArray
+{
+public:
+    inline explicit KDevVarLengthArray(int size = 0);
+
+    inline KDevVarLengthArray(const KDevVarLengthArray<T, Prealloc> &other)
+        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
+    {
+        append(other.constData(), other.size());
+    }
+
+    inline ~KDevVarLengthArray() {
+        if (QTypeInfo<T>::isComplex) {
+            T *i = ptr + s;
+            while (i-- > ptr)
+                i->~T();
+        }
+        if (ptr != reinterpret_cast<T *>(array))
+            qFree(ptr);
+    }
+    inline KDevVarLengthArray<T, Prealloc> &operator=(const KDevVarLengthArray<T, Prealloc> &other)
+    {
+        if (this != &other) {
+            clear();
+            append(other.constData(), other.size());
+        }
+        return *this;
+    }
+
+    inline int size() const { return s; }
+    inline int count() const { return s; }
+    inline bool isEmpty() const { return (s == 0); }
+    inline void resize(int size);
+    inline void clear() { resize(0); }
+
+    inline int capacity() const { return a; }
+    inline void reserve(int size);
+
+    inline T &operator[](int idx) {
+        Q_ASSERT(idx >= 0 && idx < s);
+        return ptr[idx];
+    }
+    inline const T &operator[](int idx) const {
+        Q_ASSERT(idx >= 0 && idx < s);
+        return ptr[idx];
+    }
+
+    ///Returns the index of the given item in this array, or -1
+    int indexOf(const T& t) const {
+        for(int a = 0; a < s; ++a)
+            if(t == ptr[a])
+                return a;
+        return -1;
+    }
+    
+    inline KDevVarLengthArray& operator<<(const T &t) {
+        append(t);
+        return *this;
+    }
+
+    inline void append(const T &t) {
+        const int idx = s++;
+        ///This is currently the difference to KDevVarLengthArray(which uses s == a), and it prevents a crash.
+        if (s >= a)
+            realloc(s, s<<1);
+        if (QTypeInfo<T>::isComplex) {
+            new (ptr + idx) T(t);
+        } else {
+            ptr[idx] = t;
+        }
+    }
+    void append(const T *buf, int size);
+
+    inline T *data() { return ptr; }
+    inline const T *data() const { return ptr; }
+    inline const T * constData() const { return ptr; }
+
+    ///Returns whether the given item is contained in this array
+    bool contains(const T& value) const {
+      for(int a = 0; a < s; ++a)
+          if(ptr[a] == value)
+          return true;
+
+      return false;
+    }
+
+    ///Inserts the given item at the given position, moving all items behind the position back
+    void insert(const T& item, int position) {
+        Q_ASSERT(position >= 0 && position <= size());
+        resize(s+1);
+        for(int a = s-1; a > position; --a) {
+            ptr[a] = ptr[a-1];
+        }
+        ptr[position] = item;
+    }
+
+    ///Removes the given position from the array, moving all items behind it one back.
+    void erase(int position) {
+        Q_ASSERT(position >= 0 && position < s);
+        for(int a = position; a < s-1; ++a) {
+            ptr[a] = ptr[a+1];
+        }
+        resize(s-1);
+    }
+
+    // Removes exactly one occurrence of the given value from the array. Returns false if none was found.
+    bool removeOne(const T& value) {
+    for(int a = 0; a < s; ++a) {
+        if(ptr[a] == value) {
+        erase(a);
+        return true;
+        }
+    }
+    return false;
+    }
+
+    T& back() {
+        return ptr[s-1];
+    }
+
+    const T& back() const {
+        return ptr[s-1];
+    }
+
+    void pop_back() {
+        Q_ASSERT(s > 0);
+        resize(s-1);
+    }
+
+private:
+    void realloc(int size, int alloc);
+
+    int a;
+    int s;
+    T *ptr;
+    union {
+        // ### Qt 5: Use 'Prealloc * sizeof(T)' as array size
+        char array[sizeof(qint64) * (((Prealloc * sizeof(T)) / sizeof(qint64)) + 1)];
+        qint64 q_for_alignment_1;
+        double q_for_alignment_2;
+    };
+};
+
+template <class T, int Prealloc>
+Q_INLINE_TEMPLATE KDevVarLengthArray<T, Prealloc>::KDevVarLengthArray(int asize)
+    : s(asize) {
+    if (s > Prealloc) {
+        ptr = reinterpret_cast<T *>(qMalloc(s * sizeof(T)));
+        a = s;
+    } else {
+        ptr = reinterpret_cast<T *>(array);
+        a = Prealloc;
+    }
+    if (QTypeInfo<T>::isComplex) {
+        T *i = ptr + s;
+        while (i != ptr)
+            new (--i) T;
+    }
+}
+
+template <class T, int Prealloc>
+Q_INLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::resize(int asize)
+{ Q_ASSERT(asize >= 0 && asize < 100000); realloc(asize, qMax(asize, a)); }
+
+template <class T, int Prealloc>
+Q_INLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::reserve(int asize)
+{ if (asize > a) realloc(s, asize); }
+
+template <class T, int Prealloc>
+Q_OUTOFLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::append(const T *abuf, int asize)
+{
+    Q_ASSERT(abuf);
+    if (asize <= 0)
+        return;
+
+    const int idx = s;
+    const int news = s + asize;
+    if (news >= a)
+        realloc(news, news<<1);
+    else
+        s = news;
+
+    if (QTypeInfo<T>::isComplex) {
+        T *i = ptr + idx;
+        T *j = i + asize;
+        while (i < j)
+            new (i++) T(*abuf++);
+    } else {
+        qMemCopy(&ptr[idx], abuf, asize * sizeof(T));
+    }
+}
+
+template <class T, int Prealloc>
+Q_OUTOFLINE_TEMPLATE void KDevVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
+{
+    Q_ASSERT(aalloc >= asize);
+    T *oldPtr = ptr;
+    int osize = s;
+    s = asize;
+
+    if (aalloc != a) {
+        ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T)));
+        if (ptr) {
+            a = aalloc;
+
+            if (QTypeInfo<T>::isStatic) {
+                T *i = ptr + osize;
+                T *j = oldPtr + osize;
+                while (i != ptr) {
+                    new (--i) T(*--j);
+                    j->~T();
+                }
+            } else {
+                qMemCopy(ptr, oldPtr, osize * sizeof(T));
+            }
+        } else {
+            ptr = oldPtr;
+            s = 0;
+            asize = 0;
+        }
+    }
+
+    if (QTypeInfo<T>::isComplex) {
+        if (asize < osize) {
+            T *i = oldPtr + osize;
+            T *j = oldPtr + asize;
+            while (i-- != j)
+                i->~T();
+        } else {
+            T *i = ptr + asize;
+            T *j = ptr + osize;
+            while (i != j)
+                new (--i) T;
+        }
+    }
+
+    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
+        qFree(oldPtr);
+}
+#endif
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QVARLENGTHARRAY_H