LCOV - app.info - content/xslt/src/xslt/txInstructions.cpp

LCOV - code coverage report
| Current view: | directory - content/xslt/src/xslt - txInstructions.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 447 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 61 | 0 | 0.0 %

           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                 :  * Jonas Sicking.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 2002
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Jonas Sicking <jonas@sicking.cc>
          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 "txInstructions.h"
          40                 : #include "txError.h"
          41                 : #include "txExpr.h"
          42                 : #include "txStylesheet.h"
          43                 : #include "txNodeSetContext.h"
          44                 : #include "txTextHandler.h"
          45                 : #include "nsIConsoleService.h"
          46                 : #include "nsServiceManagerUtils.h"
          47                 : #include "txStringUtils.h"
          48                 : #include "nsGkAtoms.h"
          49                 : #include "txRtfHandler.h"
          50                 : #include "txNodeSorter.h"
          51                 : #include "txXSLTNumber.h"
          52                 : #include "txExecutionState.h"
          53                 :
          54                 : nsresult
          55               0 : txApplyDefaultElementTemplate::execute(txExecutionState& aEs)
          56                 : {
          57               0 :     txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
          58               0 :     txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
          59               0 :     txStylesheet::ImportFrame* frame = 0;
          60                 :     txInstruction* templ =
          61               0 :         aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
          62               0 :                                       mode, &aEs, nsnull, &frame);
          63                 :
          64               0 :     aEs.pushTemplateRule(frame, mode, aEs.mTemplateParams);
          65                 :
          66               0 :     return aEs.runTemplate(templ);
          67                 : }
          68                 :
          69                 : nsresult
          70               0 : txApplyImportsEnd::execute(txExecutionState& aEs)
          71                 : {
          72               0 :     aEs.popTemplateRule();
          73               0 :     aEs.popParamMap();
          74                 :
          75               0 :     return NS_OK;
          76                 : }
          77                 :
          78                 : nsresult
          79               0 : txApplyImportsStart::execute(txExecutionState& aEs)
          80                 : {
          81               0 :     txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
          82                 :     // The frame is set to null when there is no current template rule, or
          83                 :     // when the current template rule is a default template. However this
          84                 :     // instruction isn't used in default templates.
          85               0 :     if (!rule->mFrame) {
          86                 :         // XXX ErrorReport: apply-imports instantiated without a current rule
          87               0 :         return NS_ERROR_XSLT_EXECUTION_FAILURE;
          88                 :     }
          89                 :
          90               0 :     nsresult rv = aEs.pushParamMap(rule->mParams);
          91               0 :     NS_ENSURE_SUCCESS(rv, rv);
          92                 :
          93               0 :     txStylesheet::ImportFrame* frame = 0;
          94               0 :     txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
          95                 :     txInstruction* templ =
          96               0 :         aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
          97               0 :                                       mode, &aEs, rule->mFrame, &frame);
          98                 :
          99               0 :     aEs.pushTemplateRule(frame, mode, rule->mParams);
         100                 :
         101               0 :     return aEs.runTemplate(templ);
         102                 : }
         103                 :
         104               0 : txApplyTemplates::txApplyTemplates(const txExpandedName& aMode)
         105               0 :     : mMode(aMode)
         106                 : {
         107               0 : }
         108                 :
         109                 : nsresult
         110               0 : txApplyTemplates::execute(txExecutionState& aEs)
         111                 : {
         112               0 :     txStylesheet::ImportFrame* frame = 0;
         113                 :     txInstruction* templ =
         114               0 :         aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
         115               0 :                                       mMode, &aEs, nsnull, &frame);
         116                 :
         117               0 :     aEs.pushTemplateRule(frame, mMode, aEs.mTemplateParams);
         118                 :
         119               0 :     return aEs.runTemplate(templ);
         120                 : }
         121                 :
         122               0 : txAttribute::txAttribute(nsAutoPtr<Expr> aName, nsAutoPtr<Expr> aNamespace,
         123                 :                          txNamespaceMap* aMappings)
         124                 :     : mName(aName),
         125                 :       mNamespace(aNamespace),
         126               0 :       mMappings(aMappings)
         127                 : {
         128               0 : }
         129                 :
         130                 : nsresult
         131               0 : txAttribute::execute(txExecutionState& aEs)
         132                 : {
         133               0 :     nsAutoString name;
         134               0 :     nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
         135               0 :     NS_ENSURE_SUCCESS(rv, rv);
         136                 :
         137                 :     const PRUnichar* colon;
         138               0 :     if (!XMLUtils::isValidQName(name, &colon) ||
         139               0 :         TX_StringEqualsAtom(name, nsGkAtoms::xmlns)) {
         140               0 :         return NS_OK;
         141                 :     }
         142                 :
         143               0 :     nsCOMPtr<nsIAtom> prefix;
         144               0 :     PRUint32 lnameStart = 0;
         145               0 :     if (colon) {
         146               0 :         prefix = do_GetAtom(Substring(name.get(), colon));
         147               0 :         lnameStart = colon - name.get() + 1;
         148                 :     }
         149                 :
         150               0 :     PRInt32 nsId = kNameSpaceID_None;
         151               0 :     if (mNamespace) {
         152               0 :         nsAutoString nspace;
         153               0 :         rv = mNamespace->evaluateToString(aEs.getEvalContext(),
         154               0 :                                           nspace);
         155               0 :         NS_ENSURE_SUCCESS(rv, rv);
         156                 :
         157               0 :         if (!nspace.IsEmpty()) {
         158               0 :             nsId = txNamespaceManager::getNamespaceID(nspace);
         159                 :         }
         160                 :     }
         161               0 :     else if (colon) {
         162               0 :         nsId = mMappings->lookupNamespace(prefix);
         163                 :     }
         164                 :
         165                 :     nsAutoPtr<txTextHandler> handler(
         166               0 :         static_cast<txTextHandler*>(aEs.popResultHandler()));
         167                 :
         168                 :     // add attribute if everything was ok
         169                 :     return nsId != kNameSpaceID_Unknown ?
         170               0 :            aEs.mResultHandler->attribute(prefix, Substring(name, lnameStart),
         171               0 :                                          nsId, handler->mValue) :
         172               0 :            NS_OK;
         173                 : }
         174                 :
         175               0 : txCallTemplate::txCallTemplate(const txExpandedName& aName)
         176               0 :     : mName(aName)
         177                 : {
         178               0 : }
         179                 :
         180                 : nsresult
         181               0 : txCallTemplate::execute(txExecutionState& aEs)
         182                 : {
         183               0 :     txInstruction* instr = aEs.mStylesheet->getNamedTemplate(mName);
         184               0 :     NS_ENSURE_TRUE(instr, NS_ERROR_XSLT_EXECUTION_FAILURE);
         185                 :
         186               0 :     nsresult rv = aEs.runTemplate(instr);
         187               0 :     NS_ENSURE_SUCCESS(rv, rv);
         188                 :
         189               0 :     return NS_OK;
         190                 : }
         191                 :
         192               0 : txCheckParam::txCheckParam(const txExpandedName& aName)
         193               0 :     : mName(aName), mBailTarget(nsnull)
         194                 : {
         195               0 : }
         196                 :
         197                 : nsresult
         198               0 : txCheckParam::execute(txExecutionState& aEs)
         199                 : {
         200               0 :     nsresult rv = NS_OK;
         201               0 :     if (aEs.mTemplateParams) {
         202               0 :         nsRefPtr<txAExprResult> exprRes;
         203               0 :         aEs.mTemplateParams->getVariable(mName, getter_AddRefs(exprRes));
         204               0 :         if (exprRes) {
         205               0 :             rv = aEs.bindVariable(mName, exprRes);
         206               0 :             NS_ENSURE_SUCCESS(rv, rv);
         207                 :
         208               0 :             aEs.gotoInstruction(mBailTarget);
         209                 :         }
         210                 :     }
         211                 :
         212               0 :     return NS_OK;
         213                 : }
         214                 :
         215               0 : txConditionalGoto::txConditionalGoto(nsAutoPtr<Expr> aCondition,
         216                 :                                      txInstruction* aTarget)
         217                 :     : mCondition(aCondition),
         218               0 :       mTarget(aTarget)
         219                 : {
         220               0 : }
         221                 :
         222                 : nsresult
         223               0 : txConditionalGoto::execute(txExecutionState& aEs)
         224                 : {
         225                 :     bool exprRes;
         226               0 :     nsresult rv = mCondition->evaluateToBool(aEs.getEvalContext(), exprRes);
         227               0 :     NS_ENSURE_SUCCESS(rv, rv);
         228                 :
         229               0 :     if (!exprRes) {
         230               0 :         aEs.gotoInstruction(mTarget);
         231                 :     }
         232                 :
         233               0 :     return NS_OK;
         234                 : }
         235                 :
         236                 : nsresult
         237               0 : txComment::execute(txExecutionState& aEs)
         238                 : {
         239                 :     nsAutoPtr<txTextHandler> handler(
         240               0 :         static_cast<txTextHandler*>(aEs.popResultHandler()));
         241               0 :     PRUint32 length = handler->mValue.Length();
         242               0 :     PRInt32 pos = 0;
         243               0 :     while ((pos = handler->mValue.FindChar('-', (PRUint32)pos)) != kNotFound) {
         244               0 :         ++pos;
         245               0 :         if ((PRUint32)pos == length || handler->mValue.CharAt(pos) == '-') {
         246               0 :             handler->mValue.Insert(PRUnichar(' '), pos++);
         247               0 :             ++length;
         248                 :         }
         249                 :     }
         250                 :
         251               0 :     return aEs.mResultHandler->comment(handler->mValue);
         252                 : }
         253                 :
         254                 : nsresult
         255               0 : txCopyBase::copyNode(const txXPathNode& aNode, txExecutionState& aEs)
         256                 : {
         257               0 :     switch (txXPathNodeUtils::getNodeType(aNode)) {
         258                 :         case txXPathNodeType::ATTRIBUTE_NODE:
         259                 :         {
         260               0 :             nsAutoString nodeValue;
         261               0 :             txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
         262                 :
         263                 :             nsCOMPtr<nsIAtom> localName =
         264               0 :                 txXPathNodeUtils::getLocalName(aNode);
         265                 :             return aEs.mResultHandler->
         266                 :                 attribute(txXPathNodeUtils::getPrefix(aNode),
         267                 :                           localName, nsnull,
         268                 :                           txXPathNodeUtils::getNamespaceID(aNode),
         269               0 :                           nodeValue);
         270                 :         }
         271                 :         case txXPathNodeType::COMMENT_NODE:
         272                 :         {
         273               0 :             nsAutoString nodeValue;
         274               0 :             txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
         275               0 :             return aEs.mResultHandler->comment(nodeValue);
         276                 :         }
         277                 :         case txXPathNodeType::DOCUMENT_NODE:
         278                 :         case txXPathNodeType::DOCUMENT_FRAGMENT_NODE:
         279                 :         {
         280                 :             // Copy children
         281               0 :             txXPathTreeWalker walker(aNode);
         282               0 :             bool hasChild = walker.moveToFirstChild();
         283               0 :             while (hasChild) {
         284               0 :                 copyNode(walker.getCurrentPosition(), aEs);
         285               0 :                 hasChild = walker.moveToNextSibling();
         286                 :             }
         287                 :             break;
         288                 :         }
         289                 :         case txXPathNodeType::ELEMENT_NODE:
         290                 :         {
         291                 :             nsCOMPtr<nsIAtom> localName =
         292               0 :                 txXPathNodeUtils::getLocalName(aNode);
         293                 :             nsresult rv = aEs.mResultHandler->
         294                 :                 startElement(txXPathNodeUtils::getPrefix(aNode),
         295                 :                              localName, nsnull,
         296               0 :                              txXPathNodeUtils::getNamespaceID(aNode));
         297               0 :             NS_ENSURE_SUCCESS(rv, rv);
         298                 :
         299                 :             // Copy attributes
         300               0 :             txXPathTreeWalker walker(aNode);
         301               0 :             if (walker.moveToFirstAttribute()) {
         302               0 :                 do {
         303               0 :                     nsAutoString nodeValue;
         304               0 :                     walker.appendNodeValue(nodeValue);
         305                 :
         306               0 :                     const txXPathNode& attr = walker.getCurrentPosition();
         307               0 :                     localName = txXPathNodeUtils::getLocalName(attr);
         308                 :                     rv = aEs.mResultHandler->
         309                 :                         attribute(txXPathNodeUtils::getPrefix(attr),
         310                 :                                   localName, nsnull,
         311                 :                                   txXPathNodeUtils::getNamespaceID(attr),
         312               0 :                                   nodeValue);
         313               0 :                     NS_ENSURE_SUCCESS(rv, rv);
         314                 :                 } while (walker.moveToNextAttribute());
         315               0 :                 walker.moveToParent();
         316                 :             }
         317                 :
         318                 :             // Copy children
         319               0 :             bool hasChild = walker.moveToFirstChild();
         320               0 :             while (hasChild) {
         321               0 :                 copyNode(walker.getCurrentPosition(), aEs);
         322               0 :                 hasChild = walker.moveToNextSibling();
         323                 :             }
         324                 :
         325               0 :             return aEs.mResultHandler->endElement();
         326                 :         }
         327                 :         case txXPathNodeType::PROCESSING_INSTRUCTION_NODE:
         328                 :         {
         329               0 :             nsAutoString target, data;
         330               0 :             txXPathNodeUtils::getNodeName(aNode, target);
         331               0 :             txXPathNodeUtils::appendNodeValue(aNode, data);
         332               0 :             return aEs.mResultHandler->processingInstruction(target, data);
         333                 :         }
         334                 :         case txXPathNodeType::TEXT_NODE:
         335                 :         case txXPathNodeType::CDATA_SECTION_NODE:
         336                 :         {
         337               0 :             nsAutoString nodeValue;
         338               0 :             txXPathNodeUtils::appendNodeValue(aNode, nodeValue);
         339               0 :             return aEs.mResultHandler->characters(nodeValue, false);
         340                 :         }
         341                 :     }
         342                 :
         343               0 :     return NS_OK;
         344                 : }
         345                 :
         346               0 : txCopy::txCopy()
         347               0 :     : mBailTarget(nsnull)
         348                 : {
         349               0 : }
         350                 :
         351                 : nsresult
         352               0 : txCopy::execute(txExecutionState& aEs)
         353                 : {
         354               0 :     nsresult rv = NS_OK;
         355               0 :     const txXPathNode& node = aEs.getEvalContext()->getContextNode();
         356                 :
         357               0 :     switch (txXPathNodeUtils::getNodeType(node)) {
         358                 :         case txXPathNodeType::DOCUMENT_NODE:
         359                 :         case txXPathNodeType::DOCUMENT_FRAGMENT_NODE:
         360                 :         {
         361               0 :             const nsAFlatString& empty = EmptyString();
         362                 :
         363                 :             // "close" current element to ensure that no attributes are added
         364               0 :             rv = aEs.mResultHandler->characters(empty, false);
         365               0 :             NS_ENSURE_SUCCESS(rv, rv);
         366                 :
         367               0 :             rv = aEs.pushBool(false);
         368               0 :             NS_ENSURE_SUCCESS(rv, rv);
         369                 :
         370               0 :             break;
         371                 :         }
         372                 :         case txXPathNodeType::ELEMENT_NODE:
         373                 :         {
         374                 :             nsCOMPtr<nsIAtom> localName =
         375               0 :                 txXPathNodeUtils::getLocalName(node);
         376                 :             rv = aEs.mResultHandler->
         377                 :                 startElement(txXPathNodeUtils::getPrefix(node),
         378                 :                              localName, nsnull,
         379               0 :                              txXPathNodeUtils::getNamespaceID(node));
         380               0 :             NS_ENSURE_SUCCESS(rv, rv);
         381                 :
         382                 :             // XXX copy namespace nodes once we have them
         383                 :
         384               0 :             rv = aEs.pushBool(true);
         385               0 :             NS_ENSURE_SUCCESS(rv, rv);
         386                 :
         387               0 :             break;
         388                 :         }
         389                 :         default:
         390                 :         {
         391               0 :             rv = copyNode(node, aEs);
         392               0 :             NS_ENSURE_SUCCESS(rv, rv);
         393                 :
         394               0 :             aEs.gotoInstruction(mBailTarget);
         395                 :         }
         396                 :     }
         397                 :
         398               0 :     return NS_OK;
         399                 : }
         400                 :
         401               0 : txCopyOf::txCopyOf(nsAutoPtr<Expr> aSelect)
         402               0 :     : mSelect(aSelect)
         403                 : {
         404               0 : }
         405                 :
         406                 : nsresult
         407               0 : txCopyOf::execute(txExecutionState& aEs)
         408                 : {
         409               0 :     nsRefPtr<txAExprResult> exprRes;
         410               0 :     nsresult rv = mSelect->evaluate(aEs.getEvalContext(),
         411               0 :                                     getter_AddRefs(exprRes));
         412               0 :     NS_ENSURE_SUCCESS(rv, rv);
         413                 :
         414               0 :     switch (exprRes->getResultType()) {
         415                 :         case txAExprResult::NODESET:
         416                 :         {
         417                 :             txNodeSet* nodes = static_cast<txNodeSet*>
         418                 :                                           (static_cast<txAExprResult*>
         419               0 :                                                       (exprRes));
         420                 :             PRInt32 i;
         421               0 :             for (i = 0; i < nodes->size(); ++i) {
         422               0 :                 rv = copyNode(nodes->get(i), aEs);
         423               0 :                 NS_ENSURE_SUCCESS(rv, rv);
         424                 :             }
         425               0 :             break;
         426                 :         }
         427                 :         case txAExprResult::RESULT_TREE_FRAGMENT:
         428                 :         {
         429                 :             txResultTreeFragment* rtf =
         430                 :                 static_cast<txResultTreeFragment*>
         431               0 :                            (static_cast<txAExprResult*>(exprRes));
         432               0 :             return rtf->flushToHandler(aEs.mResultHandler);
         433                 :         }
         434                 :         default:
         435                 :         {
         436               0 :             nsAutoString value;
         437               0 :             exprRes->stringValue(value);
         438               0 :             if (!value.IsEmpty()) {
         439               0 :                 return aEs.mResultHandler->characters(value, false);
         440                 :             }
         441               0 :             break;
         442                 :         }
         443                 :     }
         444                 :
         445               0 :     return NS_OK;
         446                 : }
         447                 :
         448                 : nsresult
         449               0 : txEndElement::execute(txExecutionState& aEs)
         450                 : {
         451                 :     // This will return false if startElement was not called. This happens
         452                 :     // when <xsl:element> produces a bad name, or when <xsl:copy> copies a
         453                 :     // document node.
         454               0 :     if (aEs.popBool()) {
         455               0 :         return aEs.mResultHandler->endElement();
         456                 :     }
         457                 :
         458               0 :     return NS_OK;
         459                 : }
         460                 :
         461                 : nsresult
         462               0 : txErrorInstruction::execute(txExecutionState& aEs)
         463                 : {
         464                 :     // XXX ErrorReport: unknown instruction executed
         465               0 :     return NS_ERROR_XSLT_EXECUTION_FAILURE;
         466                 : }
         467                 :
         468               0 : txGoTo::txGoTo(txInstruction* aTarget)
         469               0 :     : mTarget(aTarget)
         470                 : {
         471               0 : }
         472                 :
         473                 : nsresult
         474               0 : txGoTo::execute(txExecutionState& aEs)
         475                 : {
         476               0 :     aEs.gotoInstruction(mTarget);
         477                 :
         478               0 :     return NS_OK;
         479                 : }
         480                 :
         481               0 : txInsertAttrSet::txInsertAttrSet(const txExpandedName& aName)
         482               0 :     : mName(aName)
         483                 : {
         484               0 : }
         485                 :
         486                 : nsresult
         487               0 : txInsertAttrSet::execute(txExecutionState& aEs)
         488                 : {
         489               0 :     txInstruction* instr = aEs.mStylesheet->getAttributeSet(mName);
         490               0 :     NS_ENSURE_TRUE(instr, NS_ERROR_XSLT_EXECUTION_FAILURE);
         491                 :
         492               0 :     nsresult rv = aEs.runTemplate(instr);
         493               0 :     NS_ENSURE_SUCCESS(rv, rv);
         494                 :
         495               0 :     return NS_OK;
         496                 : }
         497                 :
         498               0 : txLoopNodeSet::txLoopNodeSet(txInstruction* aTarget)
         499               0 :     : mTarget(aTarget)
         500                 : {
         501               0 : }
         502                 :
         503                 : nsresult
         504               0 : txLoopNodeSet::execute(txExecutionState& aEs)
         505                 : {
         506               0 :     aEs.popTemplateRule();
         507                 :     txNodeSetContext* context =
         508               0 :         static_cast<txNodeSetContext*>(aEs.getEvalContext());
         509               0 :     if (!context->hasNext()) {
         510               0 :         delete aEs.popEvalContext();
         511                 :
         512               0 :         return NS_OK;
         513                 :     }
         514                 :
         515               0 :     context->next();
         516               0 :     aEs.gotoInstruction(mTarget);
         517                 :
         518               0 :     return NS_OK;
         519                 : }
         520                 :
         521               0 : txLREAttribute::txLREAttribute(PRInt32 aNamespaceID, nsIAtom* aLocalName,
         522                 :                                nsIAtom* aPrefix, nsAutoPtr<Expr> aValue)
         523                 :     : mNamespaceID(aNamespaceID),
         524                 :       mLocalName(aLocalName),
         525                 :       mPrefix(aPrefix),
         526               0 :       mValue(aValue)
         527                 : {
         528               0 :     if (aNamespaceID == kNameSpaceID_None) {
         529               0 :         mLowercaseLocalName = TX_ToLowerCaseAtom(aLocalName);
         530                 :     }
         531               0 : }
         532                 :
         533                 : nsresult
         534               0 : txLREAttribute::execute(txExecutionState& aEs)
         535                 : {
         536               0 :     nsRefPtr<txAExprResult> exprRes;
         537               0 :     nsresult rv = mValue->evaluate(aEs.getEvalContext(),
         538               0 :                                    getter_AddRefs(exprRes));
         539               0 :     NS_ENSURE_SUCCESS(rv, rv);
         540                 :
         541               0 :     const nsString* value = exprRes->stringValuePointer();
         542               0 :     if (value) {
         543                 :         return aEs.mResultHandler->attribute(mPrefix, mLocalName,
         544                 :                                              mLowercaseLocalName,
         545               0 :                                              mNamespaceID, *value);
         546                 :     }
         547                 :
         548               0 :     nsAutoString valueStr;
         549               0 :     exprRes->stringValue(valueStr);
         550                 :     return aEs.mResultHandler->attribute(mPrefix, mLocalName,
         551                 :                                          mLowercaseLocalName,
         552               0 :                                          mNamespaceID, valueStr);
         553                 : }
         554                 :
         555               0 : txMessage::txMessage(bool aTerminate)
         556               0 :     : mTerminate(aTerminate)
         557                 : {
         558               0 : }
         559                 :
         560                 : nsresult
         561               0 : txMessage::execute(txExecutionState& aEs)
         562                 : {
         563                 :     nsAutoPtr<txTextHandler> handler(
         564               0 :         static_cast<txTextHandler*>(aEs.popResultHandler()));
         565                 :
         566                 :     nsCOMPtr<nsIConsoleService> consoleSvc =
         567               0 :       do_GetService("@mozilla.org/consoleservice;1");
         568               0 :     if (consoleSvc) {
         569               0 :         nsAutoString logString(NS_LITERAL_STRING("xsl:message - "));
         570               0 :         logString.Append(handler->mValue);
         571               0 :         consoleSvc->LogStringMessage(logString.get());
         572                 :     }
         573                 :
         574               0 :     return mTerminate ? NS_ERROR_XSLT_ABORTED : NS_OK;
         575                 : }
         576                 :
         577               0 : txNumber::txNumber(txXSLTNumber::LevelType aLevel, nsAutoPtr<txPattern> aCount,
         578                 :                    nsAutoPtr<txPattern> aFrom, nsAutoPtr<Expr> aValue,
         579                 :                    nsAutoPtr<Expr> aFormat, nsAutoPtr<Expr> aGroupingSeparator,
         580                 :                    nsAutoPtr<Expr> aGroupingSize)
         581                 :     : mLevel(aLevel), mCount(aCount), mFrom(aFrom), mValue(aValue),
         582                 :       mFormat(aFormat), mGroupingSeparator(aGroupingSeparator),
         583               0 :       mGroupingSize(aGroupingSize)
         584                 : {
         585               0 : }
         586                 :
         587                 : nsresult
         588               0 : txNumber::execute(txExecutionState& aEs)
         589                 : {
         590               0 :     nsAutoString res;
         591                 :     nsresult rv =
         592                 :         txXSLTNumber::createNumber(mValue, mCount, mFrom, mLevel, mGroupingSize,
         593                 :                                    mGroupingSeparator, mFormat,
         594               0 :                                    aEs.getEvalContext(), res);
         595               0 :     NS_ENSURE_SUCCESS(rv, rv);
         596                 :
         597               0 :     return aEs.mResultHandler->characters(res, false);
         598                 : }
         599                 :
         600                 : nsresult
         601               0 : txPopParams::execute(txExecutionState& aEs)
         602                 : {
         603               0 :     delete aEs.popParamMap();
         604                 :
         605               0 :     return NS_OK;
         606                 : }
         607                 :
         608               0 : txProcessingInstruction::txProcessingInstruction(nsAutoPtr<Expr> aName)
         609               0 :     : mName(aName)
         610                 : {
         611               0 : }
         612                 :
         613                 : nsresult
         614               0 : txProcessingInstruction::execute(txExecutionState& aEs)
         615                 : {
         616                 :     nsAutoPtr<txTextHandler> handler(
         617               0 :         static_cast<txTextHandler*>(aEs.popResultHandler()));
         618               0 :     XMLUtils::normalizePIValue(handler->mValue);
         619                 :
         620               0 :     nsAutoString name;
         621               0 :     nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
         622               0 :     NS_ENSURE_SUCCESS(rv, rv);
         623                 :
         624                 :     // Check name validity (must be valid NCName and a PITarget)
         625                 :     // XXX Need to check for NCName and PITarget
         626                 :     const PRUnichar* colon;
         627               0 :     if (!XMLUtils::isValidQName(name, &colon)) {
         628                 :         // XXX ErrorReport: bad PI-target
         629               0 :         return NS_ERROR_FAILURE;
         630                 :     }
         631                 :
         632               0 :     return aEs.mResultHandler->processingInstruction(name, handler->mValue);
         633                 : }
         634                 :
         635               0 : txPushNewContext::txPushNewContext(nsAutoPtr<Expr> aSelect)
         636               0 :     : mSelect(aSelect), mBailTarget(nsnull)
         637                 : {
         638               0 : }
         639                 :
         640               0 : txPushNewContext::~txPushNewContext()
         641                 : {
         642               0 : }
         643                 :
         644                 : nsresult
         645               0 : txPushNewContext::execute(txExecutionState& aEs)
         646                 : {
         647               0 :     nsRefPtr<txAExprResult> exprRes;
         648               0 :     nsresult rv = mSelect->evaluate(aEs.getEvalContext(),
         649               0 :                                     getter_AddRefs(exprRes));
         650               0 :     NS_ENSURE_SUCCESS(rv, rv);
         651                 :
         652               0 :     if (exprRes->getResultType() != txAExprResult::NODESET) {
         653                 :         // XXX ErrorReport: nodeset expected
         654               0 :         return NS_ERROR_XSLT_NODESET_EXPECTED;
         655                 :     }
         656                 :
         657                 :     txNodeSet* nodes = static_cast<txNodeSet*>
         658                 :                                   (static_cast<txAExprResult*>
         659               0 :                                               (exprRes));
         660                 :
         661               0 :     if (nodes->isEmpty()) {
         662               0 :         aEs.gotoInstruction(mBailTarget);
         663                 :
         664               0 :         return NS_OK;
         665                 :     }
         666                 :
         667               0 :     txNodeSorter sorter;
         668               0 :     PRUint32 i, count = mSortKeys.Length();
         669               0 :     for (i = 0; i < count; ++i) {
         670               0 :         SortKey& sort = mSortKeys[i];
         671                 :         rv = sorter.addSortElement(sort.mSelectExpr, sort.mLangExpr,
         672                 :                                    sort.mDataTypeExpr, sort.mOrderExpr,
         673                 :                                    sort.mCaseOrderExpr,
         674               0 :                                    aEs.getEvalContext());
         675               0 :         NS_ENSURE_SUCCESS(rv, rv);
         676                 :     }
         677               0 :     nsRefPtr<txNodeSet> sortedNodes;
         678               0 :     rv = sorter.sortNodeSet(nodes, &aEs, getter_AddRefs(sortedNodes));
         679               0 :     NS_ENSURE_SUCCESS(rv, rv);
         680                 :
         681               0 :     txNodeSetContext* context = new txNodeSetContext(sortedNodes, &aEs);
         682               0 :     NS_ENSURE_TRUE(context, NS_ERROR_OUT_OF_MEMORY);
         683                 :
         684               0 :     context->next();
         685                 :
         686               0 :     rv = aEs.pushEvalContext(context);
         687               0 :     if (NS_FAILED(rv)) {
         688               0 :         delete context;
         689               0 :         return rv;
         690                 :     }
         691                 :
         692               0 :     return NS_OK;
         693                 : }
         694                 :
         695                 : nsresult
         696               0 : txPushNewContext::addSort(nsAutoPtr<Expr> aSelectExpr,
         697                 :                           nsAutoPtr<Expr> aLangExpr,
         698                 :                           nsAutoPtr<Expr> aDataTypeExpr,
         699                 :                           nsAutoPtr<Expr> aOrderExpr,
         700                 :                           nsAutoPtr<Expr> aCaseOrderExpr)
         701                 : {
         702               0 :     if (SortKey *key = mSortKeys.AppendElement()) {
         703                 :         // workaround for not triggering the Copy Constructor
         704               0 :         key->mSelectExpr = aSelectExpr;
         705               0 :         key->mLangExpr = aLangExpr;
         706               0 :         key->mDataTypeExpr = aDataTypeExpr;
         707               0 :         key->mOrderExpr = aOrderExpr;
         708               0 :         key->mCaseOrderExpr = aCaseOrderExpr;
         709               0 :         return NS_OK;
         710                 :     }
         711               0 :     return NS_ERROR_OUT_OF_MEMORY;
         712                 : }
         713                 :
         714                 : nsresult
         715               0 : txPushNullTemplateRule::execute(txExecutionState& aEs)
         716                 : {
         717               0 :     aEs.pushTemplateRule(nsnull, txExpandedName(), nsnull);
         718               0 :     return NS_OK;
         719                 : }
         720                 :
         721                 : nsresult
         722               0 : txPushParams::execute(txExecutionState& aEs)
         723                 : {
         724               0 :     return aEs.pushParamMap(nsnull);
         725                 : }
         726                 :
         727                 : nsresult
         728               0 : txPushRTFHandler::execute(txExecutionState& aEs)
         729                 : {
         730               0 :     txAXMLEventHandler* handler = new txRtfHandler;
         731               0 :     NS_ENSURE_TRUE(handler, NS_ERROR_OUT_OF_MEMORY);
         732                 :
         733               0 :     nsresult rv = aEs.pushResultHandler(handler);
         734               0 :     if (NS_FAILED(rv)) {
         735               0 :         delete handler;
         736               0 :         return rv;
         737                 :     }
         738                 :
         739               0 :     return NS_OK;
         740                 : }
         741                 :
         742               0 : txPushStringHandler::txPushStringHandler(bool aOnlyText)
         743               0 :     : mOnlyText(aOnlyText)
         744                 : {
         745               0 : }
         746                 :
         747                 : nsresult
         748               0 : txPushStringHandler::execute(txExecutionState& aEs)
         749                 : {
         750               0 :     txAXMLEventHandler* handler = new txTextHandler(mOnlyText);
         751               0 :     NS_ENSURE_TRUE(handler, NS_ERROR_OUT_OF_MEMORY);
         752                 :
         753               0 :     nsresult rv = aEs.pushResultHandler(handler);
         754               0 :     if (NS_FAILED(rv)) {
         755               0 :         delete handler;
         756               0 :         return rv;
         757                 :     }
         758                 :
         759               0 :     return NS_OK;
         760                 : }
         761                 :
         762               0 : txRemoveVariable::txRemoveVariable(const txExpandedName& aName)
         763               0 :     : mName(aName)
         764                 : {
         765               0 : }
         766                 :
         767                 : nsresult
         768               0 : txRemoveVariable::execute(txExecutionState& aEs)
         769                 : {
         770               0 :     aEs.removeVariable(mName);
         771                 :
         772               0 :     return NS_OK;
         773                 : }
         774                 :
         775                 : nsresult
         776               0 : txReturn::execute(txExecutionState& aEs)
         777                 : {
         778               0 :     NS_ASSERTION(!mNext, "instructions exist after txReturn");
         779               0 :     aEs.returnFromTemplate();
         780                 :
         781               0 :     return NS_OK;
         782                 : }
         783                 :
         784               0 : txSetParam::txSetParam(const txExpandedName& aName, nsAutoPtr<Expr> aValue)
         785               0 :     : mName(aName), mValue(aValue)
         786                 : {
         787               0 : }
         788                 :
         789                 : nsresult
         790               0 : txSetParam::execute(txExecutionState& aEs)
         791                 : {
         792               0 :     nsresult rv = NS_OK;
         793               0 :     if (!aEs.mTemplateParams) {
         794               0 :         aEs.mTemplateParams = new txVariableMap;
         795               0 :         NS_ENSURE_TRUE(aEs.mTemplateParams, NS_ERROR_OUT_OF_MEMORY);
         796                 :     }
         797                 :
         798               0 :     nsRefPtr<txAExprResult> exprRes;
         799               0 :     if (mValue) {
         800               0 :         rv = mValue->evaluate(aEs.getEvalContext(),
         801               0 :                               getter_AddRefs(exprRes));
         802               0 :         NS_ENSURE_SUCCESS(rv, rv);
         803                 :     }
         804                 :     else {
         805                 :         nsAutoPtr<txRtfHandler> rtfHandler(
         806               0 :             static_cast<txRtfHandler*>(aEs.popResultHandler()));
         807               0 :         rv = rtfHandler->getAsRTF(getter_AddRefs(exprRes));
         808               0 :         NS_ENSURE_SUCCESS(rv, rv);
         809                 :     }
         810                 :
         811               0 :     rv = aEs.mTemplateParams->bindVariable(mName, exprRes);
         812               0 :     NS_ENSURE_SUCCESS(rv, rv);
         813                 :
         814               0 :     return NS_OK;
         815                 : }
         816                 :
         817               0 : txSetVariable::txSetVariable(const txExpandedName& aName,
         818                 :                              nsAutoPtr<Expr> aValue)
         819               0 :     : mName(aName), mValue(aValue)
         820                 : {
         821               0 : }
         822                 :
         823                 : nsresult
         824               0 : txSetVariable::execute(txExecutionState& aEs)
         825                 : {
         826               0 :     nsresult rv = NS_OK;
         827               0 :     nsRefPtr<txAExprResult> exprRes;
         828               0 :     if (mValue) {
         829               0 :         rv = mValue->evaluate(aEs.getEvalContext(), getter_AddRefs(exprRes));
         830               0 :         NS_ENSURE_SUCCESS(rv, rv);
         831                 :     }
         832                 :     else {
         833                 :         nsAutoPtr<txRtfHandler> rtfHandler(
         834               0 :             static_cast<txRtfHandler*>(aEs.popResultHandler()));
         835               0 :         rv = rtfHandler->getAsRTF(getter_AddRefs(exprRes));
         836               0 :         NS_ENSURE_SUCCESS(rv, rv);
         837                 :     }
         838                 :
         839               0 :     return aEs.bindVariable(mName, exprRes);
         840                 : }
         841                 :
         842               0 : txStartElement::txStartElement(nsAutoPtr<Expr> aName,
         843                 :                                nsAutoPtr<Expr> aNamespace,
         844                 :                                txNamespaceMap* aMappings)
         845                 :     : mName(aName),
         846                 :       mNamespace(aNamespace),
         847               0 :       mMappings(aMappings)
         848                 : {
         849               0 : }
         850                 :
         851                 : nsresult
         852               0 : txStartElement::execute(txExecutionState& aEs)
         853                 : {
         854               0 :     nsAutoString name;
         855               0 :     nsresult rv = mName->evaluateToString(aEs.getEvalContext(), name);
         856               0 :     NS_ENSURE_SUCCESS(rv, rv);
         857                 :
         858                 :
         859               0 :     PRInt32 nsId = kNameSpaceID_None;
         860               0 :     nsCOMPtr<nsIAtom> prefix;
         861               0 :     PRUint32 lnameStart = 0;
         862                 :
         863                 :     const PRUnichar* colon;
         864               0 :     if (XMLUtils::isValidQName(name, &colon)) {
         865               0 :         if (colon) {
         866               0 :             prefix = do_GetAtom(Substring(name.get(), colon));
         867               0 :             lnameStart = colon - name.get() + 1;
         868                 :         }
         869                 :
         870               0 :         if (mNamespace) {
         871               0 :             nsAutoString nspace;
         872               0 :             rv = mNamespace->evaluateToString(aEs.getEvalContext(),
         873               0 :                                               nspace);
         874               0 :             NS_ENSURE_SUCCESS(rv, rv);
         875                 :
         876               0 :             if (!nspace.IsEmpty()) {
         877               0 :                 nsId = txNamespaceManager::getNamespaceID(nspace);
         878                 :             }
         879                 :         }
         880                 :         else {
         881               0 :             nsId = mMappings->lookupNamespace(prefix);
         882                 :         }
         883                 :     }
         884                 :     else {
         885               0 :        nsId = kNameSpaceID_Unknown;
         886                 :     }
         887                 :
         888               0 :     bool success = true;
         889                 :
         890               0 :     if (nsId != kNameSpaceID_Unknown) {
         891                 :         rv = aEs.mResultHandler->startElement(prefix,
         892               0 :                                               Substring(name, lnameStart),
         893               0 :                                               nsId);
         894                 :     }
         895                 :     else {
         896               0 :         rv = NS_ERROR_XSLT_BAD_NODE_NAME;
         897                 :     }
         898                 :
         899               0 :     if (rv == NS_ERROR_XSLT_BAD_NODE_NAME) {
         900               0 :         success = false;
         901                 :         // we call characters with an empty string to "close" any element to
         902                 :         // make sure that no attributes are added
         903               0 :         rv = aEs.mResultHandler->characters(EmptyString(), false);
         904                 :     }
         905               0 :     NS_ENSURE_SUCCESS(rv, rv);
         906                 :
         907               0 :     rv = aEs.pushBool(success);
         908               0 :     NS_ENSURE_SUCCESS(rv, rv);
         909                 :
         910               0 :     return NS_OK;
         911                 : }
         912                 :
         913                 :
         914               0 : txStartLREElement::txStartLREElement(PRInt32 aNamespaceID,
         915                 :                                      nsIAtom* aLocalName,
         916                 :                                      nsIAtom* aPrefix)
         917                 :     : mNamespaceID(aNamespaceID),
         918                 :       mLocalName(aLocalName),
         919               0 :       mPrefix(aPrefix)
         920                 : {
         921               0 :     if (aNamespaceID == kNameSpaceID_None) {
         922               0 :         mLowercaseLocalName = TX_ToLowerCaseAtom(aLocalName);
         923                 :     }
         924               0 : }
         925                 :
         926                 : nsresult
         927               0 : txStartLREElement::execute(txExecutionState& aEs)
         928                 : {
         929                 :     nsresult rv = aEs.mResultHandler->startElement(mPrefix, mLocalName,
         930                 :                                                    mLowercaseLocalName,
         931               0 :                                                    mNamespaceID);
         932               0 :     NS_ENSURE_SUCCESS(rv, rv);
         933                 :
         934               0 :     rv = aEs.pushBool(true);
         935               0 :     NS_ENSURE_SUCCESS(rv, rv);
         936                 :
         937               0 :     return NS_OK;
         938                 : }
         939                 :
         940               0 : txText::txText(const nsAString& aStr, bool aDOE)
         941                 :     : mStr(aStr),
         942               0 :       mDOE(aDOE)
         943                 : {
         944               0 : }
         945                 :
         946                 : nsresult
         947               0 : txText::execute(txExecutionState& aEs)
         948                 : {
         949               0 :     return aEs.mResultHandler->characters(mStr, mDOE);
         950                 : }
         951                 :
         952               0 : txValueOf::txValueOf(nsAutoPtr<Expr> aExpr, bool aDOE)
         953                 :     : mExpr(aExpr),
         954               0 :       mDOE(aDOE)
         955                 : {
         956               0 : }
         957                 :
         958                 : nsresult
         959               0 : txValueOf::execute(txExecutionState& aEs)
         960                 : {
         961               0 :     nsRefPtr<txAExprResult> exprRes;
         962               0 :     nsresult rv = mExpr->evaluate(aEs.getEvalContext(),
         963               0 :                                   getter_AddRefs(exprRes));
         964               0 :     NS_ENSURE_SUCCESS(rv, rv);
         965                 :
         966               0 :     const nsString* value = exprRes->stringValuePointer();
         967               0 :     if (value) {
         968               0 :         if (!value->IsEmpty()) {
         969               0 :             return aEs.mResultHandler->characters(*value, mDOE);
         970                 :         }
         971                 :     }
         972                 :     else {
         973               0 :         nsAutoString valueStr;
         974               0 :         exprRes->stringValue(valueStr);
         975               0 :         if (!valueStr.IsEmpty()) {
         976               0 :             return aEs.mResultHandler->characters(valueStr, mDOE);
         977                 :         }
         978                 :     }
         979                 :
         980               0 :     return NS_OK;
         981                 : }

Generated by: LCOV version 1.7