LCOV - app.info - content/xslt/src/xpath/txExpr.h

LCOV - code coverage report
| Current view: | directory - content/xslt/src/xpath - txExpr.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 140 | 31 | 22.1 %
| Date: | 2012-07-07 | Functions: | 87 | 15 | 17.2 %

           1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is TransforMiiX XSLT processor code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * The MITRE Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1999
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Keith Visco <kvisco@ziplink.net> (Original Author)
          24                 :  *   Larry Fitzpatick, OpenText <lef@opentext.com>
          25                 :  *   Jonas Sicking <sicking@bigfoot.com>
          26                 :  *
          27                 :  * Alternatively, the contents of this file may be used under the terms of
          28                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          29                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          30                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          31                 :  * of those above. If you wish to allow use of your version of this file only
          32                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          33                 :  * use your version of this file under the terms of the MPL, indicate your
          34                 :  * decision by deleting the provisions above and replace them with the notice
          35                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          36                 :  * the provisions above, a recipient may use your version of this file under
          37                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          38                 :  *
          39                 :  * ***** END LICENSE BLOCK ***** */
          40                 :
          41                 : #ifndef TRANSFRMX_EXPR_H
          42                 : #define TRANSFRMX_EXPR_H
          43                 :
          44                 : #include "nsAutoPtr.h"
          45                 : #include "txExprResult.h"
          46                 : #include "txCore.h"
          47                 : #include "nsString.h"
          48                 : #include "txOwningArray.h"
          49                 : #include "nsIAtom.h"
          50                 :
          51                 : #ifdef DEBUG
          52                 : #define TX_TO_STRING
          53                 : #endif
          54                 :
          55                 : /*
          56                 :   XPath class definitions.
          57                 :   Much of this code was ported from XSL:P.
          58                 : */
          59                 :
          60                 : class nsIAtom;
          61                 : class txIParseContext;
          62                 : class txIMatchContext;
          63                 : class txIEvalContext;
          64                 : class txNodeSet;
          65                 : class txXPathNode;
          66                 :
          67                 : /**
          68                 :  * A Base Class for all XSL Expressions
          69                 : **/
          70                 : class Expr
          71                 : {
          72                 : public:
          73              42 :     Expr()
          74              42 :     {
          75              42 :         MOZ_COUNT_CTOR(Expr);
          76              42 :     }
          77              42 :     virtual ~Expr()
          78              42 :     {
          79              42 :         MOZ_COUNT_DTOR(Expr);
          80              84 :     }
          81                 :
          82                 :     /**
          83                 :      * Evaluates this Expr based on the given context node and processor state
          84                 :      * @param context the context node for evaluation of this Expr
          85                 :      * @param ps the ContextState containing the stack information needed
          86                 :      * for evaluation
          87                 :      * @return the result of the evaluation
          88                 :     **/
          89                 :     virtual nsresult evaluate(txIEvalContext* aContext,
          90                 :                               txAExprResult** aResult) = 0;
          91                 :
          92                 :
          93                 :     /**
          94                 :      * Returns the type of this expression.
          95                 :      */
          96                 :     enum ExprType {
          97                 :         LOCATIONSTEP_EXPR,
          98                 :         PATH_EXPR,
          99                 :         UNION_EXPR,
         100                 :         LITERAL_EXPR,
         101                 :         OTHER_EXPR
         102                 :     };
         103               0 :     virtual ExprType getType()
         104                 :     {
         105               0 :       return OTHER_EXPR;
         106                 :     }
         107                 :
         108                 :     /**
         109                 :      * Returns the type or types of results this Expr return.
         110                 :      */
         111                 :     typedef PRUint16 ResultType;
         112                 :     enum {
         113                 :         NODESET_RESULT = 0x01,
         114                 :         BOOLEAN_RESULT = 0x02,
         115                 :         NUMBER_RESULT = 0x04,
         116                 :         STRING_RESULT = 0x08,
         117                 :         RTF_RESULT = 0x10,
         118                 :         ANY_RESULT = 0xFFFF
         119                 :     };
         120                 :     virtual ResultType getReturnType() = 0;
         121               0 :     bool canReturnType(ResultType aType)
         122                 :     {
         123               0 :         return (getReturnType() & aType) != 0;
         124                 :     }
         125                 :
         126                 :     typedef PRUint16 ContextSensitivity;
         127                 :     enum {
         128                 :         NO_CONTEXT = 0x00,
         129                 :         NODE_CONTEXT = 0x01,
         130                 :         POSITION_CONTEXT = 0x02,
         131                 :         SIZE_CONTEXT = 0x04,
         132                 :         NODESET_CONTEXT = POSITION_CONTEXT | SIZE_CONTEXT,
         133                 :         VARIABLES_CONTEXT = 0x08,
         134                 :         PRIVATE_CONTEXT = 0x10,
         135                 :         ANY_CONTEXT = 0xFFFF
         136                 :     };
         137                 :
         138                 :     /**
         139                 :      * Returns true if this expression is sensitive to *any* of
         140                 :      * the requested contexts in aContexts.
         141                 :      */
         142                 :     virtual bool isSensitiveTo(ContextSensitivity aContexts) = 0;
         143                 :
         144                 :     /**
         145                 :      * Returns sub-expression at given position
         146                 :      */
         147                 :     virtual Expr* getSubExprAt(PRUint32 aPos) = 0;
         148                 :
         149                 :     /**
         150                 :      * Replace sub-expression at given position. Does not delete the old
         151                 :      * expression, that is the responsibility of the caller.
         152                 :      */
         153                 :     virtual void setSubExprAt(PRUint32 aPos, Expr* aExpr) = 0;
         154                 :
         155                 :     virtual nsresult evaluateToBool(txIEvalContext* aContext,
         156                 :                                     bool& aResult);
         157                 :
         158                 :     virtual nsresult evaluateToString(txIEvalContext* aContext,
         159                 :                                       nsString& aResult);
         160                 :
         161                 : #ifdef TX_TO_STRING
         162                 :     /**
         163                 :      * Returns the String representation of this Expr.
         164                 :      * @param dest the String to use when creating the String
         165                 :      * representation. The String representation will be appended to
         166                 :      * any data in the destination String, to allow cascading calls to
         167                 :      * other #toString() methods for Expressions.
         168                 :      * @return the String representation of this Expr.
         169                 :     **/
         170                 :     virtual void toString(nsAString& str) = 0;
         171                 : #endif
         172                 : }; //-- Expr
         173                 :
         174                 : #ifdef TX_TO_STRING
         175                 : #define TX_DECL_TOSTRING \
         176                 :     void toString(nsAString& aDest);
         177                 : #define TX_DECL_GETNAMEATOM \
         178                 :     nsresult getNameAtom(nsIAtom** aAtom);
         179                 : #else
         180                 : #define TX_DECL_TOSTRING
         181                 : #define TX_DECL_GETNAMEATOM
         182                 : #endif
         183                 :
         184                 : #define TX_DECL_EXPR_BASE \
         185                 :     nsresult evaluate(txIEvalContext* aContext, txAExprResult** aResult); \
         186                 :     ResultType getReturnType(); \
         187                 :     bool isSensitiveTo(ContextSensitivity aContexts);
         188                 :
         189                 : #define TX_DECL_EXPR \
         190                 :     TX_DECL_EXPR_BASE \
         191                 :     TX_DECL_TOSTRING \
         192                 :     Expr* getSubExprAt(PRUint32 aPos); \
         193                 :     void setSubExprAt(PRUint32 aPos, Expr* aExpr);
         194                 :
         195                 : #define TX_DECL_OPTIMIZABLE_EXPR \
         196                 :     TX_DECL_EXPR \
         197                 :     ExprType getType();
         198                 :
         199                 :
         200                 : #define TX_DECL_FUNCTION \
         201                 :     TX_DECL_GETNAMEATOM \
         202                 :     TX_DECL_EXPR_BASE
         203                 :
         204                 : #define TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType)          \
         205                 : Expr::ResultType                                              \
         206                 : _class::getReturnType()                                       \
         207                 : {                                                             \
         208                 :     return _ReturnType;                                       \
         209                 : }
         210                 :
         211                 : #define TX_IMPL_EXPR_STUBS_0(_class, _ReturnType)             \
         212                 : TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType)                  \
         213                 : Expr*                                                         \
         214                 : _class::getSubExprAt(PRUint32 aPos)                           \
         215                 : {                                                             \
         216                 :     return nsnull;                                            \
         217                 : }                                                             \
         218                 : void                                                          \
         219                 : _class::setSubExprAt(PRUint32 aPos, Expr* aExpr)              \
         220                 : {                                                             \
         221                 :     NS_NOTREACHED("setting bad subexpression index");         \
         222                 : }
         223                 :
         224                 : #define TX_IMPL_EXPR_STUBS_1(_class, _ReturnType, _Expr1)     \
         225                 : TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType)                  \
         226                 : Expr*                                                         \
         227                 : _class::getSubExprAt(PRUint32 aPos)                           \
         228                 : {                                                             \
         229                 :     if (aPos == 0) {                                          \
         230                 :         return _Expr1;                                        \
         231                 :     }                                                         \
         232                 :     return nsnull;                                            \
         233                 : }                                                             \
         234                 : void                                                          \
         235                 : _class::setSubExprAt(PRUint32 aPos, Expr* aExpr)              \
         236                 : {                                                             \
         237                 :     NS_ASSERTION(aPos < 1, "setting bad subexpression index");\
         238                 :     _Expr1.forget();                                          \
         239                 :     _Expr1 = aExpr;                                           \
         240                 : }
         241                 :
         242                 : #define TX_IMPL_EXPR_STUBS_2(_class, _ReturnType, _Expr1, _Expr2) \
         243                 : TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType)                  \
         244                 : Expr*                                                         \
         245                 : _class::getSubExprAt(PRUint32 aPos)                           \
         246                 : {                                                             \
         247                 :     switch(aPos) {                                            \
         248                 :         case 0:                                               \
         249                 :             return _Expr1;                                    \
         250                 :         case 1:                                               \
         251                 :             return _Expr2;                                    \
         252                 :         default:                                              \
         253                 :             break;                                            \
         254                 :     }                                                         \
         255                 :     return nsnull;                                            \
         256                 : }                                                             \
         257                 : void                                                          \
         258                 : _class::setSubExprAt(PRUint32 aPos, Expr* aExpr)              \
         259                 : {                                                             \
         260                 :     NS_ASSERTION(aPos < 2, "setting bad subexpression index");\
         261                 :     if (aPos == 0) {                                          \
         262                 :         _Expr1.forget();                                      \
         263                 :         _Expr1 = aExpr;                                       \
         264                 :     }                                                         \
         265                 :     else {                                                    \
         266                 :         _Expr2.forget();                                      \
         267                 :         _Expr2 = aExpr;                                       \
         268                 :     }                                                         \
         269                 : }
         270                 :
         271                 : #define TX_IMPL_EXPR_STUBS_LIST(_class, _ReturnType, _ExprList) \
         272                 : TX_IMPL_EXPR_STUBS_BASE(_class, _ReturnType)                  \
         273                 : Expr*                                                         \
         274                 : _class::getSubExprAt(PRUint32 aPos)                           \
         275                 : {                                                             \
         276                 :     return _ExprList.SafeElementAt(aPos);                     \
         277                 : }                                                             \
         278                 : void                                                          \
         279                 : _class::setSubExprAt(PRUint32 aPos, Expr* aExpr)              \
         280                 : {                                                             \
         281                 :     NS_ASSERTION(aPos < _ExprList.Length(),                   \
         282                 :                  "setting bad subexpression index");          \
         283                 :     _ExprList[aPos] = aExpr;                                  \
         284                 : }
         285                 :
         286                 :
         287                 : /**
         288                 :  * This class represents a FunctionCall as defined by the XPath 1.0
         289                 :  * Recommendation.
         290                 : **/
         291                 : class FunctionCall : public Expr
         292               0 : {
         293                 : public:
         294                 :     /**
         295                 :      * Adds the given parameter to this FunctionCall's parameter list.
         296                 :      * The ownership of the given Expr is passed over to the FunctionCall,
         297                 :      * even on failure.
         298                 :      * @param aExpr the Expr to add to this FunctionCall's parameter list
         299                 :      * @return nsresult indicating out of memory
         300                 :      */
         301               0 :     nsresult addParam(Expr* aExpr)
         302                 :     {
         303               0 :         return mParams.AppendElement(aExpr) ?
         304               0 :             NS_OK : NS_ERROR_OUT_OF_MEMORY;
         305                 :     }
         306                 :
         307                 :     /**
         308                 :      * Check if the number of parameters falls within a range.
         309                 :      *
         310                 :      * @param aParamCountMin minimum number of required parameters.
         311                 :      * @param aParamCountMax maximum number of parameters. If aParamCountMax
         312                 :      *                       is negative the maximum number is not checked.
         313                 :      * @return boolean representing whether the number of parameters falls
         314                 :      *         within the expected range or not.
         315                 :      *
         316                 :      * XXX txIEvalContext should be txIParseContest, bug 143291
         317                 :      */
         318                 :     virtual bool requireParams(PRInt32 aParamCountMin,
         319                 :                                  PRInt32 aParamCountMax,
         320                 :                                  txIEvalContext* aContext);
         321                 :
         322                 :     TX_DECL_TOSTRING
         323                 :     Expr* getSubExprAt(PRUint32 aPos);
         324                 :     void setSubExprAt(PRUint32 aPos, Expr* aExpr);
         325                 :
         326                 : protected:
         327                 :
         328                 :     txOwningArray<Expr> mParams;
         329                 :
         330                 :     /*
         331                 :      * Evaluates the given Expression and converts its result to a number.
         332                 :      */
         333                 :     static nsresult evaluateToNumber(Expr* aExpr, txIEvalContext* aContext,
         334                 :                                      double* aResult);
         335                 :
         336                 :     /*
         337                 :      * Evaluates the given Expression and converts its result to a NodeSet.
         338                 :      * If the result is not a NodeSet an error is returned.
         339                 :      */
         340                 :     static nsresult evaluateToNodeSet(Expr* aExpr, txIEvalContext* aContext,
         341                 :                                       txNodeSet** aResult);
         342                 :
         343                 :     /**
         344                 :      * Returns true if any argument is sensitive to the given context.
         345                 :      */
         346                 :     bool argsSensitiveTo(ContextSensitivity aContexts);
         347                 :
         348                 :
         349                 : #ifdef TX_TO_STRING
         350                 :     /*
         351                 :      * Returns the name of the function as an atom.
         352                 :      */
         353                 :     virtual nsresult getNameAtom(nsIAtom** aAtom) = 0;
         354                 : #endif
         355                 : };
         356                 :
         357                 : class txCoreFunctionCall : public FunctionCall
         358               0 : {
         359                 : public:
         360                 :
         361                 :     // This must be ordered in the same order as descriptTable in
         362                 :     // txCoreFunctionCall.cpp. If you change one, change the other.
         363                 :     enum eType {
         364                 :         COUNT = 0,         // count()
         365                 :         ID,                // id()
         366                 :         LAST,              // last()
         367                 :         LOCAL_NAME,        // local-name()
         368                 :         NAMESPACE_URI,     // namespace-uri()
         369                 :         NAME,              // name()
         370                 :         POSITION,          // position()
         371                 :
         372                 :         CONCAT,            // concat()
         373                 :         CONTAINS,          // contains()
         374                 :         NORMALIZE_SPACE,   // normalize-space()
         375                 :         STARTS_WITH,       // starts-with()
         376                 :         STRING,            // string()
         377                 :         STRING_LENGTH,     // string-length()
         378                 :         SUBSTRING,         // substring()
         379                 :         SUBSTRING_AFTER,   // substring-after()
         380                 :         SUBSTRING_BEFORE,  // substring-before()
         381                 :         TRANSLATE,         // translate()
         382                 :
         383                 :         NUMBER,            // number()
         384                 :         ROUND,             // round()
         385                 :         FLOOR,             // floor()
         386                 :         CEILING,           // ceiling()
         387                 :         SUM,               // sum()
         388                 :
         389                 :         BOOLEAN,           // boolean()
         390                 :         _FALSE,            // false()
         391                 :         LANG,              // lang()
         392                 :         _NOT,              // not()
         393                 :         _TRUE              // true()
         394                 :     };
         395                 :
         396                 :     /*
         397                 :      * Creates a txCoreFunctionCall of the given type
         398                 :      */
         399               0 :     txCoreFunctionCall(eType aType) : mType(aType)
         400                 :     {
         401               0 :     }
         402                 :
         403                 :     TX_DECL_FUNCTION
         404                 :
         405                 :     static bool getTypeFromAtom(nsIAtom* aName, eType& aType);
         406                 :
         407                 : private:
         408                 :     eType mType;
         409                 : };
         410                 :
         411                 :
         412                 : /*
         413                 :  * This class represents a NodeTest as defined by the XPath spec
         414                 :  */
         415                 : class txNodeTest
         416                 : {
         417                 : public:
         418              42 :     txNodeTest()
         419              42 :     {
         420              42 :         MOZ_COUNT_CTOR(txNodeTest);
         421              42 :     }
         422              42 :     virtual ~txNodeTest()
         423              42 :     {
         424              42 :         MOZ_COUNT_DTOR(txNodeTest);
         425              84 :     }
         426                 :
         427                 :     /*
         428                 :      * Virtual methods
         429                 :      * pretty much a txPattern, but not supposed to be used
         430                 :      * standalone. The NodeTest node() is different to the
         431                 :      * Pattern "node()" (document node isn't matched)
         432                 :      */
         433                 :     virtual bool matches(const txXPathNode& aNode,
         434                 :                            txIMatchContext* aContext) = 0;
         435                 :     virtual double getDefaultPriority() = 0;
         436                 :
         437                 :     /**
         438                 :      * Returns the type of this nodetest.
         439                 :      */
         440                 :     enum NodeTestType {
         441                 :         NAME_TEST,
         442                 :         NODETYPE_TEST,
         443                 :         OTHER_TEST
         444                 :     };
         445               0 :     virtual NodeTestType getType()
         446                 :     {
         447               0 :       return OTHER_TEST;
         448                 :     }
         449                 :
         450                 :     /**
         451                 :      * Returns true if this expression is sensitive to *any* of
         452                 :      * the requested flags.
         453                 :      */
         454                 :     virtual bool isSensitiveTo(Expr::ContextSensitivity aContext) = 0;
         455                 :
         456                 : #ifdef TX_TO_STRING
         457                 :     virtual void toString(nsAString& aDest) = 0;
         458                 : #endif
         459                 : };
         460                 :
         461                 : #define TX_DECL_NODE_TEST \
         462                 :     TX_DECL_TOSTRING \
         463                 :     bool matches(const txXPathNode& aNode, txIMatchContext* aContext); \
         464                 :     double getDefaultPriority(); \
         465                 :     bool isSensitiveTo(Expr::ContextSensitivity aContext);
         466                 :
         467                 : /*
         468                 :  * This class represents a NameTest as defined by the XPath spec
         469                 :  */
         470                 : class txNameTest : public txNodeTest
         471               0 : {
         472                 : public:
         473                 :     /*
         474                 :      * Creates a new txNameTest with the given type and the given
         475                 :      * principal node type
         476                 :      */
         477                 :     txNameTest(nsIAtom* aPrefix, nsIAtom* aLocalName, PRInt32 aNSID,
         478                 :                PRUint16 aNodeType);
         479                 :
         480                 :     NodeTestType getType();
         481                 :
         482                 :     TX_DECL_NODE_TEST
         483                 :
         484                 :     nsCOMPtr<nsIAtom> mPrefix;
         485                 :     nsCOMPtr<nsIAtom> mLocalName;
         486                 :     PRInt32 mNamespace;
         487                 : private:
         488                 :     PRUint16 mNodeType;
         489                 : };
         490                 :
         491                 : /*
         492                 :  * This class represents a NodeType as defined by the XPath spec
         493                 :  */
         494                 : class txNodeTypeTest : public txNodeTest
         495             168 : {
         496                 : public:
         497                 :     enum NodeType {
         498                 :         COMMENT_TYPE,
         499                 :         TEXT_TYPE,
         500                 :         PI_TYPE,
         501                 :         NODE_TYPE
         502                 :     };
         503                 :
         504                 :     /*
         505                 :      * Creates a new txNodeTypeTest of the given type
         506                 :      */
         507              42 :     txNodeTypeTest(NodeType aNodeType)
         508              42 :         : mNodeType(aNodeType)
         509                 :     {
         510              42 :     }
         511                 :
         512                 :     /*
         513                 :      * Sets the name of the node to match. Only availible for pi nodes
         514                 :      */
         515               0 :     void setNodeName(const nsAString& aName)
         516                 :     {
         517               0 :         mNodeName = do_GetAtom(aName);
         518               0 :     }
         519                 :
         520               0 :     NodeType getNodeTestType()
         521                 :     {
         522               0 :         return mNodeType;
         523                 :     }
         524                 :
         525                 :     NodeTestType getType();
         526                 :
         527                 :     TX_DECL_NODE_TEST
         528                 :
         529                 : private:
         530                 :     NodeType mNodeType;
         531                 :     nsCOMPtr<nsIAtom> mNodeName;
         532                 : };
         533                 :
         534                 : /**
         535                 :  * Class representing a nodetest combined with a predicate. May only be used
         536                 :  * if the predicate is not sensitive to the context-nodelist.
         537                 :  */
         538                 : class txPredicatedNodeTest : public txNodeTest
         539               0 : {
         540                 : public:
         541                 :     txPredicatedNodeTest(txNodeTest* aNodeTest, Expr* aPredicate);
         542                 :     TX_DECL_NODE_TEST
         543                 :
         544                 : private:
         545                 :     nsAutoPtr<txNodeTest> mNodeTest;
         546                 :     nsAutoPtr<Expr> mPredicate;
         547                 : };
         548                 :
         549                 : /**
         550                 :  * Represents an ordered list of Predicates,
         551                 :  * for use with Step and Filter Expressions
         552                 : **/
         553              84 : class PredicateList  {
         554                 : public:
         555                 :     /**
         556                 :      * Adds the given Expr to the list.
         557                 :      * The ownership of the given Expr is passed over the PredicateList,
         558                 :      * even on failure.
         559                 :      * @param aExpr the Expr to add to the list
         560                 :      * @return nsresult indicating out of memory
         561                 :      */
         562               0 :     nsresult add(Expr* aExpr)
         563                 :     {
         564               0 :         NS_ASSERTION(aExpr, "missing expression");
         565               0 :         return mPredicates.AppendElement(aExpr) ?
         566               0 :             NS_OK : NS_ERROR_OUT_OF_MEMORY;
         567                 :     }
         568                 :
         569                 :     nsresult evaluatePredicates(txNodeSet* aNodes, txIMatchContext* aContext);
         570                 :
         571                 :     /**
         572                 :      * Drops the first predicate without deleting it.
         573                 :      */
         574               0 :     void dropFirst()
         575                 :     {
         576               0 :         mPredicates.RemoveElementAt(0);
         577               0 :     }
         578                 :
         579                 :     /**
         580                 :      * returns true if this predicate list is empty
         581                 :     **/
         582              42 :     bool isEmpty()
         583                 :     {
         584              42 :         return mPredicates.IsEmpty();
         585                 :     }
         586                 :
         587                 : #ifdef TX_TO_STRING
         588                 :     /**
         589                 :      * Returns the String representation of this PredicateList.
         590                 :      * @param dest the String to use when creating the String
         591                 :      * representation. The String representation will be appended to
         592                 :      * any data in the destination String, to allow cascading calls to
         593                 :      * other #toString() methods for Expressions.
         594                 :      * @return the String representation of this PredicateList.
         595                 :     **/
         596                 :     void toString(nsAString& dest);
         597                 : #endif
         598                 :
         599                 : protected:
         600                 :     bool isSensitiveTo(Expr::ContextSensitivity aContext);
         601              84 :     Expr* getSubExprAt(PRUint32 aPos)
         602                 :     {
         603              84 :         return mPredicates.SafeElementAt(aPos);
         604                 :     }
         605               0 :     void setSubExprAt(PRUint32 aPos, Expr* aExpr)
         606                 :     {
         607               0 :         NS_ASSERTION(aPos < mPredicates.Length(),
         608                 :                      "setting bad subexpression index");
         609               0 :         mPredicates[aPos] = aExpr;
         610               0 :     }
         611                 :
         612                 :     //-- list of predicates
         613                 :     txOwningArray<Expr> mPredicates;
         614                 : }; //-- PredicateList
         615                 :
         616                 : class LocationStep : public Expr,
         617                 :                      public PredicateList
         618             168 : {
         619                 : public:
         620                 :     enum LocationStepType {
         621                 :         ANCESTOR_AXIS = 0,
         622                 :         ANCESTOR_OR_SELF_AXIS,
         623                 :         ATTRIBUTE_AXIS,
         624                 :         CHILD_AXIS,
         625                 :         DESCENDANT_AXIS,
         626                 :         DESCENDANT_OR_SELF_AXIS,
         627                 :         FOLLOWING_AXIS,
         628                 :         FOLLOWING_SIBLING_AXIS,
         629                 :         NAMESPACE_AXIS,
         630                 :         PARENT_AXIS,
         631                 :         PRECEDING_AXIS,
         632                 :         PRECEDING_SIBLING_AXIS,
         633                 :         SELF_AXIS
         634                 :     };
         635                 :
         636                 :     /**
         637                 :      * Creates a new LocationStep using the given NodeExpr and Axis Identifier
         638                 :      * @param nodeExpr the NodeExpr to use when matching Nodes
         639                 :      * @param axisIdentifier the Axis Identifier in which to search for nodes
         640                 :     **/
         641              42 :     LocationStep(txNodeTest* aNodeTest,
         642                 :                  LocationStepType aAxisIdentifier)
         643                 :         : mNodeTest(aNodeTest),
         644              42 :           mAxisIdentifier(aAxisIdentifier)
         645                 :     {
         646              42 :     }
         647                 :
         648                 :     TX_DECL_OPTIMIZABLE_EXPR
         649                 :
         650               0 :     txNodeTest* getNodeTest()
         651                 :     {
         652               0 :         return mNodeTest;
         653                 :     }
         654               0 :     void setNodeTest(txNodeTest* aNodeTest)
         655                 :     {
         656               0 :         mNodeTest.forget();
         657               0 :         mNodeTest = aNodeTest;
         658               0 :     }
         659              42 :     LocationStepType getAxisIdentifier()
         660                 :     {
         661              42 :         return mAxisIdentifier;
         662                 :     }
         663               0 :     void setAxisIdentifier(LocationStepType aAxisIdentifier)
         664                 :     {
         665               0 :         mAxisIdentifier = aAxisIdentifier;
         666               0 :     }
         667                 :
         668                 : private:
         669                 :     void fromDescendants(const txXPathNode& aNode, txIMatchContext* aCs,
         670                 :                          txNodeSet* aNodes);
         671                 :     void fromDescendantsRev(const txXPathNode& aNode, txIMatchContext* aCs,
         672                 :                             txNodeSet* aNodes);
         673                 :
         674                 :     nsAutoPtr<txNodeTest> mNodeTest;
         675                 :     LocationStepType mAxisIdentifier;
         676                 : };
         677                 :
         678                 : class FilterExpr : public Expr,
         679                 :                    public PredicateList
         680               0 : {
         681                 : public:
         682                 :
         683                 :     /**
         684                 :      * Creates a new FilterExpr using the given Expr
         685                 :      * @param expr the Expr to use for evaluation
         686                 :      */
         687               0 :     FilterExpr(Expr* aExpr)
         688               0 :         : expr(aExpr)
         689                 :     {
         690               0 :     }
         691                 :
         692                 :     TX_DECL_EXPR
         693                 :
         694                 : private:
         695                 :     nsAutoPtr<Expr> expr;
         696                 :
         697                 : }; //-- FilterExpr
         698                 :
         699                 :
         700               0 : class txLiteralExpr : public Expr {
         701                 : public:
         702               0 :     txLiteralExpr(double aDbl)
         703               0 :         : mValue(new NumberResult(aDbl, nsnull))
         704                 :     {
         705               0 :     }
         706               0 :     txLiteralExpr(const nsAString& aStr)
         707               0 :         : mValue(new StringResult(aStr, nsnull))
         708                 :     {
         709               0 :     }
         710               0 :     txLiteralExpr(txAExprResult* aValue)
         711               0 :         : mValue(aValue)
         712                 :     {
         713               0 :     }
         714                 :
         715                 :     TX_DECL_EXPR
         716                 :
         717                 : private:
         718                 :     nsRefPtr<txAExprResult> mValue;
         719                 : };
         720                 :
         721                 : /**
         722                 :  * Represents an UnaryExpr. Returns the negative value of its expr.
         723                 : **/
         724               0 : class UnaryExpr : public Expr {
         725                 :
         726                 : public:
         727                 :
         728               0 :     UnaryExpr(Expr* aExpr)
         729               0 :         : expr(aExpr)
         730                 :     {
         731               0 :     }
         732                 :
         733                 :     TX_DECL_EXPR
         734                 :
         735                 : private:
         736                 :     nsAutoPtr<Expr> expr;
         737                 : }; //-- UnaryExpr
         738                 :
         739                 : /**
         740                 :  * Represents a BooleanExpr, a binary expression that
         741                 :  * performs a boolean operation between its lvalue and rvalue.
         742                 : **/
         743                 : class BooleanExpr : public Expr
         744               0 : {
         745                 : public:
         746                 :
         747                 :     //-- BooleanExpr Types
         748                 :     enum _BooleanExprType { AND = 1, OR };
         749                 :
         750               0 :      BooleanExpr(Expr* aLeftExpr, Expr* aRightExpr, short aOp)
         751                 :          : leftExpr(aLeftExpr),
         752                 :            rightExpr(aRightExpr),
         753               0 :            op(aOp)
         754                 :     {
         755               0 :     }
         756                 :
         757                 :     TX_DECL_EXPR
         758                 :
         759                 : private:
         760                 :     nsAutoPtr<Expr> leftExpr, rightExpr;
         761                 :     short op;
         762                 : }; //-- BooleanExpr
         763                 :
         764                 : /**
         765                 :  * Represents a MultiplicativeExpr, a binary expression that
         766                 :  * performs a multiplicative operation between its lvalue and rvalue:
         767                 :  *  *   : multiply
         768                 :  * mod  : modulus
         769                 :  * div  : divide
         770                 :  *
         771                 : **/
         772                 : class txNumberExpr : public Expr
         773               0 : {
         774                 : public:
         775                 :
         776                 :     enum eOp { ADD, SUBTRACT, DIVIDE, MULTIPLY, MODULUS };
         777                 :
         778               0 :     txNumberExpr(Expr* aLeftExpr, Expr* aRightExpr, eOp aOp)
         779                 :         : mLeftExpr(aLeftExpr),
         780                 :           mRightExpr(aRightExpr),
         781               0 :           mOp(aOp)
         782                 :     {
         783               0 :     }
         784                 :
         785                 :     TX_DECL_EXPR
         786                 :
         787                 : private:
         788                 :     nsAutoPtr<Expr> mLeftExpr, mRightExpr;
         789                 :     eOp mOp;
         790                 : }; //-- MultiplicativeExpr
         791                 :
         792                 : /**
         793                 :  * Represents a RelationalExpr, an expression that compares its lvalue
         794                 :  * to its rvalue using:
         795                 :  * =  : equal to
         796                 :  * <  : less than
         797                 :  * >  : greater than
         798                 :  * <= : less than or equal to
         799                 :  * >= : greater than or equal to
         800                 :  *
         801                 : **/
         802                 : class RelationalExpr : public Expr
         803               0 : {
         804                 : public:
         805                 :     enum RelationalExprType {
         806                 :         EQUAL,
         807                 :         NOT_EQUAL,
         808                 :         LESS_THAN,
         809                 :         GREATER_THAN,
         810                 :         LESS_OR_EQUAL,
         811                 :         GREATER_OR_EQUAL
         812                 :     };
         813                 :
         814               0 :     RelationalExpr(Expr* aLeftExpr, Expr* aRightExpr, RelationalExprType aOp)
         815                 :         : mLeftExpr(aLeftExpr),
         816                 :           mRightExpr(aRightExpr),
         817               0 :           mOp(aOp)
         818                 :     {
         819               0 :     }
         820                 :
         821                 :
         822                 :     TX_DECL_EXPR
         823                 :
         824                 : private:
         825                 :     bool compareResults(txIEvalContext* aContext, txAExprResult* aLeft,
         826                 :                           txAExprResult* aRight);
         827                 :
         828                 :     nsAutoPtr<Expr> mLeftExpr;
         829                 :     nsAutoPtr<Expr> mRightExpr;
         830                 :     RelationalExprType mOp;
         831                 : };
         832                 :
         833                 : /**
         834                 :  * VariableRefExpr
         835                 :  * Represents a variable reference ($refname)
         836                 : **/
         837               0 : class VariableRefExpr : public Expr {
         838                 :
         839                 : public:
         840                 :
         841                 :     VariableRefExpr(nsIAtom* aPrefix, nsIAtom* aLocalName, PRInt32 aNSID);
         842                 :
         843                 :     TX_DECL_EXPR
         844                 :
         845                 : private:
         846                 :     nsCOMPtr<nsIAtom> mPrefix;
         847                 :     nsCOMPtr<nsIAtom> mLocalName;
         848                 :     PRInt32 mNamespace;
         849                 : };
         850                 :
         851                 : /**
         852                 :  *  Represents a PathExpr
         853                 : **/
         854               0 : class PathExpr : public Expr {
         855                 :
         856                 : public:
         857                 :
         858                 :     //-- Path Operators
         859                 :     //-- RELATIVE_OP is the default
         860                 :     //-- LF, changed from static const short to enum
         861                 :     enum PathOperator { RELATIVE_OP, DESCENDANT_OP };
         862                 :
         863                 :     /**
         864                 :      * Adds the Expr to this PathExpr
         865                 :      * The ownership of the given Expr is passed over the PathExpr,
         866                 :      * even on failure.
         867                 :      * @param aExpr the Expr to add to this PathExpr
         868                 :      * @return nsresult indicating out of memory
         869                 :      */
         870                 :     nsresult addExpr(Expr* aExpr, PathOperator pathOp);
         871                 :
         872                 :     /**
         873                 :      * Removes and deletes the expression at the given index.
         874                 :      */
         875               0 :     void deleteExprAt(PRUint32 aPos)
         876                 :     {
         877               0 :         NS_ASSERTION(aPos < mItems.Length(),
         878                 :                      "killing bad expression index");
         879               0 :         mItems.RemoveElementAt(aPos);
         880               0 :     }
         881                 :
         882                 :     TX_DECL_OPTIMIZABLE_EXPR
         883                 :
         884               0 :     PathOperator getPathOpAt(PRUint32 aPos)
         885                 :     {
         886               0 :         NS_ASSERTION(aPos < mItems.Length(), "getting bad pathop index");
         887               0 :         return mItems[aPos].pathOp;
         888                 :     }
         889               0 :     void setPathOpAt(PRUint32 aPos, PathOperator aPathOp)
         890                 :     {
         891               0 :         NS_ASSERTION(aPos < mItems.Length(), "setting bad pathop index");
         892               0 :         mItems[aPos].pathOp = aPathOp;
         893               0 :     }
         894                 :
         895                 : private:
         896               0 :     class PathExprItem {
         897                 :     public:
         898                 :         nsAutoPtr<Expr> expr;
         899                 :         PathOperator pathOp;
         900                 :     };
         901                 :
         902                 :     nsTArray<PathExprItem> mItems;
         903                 :
         904                 :     /*
         905                 :      * Selects from the descendants of the context node
         906                 :      * all nodes that match the Expr
         907                 :      */
         908                 :     nsresult evalDescendants(Expr* aStep, const txXPathNode& aNode,
         909                 :                              txIMatchContext* aContext,
         910                 :                              txNodeSet* resNodes);
         911                 : };
         912                 :
         913                 : /**
         914                 :  * This class represents a RootExpr, which only matches the Document node
         915                 : **/
         916               0 : class RootExpr : public Expr {
         917                 : public:
         918                 :     /**
         919                 :      * Creates a new RootExpr
         920                 :      */
         921               0 :     RootExpr()
         922                 : #ifdef TX_TO_STRING
         923               0 :         : mSerialize(true)
         924                 : #endif
         925                 :     {
         926               0 :     }
         927                 :
         928                 :     TX_DECL_EXPR
         929                 :
         930                 : #ifdef TX_TO_STRING
         931                 : public:
         932               0 :     void setSerialize(bool aSerialize)
         933                 :     {
         934               0 :         mSerialize = aSerialize;
         935               0 :     }
         936                 :
         937                 : private:
         938                 :     // When a RootExpr is used in a PathExpr it shouldn't be serialized
         939                 :     bool mSerialize;
         940                 : #endif
         941                 : }; //-- RootExpr
         942                 :
         943                 : /**
         944                 :  *  Represents a UnionExpr
         945                 : **/
         946               0 : class UnionExpr : public Expr {
         947                 : public:
         948                 :     /**
         949                 :      * Adds the PathExpr to this UnionExpr
         950                 :      * The ownership of the given Expr is passed over the UnionExpr,
         951                 :      * even on failure.
         952                 :      * @param aExpr the Expr to add to this UnionExpr
         953                 :      * @return nsresult indicating out of memory
         954                 :      */
         955               0 :     nsresult addExpr(Expr* aExpr)
         956                 :     {
         957               0 :         return mExpressions.AppendElement(aExpr) ?
         958               0 :             NS_OK : NS_ERROR_OUT_OF_MEMORY;
         959                 :     }
         960                 :
         961                 :     /**
         962                 :      * Removes and deletes the expression at the given index.
         963                 :      */
         964               0 :     void deleteExprAt(PRUint32 aPos)
         965                 :     {
         966               0 :         NS_ASSERTION(aPos < mExpressions.Length(),
         967                 :                      "killing bad expression index");
         968                 :
         969               0 :         delete mExpressions[aPos];
         970               0 :         mExpressions.RemoveElementAt(aPos);
         971               0 :     }
         972                 :
         973                 :     TX_DECL_OPTIMIZABLE_EXPR
         974                 :
         975                 : private:
         976                 :
         977                 :    txOwningArray<Expr> mExpressions;
         978                 :
         979                 : }; //-- UnionExpr
         980                 :
         981                 : /**
         982                 :  * Class specializing in executing expressions like "@foo" where we are
         983                 :  * interested in different result-types, and expressions like "@foo = 'hi'"
         984                 :  */
         985                 : class txNamedAttributeStep : public Expr
         986               0 : {
         987                 : public:
         988                 :     txNamedAttributeStep(PRInt32 aNsID, nsIAtom* aPrefix,
         989                 :                          nsIAtom* aLocalName);
         990                 :
         991                 :     TX_DECL_EXPR
         992                 :
         993                 : private:
         994                 :     PRInt32 mNamespace;
         995                 :     nsCOMPtr<nsIAtom> mPrefix;
         996                 :     nsCOMPtr<nsIAtom> mLocalName;
         997                 : };
         998                 :
         999                 : /**
        1000                 :  *
        1001                 :  */
        1002                 : class txUnionNodeTest : public txNodeTest
        1003               0 : {
        1004                 : public:
        1005               0 :     nsresult addNodeTest(txNodeTest* aNodeTest)
        1006                 :     {
        1007               0 :         return mNodeTests.AppendElement(aNodeTest) ?
        1008               0 :             NS_OK : NS_ERROR_OUT_OF_MEMORY;
        1009                 :     }
        1010                 :
        1011                 :     TX_DECL_NODE_TEST
        1012                 :
        1013                 : private:
        1014                 :     txOwningArray<txNodeTest> mNodeTests;
        1015                 : };
        1016                 :
        1017                 : /**
        1018                 :  *  Expression that failed to parse
        1019                 :  */
        1020                 : class txErrorExpr : public Expr
        1021               0 : {
        1022                 : public:
        1023                 : #ifdef TX_TO_STRING
        1024               0 :     txErrorExpr(const nsAString& aStr)
        1025               0 :       : mStr(aStr)
        1026                 :     {
        1027               0 :     }
        1028                 : #endif
        1029                 :
        1030                 :     TX_DECL_EXPR
        1031                 :
        1032                 : #ifdef TX_TO_STRING
        1033                 : private:
        1034                 :     nsString mStr;
        1035                 : #endif
        1036                 : };
        1037                 :
        1038                 : #endif
        1039                 :
        1040                 :

Generated by: LCOV version 1.7