1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //

    43 //  W A R N I N G

    44 //  -------------

    45 //

    46 // This file is not part of the Qt API.  It exists purely as an

    47 // implementation detail.  This header file may change from version to

    48 // version without notice, or even be removed.

    49 //

    50 // We mean it.

    51 

    52 #ifndef Patternist_Tokenizer_H

    53 #define Patternist_Tokenizer_H

    54 

    55 #include <QPair>

    56 #include <QSharedData>

    57 #include <QString>

    58 #include <QUrl>

    59 

    60 #include "qparsercontext_p.h"

    61 #include "qtokensource_p.h"

    62 

    63 /**

    64  * @file

    65  * @short Contains functions and classes used by the parser and tokenizer.

    66  */

    67 

    68 QT_BEGIN_HEADER

    69 

    70 QT_BEGIN_NAMESPACE

    71 

    72 namespace QPatternist

    73 {

    74     typedef QPair<QString, Expression::Ptr> AttributeHolder;

    75     typedef QVector<AttributeHolder> AttributeHolderVector;

    76 

    77     class OrderSpecTransfer

    78     {

    79     public:

    80         typedef QList<OrderSpecTransfer> List;

    81         inline OrderSpecTransfer()

    82         {

    83         }

    84 

    85         inline OrderSpecTransfer(const Expression::Ptr &aExpr,

    86                                  const OrderBy::OrderSpec aOrderSpec) : expression(aExpr),

    87                                                                         orderSpec(aOrderSpec)

    88         {

    89             Q_ASSERT(expression);

    90         }

    91 

    92         Expression::Ptr     expression;

    93         OrderBy::OrderSpec  orderSpec;

    94     };

    95 

    96     /**

    97      * @short The value the parser, but not the tokenizers, uses for tokens and

    98      * non-terminals.

    99      *

   100      * It is inefficient but ensures nothing leaks, by invoking C++

   101      * destructors even in the cases the code throws exceptions. This might be

   102      * able to be done in a more efficient way -- suggestions are welcome.

   103      */

   104     class TokenValue

   105     {

   106     public:

   107         QString                         sval;

   108 

   109         Expression::Ptr                 expr;

   110         Expression::List                expressionList;

   111 

   112         Cardinality                     cardinality;

   113         ItemType::Ptr                   itemType;

   114         SequenceType::Ptr               sequenceType;

   115         FunctionArgument::List          functionArguments;

   116         FunctionArgument::Ptr           functionArgument;

   117         QVector<QXmlName>               qNameVector;

   118         QXmlName                        qName;

   119         /**

   120          * Holds enum values.

   121          */

   122         EnumUnion                       enums;

   123 

   124         AttributeHolder                 attributeHolder;

   125         AttributeHolderVector           attributeHolders;

   126         OrderSpecTransfer::List         orderSpecs;

   127         OrderSpecTransfer               orderSpec;

   128     };

   129 }

   130 

   131 QT_END_NAMESPACE

   132 

   133 /**

   134  * Macro for the data type of semantic values; int by default.

   135  * See section Data Types of Semantic Values.

   136  */

   137 #define YYSTYPE QPatternist::TokenValue

   138 

   139 #include "qquerytransformparser_p.h" /* This inclusion must be after TokenValue. */

   140 

   141 QT_BEGIN_NAMESPACE

   142 

   143 namespace QPatternist

   144 {

   145     /**

   146      * @short Base class for all tokenizers.

   147      *

   148      * The main entry point is nextToken(), which ones calls to retrieve the stream

   149      * of tokens this Tokenizer delivers.

   150      *

   151      * @see <a href="http://www.w3.org/TR/xquery-xpath-parsing/">Building a

   152      * Tokenizer for XPath or XQuery</a>

   153      * @author Frans Englich <frans.englich@nokia.com>

   154      */

   155     class Tokenizer : public TokenSource

   156     {

   157     public:

   158         inline Tokenizer(const QUrl &queryU) : m_queryURI(queryU)

   159         {

   160             Q_ASSERT(queryU.isValid());

   161         }

   162 

   163         typedef QExplicitlySharedDataPointer<Tokenizer> Ptr;

   164 

   165         /**

   166          * Switches the Tokenizer to only do scanning, and returns complete

   167          * strings for attribute value templates as opposed to the tokens for

   168          * the contained expressions.

   169          *

   170          * The current position in the stream is returned. It can be used to

   171          * later resume regular tokenization.

   172          */

   173         virtual int commenceScanOnly() = 0;

   174 

   175         /**

   176          * Resumes regular parsing from @p position. The tokenizer must be in

   177          * the scan-only state, which the commenceScanOnly() call transists to.

   178          *

   179          * The tokenizer will return the token POSITION_SET once after this

   180          * function has been called.

   181          */

   182         virtual void resumeTokenizationFrom(const int position) = 0;

   183 

   184         /**

   185          * @returns the URI of the resource being tokenized.

   186          */

   187         inline const QUrl &queryURI() const

   188         {

   189             return m_queryURI;

   190         }

   191 

   192         virtual void setParserContext(const ParserContext::Ptr &parseInfo) = 0;

   193 

   194     protected:

   195         /**

   196          * Returns a string representation of @p token.

   197          *

   198          * This function is used for debugging purposes. The implementation of

   199          * this function is in querytransformparser.ypp.

   200          */

   201         static QString tokenToString(const Token &token);

   202 

   203     private:

   204         Q_DISABLE_COPY(Tokenizer)

   205         const QUrl m_queryURI;

   206     };

   207 

   208 }

   209 

   210 #undef Patternist_DEBUG_PARSER // disable it for now

   211 

   212 QT_END_NAMESPACE

   213 

   214 QT_END_HEADER

   215 

   216 #endif