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-06-02 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