Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 352 insertions, 0 deletions

diff --git a/src/xmlpatterns/functions/qsequencefns.cpp b/src/xmlpatterns/functions/qsequencefns.cpp
new file mode 100644
index 0000000..a234377
--- /dev/null
+++ b/src/xmlpatterns/functions/qsequencefns.cpp
@@ -0,0 +1,352 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtXmlPatterns module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbuiltintypes_p.h"
+#include "qcommonsequencetypes_p.h"
+#include "qcommonvalues_p.h"
+#include "qdistinctiterator_p.h"
+#include "qebvextractor_p.h"
+#include "qemptysequence_p.h"
+#include "qgenericsequencetype_p.h"
+#include "qindexofiterator_p.h"
+#include "qinsertioniterator_p.h"
+#include "qinteger_p.h"
+#include "qremovaliterator_p.h"
+#include "qsequencegeneratingfns_p.h"
+#include "qsubsequenceiterator_p.h"
+
+#include "qsequencefns_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+bool BooleanFN::evaluateEBV(const DynamicContext::Ptr &context) const
+{
+    return m_operands.first()->evaluateEBV(context);
+}
+
+Expression::Ptr BooleanFN::typeCheck(const StaticContext::Ptr &context,
+                                     const SequenceType::Ptr &reqType)
+{
+    return EBVExtractor::typeCheck<FunctionCall>(context, reqType, this);
+}
+
+Item::Iterator::Ptr IndexOfFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    return Item::Iterator::Ptr(new IndexOfIterator(m_operands.first()->evaluateSequence(context),
+                                                   m_operands.at(1)->evaluateSingleton(context),
+                                                   comparator(), context,
+                                                   ConstPtr(this)));
+}
+
+Expression::Ptr IndexOfFN::typeCheck(const StaticContext::Ptr &context,
+                                     const SequenceType::Ptr &reqType)
+{
+    const Expression::Ptr me(FunctionCall::typeCheck(context, reqType));
+    const ItemType::Ptr t1(m_operands.first()->staticType()->itemType());
+    const ItemType::Ptr t2(m_operands.at(1)->staticType()->itemType());
+
+    if(*CommonSequenceTypes::Empty == *t1 ||
+       *CommonSequenceTypes::Empty == *t2)
+    {
+        return EmptySequence::create(this, context);
+    }
+    else
+    {
+        prepareComparison(fetchComparator(t1, t2, context));
+        return me;
+    }
+}
+
+Item::Iterator::Ptr DistinctValuesFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    return Item::Iterator::Ptr(new DistinctIterator(m_operands.first()->evaluateSequence(context),
+                                                    comparator(),
+                                                    ConstPtr(this),
+                                                    context));
+}
+
+Expression::Ptr DistinctValuesFN::typeCheck(const StaticContext::Ptr &context,
+                                            const SequenceType::Ptr &reqType)
+{
+    const Expression::Ptr me(FunctionCall::typeCheck(context, reqType));
+    const ItemType::Ptr t1(m_operands.first()->staticType()->itemType());
+
+    if(*CommonSequenceTypes::Empty == *t1)
+        return EmptySequence::create(this, context);
+    else if(!m_operands.first()->staticType()->cardinality().allowsMany())
+        return m_operands.first();
+    else if(BuiltinTypes::xsAnyAtomicType->xdtTypeMatches(t1))
+        return me;
+    else
+    {
+        prepareComparison(fetchComparator(t1, t1, context));
+        return me;
+    }
+}
+
+SequenceType::Ptr DistinctValuesFN::staticType() const
+{
+    const SequenceType::Ptr t(m_operands.first()->staticType());
+    return makeGenericSequenceType(t->itemType(),
+                                   t->cardinality().allowsMany() ? Cardinality::oneOrMore()
+                                                                 : Cardinality::exactlyOne());
+}
+
+Item::Iterator::Ptr InsertBeforeFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    const Item::Iterator::Ptr target(m_operands.first()->evaluateSequence(context));
+    const Item::Iterator::Ptr inserts(m_operands.at(2)->evaluateSequence(context));
+
+    xsInteger position = m_operands.at(1)->evaluateSingleton(context).as<Numeric>()->toInteger();
+
+    if(position < 1)
+        position = 1;
+
+    return Item::Iterator::Ptr(new InsertionIterator(target, position, inserts));
+}
+
+Item InsertBeforeFN::evaluateSingleton(const DynamicContext::Ptr &context) const
+{
+    return evaluateSequence(context)->next();
+}
+
+SequenceType::Ptr InsertBeforeFN::staticType() const
+{
+    const SequenceType::Ptr t1(m_operands.first()->staticType());
+    const SequenceType::Ptr t2(m_operands.last()->staticType());
+
+    return makeGenericSequenceType(t1->itemType() | t2->itemType(),
+                                   t1->cardinality() + t2->cardinality());
+}
+
+Item::Iterator::Ptr RemoveFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    const xsInteger pos = m_operands.last()->evaluateSingleton(context).as<Numeric>()->toInteger();
+    Item::Iterator::Ptr it(m_operands.first()->evaluateSequence(context));
+
+    if(pos < 1)
+        return it;
+
+    return Item::Iterator::Ptr(new RemovalIterator(it, pos));
+}
+
+Item RemoveFN::evaluateSingleton(const DynamicContext::Ptr &context) const
+{
+    const xsInteger pos = m_operands.last()->evaluateSingleton(context).as<Numeric>()->toInteger();
+    if(pos <= 1)
+        return Item();
+
+    return m_operands.first()->evaluateSingleton(context);
+}
+
+SequenceType::Ptr RemoveFN::staticType() const
+{
+    const SequenceType::Ptr opType(m_operands.first()->staticType());
+    const Cardinality c(opType->cardinality());
+
+    if(c.minimum() == 0)
+        return makeGenericSequenceType(opType->itemType(), c);
+    else
+    {
+        return makeGenericSequenceType(opType->itemType(),
+                                       Cardinality::fromRange(c.minimum() - 1,
+                                                              c.maximum()));
+    }
+}
+
+Item::Iterator::Ptr ReverseFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    return m_operands.first()->evaluateSequence(context)->toReversed();
+}
+
+Expression::Ptr ReverseFN::typeCheck(const StaticContext::Ptr &context,
+                                     const SequenceType::Ptr &reqType)
+{
+    if(m_operands.first()->staticType()->cardinality().allowsMany())
+        return FunctionCall::typeCheck(context, reqType);
+    else
+        return m_operands.first()->typeCheck(context, reqType);
+}
+
+SequenceType::Ptr ReverseFN::staticType() const
+{
+    return m_operands.first()->staticType();
+}
+
+SubsequenceFN::SubsequenceFN() : m_hasTypeChecked(false)
+{
+}
+
+Expression::Ptr SubsequenceFN::typeCheck(const StaticContext::Ptr &context,
+                                         const SequenceType::Ptr &reqType)
+{
+    m_hasTypeChecked = true;
+    return FunctionCall::typeCheck(context, reqType);
+}
+
+Item::Iterator::Ptr SubsequenceFN::evaluateSequence(const DynamicContext::Ptr &context) const
+{
+    Item::Iterator::Ptr it(m_operands.first()->evaluateSequence(context));
+
+    xsInteger startingLoc = m_operands.at(1)->evaluateSingleton(context).as<Numeric>()->round()->toInteger();
+    xsInteger length = -1;
+
+    if(m_operands.count() == 3)
+    {
+        length = m_operands.last()->evaluateSingleton(context).as<Numeric>()->toInteger();
+
+        if(startingLoc + length < 1 || (startingLoc > (startingLoc + length)))
+            return CommonValues::emptyIterator;
+    }
+
+    /* F&O, 15.1.10, "If $startingLoc is zero or negative, the
+     * subsequence includes items from the beginning of the $sourceSeq." */
+    if(startingLoc < 1)
+        startingLoc = 1;
+
+    if(length < 1 && length != -1)
+        return CommonValues::emptyIterator;
+    return Item::Iterator::Ptr(new SubsequenceIterator(it, startingLoc, length));
+}
+
+Item SubsequenceFN::evaluateSingleton(const DynamicContext::Ptr &context) const
+{
+    return evaluateSequence(context)->next();
+}
+
+Expression::Ptr SubsequenceFN::compress(const StaticContext::Ptr &context)
+{
+    const Expression::Ptr me(FunctionCall::compress(context));
+    if(me != this)
+        return me;
+
+    const Expression::Ptr lenArg(m_operands.value(2));
+    if(lenArg && lenArg->isEvaluated())
+    {
+        const xsInteger length = lenArg->as<Literal>()->item().as<Numeric>()->round()->toInteger();
+
+        if(length <= 0)
+            return EmptySequence::create(this, context);
+    }
+
+    return me;
+}
+
+SequenceType::Ptr SubsequenceFN::staticType() const
+{
+    const SequenceType::Ptr opType(m_operands.first()->staticType());
+    const Cardinality opCard(opType->cardinality());
+
+    /* Optimization: we can do much stronger inference here. If the length is a
+     * constant, we can constrain the range at least upwards of the
+     * cardinality, for instance. */
+
+    /* The subsequence(expr, 1, 1), add empty-sequence() to the static type.
+     *
+     * Note that we cannot do all these inferences before we've typechecked our
+     * operands. The only known case of where our staticType() is called before
+     * typeCheck() is through xmlpatternsview, although it wouldn't be
+     * surprising if the more exotic paths can achieve that too.
+     */
+    if(m_hasTypeChecked &&
+       m_operands.at(1)->isEvaluated()                                                      &&
+       m_operands.count() == 3                                                              &&
+       m_operands.at(2)->isEvaluated()                                                      &&
+       m_operands.at(1)->as<Literal>()->item().as<Numeric>()->round()->toInteger() == 1     &&
+       m_operands.at(2)->as<Literal>()->item().as<Numeric>()->round()->toInteger() == 1)
+    {
+        return makeGenericSequenceType(opType->itemType(),
+                                       opCard.toWithoutMany());
+    }
+    else
+    {
+        return makeGenericSequenceType(opType->itemType(),
+                                       opCard | Cardinality::zeroOrOne());
+    }
+}
+
+Expression::Ptr DocFN::typeCheck(const StaticContext::Ptr &context,
+                                 const SequenceType::Ptr &reqType)
+{
+    /* See the doxygen documentation for this function for the explanation
+     * to why this implementation is here, as opposed to in
+     * qsequencegeneratingfns.cpp. */
+
+    Q_ASSERT(context);
+
+    prepareStaticBaseURI(context);
+
+    const Expression::Ptr uriOp(m_operands.first());
+
+    if(!uriOp->isEvaluated())
+        return Expression::Ptr(FunctionCall::typeCheck(context, reqType));
+
+    const Item uriItem(uriOp->evaluateSingleton(context->dynamicContext()));
+
+    if(!uriItem)
+        return EmptySequence::create(this, context)->typeCheck(context, reqType); // TODO test this
+
+    /* These two lines were previously in a separate function but are now duplicated
+     * in DocFN::evaluateSingleton(), as part of a workaround for solaris-cc-64. */
+    const QUrl mayRela(AnyURI::toQUrl<ReportContext::FODC0005>(uriItem.stringValue(), context, this));
+    const QUrl uri(context->resolveURI(mayRela, staticBaseURI()));
+
+    /* The URI is supplied statically, so, let's try to be clever. */
+    Q_ASSERT_X(context->resourceLoader(), Q_FUNC_INFO,
+               "No resource loader is set in the StaticContext.");
+    m_type = context->resourceLoader()->announceDocument(uri, ResourceLoader::MayUse);
+
+    if(m_type)
+    {
+        Q_ASSERT(CommonSequenceTypes::ZeroOrOneDocumentNode->matches(m_type));
+        return Expression::Ptr(FunctionCall::typeCheck(context, reqType));
+    }
+    else
+    {
+        context->error(QtXmlPatterns::tr("It will not be possible to retrieve %1.").arg(formatURI(uri)),
+                       ReportContext::FODC0002, this);
+        return Expression::Ptr();
+    }
+}
+
+QT_END_NAMESPACE