merged Qt5 port and exception parsing

git-svn-id: http://svn.code.sf.net/p/pythonqt/code/trunk@256 ea8d5007-eb21-0410-b261-ccb3ea6e24a9

Author: florianlink

generator/abstractmetabuilder.cpp

@@ -1383,8 +1383,11 @@ void AbstractMetaBuilder::traverseFunctions(ScopeModelItem scope_item, AbstractM
                 }
 
                 meta_class->addFunction(meta_function);
-            } else if (meta_function->isDestructor() && !meta_function->isPublic()) {
-                meta_class->setHasPublicDestructor(false);
+            } else if (meta_function->isDestructor()) {
+                meta_class->setDestructorException(meta_function->exception());
+                if (!meta_function->isPublic()) {
+                  meta_class->setHasPublicDestructor(false);
+                }
             }
         }
     }
@@ -1564,6 +1567,7 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
 
     AbstractMetaFunction *meta_function = createMetaFunction();
     meta_function->setConstant(function_item->isConstant());
+    meta_function->setException(function_item->exception());
 
     ReportHandler::debugMedium(QString(" - %2()").arg(function_name));
 
@@ -1851,7 +1855,7 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
                 return t;
 
             ClassModelItem item = m_dom->findClass(contexts.at(0));
-            if (item != 0)
+            if (item)
                 contexts += item->baseClasses();
             contexts.pop_front();
 

generator/abstractmetalang.cpp

@@ -313,6 +313,7 @@ AbstractMetaFunction *AbstractMetaFunction::copy() const
     if (type())
         cpy->setType(type()->copy());
     cpy->setConstant(isConstant());
+    cpy->setException(exception());
     cpy->setOriginalAttributes(originalAttributes());
 
     foreach (AbstractMetaArgument *arg, arguments())

generator/abstractmetalang.h

@@ -490,7 +490,6 @@ class AbstractMetaFunction : public AbstractMetaAttributes
     void setFunctionType(FunctionType type) { m_function_type = type; }
 
     bool isVirtual() const { return !(isFinal() || isSignal() || isStatic()); }
-
     QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
     QString signature() const;
     QString targetLangSignature(bool minimal = false) const;
@@ -500,6 +499,8 @@ class AbstractMetaFunction : public AbstractMetaAttributes
     bool isConstant() const { return m_constant; }
     void setConstant(bool constant) { m_constant = constant; }
 
+    QString exception() const { return m_exception; }
+    void setException(const QString &exception) { m_exception = exception; }
     QString toString() const { return m_name; }
 
     uint compareTo(const AbstractMetaFunction *other) const;
@@ -559,6 +560,7 @@ class AbstractMetaFunction : public AbstractMetaAttributes
     const AbstractMetaClass *m_interface_class;
     QPropertySpec *m_property_spec;
     AbstractMetaArgumentList m_arguments;
+    QString m_exception;
     uint m_constant                 : 1;
     uint m_invalid                  : 1;
 };
@@ -708,6 +710,8 @@ class AbstractMetaClass : public AbstractMetaAttributes
     bool hasPublicDestructor() const { return m_has_public_destructor; }
     void setHasPublicDestructor(bool on) { m_has_public_destructor = on; }
 
+    QString destructorException() const { return m_destructor_exception; }
+    void setDestructorException(const QString &exception) { m_destructor_exception = exception; }
     AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
     AbstractMetaFunctionList queryFunctions(uint query) const;
     inline AbstractMetaFunctionList allVirtualFunctions() const;
@@ -797,7 +801,6 @@ class AbstractMetaClass : public AbstractMetaAttributes
     bool hasCloneOperator() const { return m_has_clone_operator; }
 
     bool hasDefaultIsNull() const;
-
     void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
     QList<QPropertySpec *> propertySpecs() const { return m_property_specs; }
 
@@ -832,7 +835,6 @@ class AbstractMetaClass : public AbstractMetaAttributes
 
     void setTypeAlias(bool typeAlias) { m_is_type_alias = typeAlias; }
     bool isTypeAlias() const { return m_is_type_alias; }
-
     bool operator <(const AbstractMetaClass &a) const {
       return qualifiedCppName() < a.qualifiedCppName();
     }
@@ -852,6 +854,7 @@ class AbstractMetaClass : public AbstractMetaAttributes
     uint m_has_clone_operator :1;
     uint m_is_type_alias : 1;
     uint m_reserved : 19;
+    QString m_destructor_exception;
 
     const AbstractMetaClass *m_enclosing_class;
     AbstractMetaClass *m_base_class;

generator/asttoxml.cpp

@@ -139,6 +139,12 @@ void writeOutFunction(QXmlStreamWriter &s, FunctionModelItem &item) {
     s.writeStartElement("function");
     s.writeAttribute("name", qualified_name);
 
+    if (!item->exception().isEmpty()) {
+        s.writeStartElement("exception");
+        s.writeAttribute("throw", item->exception());
+        s.writeEndElement();
+    }
+
     ArgumentList arguments = item->arguments();
     for(int i=0; i < arguments.size() ; i++) {
         s.writeStartElement("argument");

generator/main.h

@@ -80,11 +80,11 @@ struct Preprocess
         // Environment INCLUDE
         QString includePath = getenv("INCLUDE");
         if (!includePath.isEmpty())
-            includes += includePath.split(path_splitter);        
+            includes += includePath.split(path_splitter);
 
         // Includes from the command line
         if (!commandLineIncludes.isEmpty())
-            includes += commandLineIncludes.split(path_splitter);        
+            includes += commandLineIncludes.split(path_splitter);
 
         // Include Qt
         QString qtdir = getenv ("QTDIR");
@@ -111,12 +111,13 @@ struct Preprocess
             includes << qtdir;
         }
 
-        foreach (QString include, includes)
-            preprocess.push_include_path(QDir::convertSeparators(include).toStdString());        
+        foreach (QString include, includes) {
+            preprocess.push_include_path(QDir::toNativeSeparators(include).toStdString());
+        }
 
         QString currentDir = QDir::current().absolutePath();
         QFileInfo sourceInfo(sourceFile);
-        QDir::setCurrent(sourceInfo.absolutePath());        
+        QDir::setCurrent(sourceInfo.absolutePath());
 
         std::string result;
         result.reserve (20 * 1024); // 20K

generator/parser/binder.cpp

@@ -281,6 +281,8 @@ void Binder::declare_symbol(SimpleDeclarationAST *node, InitDeclaratorAST *init_
       fun->setName(name_cc.name());
       fun->setAbstract(init_declarator->initializer != 0);
       fun->setConstant(declarator->fun_cv != 0);
+      fun->setException(exceptionSpecToString(declarator->exception_spec));
+
       fun->setTemplateParameters(_M_current_template_parameters);
       applyStorageSpecifiers(node->storage_specifiers, model_static_cast<MemberModelItem>(fun));
       applyFunctionSpecifiers(node->function_specifiers, fun);
@@ -389,6 +391,7 @@ void Binder::visitFunctionDefinition(FunctionDefinitionAST *node)
   _M_current_function->setFunctionType(_M_current_function_type);
   _M_current_function->setConstant(declarator->fun_cv != 0);
   _M_current_function->setTemplateParameters(_M_current_template_parameters);
+  _M_current_function->setException(exceptionSpecToString(declarator->exception_spec));
 
   applyStorageSpecifiers(node->storage_specifiers,
                           model_static_cast<MemberModelItem>(_M_current_function));
@@ -745,7 +748,7 @@ static QString strip_preprocessor_lines(const QString &name)
 
 void Binder::visitEnumerator(EnumeratorAST *node)
 {
-  Q_ASSERT(_M_current_enum != 0);
+  Q_ASSERT(_M_current_enum.data() != 0);
   EnumeratorModelItem e = model()->create<EnumeratorModelItem>();
   updateItemPosition (e->toItem(), node);
   e->setName(decode_symbol(node->id)->as_string());
@@ -920,4 +923,16 @@ void Binder::updateItemPosition(CodeModelItem item, AST *node)
   item->setFileName (filename);
 }
 
+QString Binder::exceptionSpecToString(ExceptionSpecificationAST* exception_spec)
+{
+  QString exception;
+  if (exception_spec) {
+    const Token &start_token = _M_token_stream->token((int) exception_spec->start_token);
+    const Token &end_token = _M_token_stream->token((int) exception_spec->end_token);
+
+    exception = QString::fromUtf8(&start_token.text[start_token.position],
+                                  (int)(end_token.position - start_token.position));
+  }
+  return exception;
+}
 // kate: space-indent on; indent-width 2; replace-tabs on;

generator/parser/binder.h

@@ -107,6 +107,8 @@ class Binder: protected DefaultVisitor
 
   void updateItemPosition(CodeModelItem item, AST *node);
 
+  QString exceptionSpecToString(ExceptionSpecificationAST *exception_spec);
+
 private:
   CodeModel *_M_model;
   LocationManager &_M_location;

generator/parser/codemodel.cpp

@@ -660,6 +660,16 @@ void _FunctionModelItem::setFunctionType(CodeModel::FunctionType functionType)
   _M_functionType = functionType;
 }
 
+QString _FunctionModelItem::exception() const
+{
+  return _M_exception;
+}
+
+void _FunctionModelItem::setException(const QString &exception)
+{
+  _M_exception = exception;
+}
+
 bool _FunctionModelItem::isVariadics() const
 {
   return _M_isVariadics;

generator/parser/codemodel.h

@@ -541,6 +541,9 @@ class _FunctionModelItem: public _MemberModelItem
   CodeModel::FunctionType functionType() const;
   void setFunctionType(CodeModel::FunctionType functionType);
 
+  QString exception() const;
+  void setException(const QString &exception);
+
   bool isVirtual() const;
   void setVirtual(bool isVirtual);
 
@@ -571,6 +574,7 @@ class _FunctionModelItem: public _MemberModelItem
 private:
   ArgumentList _M_arguments;
   CodeModel::FunctionType _M_functionType;
+  QString _M_exception;
   union
   {
     struct

generator/parser/codemodel_finder.cpp

@@ -59,7 +59,7 @@ CodeModelFinder::~CodeModelFinder()
 
 ScopeModelItem CodeModelFinder::resolveScope(NameAST *name, ScopeModelItem scope)
 {
-  Q_ASSERT(scope != 0);
+  Q_ASSERT(scope.data() != 0);
 
   ResolvePolicy saved_resolve_policy = _M_resolve_policy;
   _M_resolve_policy = ResolveScope;

generator/parser/codemodel_pointer.h

@@ -119,6 +119,24 @@ template <class T> class CodeModelPointer
     inline T *data() { return (T *) *this; }
     inline const T *data() const { return (const T *) *this; }
     inline const T *constData() const { return (const T *) *this; }
+
+
+#   if QT_VERSION >= 0x050000
+    operator T * () const {
+        return QAtomicPointer<T>::load();
+    }
+    inline bool operator!() const { return !(bool)*this; }
+    operator bool () const {
+        return (bool)QAtomicPointer<T>::load();
+    }
+
+    inline T *operator->() { return QAtomicPointer<T>::load(); }
+    inline const T *operator->() const { return QAtomicPointer<T>::load(); }
+    inline bool operator==(const CodeModelPointer<T> &other) const { return (T*)*this == (T*)other; }
+    inline bool operator!=(const CodeModelPointer<T> &other) const { return (T*)*this != (T*)other; }
+    inline bool operator==(const T *ptr) const { return (T*)*this == ptr; }
+    inline bool operator!=(const T *ptr) const { return (T*)*this != ptr; }
+#   endif
 #endif
 };
 

generator/qtscript_masterinclude.h

@@ -49,12 +49,19 @@
 
 #include <QtUiTools/QtUiTools>
 
+#if QT_VERSION >= 0x050000
+#include <QtWidgets/QtWidgets>
+#endif
+
 #ifndef QT_NO_XMLPATTERNS
 #  include <QtXmlPatterns/QtXmlPatterns>
 #endif
 
 #ifndef QT_NO_WEBKIT
 #  include <QtWebKit/QtWebKit>
+#if QT_VERSION >= 0x050000
+#  include <QtWebKitWidgets/QtWebKitWidgets>
+#endif
 #endif
 
 #ifndef QT_NO_PHONON

generator/shellgenerator.cpp

@@ -107,7 +107,7 @@ void ShellGenerator::writeTypeInfo(QTextStream &s, const AbstractMetaType *type,
 
     if (type->isReference() && !(options & ExcludeReference) && !(options & ConvertReferenceToPtr))
         s << "&";
-  
+
     if (type->isReference() && (options & ConvertReferenceToPtr)) {
       s << "*";
     }
@@ -135,7 +135,7 @@ void ShellGenerator::writeFunctionArguments(QTextStream &s, const AbstractMetaCl
         if ((option & IncludeDefaultExpression) && !arg->originalDefaultValueExpression().isEmpty()) {
             s << " = "; 
 
-          QString expr = arg->originalDefaultValueExpression();
+            QString expr = arg->originalDefaultValueExpression();
           if (expr != "0") {
             QString qualifier;
             if (arg->type()->typeEntry()->isEnum() && expr.indexOf("::") < 0) {
@@ -153,7 +153,7 @@ void ShellGenerator::writeFunctionArguments(QTextStream &s, const AbstractMetaCl
           if (expr == "MediaSource()") {
             expr = "Phonon::MediaSource()";
           }
-          s << expr; 
+            s << expr; 
         }
     }
 }
@@ -222,9 +222,9 @@ void ShellGenerator::writeFunctionSignature(QTextStream &s,
       function_name = meta_function->name();
     }
 
-  if (meta_function->attributes() & AbstractMetaAttributes::SetterFunction)
+    if (meta_function->attributes() & AbstractMetaAttributes::SetterFunction)
     s << "py_set_";
-  else if (meta_function->attributes() & AbstractMetaAttributes::GetterFunction)
+    else if (meta_function->attributes() & AbstractMetaAttributes::GetterFunction)
     s << "py_get_";
 
   s << name_prefix << function_name;
@@ -250,8 +250,9 @@ void ShellGenerator::writeFunctionSignature(QTextStream &s,
     s << ")";
     if (meta_function->isConstant())
         s << " const";
+    if (!meta_function->exception().isEmpty())
+        s << " " << meta_function->exception();
 }
-
 bool function_sorter(AbstractMetaFunction *a, AbstractMetaFunction *b);
 
 AbstractMetaFunctionList ShellGenerator::getFunctionsToWrap(const AbstractMetaClass* meta_class)
@@ -379,4 +380,3 @@ bool ShellGenerator::isBuiltIn(const QString& name) {
   }
   return builtIn.contains(name);
 }
-