LCOV - app.info - content/xslt/src/xpath/nsXPathExpression.cpp

LCOV - code coverage report
| Current view: | directory - content/xslt/src/xpath - nsXPathExpression.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 87 | 57 | 65.5 %
| Date: | 2012-07-07 | Functions: | 19 | 13 | 68.4 %

           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                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 2001
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Peter Van der Beken <peterv@propagandism.org>
          24                 :  *
          25                 :  * Alternatively, the contents of this file may be used under the terms of
          26                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          27                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          29                 :  * of those above. If you wish to allow use of your version of this file only
          30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          31                 :  * use your version of this file under the terms of the MPL, indicate your
          32                 :  * decision by deleting the provisions above and replace them with the notice
          33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          34                 :  * the provisions above, a recipient may use your version of this file under
          35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          36                 :  *
          37                 :  * ***** END LICENSE BLOCK ***** */
          38                 :
          39                 : #include "nsXPathExpression.h"
          40                 : #include "txExpr.h"
          41                 : #include "txExprResult.h"
          42                 : #include "nsDOMError.h"
          43                 : #include "nsIDOMCharacterData.h"
          44                 : #include "nsDOMClassInfoID.h"
          45                 : #include "nsIDOMDocument.h"
          46                 : #include "nsIDOMXPathNamespace.h"
          47                 : #include "nsXPathResult.h"
          48                 : #include "nsDOMError.h"
          49                 : #include "txURIUtils.h"
          50                 : #include "txXPathTreeWalker.h"
          51                 :
          52            1516 : NS_IMPL_CYCLE_COLLECTION_1(nsXPathExpression, mDocument)
          53                 :
          54             236 : NS_IMPL_CYCLE_COLLECTING_ADDREF(nsXPathExpression)
          55             278 : NS_IMPL_CYCLE_COLLECTING_RELEASE(nsXPathExpression)
          56                 :
          57                 : DOMCI_DATA(XPathExpression, nsXPathExpression)
          58                 :
          59             686 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXPathExpression)
          60             378 :   NS_INTERFACE_MAP_ENTRY(nsIDOMXPathExpression)
          61             252 :   NS_INTERFACE_MAP_ENTRY(nsIDOMNSXPathExpression)
          62             252 :   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMXPathExpression)
          63             210 :   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(XPathExpression)
          64             168 : NS_INTERFACE_MAP_END
          65                 :
          66              42 : nsXPathExpression::nsXPathExpression(nsAutoPtr<Expr>& aExpression,
          67                 :                                      txResultRecycler* aRecycler,
          68                 :                                      nsIDOMDocument *aDocument)
          69                 :     : mExpression(aExpression),
          70                 :       mRecycler(aRecycler),
          71              42 :       mDocument(aDocument)
          72                 : {
          73              42 : }
          74                 :
          75                 : NS_IMETHODIMP
          76              42 : nsXPathExpression::Evaluate(nsIDOMNode *aContextNode,
          77                 :                             PRUint16 aType,
          78                 :                             nsISupports *aInResult,
          79                 :                             nsISupports **aResult)
          80                 : {
          81              42 :     return EvaluateWithContext(aContextNode, 1, 1, aType, aInResult, aResult);
          82                 : }
          83                 :
          84                 : NS_IMETHODIMP
          85              42 : nsXPathExpression::EvaluateWithContext(nsIDOMNode *aContextNode,
          86                 :                                        PRUint32 aContextPosition,
          87                 :                                        PRUint32 aContextSize,
          88                 :                                        PRUint16 aType,
          89                 :                                        nsISupports *aInResult,
          90                 :                                        nsISupports **aResult)
          91                 : {
          92              84 :     nsCOMPtr<nsINode> context = do_QueryInterface(aContextNode);
          93              42 :     NS_ENSURE_ARG(context);
          94                 :
          95              42 :     if (aContextPosition > aContextSize)
          96               0 :         return NS_ERROR_FAILURE;
          97                 :
          98              42 :     if (!nsContentUtils::CanCallerAccess(aContextNode))
          99               0 :         return NS_ERROR_DOM_SECURITY_ERR;
         100                 :
         101              42 :     if (mDocument && mDocument != aContextNode) {
         102              84 :         nsCOMPtr<nsIDOMDocument> contextDocument;
         103              42 :         aContextNode->GetOwnerDocument(getter_AddRefs(contextDocument));
         104                 :
         105              42 :         if (mDocument != contextDocument) {
         106               0 :             return NS_ERROR_DOM_WRONG_DOCUMENT_ERR;
         107                 :         }
         108                 :     }
         109                 :
         110              42 :     PRUint16 nodeType = context->NodeType();
         111                 :
         112              42 :     if (nodeType == nsIDOMNode::TEXT_NODE ||
         113                 :         nodeType == nsIDOMNode::CDATA_SECTION_NODE) {
         114              66 :         nsCOMPtr<nsIDOMCharacterData> textNode = do_QueryInterface(aContextNode);
         115              33 :         NS_ENSURE_TRUE(textNode, NS_ERROR_FAILURE);
         116                 :
         117              33 :         if (textNode) {
         118                 :             PRUint32 textLength;
         119              33 :             textNode->GetLength(&textLength);
         120              33 :             if (textLength == 0)
         121               0 :                 return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
         122              33 :         }
         123                 :
         124                 :         // XXX Need to get logical XPath text node for CDATASection
         125                 :         //     and Text nodes.
         126                 :     }
         127               9 :     else if (nodeType != nsIDOMNode::DOCUMENT_NODE &&
         128                 :              nodeType != nsIDOMNode::ELEMENT_NODE &&
         129                 :              nodeType != nsIDOMNode::ATTRIBUTE_NODE &&
         130                 :              nodeType != nsIDOMNode::COMMENT_NODE &&
         131                 :              nodeType != nsIDOMNode::PROCESSING_INSTRUCTION_NODE &&
         132                 :              nodeType != nsIDOMXPathNamespace::XPATH_NAMESPACE_NODE) {
         133               0 :         return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
         134                 :     }
         135                 :
         136              42 :     NS_ENSURE_ARG(aResult);
         137              42 :     *aResult = nsnull;
         138                 :
         139              84 :     nsAutoPtr<txXPathNode> contextNode(txXPathNativeNode::createXPathNode(aContextNode));
         140              42 :     if (!contextNode) {
         141               0 :         return NS_ERROR_OUT_OF_MEMORY;
         142                 :     }
         143                 :
         144              42 :     EvalContextImpl eContext(*contextNode, aContextPosition, aContextSize,
         145             126 :                              mRecycler);
         146              84 :     nsRefPtr<txAExprResult> exprResult;
         147              42 :     nsresult rv = mExpression->evaluate(&eContext, getter_AddRefs(exprResult));
         148              42 :     NS_ENSURE_SUCCESS(rv, rv);
         149                 :
         150              42 :     PRUint16 resultType = aType;
         151              42 :     if (aType == nsIDOMXPathResult::ANY_TYPE) {
         152               0 :         short exprResultType = exprResult->getResultType();
         153               0 :         switch (exprResultType) {
         154                 :             case txAExprResult::NUMBER:
         155               0 :                 resultType = nsIDOMXPathResult::NUMBER_TYPE;
         156               0 :                 break;
         157                 :             case txAExprResult::STRING:
         158               0 :                 resultType = nsIDOMXPathResult::STRING_TYPE;
         159               0 :                 break;
         160                 :             case txAExprResult::BOOLEAN:
         161               0 :                 resultType = nsIDOMXPathResult::BOOLEAN_TYPE;
         162               0 :                 break;
         163                 :             case txAExprResult::NODESET:
         164               0 :                 resultType = nsIDOMXPathResult::UNORDERED_NODE_ITERATOR_TYPE;
         165               0 :                 break;
         166                 :             case txAExprResult::RESULT_TREE_FRAGMENT:
         167               0 :                 NS_ERROR("Can't return a tree fragment!");
         168               0 :                 return NS_ERROR_FAILURE;
         169                 :         }
         170                 :     }
         171                 :
         172                 :     // We need a result object and it must be our implementation.
         173              84 :     nsCOMPtr<nsIXPathResult> xpathResult = do_QueryInterface(aInResult);
         174              42 :     if (!xpathResult) {
         175                 :         // Either no aInResult or not one of ours.
         176              42 :         xpathResult = new nsXPathResult();
         177              42 :         NS_ENSURE_TRUE(xpathResult, NS_ERROR_OUT_OF_MEMORY);
         178                 :     }
         179              42 :     rv = xpathResult->SetExprResult(exprResult, resultType, context);
         180              42 :     NS_ENSURE_SUCCESS(rv, rv);
         181                 :
         182              42 :     return CallQueryInterface(xpathResult, aResult);
         183                 : }
         184                 :
         185                 : /*
         186                 :  * Implementation of the txIEvalContext private to nsXPathExpression
         187                 :  * EvalContextImpl bases on only one context node and no variables
         188                 :  */
         189                 :
         190                 : nsresult
         191               0 : nsXPathExpression::EvalContextImpl::getVariable(PRInt32 aNamespace,
         192                 :                                                 nsIAtom* aLName,
         193                 :                                                 txAExprResult*& aResult)
         194                 : {
         195               0 :     aResult = 0;
         196               0 :     return NS_ERROR_INVALID_ARG;
         197                 : }
         198                 :
         199              33 : bool nsXPathExpression::EvalContextImpl::isStripSpaceAllowed(const txXPathNode& aNode)
         200                 : {
         201              33 :     return false;
         202                 : }
         203                 :
         204               0 : void* nsXPathExpression::EvalContextImpl::getPrivateContext()
         205                 : {
         206                 :     // we don't have a private context here.
         207               0 :     return nsnull;
         208                 : }
         209                 :
         210              42 : txResultRecycler* nsXPathExpression::EvalContextImpl::recycler()
         211                 : {
         212              42 :     return mRecycler;
         213                 : }
         214                 :
         215               0 : void nsXPathExpression::EvalContextImpl::receiveError(const nsAString& aMsg,
         216                 :                                                       nsresult aRes)
         217                 : {
         218               0 :     mLastError = aRes;
         219                 :     // forward aMsg to console service?
         220               0 : }
         221                 :
         222              42 : const txXPathNode& nsXPathExpression::EvalContextImpl::getContextNode()
         223                 : {
         224              42 :     return mContextNode;
         225                 : }
         226                 :
         227               0 : PRUint32 nsXPathExpression::EvalContextImpl::size()
         228                 : {
         229               0 :     return mContextSize;
         230                 : }
         231                 :
         232               0 : PRUint32 nsXPathExpression::EvalContextImpl::position()
         233                 : {
         234               0 :     return mContextPosition;
         235            4392 : }

Generated by: LCOV version 1.7