src/xmlpatterns/functions/qpatternplatform.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QHash>
  43
  44 #include "qpatternistlocale_p.h"
  45
  46 #include "qpatternplatform_p.h"
  47
  48 QT_BEGIN_NAMESPACE
  49
  50 using namespace QPatternist;
  51
  52 namespace QPatternist
  53 {
  54     /**
  55      * @short Used internally by PatternPlatform and describes
  56      * a flag that affects how a pattern is treated.
  57      *
  58      * The member variables aren't declared @c const, in order
  59      * to make the synthesized assignment operator and copy constructor work.
  60      *
  61      * @ingroup Patternist_utils
  62      * @author Frans Englich <frans.englich@nokia.com>
  63      */
  64     class PatternFlag
  65     {
  66     public:
  67         typedef QHash<QChar, PatternFlag> Hash;
  68
  69         inline PatternFlag() : flag(PatternPlatform::NoFlags)
  70         {
  71         }
  72
  73         inline PatternFlag(const PatternPlatform::Flag opt,
  74                            const QString &descr) : flag(opt),
  75                                                    description(descr)
  76         {
  77         }
  78
  79         PatternPlatform::Flag   flag;
  80         QString                 description;
  81
  82         static inline Hash flagDescriptions();
  83     };
  84 }
  85
  86 static inline PatternFlag::Hash flagDescriptions()
  87 {
  88     PatternFlag::Hash retval;
  89
  90     retval.insert(QChar(QLatin1Char('s')),
  91                   PatternFlag(PatternPlatform::DotAllMode,
  92                               QtXmlPatterns::tr("%1 matches newline characters").arg(formatKeyword(QLatin1Char('.')))));
  93
  94     retval.insert(QChar(QLatin1Char('m')),
  95                   PatternFlag(PatternPlatform::MultiLineMode,
  96                               QtXmlPatterns::tr("%1 and %2 match the start and end of a line.")
  97                                    .arg(formatKeyword(QLatin1Char('^')))
  98                                    .arg(formatKeyword(QLatin1Char('$')))));
  99
 100     retval.insert(QChar(QLatin1Char('i')),
 101                   PatternFlag(PatternPlatform::CaseInsensitive,
 102                               QtXmlPatterns::tr("Matches are case insensitive")));
 103
 104     retval.insert(QChar(QLatin1Char('x')),
 105                   PatternFlag(PatternPlatform::SimplifyWhitespace,
 106                               QtXmlPatterns::tr("Whitespace characters are removed, except when they appear "
 107                                  "in character classes")));
 108
 109     return retval;
 110 }
 111
 112 PatternPlatform::PatternPlatform(const qint8 flagsPosition) : m_compiledParts(NoPart),
 113                                                               m_flags(NoFlags),
 114                                                               m_flagsPosition(flagsPosition)
 115 {
 116 }
 117
 118 const QRegExp PatternPlatform::pattern(const DynamicContext::Ptr &context) const
 119 {
 120     if(m_compiledParts == FlagsAndPattern) /* This is the most common case. */
 121     {
 122         Q_ASSERT(m_pattern.isValid());
 123         return m_pattern;
 124     }
 125
 126     QRegExp retvalPattern;
 127     Flags flags;
 128
 129     /* Compile the flags, if necessary. */
 130     if(m_compiledParts.testFlag(FlagsPrecompiled))
 131         flags = m_flags;
 132     else
 133     {
 134         const Expression::Ptr flagsOp(m_operands.value(m_flagsPosition));
 135
 136         if(flagsOp)
 137             flags = parseFlags(flagsOp->evaluateSingleton(context).stringValue(), context);
 138         else
 139             flags = NoFlags;
 140     }
 141
 142     /* Compile the pattern, if necessary. */
 143     if(m_compiledParts.testFlag(PatternPrecompiled))
 144         retvalPattern = m_pattern;
 145     else
 146     {
 147         retvalPattern = parsePattern(m_operands.at(1)->evaluateSingleton(context).stringValue(),
 148                                      context);
 149
 150     }
 151
 152     applyFlags(flags, retvalPattern);
 153
 154     Q_ASSERT(m_pattern.isValid());
 155     return retvalPattern;
 156 }
 157
 158 void PatternPlatform::applyFlags(const Flags flags, QRegExp &patternP)
 159 {
 160     Q_ASSERT(patternP.isValid());
 161     if(flags == NoFlags)
 162         return;
 163
 164     if(flags & CaseInsensitive)
 165     {
 166         patternP.setCaseSensitivity(Qt::CaseInsensitive);
 167     }
 168     // TODO Apply the other flags, like 'x'.
 169 }
 170
 171 QRegExp PatternPlatform::parsePattern(const QString &pattern,
 172                                       const ReportContext::Ptr &context) const
 173 {
 174     return parsePattern(pattern, context, this);
 175 }
 176
 177 QRegExp PatternPlatform::parsePattern(const QString &patternP,
 178                                       const ReportContext::Ptr &context,
 179                                       const SourceLocationReflection *const location)
 180 {
 181     if(patternP == QLatin1String("(.)\\3") ||
 182        patternP == QLatin1String("\\3")    ||
 183        patternP == QLatin1String("(.)\\2"))
 184     {
 185         context->error(QLatin1String("We don't want to hang infinitely on K2-MatchesFunc-9, "
 186                                      "10 and 11."),
 187                        ReportContext::FOER0000, location);
 188         return QRegExp();
 189     }
 190
 191     QString rewrittenPattern(patternP);
 192
 193     /* We rewrite some well known patterns to QRegExp style here. Note that
 194      * these character classes only works in the ASCII range, and fail for
 195      * others. This support needs to be in QRegExp, since it's about checking
 196      * QChar::category(). */
 197     rewrittenPattern.replace(QLatin1String("[\\i-[:]]"), QLatin1String("[a-zA-Z_]"));
 198     rewrittenPattern.replace(QLatin1String("[\\c-[:]]"), QLatin1String("[a-zA-Z0-9_\\-\\.]"));
 199
 200     QRegExp retval(rewrittenPattern, Qt::CaseSensitive, QRegExp::W3CXmlSchema11);
 201
 202     if(retval.isValid())
 203         return retval;
 204     else
 205     {
 206         context->error(QtXmlPatterns::tr("%1 is an invalid regular expression pattern: %2")
 207                                         .arg(formatExpression(patternP), retval.errorString()),
 208                                    ReportContext::FORX0002, location);
 209         return QRegExp();
 210     }
 211 }
 212
 213 PatternPlatform::Flags PatternPlatform::parseFlags(const QString &flags,
 214                                                    const DynamicContext::Ptr &context) const
 215 {
 216
 217     if(flags.isEmpty())
 218         return NoFlags;
 219
 220     const PatternFlag::Hash flagDescrs(flagDescriptions());
 221     const int len = flags.length();
 222     Flags retval = NoFlags;
 223
 224     for(int i = 0; i < len; ++i)
 225     {
 226         const QChar flag(flags.at(i));
 227         const Flag specified = flagDescrs.value(flag).flag;
 228
 229         if(specified != NoFlags)
 230         {
 231             retval |= specified;
 232             continue;
 233         }
 234
 235         /* Generate a nice error message. */
 236         QString message(QtXmlPatterns::tr("%1 is an invalid flag for regular expressions. Valid flags are:")
 237                              .arg(formatKeyword(flag)));
 238
 239         /* This is formatting, so don't bother translators with it. */
 240         message.append(QLatin1Char('\n'));
 241
 242         const PatternFlag::Hash::const_iterator end(flagDescrs.constEnd());
 243         PatternFlag::Hash::const_iterator it(flagDescrs.constBegin());
 244
 245         for(; it != end;)
 246         {
 247             // TODO handle bidi correctly
 248             // TODO format this with rich text(list/table)
 249             message.append(formatKeyword(it.key()));
 250             message.append(QLatin1String(" - "));
 251             message.append(it.value().description);
 252
 253             ++it;
 254             if(it != end)
 255                 message.append(QLatin1Char('\n'));
 256         }
 257
 258         context->error(message, ReportContext::FORX0001, this);
 259         return NoFlags;
 260     }
 261
 262     return retval;
 263 }
 264
 265 Expression::Ptr PatternPlatform::compress(const StaticContext::Ptr &context)
 266 {
 267     const Expression::Ptr me(FunctionCall::compress(context));
 268     if(me != this)
 269         return me;
 270
 271     if(m_operands.at(1)->is(IDStringValue))
 272     {
 273         const DynamicContext::Ptr dynContext(context->dynamicContext());
 274
 275         m_pattern = parsePattern(m_operands.at(1)->evaluateSingleton(dynContext).stringValue(),
 276                                  dynContext);
 277         m_compiledParts |= PatternPrecompiled;
 278     }
 279
 280     const Expression::Ptr flagOperand(m_operands.value(m_flagsPosition));
 281
 282     if(!flagOperand)
 283     {
 284         m_flags = NoFlags;
 285         m_compiledParts |= FlagsPrecompiled;
 286     }
 287     else if(flagOperand->is(IDStringValue))
 288     {
 289         const DynamicContext::Ptr dynContext(context->dynamicContext());
 290         m_flags = parseFlags(flagOperand->evaluateSingleton(dynContext).stringValue(),
 291                              dynContext);
 292         m_compiledParts |= FlagsPrecompiled;
 293     }
 294
 295     if(m_compiledParts == FlagsAndPattern)
 296         applyFlags(m_flags, m_pattern);
 297
 298     return me;
 299 }
 300
 301 QT_END_NAMESPACE