Add W3C XML Schema validation support

This was done by Tobias Koenig, as part of an internship at Trolltech/Qt
Software, started at Wed Oct 1 18:32:43 2008 +0200, and the last commit being
part of this commit dating Tue Feb 24 11:03:36 2009 +0100. This is work
consisting of about 650 commits squashed into one, where the first commit was
61b280386c1905a15690fdd917dcbc8eb09b6283, in the repository before Qt's history
cut.

3 files changed, 38 insertions, 34 deletions

diff --git a/src/xmlpatterns/expr/qcastingplatform.cpp b/src/xmlpatterns/expr/qcastingplatform.cpp
index 9e96fd8..16a1d60 100644
--- a/src/xmlpatterns/expr/qcastingplatform.cpp
+++ b/src/xmlpatterns/expr/qcastingplatform.cpp
@@ -83,7 +83,7 @@ Item CastingPlatform<TSubClass, issueError>::cast(const Item &sourceValue,
     else
     {
         bool castImpossible = false;
-        const AtomicCaster::Ptr caster(locateCaster(sourceValue.type(), context, castImpossible));
+        const AtomicCaster::Ptr caster(locateCaster(sourceValue.type(), context, castImpossible, static_cast<const TSubClass *>(this), targetType()));
 
         if(!issueError && castImpossible)
         {
@@ -112,7 +112,7 @@ bool CastingPlatform<TSubClass, issueError>::prepareCasting(const ReportContext:
                         or numeric at compile time. We'll do lookup at runtime instead. */
 
     bool castImpossible = false;
-    m_caster = locateCaster(sourceType, context, castImpossible);
+    m_caster = locateCaster(sourceType, context, castImpossible, static_cast<const TSubClass *>(this), targetType());
 
     return !castImpossible;
 }
@@ -120,20 +120,22 @@ bool CastingPlatform<TSubClass, issueError>::prepareCasting(const ReportContext:
 template <typename TSubClass, const bool issueError>
 AtomicCaster::Ptr CastingPlatform<TSubClass, issueError>::locateCaster(const ItemType::Ptr &sourceType,
                                                                        const ReportContext::Ptr &context,
-                                                                       bool &castImpossible) const
+                                                                       bool &castImpossible,
+                                                                       const SourceLocationReflection *const location,
+                                                                       const ItemType::Ptr &targetType)
 {
     Q_ASSERT(sourceType);
-    Q_ASSERT(targetType());
+    Q_ASSERT(targetType);
 
     const AtomicCasterLocator::Ptr locator(static_cast<AtomicType *>(
-            targetType().data())->casterLocator());
+            targetType.data())->casterLocator());
     if(!locator)
     {
         if(issueError)
         {
             context->error(QtXmlPatterns::tr("No casting is possible with %1 as the target type.")
-                                        .arg(formatType(context->namePool(), targetType())),
-                                       ReportContext::XPTY0004, static_cast<const TSubClass *>(this));
+                                        .arg(formatType(context->namePool(), targetType)),
+                                       ReportContext::XPTY0004, location);
         }
         else
             castImpossible = true;
@@ -141,15 +143,15 @@ AtomicCaster::Ptr CastingPlatform<TSubClass, issueError>::locateCaster(const Ite
         return AtomicCaster::Ptr();
     }
 
-    const AtomicCaster::Ptr caster(static_cast<const AtomicType *>(sourceType.data())->accept(locator, static_cast<const TSubClass *>(this)));
+    const AtomicCaster::Ptr caster(static_cast<const AtomicType *>(sourceType.data())->accept(locator, location));
     if(!caster)
     {
         if(issueError)
         {
             context->error(QtXmlPatterns::tr("It is not possible to cast from %1 to %2.")
                                             .arg(formatType(context->namePool(), sourceType))
-                                            .arg(formatType(context->namePool(), targetType())),
-                                       ReportContext::XPTY0004, static_cast<const TSubClass *>(this));
+                                            .arg(formatType(context->namePool(), targetType)),
+                                       ReportContext::XPTY0004, location);
         }
         else
             castImpossible = true;
diff --git a/src/xmlpatterns/expr/qcastingplatform_p.h b/src/xmlpatterns/expr/qcastingplatform_p.h
index 458e9eb..a0144b2 100644
--- a/src/xmlpatterns/expr/qcastingplatform_p.h
+++ b/src/xmlpatterns/expr/qcastingplatform_p.h
@@ -52,16 +52,17 @@
 #ifndef Patternist_CastingPlatform_H
 #define Patternist_CastingPlatform_H
 
+#include "qatomiccasterlocator_p.h"
 #include "qatomiccaster_p.h"
-#include "qqnamevalue_p.h"
 #include "qatomicstring_p.h"
-#include "qvalidationerror_p.h"
-#include "qatomiccasterlocator_p.h"
 #include "qatomictype_p.h"
 #include "qbuiltintypes_p.h"
 #include "qcommonsequencetypes_p.h"
-#include "qschematypefactory_p.h"
 #include "qpatternistlocale_p.h"
+#include "qqnamevalue_p.h"
+#include "qschematypefactory_p.h"
+#include "qstaticcontext_p.h"
+#include "qvalidationerror_p.h"
 
 QT_BEGIN_HEADER
 
@@ -101,6 +102,7 @@ namespace QPatternist
      * function targetType() must be implemented such that CastingPlatform knows
      * what type it shall cast to.
      *
+     * @see ValueFactory
      * @author Frans Englich <fenglich@trolltech.com>
      * @ingroup Patternist_expressions
      */
@@ -167,9 +169,16 @@ namespace QPatternist
          *
          * @p castImpossible is not initialized. Initialize it to @c false.
          */
-        AtomicCaster::Ptr locateCaster(const ItemType::Ptr &sourceType,
-                                       const ReportContext::Ptr &context,
-                                       bool &castImpossible) const;
+        static AtomicCaster::Ptr locateCaster(const ItemType::Ptr &sourceType,
+                                              const ReportContext::Ptr &context,
+                                              bool &castImpossible,
+                                              const SourceLocationReflection *const location,
+                                              const ItemType::Ptr &targetType);
+    private:
+        inline Item castWithCaster(const Item &sourceValue,
+                                   const AtomicCaster::Ptr &caster,
+                                   const DynamicContext::Ptr &context) const;
+
 
         inline ItemType::Ptr targetType() const
         {
diff --git a/src/xmlpatterns/expr/qexpressionfactory.cpp b/src/xmlpatterns/expr/qexpressionfactory.cpp
index ec86be0..b41b0de 100644
--- a/src/xmlpatterns/expr/qexpressionfactory.cpp
+++ b/src/xmlpatterns/expr/qexpressionfactory.cpp
@@ -81,9 +81,13 @@ Expression::Ptr ExpressionFactory::createExpression(const QString &expr,
                                                     const QUrl &queryURI,
                                                     const QXmlName &initialTemplateName)
 {
-    if(lang == QXmlQuery::XQuery10)
+    if(lang == QXmlQuery::XSLT20)
     {
-        return createExpression(Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)),
+        QByteArray query(expr.toUtf8());
+        QBuffer buffer(&query);
+        buffer.open(QIODevice::ReadOnly);
+
+        return createExpression(&buffer,
                                 context,
                                 lang,
                                 requiredType,
@@ -92,12 +96,7 @@ Expression::Ptr ExpressionFactory::createExpression(const QString &expr,
     }
     else
     {
-        Q_ASSERT(lang == QXmlQuery::XSLT20);
-        QByteArray query(expr.toUtf8());
-        QBuffer buffer(&query);
-        buffer.open(QIODevice::ReadOnly);
-
-        return createExpression(&buffer,
+        return createExpression(Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)),
                                 context,
                                 lang,
                                 requiredType,
@@ -118,16 +117,10 @@ Expression::Ptr ExpressionFactory::createExpression(QIODevice *const device,
 
     Tokenizer::Ptr tokenizer;
 
-    if(lang == QXmlQuery::XQuery10)
-    {
-
-        tokenizer = Tokenizer::Ptr(new XQueryTokenizer(QString::fromUtf8(device->readAll()), queryURI));
-    }
-    else
-    {
-        Q_ASSERT(lang == QXmlQuery::XSLT20);
+    if(lang == QXmlQuery::XSLT20)
         tokenizer = Tokenizer::Ptr(new XSLTTokenizer(device, queryURI, context, context->namePool()));
-    }
+    else
+        tokenizer = Tokenizer::Ptr(new XQueryTokenizer(QString::fromUtf8(device->readAll()), queryURI));
 
     return createExpression(tokenizer, context, lang, requiredType, queryURI, initialTemplateName);
 }