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 : }
|