rock-qtbindings 4.8.6.5

data/ext/generator/parser/tokens.cpp

@@ -0,0 +1,367 @@
+/* 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 "tokens.h"
+
+#include <QtCore/qglobal.h>
+
+
+static char const * const _S_token_names[] = {
+  "K_DCOP",
+  "Q_OBJECT",
+  "__attribute__",
+  "__typeof",
+  "and",
+  "and_eq",
+  "arrow",
+  "asm",
+  "assign",
+  "auto",
+  "bitand",
+  "bitor",
+  "bool",
+  "break",
+  "case",
+  "catch",
+  "char",
+  "char_literal",
+  "class",
+  "comment",
+  "compl",
+  "concat",
+  "const",
+  "const_cast",
+  "continue",
+  "decr",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "dynamic_cast",
+  "ellipsis",
+  "else",
+  "emit",
+  "enum",
+  "eq",
+  "explicit",
+  "export",
+  "extern",
+  "false",
+  "float",
+  "for",
+  "friend",
+  "geq",
+  "goto",
+  "identifier",
+  "if",
+  "incr",
+  "inline",
+  "int",
+  "k_dcop",
+  "k_dcop_signals",
+  "leq",
+  "long",
+  "mutable",
+  "namespace",
+  "new",
+  "not",
+  "not_eq",
+  "number_literal",
+  "operator",
+  "or",
+  "or_eq",
+  "preproc",
+  "private",
+  "protected",
+  "ptrmem",
+  "public",
+  "register",
+  "reinterpret_cast",
+  "return",
+  "scope",
+  "shift",
+  "short",
+  "signals",
+  "signed",
+  "sizeof",
+  "size_t",
+  "slots",
+  "static",
+  "static_cast",
+  "string_literal",
+  "struct",
+  "switch",
+  "template",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "typeid",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "wchar_t",
+  "while",
+  "whitespaces",
+  "xor",
+  "xor_eq"
+};
+
+static char const * const _S_token_texts[] = {
+  "K_DCOP",
+  "Q_OBJECT",
+  "__attribute__",
+  "__typeof",
+  "&&",
+  "&=",
+  ">",
+  "asm",
+  "==",
+  "auto",
+  "&",
+  "|",
+  "bool",
+  "break",
+  "case",
+  "catch",
+  "char",
+  "char_literal",
+  "class",
+  "comment",
+  "~",
+  "concat",
+  "const",
+  "const_cast",
+  "continue",
+  "--",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "dynamic_cast",
+  "...",
+  "else",
+  "emit",
+  "enum",
+  "==",
+  "explicit",
+  "export",
+  "extern",
+  "false",
+  "float",
+  "for",
+  "friend",
+  ">=",
+  "goto",
+  "identifier",
+  "if",
+  "++",
+  "inline",
+  "int",
+  "k_dcop",
+  "k_dcop_signals",
+  "<=",
+  "long",
+  "mutable",
+  "namespace",
+  "new",
+  "!",
+  "!=",
+  "number_literal",
+  "operator",
+  "||",
+  "|=",
+  "preproc",
+  "private",
+  "protected",
+  "ptrmem",
+  "public",
+  "register",
+  "reinterpret_cast",
+  "return",
+  "::",
+  "shift",
+  "short",
+  "signals",
+  "signed",
+  "sizeof",
+  "size_t",
+  "slots",
+  "static",
+  "static_cast",
+  "string_literal",
+  "struct",
+  "switch",
+  "template",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "typeid",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "wchar_t",
+  "while",
+  "whitespaces",
+  "^",
+  "^="
+};
+
+static char _S_printable[][2] = {
+  { char(32), '\0' },
+  { char(33), '\0' },
+  { char(34), '\0' },
+  { char(35), '\0' },
+  { char(36), '\0' },
+  { char(37), '\0' },
+  { char(38), '\0' },
+  { char(39), '\0' },
+  { char(40), '\0' },
+  { char(41), '\0' },
+  { char(42), '\0' },
+  { char(43), '\0' },
+  { char(44), '\0' },
+  { char(45), '\0' },
+  { char(46), '\0' },
+  { char(47), '\0' },
+  { char(48), '\0' },
+  { char(49), '\0' },
+  { char(50), '\0' },
+  { char(51), '\0' },
+  { char(52), '\0' },
+  { char(53), '\0' },
+  { char(54), '\0' },
+  { char(55), '\0' },
+  { char(56), '\0' },
+  { char(57), '\0' },
+  { char(58), '\0' },
+  { char(59), '\0' },
+  { char(60), '\0' },
+  { char(61), '\0' },
+  { char(62), '\0' },
+  { char(63), '\0' },
+  { char(64), '\0' },
+  { char(65), '\0' },
+  { char(66), '\0' },
+  { char(67), '\0' },
+  { char(68), '\0' },
+  { char(69), '\0' },
+  { char(70), '\0' },
+  { char(71), '\0' },
+  { char(72), '\0' },
+  { char(73), '\0' },
+  { char(74), '\0' },
+  { char(75), '\0' },
+  { char(76), '\0' },
+  { char(77), '\0' },
+  { char(78), '\0' },
+  { char(79), '\0' },
+  { char(80), '\0' },
+  { char(81), '\0' },
+  { char(82), '\0' },
+  { char(83), '\0' },
+  { char(84), '\0' },
+  { char(85), '\0' },
+  { char(86), '\0' },
+  { char(87), '\0' },
+  { char(88), '\0' },
+  { char(89), '\0' },
+  { char(90), '\0' },
+  { char(91), '\0' },
+  { char(92), '\0' },
+  { char(93), '\0' },
+  { char(94), '\0' },
+  { char(95), '\0' },
+  { char(96), '\0' },
+  { char(97), '\0' },
+  { char(98), '\0' },
+  { char(99), '\0' },
+  { char(100), '\0' },
+  { char(101), '\0' },
+  { char(102), '\0' },
+  { char(103), '\0' },
+  { char(104), '\0' },
+  { char(105), '\0' },
+  { char(106), '\0' },
+  { char(107), '\0' },
+  { char(108), '\0' },
+  { char(109), '\0' },
+  { char(110), '\0' },
+  { char(111), '\0' },
+  { char(112), '\0' },
+  { char(113), '\0' },
+  { char(114), '\0' },
+  { char(115), '\0' },
+  { char(116), '\0' },
+  { char(117), '\0' },
+  { char(118), '\0' },
+  { char(119), '\0' },
+  { char(120), '\0' },
+  { char(121), '\0' },
+  { char(122), '\0' },
+  { char(123), '\0' },
+  { char(124), '\0' },
+  { char(125), '\0' },
+  { char(126), '\0' },
+  { char(127), '\0' },
+  { char(128), '\0' },
+};
+
+char const *token_name(int token)
+{
+  if (token == 0)
+    {
+      return "eof";
+    }
+  else if (token >= 32 && token <= 127)
+    {
+      return _S_printable[token - 32];
+    }
+  else if (token >= 1000)
+    {
+      return _S_token_names[token - 1000];
+    }
+
+  Q_ASSERT(0);
+  return 0;
+}
+
+char const *token_text(int token)
+{
+  if (token >= 32 && token <= 127)
+    {
+      return _S_printable[token - 32];
+    }
+  else if (token >= 1000)
+    {
+      return _S_token_texts[token - 1000];
+    }
+
+  return 0;
+}

data/ext/generator/parser/tokens.h

@@ -0,0 +1,148 @@
+/* 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_size_t,
+    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
+