qtbindings 4.6.3.0-x86-mingw32

data/ext/generator/type_compiler.cpp

@@ -0,0 +1,275 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+    Copyright 2009 Arno Rehn <arno@arnorehn.de>
+
+   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 "generatorvisitor.h"
+#include "options.h"
+#include <lexer.h>
+#include <symbol.h>
+#include <tokens.h>
+#include <parsesession.h>
+
+#include <QtCore/QString>
+#include <QtDebug>
+
+TypeCompiler::TypeCompiler(ParseSession* session, GeneratorVisitor* visitor)
+  : m_session(session), m_visitor(visitor)
+{
+}
+
+void TypeCompiler::run(TypeSpecifierAST* node, const DeclaratorAST* declarator)
+{
+  m_type.clear();
+  m_realType = Type();
+  m_templateArgs.clear();
+  isRef = false;
+  pointerDepth.clear();
+  _M_cv.clear();
+
+  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);
+    }
+  visit(node);
+  
+  if (declarator)
+    run(declarator);
+}
+
+void TypeCompiler::run(const DeclaratorAST* declarator)
+{
+    if (declarator->ptr_ops)
+        run(declarator->ptr_ops);
+    
+    if (declarator->array_dimensions) {
+        const ListNode<ExpressionAST*>* it = declarator->array_dimensions->toFront(), *end = it;
+        int dim = 0;
+        m_realType.setArrayDimensions(declarator->array_dimensions->count());
+        do {
+            PrimaryExpressionAST* primary = ast_cast<PrimaryExpressionAST*>(it->element);
+            if (primary) {
+                QByteArray token = m_session->token_stream->token(primary->token).symbolByteArray();
+                bool ok = false;
+                int length = token.toInt(&ok);
+                if (ok) {
+                    m_realType.setArrayLength(dim++, length);
+                } else {
+                    m_realType.setPointerDepth(m_realType.pointerDepth() + 1);
+                }
+            } else {
+                m_realType.setPointerDepth(m_realType.pointerDepth() + 1);
+            }
+            it = it->next;
+        } while (it != end);
+        if (dim != m_realType.arrayDimensions()) {
+            m_realType.setArrayDimensions(dim);
+        }
+    }
+    
+    NameCompiler name_cc(m_session, m_visitor);
+    name_cc.run(declarator->id);
+    if (declarator->parameter_declaration_clause && declarator->sub_declarator && name_cc.qualifiedName().isEmpty()) {
+        m_realType.setIsFunctionPointer(true);
+        visit(declarator->parameter_declaration_clause);
+    }
+}
+
+void TypeCompiler::run(const ListNode< PtrOperatorAST* > *ptr_ops)
+{
+    visitNodes(this, ptr_ops);
+    if (isRef) m_realType.setIsRef(true);
+    int offset = m_realType.pointerDepth();
+    m_realType.setPointerDepth(offset + pointerDepth.count());
+    for (int i = 0; i < pointerDepth.count(); i++) {
+        if (pointerDepth[i])
+        m_realType.setIsConstPointer(offset + i, true);
+    }
+}
+
+void TypeCompiler::setRealType()
+{
+    QString typeName = m_type.join("::");
+    BasicTypeDeclaration* type = m_visitor->resolveType(typeName);
+    Class* klass;
+    Typedef* tdef;
+    Enum* e;
+    if ((klass = dynamic_cast<Class*>(type))) {
+        m_realType = Type(klass, isConstant(), isVolatile());
+    } else if ((tdef = dynamic_cast<Typedef*>(type))) {
+        if (!ParserOptions::resolveTypedefs) {
+            m_realType = Type(tdef);
+        } else {
+            m_realType = tdef->resolve();
+        }
+        if (isConstant()) m_realType.setIsConst(true);
+        if (isVolatile()) m_realType.setIsVolatile(true);
+    } else if ((e = dynamic_cast<Enum*>(type))) {
+        m_realType = Type(e, isConstant(), isVolatile());
+    } else {
+        if (!m_templateArgs.isEmpty() && m_type.count() > 1) {
+            typeName = QString();
+            // only go to the one before the last - the rest will be added as template parameters to the type directly
+            for (int i = 0; i < m_type.count() - 1; i++) {
+                typeName += m_type[i];
+                
+                // do we have template parameters for this part?
+                if (m_templateArgs.contains(i)) {
+                    typeName += "< ";
+                    for (int j = 0; j < m_templateArgs[i].count(); j++) {
+                        if (j > 0) typeName += ", ";
+                        typeName += m_templateArgs[i][j].toString();
+                    }
+                    typeName += " >";
+                }
+                typeName += "::";
+            }
+            typeName += m_type.last();
+        }
+        m_realType = Type(typeName, isConstant(), isVolatile());
+    }
+    
+    // only add template parameters if they belong to the last part of a qualified type
+    if (m_templateArgs.contains(m_type.count() - 1) && m_realType.templateArguments().isEmpty())
+        m_realType.setTemplateArguments(m_templateArgs[m_type.count() - 1]);
+}
+
+void TypeCompiler::visitClassSpecifier(ClassSpecifierAST *node)
+{
+  visit(node->name);
+}
+
+
+void TypeCompiler::visitEnumSpecifier(EnumSpecifierAST *node)
+{
+  visit(node->name);
+}
+
+void TypeCompiler::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node)
+{
+    visit(node->name);
+    setRealType();
+}
+
+void TypeCompiler::visitParameterDeclaration(ParameterDeclarationAST* node)
+{
+    TypeCompiler tc(m_session, m_visitor);
+    tc.run(node->type_specifier, node->declarator);
+    NameCompiler name_cc(m_session, m_visitor);
+    if (tc.type().isFunctionPointer())
+        name_cc.run(node->declarator->sub_declarator->id);
+    else if (node->declarator)
+        name_cc.run(node->declarator->id);
+    m_realType.appendParameter(Parameter(name_cc.name(), Type::registerType(tc.type())));
+}
+
+void TypeCompiler::visitPtrOperator(PtrOperatorAST* node)
+{
+    if (token_text(m_session->token_stream->kind(node->op))[0] == '*') {
+        QPair<bool, bool> cv = m_visitor->parseCv(node->cv);
+        pointerDepth.append(cv.first);
+    } else if (token_text(m_session->token_stream->kind(node->op))[0] == '&') {
+        isRef = true;
+    }
+}
+
+void TypeCompiler::visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node)
+{
+  if (const ListNode<std::size_t> *it = node->integrals)
+    {
+      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)
+    {
+      // ### implement me
+      m_type.push_back("typeof<...>");
+    }
+
+  visit(node->name);
+  
+  if (node->integrals) {
+    m_realType = Type(m_type.join(" "), isConstant(), isVolatile());
+    if (m_realType.name() == "unsigned") {
+        // implicit int..
+        m_realType.setName("unsigned int");
+    }
+    m_realType.setIsIntegral(true);
+  } else {
+    setRealType();
+  }
+}
+
+void TypeCompiler::visitName(NameAST *node)
+{
+
+  NameCompiler name_cc(m_session, m_visitor);
+  name_cc.run(node);
+  m_type = name_cc.qualifiedName();
+  m_templateArgs = name_cc.templateArguments();
+}
+
+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/type_compiler.h

@@ -0,0 +1,80 @@
+/* This file is part of KDevelop
+    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
+    Copyright 2009 Arno Rehn <arno@arnorehn.de>
+
+   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 "generator_export.h"
+#include "default_visitor.h"
+#include "type.h"
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QList>
+#include <QtCore/QVector>
+
+class ParseSession;
+class GeneratorVisitor;
+
+class GENERATOR_EXPORT TypeCompiler: protected DefaultVisitor
+{
+public:
+  TypeCompiler(ParseSession* session, GeneratorVisitor* visitor);
+
+//   KDevelop::QualifiedIdentifier identifier() const;
+  inline const QStringList& qualifiedName() const { return m_type; }
+  inline QList<int> cv() const { return _M_cv; }
+
+  bool isConstant() const;
+  bool isVolatile() const;
+
+  QStringList cvString() const;
+
+  const Type& type() const { return m_realType; }
+
+  void run(TypeSpecifierAST *node, const DeclaratorAST* declarator = 0);
+  void run(const DeclaratorAST *declarator);
+  void run(const ListNode<PtrOperatorAST*> *ptr_ops);
+
+protected:
+  void setRealType();
+  
+  virtual void visitClassSpecifier(ClassSpecifierAST *node);
+  virtual void visitEnumSpecifier(EnumSpecifierAST *node);
+  virtual void visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST *node);
+  virtual void visitParameterDeclaration(ParameterDeclarationAST* node);
+  virtual void visitPtrOperator(PtrOperatorAST* node);
+  virtual void visitSimpleTypeSpecifier(SimpleTypeSpecifierAST *node);
+
+  virtual void visitName(NameAST *node);
+
+private:
+  ParseSession* m_session;
+  GeneratorVisitor* m_visitor;
+  QStringList m_type;
+//   KDevelop::QualifiedIdentifier _M_type;
+  QList<int> _M_cv;
+  Type m_realType;
+  bool isRef;
+  QVector<bool> pointerDepth;
+  QMap<int, QList<Type> > m_templateArgs;
+};
+
+#endif // TYPE_COMPILER_H
+

data/ext/ruby/CMakeLists.txt

@@ -0,0 +1,63 @@
+project(Ruby)
+
+set(COMPILE_RUBY FALSE CACHE INTERNAL "")
+
+macro_optional_find_package(Ruby)
+
+if (RUBY_LIBRARY AND RUBY_INCLUDE_DIRS AND RUBY_EXECUTABLE)
+    set(COMPILE_RUBY TRUE CACHE INTERNAL "")
+endif (RUBY_LIBRARY AND RUBY_INCLUDE_DIRS AND RUBY_EXECUTABLE)
+
+macro_log_feature(COMPILE_RUBY "Ruby" "Ruby interpreter and libraries" "http://www.ruby-lang.org" FALSE "" "Needed to compile the Ruby bindings")
+
+if (NOT COMPILE_RUBY)
+    message(STATUS "Ruby Not Found Successfully")
+endif (NOT COMPILE_RUBY)
+
+SET(CUSTOM_RUBY_SITE_ARCH_DIR ${RUBY_SITEARCH_DIR} CACHE DIR "custom installation directory for ruby binary extension" )
+SET(CUSTOM_RUBY_SITE_LIB_DIR ${RUBY_SITELIB_DIR} CACHE DIR "custom installation directory for ruby extension" )
+
+# compute an overall version number which can be compared at once
+MATH(EXPR RUBY_VERSION_NUMBER "${RUBY_VERSION_MAJOR}*10000 + ${RUBY_VERSION_MINOR}*100 + ${RUBY_VERSION_PATCH}")
+
+macro_optional_add_bindings(QT_QTCORE_FOUND "QtRuby" qtruby)
+macro_optional_add_bindings(QT_QTWEBKIT_FOUND "QtWebKit" qtwebkit)
+macro_optional_add_bindings(QT_QTUITOOLS_FOUND "QtUiTools" qtuitools)
+macro_optional_add_bindings(QT_QTSCRIPT_FOUND "QtScript" qtscript)
+macro_optional_add_bindings(QT_QTTEST_FOUND "QtTest" qttest)
+
+if (RUBY_EXECUTABLE AND RUBY_LIBRARY AND RUBY_INCLUDE_DIRS)
+    EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r mkmf -e "exit(have_func('rb_hash_foreach') ? 0 : 1)" RESULT_VARIABLE RUBY_HASH_FOREACH OUTPUT_QUIET)
+    if (RUBY_HASH_FOREACH EQUAL 0)
+
+        set(CMAKE_REQUIRED_INCLUDES ${RUBY_INCLUDE_DIRS})
+        set(CMAKE_REQUIRED_LIBRARIES ${RUBY_LIBRARY})
+        CHECK_CXX_SOURCE_COMPILES("
+            #include <ruby.h>
+            int main() { ruby_init(); return 0; }" RubyCompiles)
+        if(RubyCompiles)
+            if(ENABLE_KROSSRUBY)
+                set(BUILD_KrossRuby TRUE)
+            endif(ENABLE_KROSSRUBY)
+        else(RubyCompiles)
+            message(STATUS "Failed to compile a C++ program that embeds ruby.")
+        endif(RubyCompiles)
+
+    else (RUBY_HASH_FOREACH EQUAL 0)
+
+        # 2007-02-12 sebsauer; this is a workaround for the case we failed to load
+        # the "mkmf" library what is the case e.g. on some debian distributions.
+        #EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r mkmf -e "exit(0)" RESULT_VARIABLE RUBY_HASH_FOREACH OUTPUT_QUIET ERROR_QUIET)
+        #if (${RUBY_HASH_FOREACH} EQUAL 0)
+        message(STATUS "The detected Ruby is too old for kross. A Ruby which has rb_hash_foreach is required. Upgrade to 1.8.2 or later")
+        #else (${RUBY_HASH_FOREACH} EQUAL 0)
+        #    message(STATUS "Failed to load the Ruby mkmf library. Please install the Ruby developer packages.")
+        #endif (${RUBY_HASH_FOREACH} EQUAL 0)
+
+    endif (RUBY_HASH_FOREACH EQUAL 0)
+endif (RUBY_EXECUTABLE AND RUBY_LIBRARY AND RUBY_INCLUDE_DIRS)
+message(STATUS "Ruby Executable: " ${RUBY_EXECUTABLE})
+message(STATUS "Ruby Libraries: " ${RUBY_LIBRARY})
+message(STATUS "Ruby Include Directories: " ${RUBY_INCLUDE_DIRS})
+
+macro_display_bindings_log()

data/ext/ruby/qtruby/AUTHORS

@@ -0,0 +1,54 @@
+/***************************************************************************
+ * 	(C) 2003-2004 Richard Dale All rights reserved.                        *
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+Chief Wreck On The Highway
+	Richard Dale <Richard_Dale@tipitina.demon.co.uk>
+
+Bug fixes, enhancements, sample code
+	Alex Kellett
+	
+Other contributions (from the ChangeLog), bug reports, fixes etc:
+	Alex Zepeda
+	Mikhail Yakshin
+	Imobach Sosa
+	Marek Janukowicz
+	Jochen Immend�fer
+	Dominique Devriese
+	Han Holl
+	Thibauld Favre
+	Zack Rusin
+	Jim Menard (RuBoids)
+	Ian Monroe
+	Raph Bauduin
+	Stephan Oehlert
+	David Crosby
+	Dave M
+	Caleb Tennis
+	Blackshack
+	Armin Joellenbeck
+	Dmitry Morozhnikor
+	Michael Doppler
+	Daniel Morris
+	Ryutaro Amano
+
+QtRuby is a ruby version of the PerlQt/Smoke project, written by:
+	Ashley Winters
+	Germain Garand
+	David Faure
+	
+Equipment
+	800 Mhz iBook with Yellow Dog 3.0, Macally Micro 3 button mouse
+	
+Books
+	'Programming with Qt' by Mathias Kalle Dalheimer
+	'Programming Ruby' by David Thomas and Andrew Hunt
+	'The Ruby Way' by Hal Fulton
+    'Ruby In a Nutshell' by Yukihiro Matsumoto
+    'Advanced Perl Programming' by Sriram Srinivasan