qtbindings 4.6.3.0

data/ext/generator/parser/default_visitor.h

@@ -0,0 +1,116 @@
+/* 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 DEFAULT_VISITOR_H
+#define DEFAULT_VISITOR_H
+
+#include <QtCore/Qt>
+
+#include "cppparser_export.h"
+#include "visitor.h"
+
+class CPPPARSER_EXPORT DefaultVisitor: public Visitor
+{
+public:
+  DefaultVisitor() {}
+
+protected:
+  virtual void visitAccessSpecifier(AccessSpecifierAST *);
+  virtual void visitAsmDefinition(AsmDefinitionAST *);
+  virtual void visitBaseClause(BaseClauseAST *);
+  virtual void visitBaseSpecifier(BaseSpecifierAST *);
+  virtual void visitBinaryExpression(BinaryExpressionAST *);
+  virtual void visitCastExpression(CastExpressionAST *);
+  virtual void visitClassMemberAccess(ClassMemberAccessAST *);
+  virtual void visitClassSpecifier(ClassSpecifierAST *);
+  virtual void visitCompoundStatement(CompoundStatementAST *);
+  virtual void visitCondition(ConditionAST *);
+  virtual void visitConditionalExpression(ConditionalExpressionAST *);
+  virtual void visitCppCastExpression(CppCastExpressionAST *);
+  virtual void visitCtorInitializer(CtorInitializerAST *);
+  virtual void visitDeclarationStatement(DeclarationStatementAST *);
+  virtual void visitDeclarator(DeclaratorAST *);
+  virtual void visitDeleteExpression(DeleteExpressionAST *);
+  virtual void visitDoStatement(DoStatementAST *);
+  virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *);
+  virtual void visitEnumSpecifier(EnumSpecifierAST *);
+  virtual void visitEnumerator(EnumeratorAST *);
+  virtual void visitExceptionSpecification(ExceptionSpecificationAST *);
+  virtual void visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST *);
+  virtual void visitExpressionStatement(ExpressionStatementAST *);
+  virtual void visitForStatement(ForStatementAST *);
+  virtual void visitFunctionCall(FunctionCallAST *);
+  virtual void visitFunctionDefinition(FunctionDefinitionAST *);
+  virtual void visitIfStatement(IfStatementAST *);
+  virtual void visitIncrDecrExpression(IncrDecrExpressionAST *);
+  virtual void visitInitDeclarator(InitDeclaratorAST *);
+  virtual void visitInitializer(InitializerAST *);
+  virtual void visitInitializerClause(InitializerClauseAST *);
+  virtual void visitJumpStatement(JumpStatementAST *);
+  virtual void visitLabeledStatement(LabeledStatementAST *);
+  virtual void visitLinkageBody(LinkageBodyAST *);
+  virtual void visitLinkageSpecification(LinkageSpecificationAST *);
+  virtual void visitMemInitializer(MemInitializerAST *);
+  virtual void visitName(NameAST *);
+  virtual void visitNamespace(NamespaceAST *);
+  virtual void visitNamespaceAliasDefinition(NamespaceAliasDefinitionAST *);
+  virtual void visitNewDeclarator(NewDeclaratorAST *);
+  virtual void visitNewExpression(NewExpressionAST *);
+  virtual void visitNewInitializer(NewInitializerAST *);
+  virtual void visitNewTypeId(NewTypeIdAST *);
+  virtual void visitOperator(OperatorAST *);
+  virtual void visitOperatorFunctionId(OperatorFunctionIdAST *);
+  virtual void visitParameterDeclaration(ParameterDeclarationAST *);
+  virtual void visitParameterDeclarationClause(ParameterDeclarationClauseAST *);
+  virtual void visitPostfixExpression(PostfixExpressionAST *);
+  virtual void visitPrimaryExpression(PrimaryExpressionAST *);
+  virtual void visitPtrOperator(PtrOperatorAST *);
+  virtual void visitPtrToMember(PtrToMemberAST *);
+  virtual void visitReturnStatement(ReturnStatementAST *);
+  virtual void visitSimpleDeclaration(SimpleDeclarationAST *);
+  virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *);
+  virtual void visitSizeofExpression(SizeofExpressionAST *);
+  virtual void visitStringLiteral(StringLiteralAST *);
+  virtual void visitSubscriptExpression(SubscriptExpressionAST *);
+  virtual void visitSwitchStatement(SwitchStatementAST *);
+  virtual void visitTemplateArgument(TemplateArgumentAST *);
+  virtual void visitTemplateDeclaration(TemplateDeclarationAST *);
+  virtual void visitTemplateParameter(TemplateParameterAST *);
+  virtual void visitThrowExpression(ThrowExpressionAST *);
+  virtual void visitTranslationUnit(TranslationUnitAST *);
+  virtual void visitTryBlockStatement(TryBlockStatementAST *);
+  virtual void visitCatchStatement(CatchStatementAST *);
+  virtual void visitTypeId(TypeIdAST *);
+  virtual void visitTypeIdentification(TypeIdentificationAST *);
+  virtual void visitTypeParameter(TypeParameterAST *);
+  virtual void visitTypedef(TypedefAST *);
+  virtual void visitUnaryExpression(UnaryExpressionAST *);
+  virtual void visitUnqualifiedName(UnqualifiedNameAST *);
+  virtual void visitUsing(UsingAST *);
+  virtual void visitUsingDirective(UsingDirectiveAST *);
+  virtual void visitWhileStatement(WhileStatementAST *);
+  virtual void visitWinDeclSpec(WinDeclSpecAST *);
+  virtual void visitSignalSlotExpression(SignalSlotExpressionAST *);
+
+private:
+  typedef void (Visitor::*visitor_fun_ptr)(AST *);
+  static visitor_fun_ptr _S_table[];
+};
+
+#endif // VISITOR_H
+

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;
+}