rock-qtbindings 4.8.6.5

data/ext/generator/parser/dumptree.cpp

@@ -0,0 +1,146 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+    Copyright 2006 Hamish Rodda <rodda@kde.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.
+*/
+
+#include "dumptree.h"
+#include "lexer.h"
+#include "parsesession.h"
+
+#include <QtCore/QString>
+#include <QtCore/QtDebug>
+
+#include "rpp/chartools.h"
+
+char const * const names[] = {
+  0,
+  "AccessSpecifier",
+  "AsmDefinition",
+  "BaseClause",
+  "BaseSpecifier",
+  "BinaryExpression",
+  "CastExpression",
+  "ClassMemberAccess",
+  "ClassSpecifier",
+  "CompoundStatement",
+  "Condition",
+  "ConditionalExpression",
+  "CppCastExpression",
+  "CtorInitializer",
+  "DeclarationStatement",
+  "Declarator",
+  "DeleteExpression",
+  "DoStatement",
+  "ElaboratedTypeSpecifier",
+  "EnumSpecifier",
+  "Enumerator",
+  "ExceptionSpecification",
+  "ExpressionOrDeclarationStatement",
+  "ExpressionStatement",
+  "ForStatement",
+  "FunctionCall",
+  "FunctionDefinition",
+  "IfStatement",
+  "IncrDecrExpression",
+  "InitDeclarator",
+  "Initializer",
+  "InitializerClause",
+  "LabeledStatement",
+  "LinkageBody",
+  "LinkageSpecification",
+  "MemInitializer",
+  "Name",
+  "Namespace",
+  "NamespaceAliasDefinition",
+  "NewDeclarator",
+  "NewExpression",
+  "NewInitializer",
+  "NewTypeId",
+  "Operator",
+  "OperatorFunctionId",
+  "ParameterDeclaration",
+  "ParameterDeclarationClause",
+  "PostfixExpression",
+  "PrimaryExpression",
+  "PtrOperator",
+  "PtrToMember",
+  "ReturnStatement",
+  "SimpleDeclaration",
+  "SimpleTypeSpecifier",
+  "SizeofExpression",
+  "StringLiteral",
+  "SubscriptExpression",
+  "SwitchStatement",
+  "TemplateArgument",
+  "TemplateDeclaration",
+  "TemplateParameter",
+  "ThrowExpression",
+  "TranslationUnit",
+  "TryBlockStatement",
+  "CatchStatement",
+  "TypeId",
+  "TypeIdentification",
+  "TypeParameter",
+  "Typedef",
+  "UnaryExpression",
+  "UnqualifiedName",
+  "Using",
+  "UsingDirective",
+  "WhileStatement",
+  "WinDeclSpec",
+  "Kind_Comment",
+  "Kind_JumpStatement",
+  "Kind_SignalSlotExpression"
+};
+
+DumpTree::DumpTree()
+  : m_tokenStream(0), indent(0)
+{
+}
+
+void DumpTree::dump( AST * node, class TokenStream * tokenStream )
+{
+  m_tokenStream = tokenStream;
+  visit(node);
+  m_tokenStream = 0;
+}
+
+void DumpTree::visit(AST *node)
+{
+  QString nodeText;
+  if( m_tokenStream && node ) {
+    for( std::size_t a = node->start_token; a != node->end_token; a++ ) {
+      const Token& tok( m_tokenStream->token((int) a) );
+      nodeText += tok.symbolString() + ' ';
+    }
+  }
+  if (node)
+    qDebug() << QString(indent * 2, ' ').toLatin1().constData() << names[node->kind]
+             <<  "[" << node->start_token << "," << node->end_token << "]" << nodeText << endl;
+
+  ++indent;
+  DefaultVisitor::visit(node);
+  --indent;
+
+  if (node)
+    qDebug() << QString(indent * 2, ' ').toLatin1().constData() << names[node->kind];
+}
+
+DumpTree::~ DumpTree( )
+{
+}
+

data/ext/generator/parser/dumptree.h

@@ -0,0 +1,50 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+    Copyright 2006 Hamish Rodda <rodda@kde.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 DUMPTREE_H
+#define DUMPTREE_H
+
+#include <QtCore/Qt>
+
+#include "cppparser_export.h"
+#include "default_visitor.h"
+
+class TokenStream;
+
+//Contains the name for each AST kind enumerator
+CPPPARSER_EXPORT extern char const * const names[];
+
+class CPPPARSER_EXPORT DumpTree: protected DefaultVisitor
+{
+public:
+  DumpTree();
+  virtual ~DumpTree();
+
+  void dump(AST *node, TokenStream* tokenStream = 0);
+
+protected:
+  virtual void visit(AST *node);
+
+private:
+  TokenStream* m_tokenStream;
+  int indent;
+};
+
+#endif // DUMPTREE_H
+

data/ext/generator/parser/indexedstring.cpp

@@ -0,0 +1,213 @@
+/***************************************************************************
+   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <QtCore/QStringList>
+#include <QtCore/QUrl>
+#include <QtDebug>
+
+#include "indexedstring.h"
+// #include "repositories/stringrepository.h"
+
+// #include "referencecounting.h"
+
+Q_GLOBAL_STATIC(QStringList, strings);
+
+int getIndex(const QString& str) {
+    int idx = strings()->indexOf(str);
+    if (idx > -1) return idx;
+    strings()->append(str);
+    return strings()->count() - 1;
+}
+
+IndexedString::IndexedString() : m_index(0) {
+}
+
+///@param str must be a utf8 encoded string, does not need to be 0-terminated.
+///@param length must be its length in bytes.
+IndexedString::IndexedString( const char* str, unsigned short length, unsigned int hash ) {
+  if(!length)
+    m_index = 0;
+  else if(length == 1)
+    m_index = 0xffff0000 | str[0];
+  else {
+    m_index = getIndex(QString::fromUtf8(str, length));
+    /*QMutexLocker lock(globalIndexedStringRepository->mutex());
+    
+    m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hash ? hash : hashString(str, length), length));
+    
+    if(shouldDoDUChainReferenceCounting(this))
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
+  }
+}
+
+IndexedString::IndexedString( char c ) {
+  m_index = 0xffff0000 | c;
+}
+
+IndexedString::IndexedString( const QUrl& url ) {
+  QByteArray array(url.path().toUtf8());
+
+  const char* str = array.constData();
+
+  int size = array.size();
+
+  if(!size)
+    m_index = 0;
+  else if(size == 1)
+    m_index = 0xffff0000 | str[0];
+  else {
+    m_index = getIndex(QString::fromUtf8(str));
+    /*QMutexLocker lock(globalIndexedStringRepository->mutex());
+    m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, size), size));
+    
+    if(shouldDoDUChainReferenceCounting(this))
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
+  }
+}
+
+IndexedString::IndexedString( const QString& string ) {
+  QByteArray array(string.toUtf8());
+
+  const char* str = array.constData();
+
+  int size = array.size();
+
+  if(!size)
+    m_index = 0;
+  else if(size == 1)
+    m_index = 0xffff0000 | str[0];
+  else {
+    m_index = getIndex(string);
+    /*QMutexLocker lock(globalIndexedStringRepository->mutex());
+    m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, size), size));
+
+    if(shouldDoDUChainReferenceCounting(this))
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
+  }
+}
+
+IndexedString::IndexedString( const char* str) {
+  unsigned int length = strlen(str);
+  if(!length)
+    m_index = 0;
+  else if(length == 1)
+    m_index = 0xffff0000 | str[0];
+  else {
+    m_index = getIndex(QString::fromUtf8(str));
+    /*QMutexLocker lock(globalIndexedStringRepository->mutex());
+    m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, length), length));
+    
+    if(shouldDoDUChainReferenceCounting(this))
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
+  }
+}
+
+IndexedString::IndexedString( const QByteArray& str) {
+  unsigned int length = str.length();
+  if(!length)
+    m_index = 0;
+  else if(length == 1)
+    m_index = 0xffff0000 | str[0];
+  else {
+    m_index = getIndex(QString::fromUtf8(str));
+    /*QMutexLocker lock(globalIndexedStringRepository->mutex());
+    m_index = globalIndexedStringRepository->index(IndexedStringRepositoryItemRequest(str, hashString(str, length), length));
+    
+    if(shouldDoDUChainReferenceCounting(this))
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);*/
+  }
+}
+
+IndexedString::~IndexedString() {
+  /*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
+    if(shouldDoDUChainReferenceCounting(this)) {
+      QMutexLocker lock(globalIndexedStringRepository->mutex());
+    
+      decrease(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
+    }
+  }*/
+}
+
+IndexedString::IndexedString( const IndexedString& rhs ) : m_index(rhs.m_index) {
+  /*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
+    if(shouldDoDUChainReferenceCounting(this)) {
+      QMutexLocker lock(globalIndexedStringRepository->mutex());
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
+    }
+  }*/
+}
+
+IndexedString& IndexedString::operator=(const IndexedString& rhs) {
+  if(m_index == rhs.m_index)
+    return *this;
+  /*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
+    
+    if(shouldDoDUChainReferenceCounting(this)) {
+      QMutexLocker lock(globalIndexedStringRepository->mutex());
+      decrease(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
+    }
+  }*/
+  
+  m_index = rhs.m_index;
+  
+  /*if(m_index && (m_index & 0xffff0000) != 0xffff0000) {
+    if(shouldDoDUChainReferenceCounting(this)) {
+      QMutexLocker lock(globalIndexedStringRepository->mutex());
+      increase(globalIndexedStringRepository->dynamicItemFromIndexSimple(m_index)->refCount);
+    }
+  }*/
+  
+  return *this;
+}
+
+
+QUrl IndexedString::toUrl() const {
+  QUrl url( str() );
+  return url;
+}
+
+QString IndexedString::str() const {
+  if(!m_index)
+    return QString();
+  else if((m_index & 0xffff0000) == 0xffff0000)
+    return QString(QChar((char)m_index & 0xff));
+  else
+    return strings()->at(m_index); /*stringFromItem(globalIndexedStringRepository->itemFromIndex(m_index));*/
+}
+
+int IndexedString::length() const {
+  if(!m_index)
+    return 0;
+  else if((m_index & 0xffff0000) == 0xffff0000)
+    return 1;
+  else
+    return strings()->at(m_index).length(); /*globalIndexedStringRepository->itemFromIndex(m_index)->length;*/
+}
+
+QByteArray IndexedString::byteArray() const {
+  if(!m_index)
+    return QByteArray();
+  else if((m_index & 0xffff0000) == 0xffff0000)
+    return QString(QChar((char)m_index & 0xff)).toUtf8();
+  else
+    return strings()->at(m_index).toUtf8(); /*arrayFromItem(globalIndexedStringRepository->itemFromIndex(m_index));*/
+}
+
+unsigned int IndexedString::hashString(const char* str, unsigned short length) {
+  RunningHash running;
+  for(int a = length-1; a >= 0; --a) {
+    running.append(*str);
+    ++str;
+  }
+  return running.hash;
+}

data/ext/generator/parser/indexedstring.h

@@ -0,0 +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

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

@@ -0,0 +1 @@
+1010222