From f64aa0b1e3125e4fffcd82df65f298b7bf089cc6 Mon Sep 17 00:00:00 2001 From: "peterv%netscape.com" Date: Wed, 2 Nov 2005 07:37:57 +0000 Subject: [PATCH] Fix for bug 146966 (Standalone Transformiix outputs HTML with XML prolog). r=Pike, sr=jst. --- content/xslt/src/main/Makefile.in | 1 + content/xslt/src/xslt/Makefile.in | 1 + content/xslt/src/xslt/txUnknownHandler.cpp | 230 +++++++++++++++++++++ content/xslt/src/xslt/txUnknownHandler.h | 201 ++++++++++++++++++ 4 files changed, 433 insertions(+) create mode 100644 content/xslt/src/xslt/txUnknownHandler.cpp create mode 100644 content/xslt/src/xslt/txUnknownHandler.h diff --git a/content/xslt/src/main/Makefile.in b/content/xslt/src/main/Makefile.in index f2850fbc3356..d243753ec615 100644 --- a/content/xslt/src/main/Makefile.in +++ b/content/xslt/src/main/Makefile.in @@ -106,6 +106,7 @@ OBJS =../base/ArrayList.$(OBJ_SUFFIX) \ ../xslt/txRtfHandler.$(OBJ_SUFFIX) \ ../xslt/txTextHandler.$(OBJ_SUFFIX) \ ../xslt/txTextOutput.$(OBJ_SUFFIX) \ + ../xslt/txUnknownHandler.$(OBJ_SUFFIX) \ ../xslt/txXMLOutput.$(OBJ_SUFFIX) \ ../xslt/txXSLTPatterns.$(OBJ_SUFFIX) \ ../xslt/txPatternParser.$(OBJ_SUFFIX) \ diff --git a/content/xslt/src/xslt/Makefile.in b/content/xslt/src/xslt/Makefile.in index 52a9961dcfb1..bf7f224c4e1b 100644 --- a/content/xslt/src/xslt/Makefile.in +++ b/content/xslt/src/xslt/Makefile.in @@ -60,6 +60,7 @@ CPPSRCS = Names.cpp \ ifdef TX_EXE CPPSRCS += txHTMLOutput.cpp \ txTextOutput.cpp \ + txUnknownHandler.cpp \ txXMLOutput.cpp else CPPSRCS += txMozillaTextOutput.cpp \ diff --git a/content/xslt/src/xslt/txUnknownHandler.cpp b/content/xslt/src/xslt/txUnknownHandler.cpp new file mode 100644 index 000000000000..b7639f48fb2b --- /dev/null +++ b/content/xslt/src/xslt/txUnknownHandler.cpp @@ -0,0 +1,230 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the TransforMiiX XSLT processor. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Peter Van der Beken + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "txUnknownHandler.h" + +PRUint32 txUnknownHandler::kReasonableTransactions = 8; + +txUnknownHandler::txUnknownHandler() : mTotal(0), + mMax(kReasonableTransactions) +{ + mArray = new txOutputTransaction*[kReasonableTransactions]; +} + +txUnknownHandler::~txUnknownHandler() +{ + PRUint32 counter; + for (counter = 0; counter < mTotal; ++counter) { + delete mArray[counter]; + } + delete [] mArray; +} + +void txUnknownHandler::attribute(const String& aName, + const PRInt32 aNsID, + const String& aValue) +{ + NS_ASSERTION(0, "This shouldn't be called") +} + +void txUnknownHandler::characters(const String& aData) +{ + txOneStringTransaction* transaction = + new txOneStringTransaction(txOutputTransaction::eCharacterTransaction, + aData); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::charactersNoOutputEscaping(const String& aData) +{ + txOneStringTransaction* transaction = + new txOneStringTransaction(txOutputTransaction::eCharacterNoOETransaction, + aData); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::comment(const String& aData) +{ + txOneStringTransaction* transaction = + new txOneStringTransaction(txOutputTransaction::eCommentTransaction, + aData); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::endDocument() +{ + txOutputTransaction* transaction = + new txOutputTransaction(txOutputTransaction::eEndDocumentTransaction); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::endElement(const String& aName, + const PRInt32 aNsID) +{ + NS_ASSERTION(0, "This shouldn't be called") +} + +void txUnknownHandler::processingInstruction(const String& aTarget, + const String& aData) +{ + txTwoStringTransaction* transaction = + new txTwoStringTransaction(txOutputTransaction::ePITransaction, + aTarget, aData); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::startDocument() +{ + txOutputTransaction* transaction = + new txOutputTransaction(txOutputTransaction::eStartDocumentTransaction); + if (!transaction) { + NS_ASSERTION(0, "Out of memory!") + return; + } + addTransaction(transaction); +} + +void txUnknownHandler::startElement(const String& aName, + const PRInt32 aNsID) +{ + NS_ASSERTION(0, "This shouldn't be called") +} + +void txUnknownHandler::setOutputFormat(txOutputFormat* aOutputFormat) +{ +} + +void txUnknownHandler::getOutputStream(ostream** aOutputStream) +{ + if (aOutputStream) { + *aOutputStream = mOut; + } +} + +void txUnknownHandler::setOutputStream(ostream* aOutputStream) +{ + mOut = aOutputStream; +} + +void txUnknownHandler::flush(txStreamXMLEventHandler* aHandler) +{ + PRUint32 counter; + for (counter = 0; counter < mTotal; ++counter) { + switch (mArray[counter]->mType) { + case txOutputTransaction::eCharacterTransaction: + { + txOneStringTransaction* transaction = (txOneStringTransaction*)mArray[counter]; + aHandler->characters(transaction->mString); + delete transaction; + break; + } + case txOutputTransaction::eCharacterNoOETransaction: + { + txOneStringTransaction* transaction = (txOneStringTransaction*)mArray[counter]; + aHandler->charactersNoOutputEscaping(transaction->mString); + delete transaction; + break; + } + case txOutputTransaction::eCommentTransaction: + { + txOneStringTransaction* transaction = (txOneStringTransaction*)mArray[counter]; + aHandler->comment(transaction->mString); + delete transaction; + break; + } + case txOutputTransaction::eEndDocumentTransaction: + { + aHandler->endDocument(); + delete mArray[counter]; + break; + } + case txOutputTransaction::ePITransaction: + { + txTwoStringTransaction* transaction = (txTwoStringTransaction*)mArray[counter]; + aHandler->processingInstruction(transaction->mStringOne, + transaction->mStringTwo); + delete transaction; + break; + } + case txOutputTransaction::eStartDocumentTransaction: + { + aHandler->startDocument(); + delete mArray[counter]; + break; + } + } + } + mTotal = 0; +} + +void txUnknownHandler::addTransaction(txOutputTransaction* aTransaction) +{ + if (mTotal == mMax) { + PRUint32 newMax = mMax * 2; + txOutputTransaction** newArray = new txOutputTransaction*[newMax]; + if (!newArray) { + NS_ASSERTION(0, "Out of memory!") + return; + } + mMax = newMax; + memcpy(newArray, mArray, mTotal * sizeof(txOutputTransaction*)); + delete [] mArray; + mArray = newArray; + } + mArray[mTotal++] = aTransaction; +} diff --git a/content/xslt/src/xslt/txUnknownHandler.h b/content/xslt/src/xslt/txUnknownHandler.h new file mode 100644 index 000000000000..d361b59516cf --- /dev/null +++ b/content/xslt/src/xslt/txUnknownHandler.h @@ -0,0 +1,201 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is the TransforMiiX XSLT processor. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Peter Van der Beken + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef TRANSFRMX_UNKNOWN_HANDLER_H +#define TRANSFRMX_UNKNOWN_HANDLER_H + +#include "txXMLEventHandler.h" +#include "TxString.h" + +class txOutputTransaction +{ +public: + enum txTransactionType { + eCharacterTransaction, + eCharacterNoOETransaction, + eCommentTransaction, + eEndDocumentTransaction, + ePITransaction, + eStartDocumentTransaction + }; + txOutputTransaction(txTransactionType aType) + : mType(aType) + { + }; + virtual ~txOutputTransaction() + { + }; + txTransactionType mType; +}; + +class txOneStringTransaction : public txOutputTransaction +{ +public: + txOneStringTransaction(txTransactionType aType, + String aString) + : txOutputTransaction(aType), + mString(aString) + { + }; + String mString; +}; + +class txTwoStringTransaction : public txOutputTransaction +{ +public: + txTwoStringTransaction(txTransactionType aType, + String aStringOne, + String aStringTwo) + : txOutputTransaction(aType), + mStringOne(aStringOne), + mStringTwo(aStringTwo) + { + }; + String mStringOne; + String mStringTwo; +}; + +class txUnknownHandler : public txStreamXMLEventHandler +{ +public: + txUnknownHandler(); + virtual ~txUnknownHandler(); + + /* + * Signals to receive the start of an attribute. + * + * @param aName the name of the attribute + * @param aNsID the namespace ID of the attribute + * @param aValue the value of the attribute + */ + void attribute(const String& aName, + const PRInt32 aNsID, + const String& aValue); + + /* + * Signals to receive characters. + * + * @param aData the characters to receive + */ + void characters(const String& aData); + + /* + * Signals to receive characters that don't need output escaping. + * + * @param aData the characters to receive + */ + void charactersNoOutputEscaping(const String& aData); + + /* + * Signals to receive data that should be treated as a comment. + * + * @param data the comment data to receive + */ + void comment(const String& aData); + + /* + * Signals the end of a document. It is an error to call + * this method more than once. + */ + void endDocument(); + + /* + * Signals to receive the end of an element. + * + * @param aName the name of the element + * @param aNsID the namespace ID of the element + */ + void endElement(const String& aName, + const PRInt32 aNsID); + + /* + * Signals to receive a processing instruction. + * + * @param aTarget the target of the processing instruction + * @param aData the data of the processing instruction + */ + void processingInstruction(const String& aTarget, + const String& aData); + + /* + * Signals the start of a document. + */ + void startDocument(); + + /* + * Signals to receive the start of an element. + * + * @param aName the name of the element + * @param aNsID the namespace ID of the element + */ + void startElement(const String& aName, + const PRInt32 aNsID); + /* + * Sets the output format. + * + * @param aOutputFormat the output format + */ + void setOutputFormat(txOutputFormat* aOutputFormat); + + /** + * Get the output stream. + * + * @param aOutputStream the current output stream + */ + void getOutputStream(ostream** aOutputStream); + + /* + * Sets the output stream. + * + * @param aOutputStream the output stream + */ + void setOutputStream(ostream* aOutputStream); + + void flush(txStreamXMLEventHandler* aHandler); + +private: + void addTransaction(txOutputTransaction* aTransaction); + + PRUint32 mTotal, mMax; + ostream* mOut; + txOutputTransaction** mArray; + + static PRUint32 kReasonableTransactions; +}; + +#endif