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/data/qatomicmathematicians.cpp b/src/xmlpatterns/data/qatomicmathematicians.cpp
new file mode 100644
index 00000000..3c6ce408
--- /dev/null
+++ b/src/xmlpatterns/data/qatomicmathematicians.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 <math.h>
+
+#include <qnumeric.h>
+
+#include "qabstractdatetime_p.h"
+#include "qabstractduration_p.h"
+#include "qabstractfloat_p.h"
+#include "qdaytimeduration_p.h"
+#include "qdecimal_p.h"
+#include "qinteger_p.h"
+#include "qpatternistlocale_p.h"
+
+#include "qatomicmathematicians_p.h"
+
+QT_BEGIN_NAMESPACE
+
+using namespace QPatternist;
+
+/* The translation strings is place here once, in order to reduce work for translators,
+ * and provide consistency. */
+
+static inline QString idivZeroInvalid()
+{
+    return QtXmlPatterns::tr("Integer division (%1) by zero (%2) is undefined.")
+             .arg(formatKeyword("idiv"))
+             .arg(formatData("0"));
+}
+
+static inline QString divZeroInvalid()
+{
+    return QtXmlPatterns::tr("Division (%1) by zero (%2) is undefined.")
+             .arg(formatKeyword("div"))
+             .arg(formatData("0"));
+}
+
+static inline QString modZeroInvalid()
+{
+    return QtXmlPatterns::tr("Modulus division (%1) by zero (%2) is undefined.")
+             .arg(formatKeyword("mod"))
+             .arg(formatData("0"));
+}
+
+Item DecimalMathematician::calculate(const Item &o1,
+                                     const Operator op,
+                                     const Item &o2,
+                                     const QExplicitlySharedDataPointer<DynamicContext> &context) const
+{
+    switch(op)
+    {
+        case Div:
+        {
+            if(o2.as<Numeric>()->toInteger() == 0)
+            {
+                context->error(divZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else
+                return toItem(Decimal::fromValue(o1.as<Numeric>()->toDecimal() / o2.as<Numeric>()->toDecimal()));
+        }
+        case IDiv:
+        {
+            if(o2.as<Numeric>()->toInteger() == 0)
+            {
+                context->error(idivZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else
+                return Integer::fromValue(static_cast<xsInteger>(o1.as<Numeric>()->toDecimal() /
+                                                                 o2.as<Numeric>()->toDecimal()));
+        }
+        case Substract:
+            return toItem(Decimal::fromValue(o1.as<Numeric>()->toDecimal() - o2.as<Numeric>()->toDecimal()));
+        case Mod:
+        {
+            if(o2.as<Numeric>()->toInteger() == 0)
+            {
+                context->error(modZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else
+                return toItem(Decimal::fromValue(::fmod(o1.as<Numeric>()->toDecimal(), o2.as<Numeric>()->toDecimal())));
+        }
+        case Multiply:
+            return toItem(Decimal::fromValue(o1.as<Numeric>()->toDecimal() * o2.as<Numeric>()->toDecimal()));
+        case Add:
+            return toItem(Decimal::fromValue(o1.as<Numeric>()->toDecimal() + o2.as<Numeric>()->toDecimal()));
+    }
+
+    Q_ASSERT(false);
+    return Item(); /* GCC unbarfer. */
+}
+
+Item IntegerMathematician::calculate(const Item &o1,
+                                     const Operator op,
+                                     const Item &o2,
+                                     const QExplicitlySharedDataPointer<DynamicContext> &context) const
+{
+    switch(op)
+    {
+        case Div:
+            if(o2.as<Numeric>()->toInteger() == 0)
+            {
+                context->error(divZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else /* C++ automatically performs truncation of long integer(xsInteger). */
+                return toItem(Decimal::fromValue(o1.as<Numeric>()->toDecimal() / o2.as<Numeric>()->toDecimal()));
+        case IDiv:
+        {
+            if(o2.as<Numeric>()->toInteger() == 0)
+            {
+                context->error(idivZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else /* C++ automatically performs truncation of long integer(xsInteger). */
+                return Integer::fromValue(o1.as<Numeric>()->toInteger() / o2.as<Numeric>()->toInteger());
+        }
+        case Substract:
+            return Integer::fromValue(o1.as<Numeric>()->toInteger() - o2.as<Numeric>()->toInteger());
+        case Mod:
+        {
+            const xsInteger divisor = o2.as<Numeric>()->toInteger();
+
+            if(divisor == 0)
+            {
+                context->error(modZeroInvalid(), ReportContext::FOAR0001, this);
+                return Item(); /* Silences source code analyzer warning. */
+            }
+            else
+                return Integer::fromValue(o1.as<Numeric>()->toInteger() % divisor);
+        }
+        case Multiply:
+            return Integer::fromValue(o1.as<Numeric>()->toInteger() * o2.as<Numeric>()->toInteger());
+        case Add:
+            return Integer::fromValue(o1.as<Numeric>()->toInteger() + o2.as<Numeric>()->toInteger());
+    }
+
+    Q_ASSERT(false);
+    return Item(); /* GCC unbarfer. */
+}
+
+Item DurationNumericMathematician::calculate(const Item &o1,
+                                             const Operator op,
+                                             const Item &o2,
+                                             const QExplicitlySharedDataPointer<DynamicContext> &context) const
+{
+    Q_ASSERT(op == Div || op == Multiply);
+
+    const AbstractDuration::Ptr duration(o1.as<AbstractDuration>());
+    const xsDouble dbl = o2.as<Numeric>()->toDouble();
+
+    switch(op)
+    {
+        case Div:
+        {
+            if(qIsInf(dbl))
+                return duration->fromValue(0);
+            else if(qIsNaN(dbl))
+            {
+                context->error(QtXmlPatterns::tr(
+                           "Dividing a value of type %1 by %2 (not-a-number) "
+                           "is not allowed.")
+                               .arg(formatType(context->namePool(),
+                                               duration->type()))
+                               .arg(formatData("NaN")),
+                               ReportContext::FOCA0005,
+                               this);
+                return Item();
+            }
+            else if(Double::isEqual(dbl, 0))
+            {
+                context->error(QtXmlPatterns::tr(
+                           "Dividing a value of type %1 by %2 or %3 (plus or "
+                           "minus zero) is not allowed.")
+                               .arg(formatType(context->namePool(),
+                                               duration->type()))
+                               .arg(formatData("-0"))
+                               .arg(formatData("0")),
+                               ReportContext::FODT0002,
+                               this);
+                return Item();
+            }
+
+            return duration->fromValue(static_cast<AbstractDuration::Value>(duration->value() / dbl));
+        }
+        case Multiply:
+        {
+            if(Double::isEqual(dbl, 0))
+                return duration->fromValue(0);
+            else if(qIsNaN(dbl))
+            {
+                context->error(QtXmlPatterns::tr(
+                           "Dividing a value of type %1 by %2 (not-a-number) "
+                           "is not allowed.")
+                               .arg(formatType(context->namePool(),
+                                               duration->type()))
+                               .arg(formatData("NaN")),
+                               ReportContext::FOCA0005,
+                               this);
+                return Item();
+            }
+            else if(qIsInf(dbl))
+            {
+                context->error(QtXmlPatterns::tr(
+                           "Multiplication of a value of type %1 by %2 or %3 "
+                           "(plus or minus infinity) is not allowed.")
+                               .arg(formatType(context->namePool(),
+                                               duration->type()))
+                               .arg(formatData("-INF"))
+                               .arg(formatData("INF")),
+                               ReportContext::FODT0002,
+                               this);
+                return Item();
+            }
+
+            return duration->fromValue(static_cast<AbstractDuration::Value>(duration->value() * dbl));
+        }
+        default:
+        {
+            Q_ASSERT(false);
+            return Item(); /* Silence warning. */
+        }
+    }
+}
+
+Item DurationDurationMathematician::calculate(const Item &o1,
+                                              const Operator op,
+                                              const Item &o2,
+                                              const QExplicitlySharedDataPointer<DynamicContext> &) const
+{
+    const AbstractDuration::Ptr duration(o1.as<AbstractDuration>());
+    const AbstractDuration::Value op2 = o2.as<AbstractDuration>()->value();
+
+    switch(op)
+    {
+        case Div:
+            return toItem(Decimal::fromValue(static_cast<xsDecimal>(duration->value()) / op2));
+        case Substract:
+            return duration->fromValue(duration->value() - op2);
+        case Add:
+            return duration->fromValue(duration->value() + op2);
+        default:
+        {
+            Q_ASSERT(false);
+            return Item(); /* Silence warning. */
+        }
+    }
+}
+
+OperandSwitcherMathematician::
+OperandSwitcherMathematician(const AtomicMathematician::Ptr &mathematician) : m_mather(mathematician)
+{
+    Q_ASSERT(mathematician);
+}
+
+Item OperandSwitcherMathematician::calculate(const Item &o1,
+                                             const Operator op,
+                                             const Item &o2,
+                                             const QExplicitlySharedDataPointer<DynamicContext> &context) const
+{
+    return m_mather->calculate(o2, op, o1, context);
+}
+
+
+Item DateTimeDurationMathematician::calculate(const Item &o1,
+                                              const Operator op,
+                                              const Item &o2,
+                                              const QExplicitlySharedDataPointer<DynamicContext> &context) const
+{
+    Q_ASSERT(op == Substract || op == Add);
+
+    const AbstractDateTime::Ptr adt(o1.as<AbstractDateTime>());
+    const AbstractDuration::Ptr dur(o2.as<AbstractDuration>());
+    QDateTime dt(adt->toDateTime());
+    //pDebug() << "DateTimeDurationMathematician::calculate():" << dt.toString();
+    //dt.setDateOnly(false);
+    const qint8 sign = (op == Add ? 1 : -1) * (dur->isPositive() ? 1 : -1);
+
+    // TODO milli seconds
+    dt = dt.addSecs(sign * (dur->seconds() + dur->minutes() * 60 + dur->hours() * 60 * 60));
+    dt = dt.addDays(sign * dur->days());
+    dt = dt.addMonths(sign * dur->months());
+    dt = dt.addYears(sign * dur->years());
+
+    QString msg;
+
+    if(AbstractDateTime::isRangeValid(dt.date(), msg))
+        return adt->fromValue(dt);
+    else
+    {
+        context->error(msg, ReportContext::FODT0001,
+                       this);
+        return Item();
+    }
+}
+
+Item AbstractDateTimeMathematician::calculate(const Item &o1,
+                                              const Operator op,
+                                              const Item &o2,
+                                              const QExplicitlySharedDataPointer<DynamicContext> &) const
+{
+    Q_ASSERT(op == Substract || op == Add);
+    QDateTime dt1(o1.as<AbstractDateTime>()->toDateTime());
+    QDateTime dt2(o2.as<AbstractDateTime>()->toDateTime());
+
+    const int diff = op == Add ? dt1.secsTo(dt2) : dt2.secsTo(dt1);
+
+    return toItem(DayTimeDuration::fromSeconds(diff));
+}
+
+QT_END_NAMESPACE