qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/parser/tokens.h

@@ -0,0 +1,147 @@
+/* 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 TOKENS_H
+#define TOKENS_H
+
+#include "cppparser_export.h"
+
+#include <QtCore/Qt>
+
+/**@file Token kinds.*/
+
+/**Token kinds.*/
+enum TOKEN_KIND
+{
+    Token_EOF = 0,
+
+    Token_K_DCOP = 1000,
+    Token_Q_OBJECT,
+    Token___attribute__,
+    Token___typeof,
+    Token_and,
+    Token_and_eq,
+    Token_arrow,
+    Token_asm,
+    Token_assign,
+    Token_auto,
+    Token_bitand,
+    Token_bitor,
+    Token_bool,
+    Token_break,
+    Token_case,
+    Token_catch,
+    Token_char,
+    Token_char_literal,
+    Token_class,
+    Token_comment,
+    Token_compl,
+    Token_concat,
+    Token_const,
+    Token_const_cast,
+    Token_continue,
+    Token_decr,
+    Token_default,
+    Token_delete,
+    Token_do,
+    Token_double,
+    Token_dynamic_cast,
+    Token_ellipsis,
+    Token_else,
+    Token_emit,
+    Token_enum,
+    Token_eq,
+    Token_explicit,
+    Token_export,
+    Token_extern,
+    Token_false,
+    Token_float,
+    Token_for,
+    Token_friend,
+    Token_geq,
+    Token_goto,
+    Token_identifier,
+    Token_if,
+    Token_incr,
+    Token_inline,
+    Token_int,
+    Token_k_dcop,
+    Token_k_dcop_signals,
+    Token_leq,
+    Token_long,
+    Token_mutable,
+    Token_namespace,
+    Token_new,
+    Token_not,
+    Token_not_eq,
+    Token_number_literal,
+    Token_operator,
+    Token_or,
+    Token_or_eq,
+    Token_preproc,
+    Token_private,
+    Token_protected,
+    Token_ptrmem,
+    Token_public,
+    Token_register,
+    Token_reinterpret_cast,
+    Token_return,
+    Token_scope,
+    Token_shift,
+    Token_short,
+    Token_signals,
+    Token_signed,
+    Token_sizeof,
+    Token_slots,
+    Token_static,
+    Token_static_cast,
+    Token_string_literal,
+    Token_struct,
+    Token_switch,
+    Token_template,
+    Token_this,
+    Token_throw,
+    Token_true,
+    Token_try,
+    Token_typedef,
+    Token_typeid,
+    Token_typename,
+    Token_union,
+    Token_unsigned,
+    Token_using,
+    Token_virtual,
+    Token_void,
+    Token_volatile,
+    Token_wchar_t,
+    Token_while,
+    Token_whitespaces,
+    Token_xor,
+    Token_xor_eq,
+    Token___qt_sig_slot__,
+
+    TOKEN_KIND_COUNT
+};
+
+/**@return human-readable name of the token.*/
+CPPPARSER_EXPORT char const *token_name(int token);
+
+/**@return text corresponding to the token.*/
+CPPPARSER_EXPORT char const *token_text(int token);
+
+#endif
+

data/ext/generator/parser/type_compiler.cpp

@@ -0,0 +1,135 @@
+/* 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.
+*/
+
+#include "type_compiler.h"
+#include "name_compiler.h"
+#include "lexer.h"
+#include "symbol.h"
+#include "tokens.h"
+#include "parsesession.h"
+
+#include <QtCore/QString>
+
+// using namespace KDevelop;
+
+TypeCompiler::TypeCompiler(ParseSession* session)
+  : m_session(session), m_integral(false)
+{
+}
+
+void TypeCompiler::run(TypeSpecifierAST *node)
+{
+  m_type.clear();
+  _M_cv.clear();
+
+  visit(node);
+
+  if (node && node->cv)
+    {
+      const ListNode<std::size_t> *it = node->cv->toFront();
+      const ListNode<std::size_t> *end = it;
+      do
+        {
+          int kind = m_session->token_stream->kind(it->element);
+          if (! _M_cv.contains(kind))
+            _M_cv.append(kind);
+
+          it = it->next;
+        }
+      while (it != end);
+    }
+}
+
+void TypeCompiler::visitClassSpecifier(ClassSpecifierAST *node)
+{
+  visit(node->name);
+}
+
+void TypeCompiler::visitEnumSpecifier(EnumSpecifierAST *node)
+{
+  visit(node->name);
+}
+
+void TypeCompiler::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
+{
+  visit(node->name);
+}
+
+void TypeCompiler::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
+{
+  if (const ListNode<std::size_t> *it = node->integrals)
+    {
+      m_integral = true;
+      it = it->toFront();
+      const ListNode<std::size_t> *end = it;
+      do
+        {
+          std::size_t token = it->element;
+          // FIXME
+          m_type.push_back(token_name(m_session->token_stream->kind(token)));
+          it = it->next;
+        }
+      while (it != end);
+    }
+  else if (node->type_of)
+    {
+      qDebug("*** type of");
+      // ### implement me
+      m_type.push_back("typeof<...>");
+    }
+
+  visit(node->name);
+}
+
+void TypeCompiler::visitName(NameAST *node)
+{
+  NameCompiler name_cc(m_session);
+  name_cc.run(node);
+  m_type = name_cc.qualifiedName();
+}
+
+QStringList TypeCompiler::cvString() const
+{
+  QStringList lst;
+
+  foreach (int q, cv())
+    {
+      if (q == Token_const)
+        lst.append(QLatin1String("const"));
+      else if (q == Token_volatile)
+        lst.append(QLatin1String("volatile"));
+    }
+
+  return lst;
+}
+
+bool TypeCompiler::isConstant() const
+{
+    return _M_cv.contains(Token_const);
+}
+
+bool TypeCompiler::isVolatile() const
+{
+    return _M_cv.contains(Token_volatile);
+}
+
+/*QualifiedIdentifier TypeCompiler::identifier() const
+{
+  return _M_type;
+}*/
+

data/ext/generator/parser/type_compiler.h

@@ -0,0 +1,68 @@
+/* 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 TYPE_COMPILER_H
+#define TYPE_COMPILER_H
+
+#include "cppparser_export.h"
+#include "default_visitor.h"
+// #include <language/duchain/identifier.h>
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QList>
+
+class ParseSession;
+
+class CPPPARSER_EXPORT TypeCompiler: protected DefaultVisitor
+{
+public:
+  TypeCompiler(ParseSession* session);
+
+//   KDevelop::QualifiedIdentifier identifier() const;
+  inline const QStringList& qualifiedName() const { return m_type; }
+  inline QString name() const { if (m_integral) return m_type.join(" "); else return m_type.join("::"); }
+  inline QList<int> cv() const { return _M_cv; }
+
+  bool isConstant() const;
+  bool isVolatile() const;
+
+  bool isIntegral() const { return m_integral; }
+
+  QStringList cvString() const;
+
+  void run(TypeSpecifierAST *node);
+
+protected:
+  virtual void visitClassSpecifier(ClassSpecifierAST *node);
+  virtual void visitEnumSpecifier(EnumSpecifierAST *node);
+  virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node);
+  virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node);
+
+  virtual void visitName(NameAST *node);
+
+private:
+  ParseSession* m_session;
+  QStringList m_type;
+//   KDevelop::QualifiedIdentifier _M_type;
+  QList<int> _M_cv;
+  bool m_integral;
+};
+
+#endif // TYPE_COMPILER_H
+

data/ext/generator/parser/visitor.cpp

@@ -0,0 +1,115 @@
+/* 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.
+*/
+
+#include "visitor.h"
+
+Visitor::visitor_fun_ptr Visitor::_S_table[AST::NODE_KIND_COUNT] = {
+  0,
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitAccessSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitAsmDefinition),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBaseClause),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBaseSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitBinaryExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCastExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitClassMemberAccess),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitClassSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCompoundStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCondition),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitConditionalExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCppCastExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCtorInitializer),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeclarationStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeclarator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDeleteExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitDoStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitElaboratedTypeSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitEnumSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitEnumerator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExceptionSpecification),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExpressionOrDeclarationStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitExpressionStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitForStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitFunctionCall),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitFunctionDefinition),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitIfStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitIncrDecrExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitDeclarator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitializer),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitInitializerClause),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLabeledStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLinkageBody),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitLinkageSpecification),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitMemInitializer),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitName),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNamespace),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNamespaceAliasDefinition),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewDeclarator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewInitializer),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitNewTypeId),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitOperator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitOperatorFunctionId),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitParameterDeclaration),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitParameterDeclarationClause),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPostfixExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPrimaryExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPtrOperator),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitPtrToMember),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitReturnStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSimpleDeclaration),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSimpleTypeSpecifier),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSizeofExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitStringLiteral),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSubscriptExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSwitchStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateArgument),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateDeclaration),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTemplateParameter),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitThrowExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTranslationUnit),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTryBlockStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitCatchStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeId),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeIdentification),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypeParameter),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitTypedef),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUnaryExpression),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUnqualifiedName),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUsing),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitUsingDirective),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitWhileStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitWinDeclSpec),
+  0,
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitJumpStatement),
+  reinterpret_cast<Visitor::visitor_fun_ptr>(&Visitor::visitSignalSlotExpression)
+};
+
+Visitor::Visitor()
+{
+}
+
+Visitor::~Visitor()
+{
+}
+
+void Visitor::visit(AST *node)
+{
+  if (node)
+    (this->*_S_table[node->kind])(node);
+}
+