dbertoni 00/05/18 11:37:30
Modified: c/src/XMLSupport Formatter.hpp FormatterListener.cpp
FormatterListener.hpp FormatterToDOM.cpp
FormatterToHTML.cpp FormatterToHTML.hpp
FormatterToText.cpp FormatterToXML.cpp
FormatterToXML.hpp XMLParserLiaisonDefault.cpp
Log:
Competely re-worked FormatterToHTML and FormatterToXML. Made some changes to
support switching formatters "on-the-fly"
Revision Changes Path
1.4 +0 -28 xml-xalan/c/src/XMLSupport/Formatter.hpp
Index: Formatter.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/Formatter.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- Formatter.hpp 2000/04/11 14:42:59 1.3
+++ Formatter.hpp 2000/05/18 18:37:20 1.4
@@ -79,34 +79,6 @@
{
public:
-#if defined(XALAN_INLINE_INITIALIZATION)
-
- /**
- * Output results as XML.
- */
- const int OUTPUT_METH_XML = 1;
-
- /**
- * Output results as HTML.
- */
- const int OUTPUT_METH_HTML = 2;
-
- /**
- * Output results as TEXT.
- */
- const int OUTPUT_METH_TEXT = 3;
-
-#else
-
- enum eFormats
- {
- OUTPUT_METH_XML = 1,
- OUTPUT_METH_HTML = 2,
- OUTPUT_METH_TEXT = 3
- };
-
-#endif
-
Formatter();
virtual
1.2 +4 -3 xml-xalan/c/src/XMLSupport/FormatterListener.cpp
Index: FormatterListener.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterListener.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- FormatterListener.cpp 1999/12/18 19:47:52 1.1
+++ FormatterListener.cpp 2000/05/18 18:37:23 1.2
@@ -55,7 +55,7 @@
* <http://www.apache.org/>.
*/
/**
- * $Id: FormatterListener.cpp,v 1.1 1999/12/18 19:47:52 robweir Exp $
+ * $Id: FormatterListener.cpp,v 1.2 2000/05/18 18:37:23 dbertoni Exp $
*
* $State: Exp $
*
@@ -69,8 +69,9 @@
-FormatterListener::FormatterListener() :
- DocumentHandler()
+FormatterListener::FormatterListener(eFormat theFormat) :
+ DocumentHandler(),
+ m_outputFormat(theFormat)
{
}
1.7 +23 -3 xml-xalan/c/src/XMLSupport/FormatterListener.hpp
Index: FormatterListener.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterListener.hpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- FormatterListener.hpp 2000/04/11 14:43:00 1.6
+++ FormatterListener.hpp 2000/05/18 18:37:23 1.7
@@ -58,7 +58,7 @@
#define FORMATTERLISTENER_HEADER_GUARD_1357924680
/**
- * $Id: FormatterListener.hpp,v 1.6 2000/04/11 14:43:00 dbertoni Exp $
+ * $Id: FormatterListener.hpp,v 1.7 2000/05/18 18:37:23 dbertoni Exp $
*
* $State: Exp $
*
@@ -84,11 +84,28 @@
{
public:
- FormatterListener();
- virtual
+ enum eFormat
+ {
+ OUTPUT_METHOD_NONE = 0,
+ OUTPUT_METHOD_XML = 1,
+ OUTPUT_METHOD_HTML = 2,
+ OUTPUT_METHOD_TEXT = 3,
+ OUTPUT_METHOD_DOM = 4,
+ OUTPUT_METHOD_OTHER = 5
+ };
+
+ FormatterListener(eFormat theFormat);
+ virtual
~FormatterListener();
+
+ eFormat
+ getOutputFormat() const
+ {
+ return m_outputFormat;
+ }
+
/**
* Receive notification of character data. If available, when the
* disable-output-escaping attribute is used, output raw text without
@@ -185,6 +202,9 @@
const XMLCh* const name,
AttributeList& attrs) = 0;
+private:
+
+ const eFormat m_outputFormat;
};
1.7 +2 -0 xml-xalan/c/src/XMLSupport/FormatterToDOM.cpp
Index: FormatterToDOM.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToDOM.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- FormatterToDOM.cpp 2000/04/11 14:43:00 1.6
+++ FormatterToDOM.cpp 2000/05/18 18:37:23 1.7
@@ -87,6 +87,7 @@
XalanDocument* doc,
XalanDocumentFragment* docFrag,
XalanElement* currentElement) :
+ FormatterListener(OUTPUT_METHOD_DOM),
m_doc(doc),
m_docFrag(docFrag),
m_currentElem(currentElement),
@@ -100,6 +101,7 @@
FormatterToDOM::FormatterToDOM(
XalanDocument* doc,
XalanElement* elem) :
+ FormatterListener(OUTPUT_METHOD_DOM),
m_doc(doc),
m_docFrag(0),
m_currentElem(elem),
1.17 +1196 -678 xml-xalan/c/src/XMLSupport/FormatterToHTML.cpp
Index: FormatterToHTML.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToHTML.cpp,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -r1.16 -r1.17
--- FormatterToHTML.cpp 2000/05/15 15:52:49 1.16
+++ FormatterToHTML.cpp 2000/05/18 18:37:23 1.17
@@ -55,7 +55,7 @@
* <http://www.apache.org/>.
*/
/**
- * $Id: FormatterToHTML.cpp,v 1.16 2000/05/15 15:52:49 dbertoni Exp $
+ * $Id: FormatterToHTML.cpp,v 1.17 2000/05/18 18:37:23 dbertoni Exp $
*
* $State: Exp $
*
@@ -71,12 +71,14 @@
#include <cassert>
#include <climits>
+#include <map>
-#include <sax/SAXException.hpp>
+#include <sax/AttributeList.hpp>
+
#include <PlatformSupport/DOMStringHelper.hpp>
#include <PlatformSupport/Writer.hpp>
@@ -85,46 +87,171 @@
#include <DOMSupport/DOMServices.hpp>
+
+#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
+static const char* const theHTMLSymbols1[] =
+{
+ "Alpha", "Beta",
+ "Gamma", "Delta", "Epsilon", "Zeta",
+ "Eta", "Theta", "Iota", "Kappa",
+ "Lambda", "Mu", "Nu", "Xi",
+ "Omicron", "Pi", "Rho", "", "Sigma",
+ "Tau", "Upsilon", "Phi", "Chi",
+ "Psi", "Omega", 0
+};
+
+static const char* const theHTMLSymbols2[] =
+{
+ "alpha", "beta",
+ "gamma", "delta", "epsilon", "zeta",
+ "eta", "theta", "iota", "kappa",
+ "lambda", "mu", "nu", "xi",
+ "omicron", "pi", "rho", "sigmaf",
+ "sigma", "tau", "upsilon", "phi",
+ "chi", "psi", "omega", "thetasym",
+ "upsih", "piv", 0
+};
+#else
+static const XalanDOMChar* const theHTMLSymbols1[] =
+{
+ L"Alpha", L"Beta",
+ L"Gamma", L"Delta", L"Epsilon", L"Zeta",
+ L"Eta", L"Theta", L"Iota", L"Kappa",
+ L"Lambda", L"Mu", L"Nu", L"Xi",
+ L"Omicron", L"Pi", L"Rho", L"", L"Sigma",
+ L"Tau", L"Upsilon", L"Phi", L"Chi",
+ L"Psi", L"Omega", 0
+};
+
+static const XalanDOMChar* const theHTMLSymbols2[] =
+{
+ L"alpha", L"beta",
+ L"gamma", L"delta", L"epsilon", L"zeta",
+ L"eta", L"theta", L"iota", L"kappa",
+ L"lambda", L"mu", L"nu", L"xi",
+ L"omicron", L"pi", L"rho", L"sigmaf",
+ L"sigma", L"tau", L"upsilon", L"phi",
+ L"chi", L"psi", L"omega", L"thetasym",
+ L"upsih", L"piv", 0
+};
+#endif
+
+
+#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
+static const char* const theHTMLLatin1Symbols[] =
+{
+ "nbsp", "iexcl", "cent", "pound",
+ "curren", "yen", "brvbar", "sect",
+ "uml", "copy", "ordf", "laquo",
+ "not", "shy", "reg", "macr", "deg",
+ "plusmn", "sup2", "sup3", "acute",
+ "micro", "para", "middot", "cedil",
+ "sup1", "ordm", "raquo", "frac14",
+ "frac12", "frac34", "iquest",
+ "Agrave", "Aacute", "Acirc",
+ "Atilde", "Auml", "Aring", "AElig",
+ "Ccedil", "Egrave", "Eacute", "Ecirc",
+ "Euml", "Igrave", "Iacute", "Icirc",
+ "Iuml", "ETH", "Ntilde", "Ograve",
+ "Oacute", "Ocirc", "Otilde", "Ouml",
+ "times", "Oslash", "Ugrave", "Uacute",
+ "Ucirc", "Uuml", "Yacute", "THORN",
+ "szlig", "agrave", "aacute", "acirc",
+ "atilde", "auml", "aring", "aelig",
+ "ccedil", "egrave", "eacute", "ecirc",
+ "euml", "igrave", "iacute", "icirc",
+ "iuml", "eth", "ntilde", "ograve",
+ "oacute", "ocirc", "otilde", "ouml",
+ "divide", "oslash", "ugrave", "uacute",
+ "ucirc", "uuml", "yacute", "thorn",
+ "yuml"
+};
+#else
+static const XMLCh* const theHTMLLatin1Symbols[] =
+{
+ L"nbsp", L"iexcl", L"cent", L"pound",
+ L"curren", L"yen", L"brvbar", L"sect",
+ L"uml", L"copy", L"ordf", L"laquo",
+ L"not", L"shy", L"reg", L"macr", L"deg",
+ L"plusmn", L"sup2", L"sup3", L"acute",
+ L"micro", L"para", L"middot", L"cedil",
+ L"sup1", L"ordm", L"raquo", L"frac14",
+ L"frac12", L"frac34", L"iquest",
+ L"Agrave", L"Aacute", L"Acirc",
+ L"Atilde", L"Auml", L"Aring", L"AElig",
+ L"Ccedil", L"Egrave", L"Eacute", L"Ecirc",
+ L"Euml", L"Igrave", L"Iacute", L"Icirc",
+ L"Iuml", L"ETH", L"Ntilde", L"Ograve",
+ L"Oacute", L"Ocirc", L"Otilde", L"Ouml",
+ L"times", L"Oslash", L"Ugrave", L"Uacute",
+ L"Ucirc", L"Uuml", L"Yacute", L"THORN",
+ L"szlig", L"agrave", L"aacute", L"acirc",
+ L"atilde", L"auml", L"aring", L"aelig",
+ L"ccedil", L"egrave", L"eacute", L"ecirc",
+ L"euml", L"igrave", L"iacute", L"icirc",
+ L"iuml", L"eth", L"ntilde", L"ograve",
+ L"oacute", L"ocirc", L"otilde", L"ouml",
+ L"divide", L"oslash", L"ugrave", L"uacute",
+ L"ucirc", L"uuml", L"yacute", L"thorn",
+ L"yuml"
+};
+#endif
+
+
+const FormatterToHTML::ElementFlagsMapType
FormatterToHTML::s_elementFlags =
+ FormatterToHTML::createElementFlagsMap();
+
-const FormatterToHTML::EmptiesSetType
FormatterToHTML::s_empties =
-
FormatterToHTML::createEmpties();
+const FormatterToHTML::ElemDesc
FormatterToHTML::s_dummyDesc(ElemDesc::BLOCK);
-const FormatterToHTML::EmptiesSetType
FormatterToHTML::s_attrempties =
-
FormatterToHTML::createAttrEmpties();
-const FormatterToHTML::HTMLAttributesVectorType
FormatterToHTML::s_HTMLlat1 =
-
FormatterToHTML::createAttributes();
+const XalanDOMCharVectorType FormatterToHTML::s_doctypeHeaderStartString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("<!DOCTYPE HTML")));
-const FormatterToHTML::HTMLSymbolsVectorType
FormatterToHTML::s_HTMLsymbol1 =
-
FormatterToHTML::createSymbols();
+const XalanDOMCharVectorType FormatterToHTML::s_doctypeHeaderPublicString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("
PUBLIC \"")));
-const FormatterToHTML::StringSetType FormatterToHTML::s_nonblockelems =
-
FormatterToHTML::createNonBlockElems();
+const XalanDOMCharVectorType FormatterToHTML::s_doctypeHeaderSystemString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("
SYSTEM")));
-const FormatterToHTML::StringSetType FormatterToHTML::s_escapetb =
-
FormatterToHTML::createEscapeElems();
-const FormatterToHTML::AttributesMapType FormatterToHTML::s_attruris =
-
FormatterToHTML::createAttributesMap();
+const XalanDOMCharVectorType FormatterToHTML::s_scriptString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("SCRIPT")));
+const XalanDOMCharVectorType FormatterToHTML::s_styleString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("STYLE")));
+const XalanDOMCharVectorType FormatterToHTML::s_ltString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("lt")));
+
+const XalanDOMCharVectorType FormatterToHTML::s_gtString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("gt")));
+
+const XalanDOMCharVectorType FormatterToHTML::s_ampString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("amp")));
+
+const XalanDOMCharVectorType FormatterToHTML::s_fnofString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("fnof")));
+
+
FormatterToHTML::FormatterToHTML(
Writer& writer,
- const XalanDOMString& version,
- bool doIndent,
- int indent,
const XalanDOMString& encoding,
const XalanDOMString& mediaType,
const XalanDOMString& doctypeSystem,
const XalanDOMString& doctypePublic,
- bool xmlDecl,
- const XalanDOMString& standalone) :
- FormatterToXML( writer, version, doIndent, indent,
+ bool doIndent,
+ int indent,
+ const XalanDOMString& version,
+ const XalanDOMString& standalone,
+ bool xmlDecl) :
+ FormatterToXML(writer, version, doIndent, indent,
encoding, mediaType, doctypeSystem, doctypePublic,
- xmlDecl, standalone),
+ xmlDecl, standalone, OUTPUT_METHOD_HTML),
m_currentElementName(),
m_inBlockElem(false)
{
+ initCharsMap();
}
@@ -134,227 +261,254 @@
}
+
void
-FormatterToHTML::startDocument()
+FormatterToHTML::initAttrCharsMap()
{
- m_needToOutputDocTypeDecl = true;
- m_startNewLine = false;
-
- if(true == m_needToOutputDocTypeDecl)
+ FormatterToXML::initAttrCharsMap();
+
+ m_attrCharsMap['\n'] = 'S';
+ m_attrCharsMap['<'] = 0;
+ m_attrCharsMap['>'] = 0;
+}
+
+
+
+void
+FormatterToHTML::initCharsMap()
+{
+ initAttrCharsMap();
+
+ memset(m_charsMap, 0, sizeof(m_charsMap));
+
+ m_charsMap['\n'] = 'S';
+ m_charsMap['<'] = 'S';
+ m_charsMap['>'] = 'S';
+ m_charsMap['&'] = 'S';
+
+ memset(m_charsMap, 'S', 10);
+
+ m_charsMap[0x0A] = 'S';
+ m_charsMap[0x0D] = 'S';
+
+ for(int i = 160; i < SPECIALSSIZE; ++i)
+ {
+ m_charsMap[i] = 'S';
+ }
+
+ for(int j = m_maxCharacter; j < SPECIALSSIZE; ++j)
{
- // Output the header if either the System or Public attributes
are
- // specified
- if((! isEmpty(m_doctypeSystem)) || (! isEmpty(m_doctypePublic)))
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING("<!DOCTYPE
HTML"));
- if(! isEmpty(m_doctypePublic))
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING("
PUBLIC \""));
- m_writer.write(m_doctypePublic);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- if(! isEmpty(m_doctypeSystem))
- {
- if(isEmpty(m_doctypePublic))
-
m_writer.write(XALAN_STATIC_UCODE_STRING(" SYSTEM \""));
- else
-
m_writer.write(XALAN_STATIC_UCODE_STRING(" \""));
- m_writer.write(m_doctypeSystem);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- m_writer.write(m_lineSep);
- }
+ m_charsMap[j] = 'S';
}
- m_needToOutputDocTypeDecl = false;
}
-void
-FormatterToHTML::endDocument()
+
+
+const FormatterToHTML::ElemDesc&
+FormatterToHTML::getElemDesc(const XalanDOMString& name)
{
- try
+ const ElementFlagsMapType::const_iterator i =
+ s_elementFlags.find(name);
+
+ if (i == s_elementFlags.end())
{
- m_writer.write(m_lineSep);
+ return s_dummyDesc;
}
- catch(...)
+ else
{
- throw SAXException();
+ return i->second;
}
-
- FormatterToXML::endDocument();
}
void
-FormatterToHTML::startElement(
- const XMLCh* const name,
- AttributeList& attrs)
+FormatterToHTML::startDocument()
{
- // @@ JMD: this block is not in the java version any more ...
- XalanDOMString theName(name);
- if(true == m_needToOutputDocTypeDecl)
+ m_startNewLine = false;
+ m_shouldWriteXMLHeader = false;
+
+ const bool isEmptySystem =
+ isEmpty(m_doctypeSystem);
+
+ const bool isEmptyPublic =
+ isEmpty(m_doctypePublic);
+
+ // Output the header if either the System or Public attributes are
+ // specified
+ if(isEmptySystem == false || isEmptyPublic == false)
{
- try
+ accum(s_doctypeHeaderStartString);
+
+ if(isEmptyPublic == false)
{
- if((! isEmpty(m_doctypeSystem)) || (!
isEmpty(m_doctypePublic)))
- {
-
m_writer.write(XALAN_STATIC_UCODE_STRING("<!DOCTYPE "));
- m_writer.write(name);
- if(! isEmpty(m_doctypePublic))
- {
-
m_writer.write(XALAN_STATIC_UCODE_STRING(" PUBLIC \""));
- m_writer.write(m_doctypePublic);
-
m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- if(! isEmpty(m_doctypeSystem))
- {
- if(isEmpty(m_doctypePublic))
-
m_writer.write(XALAN_STATIC_UCODE_STRING(" SYSTEM \""));
- else
-
m_writer.write(XALAN_STATIC_UCODE_STRING(" \""));
- m_writer.write(m_doctypeSystem);
-
m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- m_writer.write(m_lineSep);
- }
+ accum(s_doctypeHeaderPublicString);
+ accum(m_doctypePublic);
+ accum('"');
}
- // java: catch(IOException ioe)
- catch(...)
+
+ if(isEmptySystem == false)
{
- throw SAXException("IO error");
+ if(isEmptyPublic == true)
+ {
+ accum(s_doctypeHeaderSystemString);
+ }
+
+ accum(' ');
+ accum('"');
+
+ accum(m_doctypeSystem);
+ accum('"');
}
+
+ accum('>');
+
+ outputLineSep();
}
+
m_needToOutputDocTypeDecl = false;
+}
- bool savedDoIndent = m_doIndent;
- XalanDOMString nameUpper = toUpperCase(theName);
- // If the previous element is a non-block element or the next
- // element is a non-block element, then do not indent.
- bool isBlockElement =
- ((s_nonblockelems.end() != s_nonblockelems.find(nameUpper)) ||
- ((! isEmpty(m_currentElementName) &&
- (s_nonblockelems.end() !=
- s_nonblockelems.find(m_currentElementName)))))
- ? false : true;
+void
+FormatterToHTML::startElement(
+ const XMLCh* const name,
+ AttributeList& attrs)
+{
+ const bool savedDoIndent = m_doIndent;
- try
- {
- writeParentTagEnd();
+ writeParentTagEnd();
- if (m_ispreserve)
- m_ispreserve = false;
- else if(m_doIndent
- && (!isEmpty(m_currentElementName))
- && (!m_inBlockElem || isBlockElement))
- {
- m_startNewLine = true;
- indent(m_writer, m_currentIndent);
- }
- m_inBlockElem = !isBlockElement;
-
- // @@@ JMD: need to provide equivalent functionality here ...
- // m_isRawStack.push(elemDesc.is(ElemDesc.RAW));
-
- m_currentElementName = nameUpper;
+ const XalanDOMString nameUpper = toUpperCase(name);
- m_writer.write('<');
- m_writer.write(name);
+ const ElemDesc& elemDesc =
+ getElemDesc(nameUpper);
- int nAttrs = attrs.getLength();
- for (int i = 0; i < nAttrs ; i++)
- {
- processAttribute(attrs.getName(i), attrs.getValue(i));
- }
- // Flag the current element as not yet having any children.
- openElementForChildren();
+ bool isBlockElement = elemDesc.is(ElemDesc::BLOCK);
- m_currentIndent += m_indent;
- m_isprevtext = false;
- }
- catch(...)
+ if(m_ispreserve == true)
{
- throw SAXException("IO error");
+ m_ispreserve = false;
}
- m_doIndent = savedDoIndent;
+ else if(m_doIndent &&
+ length(m_currentElementName) != 0 &&
+ (m_inBlockElem == false || isBlockElement == true))
+ {
+ m_startNewLine = true;
+
+ indent(m_currentIndent);
+ }
+
+ m_inBlockElem = !isBlockElement;
+
+ m_isRawStack.push(elemDesc.is(ElemDesc::RAW));
+
+ m_currentElementName = nameUpper;
+
+ accum('<');
+ accum(name);
+
+ const unsigned int nAttrs = attrs.getLength();
+
+ for (unsigned int i = 0; i < nAttrs ; i++)
+ {
+ processAttribute(attrs.getName(i), attrs.getValue(i), elemDesc);
+ }
+
+ // Flag the current element as not yet having any children.
+ openElementForChildren();
+
+ m_currentIndent += m_indent;
+
+ m_isprevtext = false;
+
+ m_doIndent = savedDoIndent;
}
-
+
void
-FormatterToHTML::endElement(
- const XMLCh* const name)
+FormatterToHTML::endElement(const XMLCh* const name)
{
- try
- {
- m_currentIndent -= m_indent;
- // name = name.toUpperCase();
- const bool hasChildNodes = childNodesWereAdded();
+ m_currentIndent -= m_indent;
+
+ const bool hasChildNodes = childNodesWereAdded();
-// @@ JMD: need to provide this ...
-// m_isRawStack.pop();
+ m_isRawStack.pop();
+
+ const XalanDOMString nameUpper = toUpperCase(name);
- // @@ JMD: check that this doesn't change name ...
- XalanDOMString nameUpper = toUpperCase(name);
- bool isBlockElement = s_nonblockelems.end() ==
s_nonblockelems.find(nameUpper);
+ const ElemDesc& elemDesc =
+ getElemDesc(nameUpper);
- bool shouldIndent = false;
- if(m_ispreserve)
- {
- m_ispreserve = false;
- }
- else if(m_doIndent && (!m_inBlockElem || isBlockElement))
+ const bool isBlockElement = elemDesc.is(ElemDesc::BLOCK);
+
+ bool shouldIndent = false;
+
+ if(m_ispreserve == true)
+ {
+ m_ispreserve = false;
+ }
+ else if(m_doIndent == true && (m_inBlockElem == false || isBlockElement
== true))
+ {
+ m_startNewLine = true;
+
+ shouldIndent = true;
+ }
+
+ m_inBlockElem = !isBlockElement;
+
+ if (hasChildNodes)
+ {
+ if (shouldIndent == true)
{
- m_startNewLine = true;
- shouldIndent = true;
+ indent(m_currentIndent);
}
- m_inBlockElem = !isBlockElement;
+ accum('<');
+ accum('/');
+ accum(name);
+ accum('>');
- if (hasChildNodes == true)
+ m_currentElementName = name;
+ }
+ else
+ {
+ if(elemDesc.is(ElemDesc::EMPTY) == false)
{
+ accum('>');
+
if (shouldIndent == true)
- indent(m_writer, m_currentIndent);
- m_writer.write(XALAN_STATIC_UCODE_STRING("</"));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
+ {
+ indent(m_currentIndent);
+ }
+
+ accum('<');
+ accum('/');
+ accum(name);
+ accum('>');
}
else
{
- if(s_empties.find(toUpperCase(name)) == s_empties.end())
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- if (shouldIndent)
- indent(m_writer, m_currentIndent);
- m_writer.write(XALAN_STATIC_UCODE_STRING("</"));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- }
- else
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- }
+ accum('>');
}
-/*
- @@@ JMD: need to provide equivalent functionality here ...
- if (elemDesc.is(ElemDesc.WHITESPACESENSITIVE))
- m_ispreserve = true;
-*/
+ }
- if (hasChildNodes == true)
+ if (elemDesc.is(ElemDesc::WHITESPACESENSITIVE) == true)
+ {
+ m_ispreserve = true;
+ }
+
+ if (hasChildNodes == true)
+ {
+ if (m_preserves.empty() == false)
{
- m_ispreserve = m_preserves.top();
m_preserves.pop();
}
- m_isprevtext = false;
- }
- catch(...)
- {
- throw SAXException();
- }
+ }
+
+ m_isprevtext = false;
}
@@ -364,139 +518,165 @@
const XMLCh* const chars,
const unsigned int length)
{
- if(0 == length) return;
-
- if(m_nextIsRaw)
+ if(length != 0)
{
- m_nextIsRaw = false;
- charactersRaw (chars, length);
- return;
- }
+ if(m_inCData == true)
+ {
+ cdata(chars, length);
+ }
+ else if(m_nextIsRaw)
+ {
+ m_nextIsRaw = false;
- if((! isEmpty(m_currentElementName)) &&
- (equalsIgnoreCase(m_currentElementName,
XALAN_STATIC_UCODE_STRING("SCRIPT")) ||
- equalsIgnoreCase(m_currentElementName,
XALAN_STATIC_UCODE_STRING("STYLE"))))
- {
- try
+ charactersRaw(chars, length);
+ }
+ else if (m_isRawStack.empty() == false &&
+ m_isRawStack.top() == true)
{
writeParentTagEnd();
+
m_ispreserve = true;
- if (shouldIndent())
- indent(m_writer, m_currentIndent);
- //
m_writer.write(XALAN_STATIC_UCODE_STRING("<![CDATA["));
- // m_writer.write(chars, 0, length);
+
+ if (shouldIndent() == true)
+ {
+ indent(m_currentIndent);
+ }
+
writeNormalizedChars(chars, 0, length, false);
- // m_writer.write(XALAN_STATIC_UCODE_STRING("]]>"));
- return;
}
- // java: catch(IOException ioe)
- catch(...)
+ else
{
- throw SAXException("IO error");
- }
- }
+ writeParentTagEnd();
- try
- {
- writeParentTagEnd();
- m_ispreserve = true;
- int pos = 0;
- int end = length;
- for (int i = 0; i < end; i ++)
- {
- const XMLCh ch = chars[i];
- int chNum = ch;
- if ('\n' == ch)
- {
- m_charBuf[pos++] = m_lineSep;
- }
- else if ('<' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("lt"), pos);
- }
- else if ('>' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("gt"), pos);
- }
- else if ('&' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("amp"), pos);
- }
- else if((chNum >= 9) && (chNum <= 126))
- {
- m_charBuf[pos++] = ch;
- }
- else if((chNum >= 160) && (chNum <= 255))
- {
- pos = copyEntityIntoBuf(s_HTMLlat1[ch-160],
pos);
- }
- else if((chNum >= 913) && (chNum <= 982))
- {
- pos = copyEntityIntoBuf(s_HTMLsymbol1[ch-913],
pos);
- }
- else if (402 == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("fnof"), pos);
- }
- else if (m_isUTF8 && (0xd800 <= chNum && chNum <
0xdc00))
- {
- // UTF-16 surrogate
- copyUTF16IntoBuf( chars, i, pos, length);
- }
- else if((ch >= 0x7F) && (ch <= m_maxCharacter))
- {
- // Hope this is right...
- m_charBuf[pos++] = ch;
- }
- else
+ m_ispreserve = true;
+
+ unsigned int pos = 0;
+
+ for (unsigned int i = 0; i < length; ++i)
{
- XalanDOMString ds;
- m_charBuf[pos++] = '&';
- m_charBuf[pos++] = '#';
- ds = LongToDOMString(chNum);
- const XalanDOMChar* const pb = c_wstr(ds);
- const int
nIntStr = ds.length();
+ const XalanDOMChar ch = chars[i];
+
+ if(ch < SPECIALSSIZE && m_charsMap[ch] != 'S')
+ {
+ accum(ch);
- for(int k = 0; k < nIntStr; k++)
+ continue;
+ }
+ else if (0x0A == ch && i + 1 < length && 0x0D
== chars[i + 1])
{
- m_charBuf[pos++] = *(pb+k);
+ outputLineSep();
+
+ ++i;
}
- m_charBuf[pos++] = ';';
- }
+ if (0x0D == ch && i + 1 < length && 0x0A ==
chars[i + 1])
+ {
+ outputLineSep();
- // Use 80 as a best guess safe buffer
- if(pos > MAXSAFECHARBUF)
- {
- m_writer.write(m_charBuf, 0, pos);
- pos = 0;
+ ++i;
+ }
+ else if (0x0D == ch)
+ {
+ outputLineSep();
+
+ ++i;
+ }
+ else if ('\n' == ch)
+ {
+ outputLineSep();
+ }
+ else if ('<' == ch)
+ {
+ pos = copyEntityIntoBuffer(s_ltString,
pos);
+ }
+ else if ('>' == ch)
+ {
+ pos = copyEntityIntoBuffer(s_gtString,
pos);
+ }
+ else if ('&' == ch)
+ {
+ pos = copyEntityIntoBuffer(s_ampString,
pos);
+ }
+ else if(ch >= 9 && ch <= 126)
+ {
+ accum(ch);
+ }
+ else if(ch >= 160 && ch <= 255)
+ {
+ pos =
copyEntityIntoBuffer(theHTMLLatin1Symbols[ch - 160], pos);
+ }
+ else if(ch >= 913 && ch <= 937 && ch != 930)
+ {
+ pos =
copyEntityIntoBuffer(theHTMLSymbols1[ch - 913], pos);
+ }
+ else if(ch >= 945 && ch <= 969)
+ {
+ pos =
copyEntityIntoBuffer(theHTMLSymbols2[ch - 945], pos);
+ }
+ else if(ch >= 977 && ch <= 978)
+ {
+ // subtract the unused characters
+ pos =
copyEntityIntoBuffer(theHTMLSymbols2[ch - 945 - 7], pos);
+ }
+ else if(ch == 982)
+ {
+ // subtract the unused characters
+ pos =
copyEntityIntoBuffer(theHTMLSymbols2[ch - 945 - 10], pos);
+ }
+ else if (402 == ch)
+ {
+ pos =
copyEntityIntoBuffer(s_fnofString, pos);
+ }
+ else if (m_isUTF8 == true && 0xd800 <= ch && ch
< 0xdc00)
+ {
+ // UTF-16 surrogate
+ unsigned int next = 0;
+
+ if (i + 1 >= length)
+ {
+
throwInvalidUTF16SurrogateException(ch);
+ }
+ else
+ {
+ next = chars[++i];
+
+ if (!(0xdc00 <= next && next <
0xe000))
+ {
+
throwInvalidUTF16SurrogateException(ch, next);
+ }
+
+ next = ((ch - 0xd800) << 10) +
next - 0xdc00 + 0x00010000;
+ }
+
+ writeNumberedEntityReference(next);
+ }
+ else if(ch >= 0x007Fu && ch <= m_maxCharacter)
+ {
+ // Hope this is right...
+ accum(ch);
+ }
+ else
+ {
+ writeNumberedEntityReference(ch);
+ }
}
}
-
- m_writer.write(m_charBuf, 0, pos);
- m_isprevtext = true;
}
- // java: catch(IOException ioe)
- catch(...)
+
+ if (m_isprevtext == false)
{
- throw SAXException("IO error");
+ m_isprevtext = true;
}
}
+
void
FormatterToHTML::entityReference(const XMLCh* const name)
{
- try
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING("&"));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING(";"));
- }
- catch(...)
- {
- throw SAXException();
- }
+ accum('&');
+ accum(name);
+ accum(';');
}
@@ -506,455 +686,793 @@
const XMLCh* const ch,
const unsigned int length)
{
- if(equalsIgnoreCase(m_currentElementName,
XALAN_STATIC_UCODE_STRING("SCRIPT")) ||
- equalsIgnoreCase(m_currentElementName,
XALAN_STATIC_UCODE_STRING("STYLE")))
+ if(equalsIgnoreCase(m_currentElementName, c_wstr(s_scriptString)) ==
true ||
+ equalsIgnoreCase(m_currentElementName, c_wstr(s_styleString))
== true)
{
- try
- {
- writeParentTagEnd();
- m_ispreserve = true;
- if (shouldIndent() == true)
- {
- indent(m_writer, m_currentIndent);
- }
- // was: m_writer.write(ch, 0, length);
- writeNormalizedChars(ch, 0, length, true);
- }
- catch(...)
+ writeParentTagEnd();
+
+ m_ispreserve = true;
+
+ if (shouldIndent() == true)
{
- throw SAXException();
+ indent(m_currentIndent);
}
+
+ writeNormalizedChars(ch, 0, length, true);
}
else if(m_stripCData == true)
{
- try
- {
- writeParentTagEnd();
-
- m_ispreserve = true;
+ writeParentTagEnd();
- if (shouldIndent() == true)
- {
- indent(m_writer, m_currentIndent);
- }
+ m_ispreserve = true;
- // m_writer.write("<![CDATA[");
- m_writer.write(ch, 0, length);
- // m_writer.write("]]>");
- }
- catch(...)
+ if (shouldIndent() == true)
{
- throw SAXException();
+ indent(m_currentIndent);
}
+
+ accum(ch, 0, length);
}
else
{
- characters(ch, length);
+ cdata(ch, length);
}
}
-void FormatterToHTML::processingInstruction(
- const XMLCh* const target,
- const XMLCh* const data)
-
-{
- FormatterToXML::processingInstruction( target, data, true);
-}
void
-FormatterToHTML::processAttribute(
- const XalanDOMChar* name,
- const XalanDOMChar* value)
+FormatterToHTML::processingInstruction(
+ const XMLCh* const target,
+ const XMLCh* const data)
+
{
- try
+ // Use a fairly nasty hack to tell if the next node is supposed to be
+ // unescaped text.
+ if(equals(target, c_wstr(s_xsltNextIsRawString)) == true &&
+ equals(data, c_wstr(s_formatterToDOMString)) == true)
+ {
+ m_nextIsRaw = true;
+ }
+ else
{
- if(!equals(name, DOMServices::s_XMLNamespace) &&
- !startsWith(name,
DOMServices::s_XMLNamespaceWithSeparator))
+ writeParentTagEnd();
+
+ if (shouldIndent() == true)
{
- XalanDOMString pval;
- XalanDOMString aname = toLowerCase(name);
- if (equals(aname,
XALAN_STATIC_UCODE_STRING("xml:lang"))) aname =
XALAN_STATIC_UCODE_STRING("lang");
- // qualify with an element??
- AttributesMapType::const_iterator it =
-
(s_attruris.find(toLowerCase(m_currentElementName)));
- if (it != s_attruris.end())
- {
- const StringSetType val = (*it).second;
- // Determine if value is in the set of strings
- if(val.find(aname) != val.end())
- pval = prepAttrURI(value,
m_attrSpecialChars, m_encoding);
- else
- pval = prepAttrString(value,
m_attrSpecialChars, m_encoding);
- }
- else
- pval = prepAttrString(value,
m_attrSpecialChars, m_encoding);
+ indent(m_currentIndent);
+ }
- if(s_attrempties.find(aname) == s_attrempties.end())
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(" "));
- m_writer.write(name);
-
m_writer.write(XALAN_STATIC_UCODE_STRING("=\""));
- m_writer.write(pval);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- else
+ accum('<');
+ accum('?');
+ accum(target);
+
+ if (length(data) > 0)
+ {
+ if(isSpace(data[0]) == false)
{
- m_writer.write(XALAN_STATIC_UCODE_STRING(" "));
- if((pval.length() == 0) ||
equalsIgnoreCase(pval, aname))
- {
- m_writer.write(name);
- }
- else
- {
- m_writer.write(name);
-
m_writer.write(XALAN_STATIC_UCODE_STRING("=\""));
- m_writer.write(pval);
-
m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
+ accum(' ');
}
+
+ accum(data);
}
- }
- catch(...)
- {
- throw SAXException();
+
+ accum('>'); // different from XML
+
+ m_startNewLine = true;
}
}
-/**
- * Returns the specified <var>string</var> after substituting non ASCII
characters,
- * with <CODE>%HH</CODE>, where HH is the hex of the byte value.
- *
- * @param string String to convert to XML format.
- * @param specials Characters, should be represented in character
references.
- * @param encoding CURRENTLY NOT IMPLEMENTED.
- * @return XML-formatted string.
- */
-const XalanDOMString
-FormatterToHTML::prepAttrURI(
- const XalanDOMString& string,
- const XalanDOMString& /* specials */,
+
+void
+FormatterToHTML::writeAttrString(
+ const XalanDOMChar* string,
const XalanDOMString& /* encoding */)
{
- XalanDOMString sb;
-
- const unsigned int theLength = length(string);
+ const unsigned int strLen = length(string);
- for (unsigned int i = 0; i < theLength; i ++)
- {
- const XalanDOMChar ch = charAt(string, i);
- XalanDOMString sch(&ch, 1);
-
- const int ich = ch;
+ for (unsigned int i = 0; i < strLen; i ++)
+ {
+ const XalanDOMChar ch = string[i];
- if(((ch > 0x1F) && // X'00 - 1F' not valid
- (ch < 0x7F)) && // X'7F' not valid
- (s_escapetb.find(sch)== s_escapetb.end()) ) //
characters in the table
+ if(ch < SPECIALSSIZE && m_attrCharsMap[ch] != 'S')
{
- sb += sch; // valid character, append it
+ accum(ch);
}
- else
+ else if('&' == ch &&
+ i + 1 < strLen &&
+ '{' == string[i + 1])
+ {
+ accum(ch); // no escaping in this case, as specified in
15.2
+ }
+ else if (accumDefaultEntity(ch, i, string, strLen, false) ==
false)
{
- // need to escape the character
- const int mask1 = 0xFF00;
- const int mask2 = 0x00FF;
- assert (ich < 0xFFFF);
- const int b1 = (int)(((ich) & mask1) >> 8);
- const int b2 = (int)((ich) & mask2);
+ if (0xd800 <= ch && ch < 0xdc00)
+ {
+ // UTF-16 surrogate
- // if first 8 bytes are 0, no need to append them.
- if (b1 != 0)
- {
- sb += XALAN_STATIC_UCODE_STRING("%");
- sb += LongToHexDOMString(b1);
- }
+ unsigned int next = 0;
- sb += XALAN_STATIC_UCODE_STRING("%");
- sb += LongToHexDOMString(b2);
- }
- }
+ if (i + 1 >= strLen)
+ {
+ throwInvalidUTF16SurrogateException(ch);
+ }
+ else
+ {
+ next = string[++i];
+
+ if (!(0xdc00 <= next && next < 0xe000))
+ {
+
throwInvalidUTF16SurrogateException(ch, next);
+ }
- return sb;
+ next = ((ch - 0xd800) << 10) + next
-0xdc00 + 0x00010000;
+ }
+
+ accum('&');
+ accum('#');
+ accum('x');
+ accum(UnsignedLongToHexDOMString(next));
+ accum(';');
+ }
+ else if(ch >= 160 && ch <= 255)
+ {
+ accum('&');
+ accum(theHTMLLatin1Symbols[ch - 160]);
+ accum(';');
+ }
+ else if(ch >= 913 && ch <= 937 && ch != 930)
+ {
+ accum('&');
+ accum(theHTMLSymbols1[ch - 913]);
+ accum(';');
+ }
+ else if(ch >= 945 && ch <= 969)
+ {
+ accum('&');
+ accum(theHTMLSymbols2[ch - 945]);
+ accum(';');
+ }
+ else if(ch >= 977 && ch <= 978)
+ {
+ accum('&');
+ // substracting the number of unused characters
+ accum(theHTMLSymbols2[ch - 945 - 7]);
+ accum(';');
+ }
+ else if(ch == 982)
+ {
+ accum('&');
+ // substracting the number of unused characters
+ accum(theHTMLSymbols2[ch - 945 - 10]);
+ accum(';');
+ }
+ else if (402 == ch)
+ {
+ accum('&');
+ accum('f');
+ accum('n');
+ accum('o');
+ accum('f');
+ accum(';');
+ }
+ else
+ {
+ accum('&');
+ accum('#');
+ accum('x');
+ accum(UnsignedLongToHexDOMString(ch));
+ accum(';');
+ }
+ }
+ }
}
-
+
-FormatterToHTML::EmptiesSetType
-FormatterToHTML::createEmpties()
+unsigned int
+FormatterToHTML::copyEntityIntoBuffer(
+ const XalanDOMChar* s,
+ unsigned int pos)
{
- EmptiesSetType theEmpties;
+ const unsigned int len = length(s);
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("AREA"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("BASE"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("BR"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("COL"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("HR"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("IMG"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("INPUT"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("LINK"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("META"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("PARAM"));
+ accum('&');
- // HTML 4.0 loose DTD
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("BASEFONT"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("FRAME"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("ISINDEX"));
-
- return theEmpties;
-}
-
-FormatterToHTML::EmptiesSetType
-FormatterToHTML::createAttrEmpties()
-{
- EmptiesSetType theEmpties;
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("checked"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("disabled"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("readonly"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("multiple"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("disabled"));
- theEmpties.insert(XALAN_STATIC_UCODE_STRING("selected"));
- return theEmpties;
-}
-
-FormatterToHTML::StringSetType
-FormatterToHTML::createNonBlockElems()
-{
- StringSetType theElems;
- theElems.insert(XALAN_STATIC_UCODE_STRING("FONT"));
- // s_nonblockelems.insert(XALAN_STATIC_UCODE_STRING("A"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("TD"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("IMG"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("B"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("I"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("Q"));
- return theElems;
-}
-
-FormatterToHTML::StringSetType
-FormatterToHTML::createEscapeElems()
-{
- StringSetType theElems;
- theElems.insert(XALAN_STATIC_UCODE_STRING("%"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("<"));
- theElems.insert(XALAN_STATIC_UCODE_STRING(">"));
-// theElems.insert(XALAN_STATIC_UCODE_STRING(" "));
-// theElems.insert(XALAN_STATIC_UCODE_STRING("#"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("{"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("}"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("["));
- theElems.insert(XALAN_STATIC_UCODE_STRING("]"));
-// theElems.insert(XALAN_STATIC_UCODE_STRING("\\"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("|"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("^"));
- theElems.insert(XALAN_STATIC_UCODE_STRING("\""));
-// theElems.insert(XALAN_STATIC_UCODE_STRING("'"));
- return theElems;
+ for(unsigned int i= 0; i < len; ++i)
+ {
+ accum(s[i]);
+ }
+
+ accum(';');
+
+ return pos;
}
+
-FormatterToHTML::AttributesMapType
-FormatterToHTML::createAttributesMap()
+
+void
+FormatterToHTML::processAttribute(
+ const XalanDOMChar* name,
+ const XalanDOMChar* value,
+ const ElemDesc& elemDesc)
{
-#if !defined(XALAN_NO_NAMESPACES)
- using std::make_pair;
-#endif
+ const XalanDOMString nameUpper = toUpperCase(name);
+
+ accum(' ');
- AttributesMapType theAtts;
- StringSetType URLAttrsHREFSingle;
- URLAttrsHREFSingle.insert(XALAN_STATIC_UCODE_STRING("href"));
- StringSetType URLAttrsCITESingle;
- URLAttrsCITESingle.insert(XALAN_STATIC_UCODE_STRING("cite"));
-
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("base")),
URLAttrsHREFSingle));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("link")),
URLAttrsHREFSingle));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("area")),
URLAttrsHREFSingle));
- // From the HTML 4.0 spec: Note. The same conversion based on UTF-8
- // should be applied to values of the name attribute for the A element.
-
- StringSetType URLAttrs_A;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("href"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("name"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("a")),
URLAttrs_A));
-
- StringSetType URLAttrs_INPUT;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("src"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("usemap"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("input")),
URLAttrs_INPUT));
-
- StringSetType URLAttrs_SCRIPT;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("src"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("for"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("script")),
URLAttrs_SCRIPT));
-
- StringSetType URLAttrs_IMG;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("src"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("longdesc"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("usemap"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("img")),
URLAttrs_IMG));
-
- StringSetType URLAttrs_OBJECT;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("classid"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("codebase"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("data"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("archive"));
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("usemap"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("object")),
URLAttrs_OBJECT));
-
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("q")),
URLAttrsCITESingle));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("blockquote")),
URLAttrsCITESingle));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ins")),
URLAttrsCITESingle));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("del")),
URLAttrsCITESingle));
-
- StringSetType URLAttrs_FORM;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("action"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("form")),
URLAttrs_FORM));
-
- StringSetType URLAttrs_HEAD;
- URLAttrs_A.insert(XALAN_STATIC_UCODE_STRING("profile"));
-
theAtts.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("head")),
URLAttrs_HEAD));
- return theAtts;
+ if(elemDesc.isAttrFlagSet(nameUpper, ElemDesc::ATTREMPTY) == true &&
+ (length(value) == 0) || equalsIgnoreCase(value, name) == true)
+ {
+ accum(name);
+ }
+ else
+ {
+ accum(name);
+ accum('=');
+ accum('\"');
+
+ if(elemDesc.isAttrFlagSet(nameUpper, ElemDesc::ATTRURL) == true)
+ {
+ writeAttrURI(value, m_encoding);
+ }
+ else
+ {
+ writeAttrString(value, m_encoding);
+ }
+
+ accum('\"');
+ }
}
+
+
-FormatterToHTML::HTMLAttributesVectorType
-FormatterToHTML::createAttributes()
+void
+FormatterToHTML::writeAttrURI(
+ const XalanDOMChar* string,
+ const XalanDOMString encoding)
{
-#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
- static const char* const theHTMLAttributes[] =
- {
- "nbsp", "iexcl", "cent", "pound",
- "curren", "yen", "brvbar", "sect",
- "uml", "copy", "ordf", "laquo",
- "not", "shy", "reg", "macr", "deg",
- "plusmn", "sup2", "sup3", "acute",
- "micro", "para", "middot", "cedil",
- "sup1", "ordm", "raquo", "frac14",
- "frac12", "frac34", "iquest",
- "Agrave", "Aacute", "Acirc",
- "Atilde", "Auml", "Aring", "AElig",
- "Ccedil", "Egrave", "Eacute", "Ecirc",
- "Euml", "Igrave", "Iacute", "Icirc",
- "Iuml", "ETH", "Ntilde", "Ograve",
- "Oacute", "Ocirc", "Otilde", "Ouml",
- "times", "Oslash", "Ugrave", "Uacute",
- "Ucirc", "Uuml", "Yacute", "THORN",
- "szlig", "agrave", "aacute", "acirc",
- "atilde", "auml", "aring", "aelig",
- "ccedil", "egrave", "eacute", "ecirc",
- "euml", "igrave", "iacute", "icirc",
- "iuml", "eth", "ntilde", "ograve",
- "oacute", "ocirc", "otilde", "ouml",
- "divide", "oslash", "ugrave", "uacute",
- "ucirc", "uuml", "yacute", "thorn",
- "yuml"
- };
-#else
- static const XMLCh* const theHTMLAttributes[] =
- {
- L"nbsp", L"iexcl", L"cent", L"pound",
- L"curren", L"yen", L"brvbar", L"sect",
- L"uml", L"copy", L"ordf", L"laquo",
- L"not", L"shy", L"reg", L"macr", L"deg",
- L"plusmn", L"sup2", L"sup3", L"acute",
- L"micro", L"para", L"middot", L"cedil",
- L"sup1", L"ordm", L"raquo", L"frac14",
- L"frac12", L"frac34", L"iquest",
- L"Agrave", L"Aacute", L"Acirc",
- L"Atilde", L"Auml", L"Aring", L"AElig",
- L"Ccedil", L"Egrave", L"Eacute", L"Ecirc",
- L"Euml", L"Igrave", L"Iacute", L"Icirc",
- L"Iuml", L"ETH", L"Ntilde", L"Ograve",
- L"Oacute", L"Ocirc", L"Otilde", L"Ouml",
- L"times", L"Oslash", L"Ugrave", L"Uacute",
- L"Ucirc", L"Uuml", L"Yacute", L"THORN",
- L"szlig", L"agrave", L"aacute", L"acirc",
- L"atilde", L"auml", L"aring", L"aelig",
- L"ccedil", L"egrave", L"eacute", L"ecirc",
- L"euml", L"igrave", L"iacute", L"icirc",
- L"iuml", L"eth", L"ntilde", L"ograve",
- L"oacute", L"ocirc", L"otilde", L"ouml",
- L"divide", L"oslash", L"ugrave", L"uacute",
- L"ucirc", L"uuml", L"yacute", L"thorn",
- L"yuml"
- };
-#endif
+ const unsigned int len = length(string);
- static const size_t theArraySize =
- sizeof(theHTMLAttributes) /
sizeof(theHTMLAttributes[0]);
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ const XalanDOMChar ch = string[i];
- HTMLAttributesVectorType theAttributes;
+ // if first 8 bytes are 0, no need to append them.
+ if (ch < 9 || ch > 127 || ch == '"' || ch == ' ')
+ {
+ const unsigned int b1 = (ch & 0xFF00) >> 8;
+ const unsigned int b2 = ch & 0x00FF;
- theAttributes.reserve(theArraySize);
+ if(b1 != 0)
+ {
+ accum('%');
- for(size_t i = 0; i < theArraySize; i++)
- {
-#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
-
theAttributes.push_back(initializeAndTranscode(theHTMLAttributes[i]));
-#else
- theAttributes.push_back(theHTMLAttributes[i]);
-#endif
- }
+ accum(UnsignedLongToHexDOMString(b1));
+ }
- return theAttributes;
+ accum('%');
+ accum(UnsignedLongToHexDOMString(b2));
+ }
+ else
+ {
+ accum(ch);
+ }
+ }
}
-FormatterToHTML::HTMLSymbolsVectorType
-FormatterToHTML::createSymbols()
+FormatterToHTML::ElementFlagsMapType
+FormatterToHTML::createElementFlagsMap()
{
-#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
- static const char* const theHTMLSymbols[] =
- {
- "Alpha", "Beta",
- "Gamma", "Delta", "Epsilon", "Zeta",
- "Eta", "Theta", "Iota", "Kappa",
- "Lambda", "Mu", "Nu", "Xi",
- "Omicron", "Pi", "Rho", "", "Sigma",
- "Tau", "Upsilon", "Phi", "Chi",
- "Psi", "Omega", "alpha", "beta",
- "gamma", "delta", "epsilon", "zeta",
- "eta", "theta", "iota", "kappa",
- "lambda", "mu", "nu", "xi",
- "omicron", "pi", "rho", "sigmaf",
- "sigma", "tau", "upsilon", "phi",
- "chi", "psi", "omega", "thetasym",
- "upsih", "piv"
- };
+#if defined(XALAN_NO_NAMESPACES)
+ typedef pair<ElementFlagsMapType::iterator, bool> PairType;
#else
- static const XMLCh* const theHTMLSymbols[] =
- {
- L"Alpha", L"Beta",
- L"Gamma", L"Delta", L"Epsilon", L"Zeta",
- L"Eta", L"Theta", L"Iota", L"Kappa",
- L"Lambda", L"Mu", L"Nu", L"Xi",
- L"Omicron", L"Pi", L"Rho", L"", L"Sigma",
- L"Tau", L"Upsilon", L"Phi", L"Chi",
- L"Psi", L"Omega", L"alpha", L"beta",
- L"gamma", L"delta", L"epsilon", L"zeta",
- L"eta", L"theta", L"iota", L"kappa",
- L"lambda", L"mu", L"nu", L"xi",
- L"omicron", L"pi", L"rho", L"sigmaf",
- L"sigma", L"tau", L"upsilon", L"phi",
- L"chi", L"psi", L"omega", L"thetasym",
- L"upsih", L"piv"
- };
+ typedef std::pair<ElementFlagsMapType::iterator, bool> PairType;
#endif
- static const size_t theArraySize =
- sizeof(theHTMLSymbols) / sizeof(theHTMLSymbols[0]);
+ ElementFlagsMapType theElementFlags;
- HTMLSymbolsVectorType theSymbols;
-
- theSymbols.reserve(theArraySize);
-
- for(size_t i = 0; i < theArraySize; i++)
- {
-#if defined(XALAN_WIDE_STRING_UCODE_PROBLEM)
- theSymbols.push_back(initializeAndTranscode(theHTMLSymbols[i]));
-#else
- theSymbols.push_back(theHTMLSymbols[i]);
-#endif
- }
+ // HTML 4.0 loose DTD
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BASEFONT"),
+ ElemDesc(0|ElemDesc::EMPTY)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("FRAME"),
+ ElemDesc(0|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("FRAMESET"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("NOFRAMES"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("ISINDEX"),
+ ElemDesc(0|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("APPLET"),
+ ElemDesc(0|ElemDesc::WHITESPACESENSITIVE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("CENTER"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DIR"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("MENU"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+
+ // HTML 4.0 strict DTD
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TT"),
+ ElemDesc(0|ElemDesc::FONTSTYLE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("I"),
+ ElemDesc(0|ElemDesc::FONTSTYLE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("B"),
+ ElemDesc(0|ElemDesc::FONTSTYLE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BIG"),
+ ElemDesc(0|ElemDesc::FONTSTYLE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SMALL"),
+ ElemDesc(0|ElemDesc::FONTSTYLE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("EM"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("STRONG"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DFN"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("CODE"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SAMP"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("KBD"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("VAR"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("CITE"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("ABBR"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("ACRONYM"),
+ ElemDesc(0|ElemDesc::PHRASE)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SUP"),
+ ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SUB"),
+ ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SPAN"),
+ ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BDO"),
+ ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BR"),
+
ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BODY"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("ADDRESS"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DIV"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ PairType theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("A"),
+ ElemDesc(0|ElemDesc::SPECIAL)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("HREF"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("NAME"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("MAP"),
+
ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("AREA"),
+ ElemDesc(0|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("LINK"),
+
ElemDesc(0|ElemDesc::HEADMISC|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("IMG"),
+
ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL|ElemDesc::EMPTY|ElemDesc::WHITESPACESENSITIVE)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("SRC"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("LONGDESC"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("USEMAP"),
ElemDesc::ATTRURL);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("OBJECT"),
+
ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL|ElemDesc::HEADMISC|ElemDesc::WHITESPACESENSITIVE)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CLASSID"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CODEBASE"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DATA"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("ARCHIVE"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("USEMAP"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("PARAM"),
+ ElemDesc(0|ElemDesc::EMPTY)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("HR"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET|ElemDesc::EMPTY)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("P"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H1"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H2"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H3"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H4"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H5"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("H6"),
+ ElemDesc(0|ElemDesc::HEAD|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("PRE"),
+ ElemDesc(0|ElemDesc::PREFORMATTED|ElemDesc::BLOCK)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("Q"),
+ ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CITE"),
ElemDesc::ATTRURL);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BLOCKQUOTE"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CITE"),
ElemDesc::ATTRURL);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("INS"),
+ ElemDesc(0)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CITE"),
ElemDesc::ATTRURL);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DEL"),
+ ElemDesc(0)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CITE"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DL"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DT"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("DD"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("OL"),
+ ElemDesc(0|ElemDesc::LIST|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("UL"),
+ ElemDesc(0|ElemDesc::LIST|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("LI"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("FORM"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("ACTION"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("LABEL"),
+ ElemDesc(0|ElemDesc::FORMCTRL)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("INPUT"),
+
ElemDesc(0|ElemDesc::FORMCTRL|ElemDesc::INLINELABEL|ElemDesc::EMPTY)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("SRC"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("USEMAP"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("CHECKED"),
ElemDesc::ATTREMPTY);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DISABLED"),
ElemDesc::ATTREMPTY);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("READONLY"),
ElemDesc::ATTREMPTY);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SELECT"),
+ ElemDesc(0|ElemDesc::FORMCTRL|ElemDesc::INLINELABEL)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("READONLY"),
ElemDesc::ATTREMPTY);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("MULTIPLE"),
ElemDesc::ATTREMPTY);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("OPTGROUP"),
+ ElemDesc(0)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DISABLED"),
ElemDesc::ATTREMPTY);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("OPTION"),
+ ElemDesc(0)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DISABLED"),
ElemDesc::ATTREMPTY);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("SELECTED"),
ElemDesc::ATTREMPTY);
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TEXTAREA"),
+ ElemDesc(0|ElemDesc::FORMCTRL|ElemDesc::INLINELABEL)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DISABLED"),
ElemDesc::ATTREMPTY);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("READONLY"),
ElemDesc::ATTREMPTY);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("FIELDSET"),
+ ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("LEGEND"),
+ ElemDesc(0)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BUTTON"),
+ ElemDesc(0|ElemDesc::FORMCTRL|ElemDesc::INLINELABEL)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("DISABLED"),
ElemDesc::ATTREMPTY);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TABLE"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("CAPTION"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("THEAD"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TFOOT"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TBODY"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("COLGROUP"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("COL"),
+ ElemDesc(0|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TR"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TH"),
+ ElemDesc(0)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TD"),
+ ElemDesc(0)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("HEAD"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("PROFILE"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("TITLE"),
+ ElemDesc(0|ElemDesc::BLOCK)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("BASE"),
+ ElemDesc(0|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("HREF"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("META"),
+
ElemDesc(0|ElemDesc::HEADMISC|ElemDesc::EMPTY|ElemDesc::BLOCK)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("STYLE"),
+
ElemDesc(0|ElemDesc::HEADMISC|ElemDesc::RAW|ElemDesc::BLOCK)));
+
+ theResult =
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("SCRIPT"),
+
ElemDesc(0|ElemDesc::SPECIAL|ElemDesc::ASPECIAL|ElemDesc::HEADMISC|ElemDesc::RAW)));
+
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("SRC"),
ElemDesc::ATTRURL);
+ theResult.first->second.setAttr(XALAN_STATIC_UCODE_STRING("FOR"),
ElemDesc::ATTRURL);
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("NOSCRIPT"),
+
ElemDesc(0|ElemDesc::BLOCK|ElemDesc::BLOCKFORM|ElemDesc::BLOCKFORMFIELDSET)));
+
+ theElementFlags.insert(
+ ElementFlagsMapType::value_type(
+ XALAN_STATIC_UCODE_STRING("HTML"),
+ ElemDesc(0|ElemDesc::BLOCK)));
- return theSymbols;
+ return theElementFlags;
}
1.8 +213 -90 xml-xalan/c/src/XMLSupport/FormatterToHTML.hpp
Index: FormatterToHTML.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToHTML.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- FormatterToHTML.hpp 2000/05/15 15:52:49 1.7
+++ FormatterToHTML.hpp 2000/05/18 18:37:23 1.8
@@ -58,7 +58,7 @@
#define FORMATTERTOHTML_HEADER_GUARD_1357924680
/**
- * $Id: FormatterToHTML.hpp,v 1.7 2000/05/15 15:52:49 dbertoni Exp $
+ * $Id: FormatterToHTML.hpp,v 1.8 2000/05/18 18:37:23 dbertoni Exp $
*
* $State: Exp $
*
@@ -81,9 +81,16 @@
// Base class header file.
#include <XMLSupport/FormatterToXML.hpp>
+
+
+#include <PlatformSupport/DOMStringHelper.hpp>
+
+
+
#include <XPath/QName.hpp>
+
/**
* FormatterToHTML formats SAX-style events into HTML.
*/
@@ -92,19 +99,6 @@
public:
-#if defined(XALAN_NO_NAMESPACES)
-# define XALAN_STD
-#else
-# define XALAN_STD std::
-#endif
- typedef XALAN_STD set<XalanDOMString> EmptiesSetType;
- typedef XALAN_STD vector<XalanDOMString>
HTMLAttributesVectorType;
- typedef XALAN_STD vector<XalanDOMString> HTMLSymbolsVectorType;
- typedef XALAN_STD set<XalanDOMString> StringSetType;
- typedef XALAN_STD map<XalanDOMString, StringSetType> AttributesMapType;
-#undef XALAN_STD
-
-
/**
* Constructor for customized encoding and doctype.
* @param writer The character output stream to use.
@@ -114,15 +108,15 @@
*/
FormatterToHTML(
Writer& writer,
- const XalanDOMString& version,
- bool doIndent,
- int indent,
- const XalanDOMString& encoding,
- const XalanDOMString& mediaType,
- const XalanDOMString& doctypeSystem,
- const XalanDOMString& doctypePublic,
- bool xmlDecl,
- const XalanDOMString& standalone);
+ const XalanDOMString& encoding = XalanDOMString(),
+ const XalanDOMString& mediaType = XalanDOMString(),
+ const XalanDOMString& doctypeSystem =
XalanDOMString(),
+ const XalanDOMString& doctypePublic =
XalanDOMString(),
+ bool doIndent = true,
+ int indent
= 4,
+ const XalanDOMString& version = XalanDOMString(),
+ const XalanDOMString& standalone = XalanDOMString(),
+ bool xmlDecl =
false);
virtual
~FormatterToHTML();
@@ -134,9 +128,6 @@
startDocument();
virtual void
- endDocument();
-
- virtual void
startElement(
const XMLCh* const name,
AttributeList& attrs);
@@ -167,71 +158,215 @@
const XMLCh* const data);
+protected:
+
// These methods are new ...
+ /**
+ * Write an attribute string.
+ * @param string The string to write.
+ * @param encoding The current encoding.
+ */
+ virtual void
+ writeAttrString(
+ const XalanDOMChar* string,
+ const XalanDOMString& encoding);
+
+private:
+
+ class ElemDesc
+ {
+ public:
+
+ enum eFlags
+ {
+ EMPTY = (1 << 1),
+ FLOW = (1 << 2),
+ BLOCK = (1 << 3),
+ BLOCKFORM = (1 << 4),
+ BLOCKFORMFIELDSET = (1 << 5),
+ CDATA = (1 << 6),
+ PCDATA = (1 << 7),
+ RAW = (1 << 8),
+ INLINE = (1 << 9),
+ INLINEA = (1 << 10),
+ INLINELABEL = (1 << 11),
+ FONTSTYLE = (1 << 12),
+ PHRASE = (1 << 13),
+ FORMCTRL = (1 << 14),
+ SPECIAL = (1 << 15),
+ ASPECIAL = (1 << 16),
+ HEADMISC = (1 << 17),
+ HEAD = (1 << 18),
+ LIST = (1 << 19),
+ PREFORMATTED = (1 << 20),
+ WHITESPACESENSITIVE = (1 << 21),
+
+ ATTRURL = (1 << 1),
+ ATTREMPTY = (1 << 2)
+ };
+
+ ElemDesc(unsigned int flags = 0) :
+ m_flags(flags)
+ {
+ }
+
+ ~ElemDesc()
+ {
+ }
+
+ bool
+ is(unsigned int flags) const
+ {
+ return m_flags & flags ? true : false;
+ }
+
+ void
+ setAttr(
+ const XalanDOMString& name,
+ unsigned int flags)
+ {
+ m_attrs.insert(AttributeMapType::value_type(name,
flags));
+ }
+
+ bool
+ isAttrFlagSet(
+ const XalanDOMString& name,
+ unsigned int flags) const
+ {
+ const AttributeMapType::const_iterator i =
+ m_attrs.find(name);
+
+ if (i == m_attrs.end())
+ {
+ return false;
+ }
+ else
+ {
+ return i->second & flags ? true : false;
+ }
+ }
+
+ private:
+
+ #if defined(XALAN_NO_NAMESPACES)
+ typedef map<DOMString, unsigned int> AttributeMapType;
+ #else
+ typedef std::map<DOMString, unsigned int>
AttributeMapType;
+ #endif
+
+ const unsigned int m_flags;
+
+ AttributeMapType m_attrs;
+ };
+
+#if defined(XALAN_NO_NAMESPACES)
+ typedef map<DOMString, ElemDesc> ElementFlagsMapType;
+#else
+ typedef std::map<DOMString, ElemDesc> ElementFlagsMapType;
+#endif
+
+ static const ElementFlagsMapType s_elementFlags;
+
/**
- * Initialize the list of HTML elements that do not contain text, for
- * example, "BR"
- *
- * @return set of strings for elements
+ * Dummy description for elements not found.
*/
- static EmptiesSetType
- createEmpties();
+ static const ElemDesc s_dummyDesc;
/**
- * Initialize the list of attributes for HTML elements that do not
contain
- * text, for example, "checked."
- *
- * @return set of strings for elements
+ * The string "<!DOCTYPE HTML".
*/
- static EmptiesSetType
- createAttrEmpties();
+ static const XalanDOMCharVectorType
s_doctypeHeaderStartString;
/**
- * Initialize the list of entity reference names, for example, "nbsp."
- *
- * @return vector of strings
+ * The string " PUBLIC \"".
*/
- static HTMLAttributesVectorType
- createAttributes();
+ static const XalanDOMCharVectorType
s_doctypeHeaderPublicString;
/**
- * Initialize the list of HTML non-block elements, for example, "BR".
- * These are present alone and do not have the closing "/>" needed for
- * valid XML.
- *
- * @return vector of strings
+ * The string " SYSTEM".
*/
- static StringSetType
- createNonBlockElems();
+ static const XalanDOMCharVectorType
s_doctypeHeaderSystemString;
/**
- * Initialize the list of symbols that must be escaped, for example, "<"
- *
- * @return set of strings
+ * The string "SCRIPT".
*/
- static StringSetType
- createEscapeElems();
+ static const XalanDOMCharVectorType s_scriptString;
/**
- * Initialize the map of valid attributes for HTML tags. For example,
the
- * tag "A" can have attributes of "HREF" and "NAME"
- *
- * @return map of attributes to vector of tags
+ * The string "STYLE".
+ */
+ static const XalanDOMCharVectorType s_styleString;
+
+ /**
+ * The string "lt".
+ */
+ static const XalanDOMCharVectorType s_ltString;
+
+ /**
+ * The string "gt".
+ */
+ static const XalanDOMCharVectorType s_gtString;
+
+ /**
+ * The string "amp.
+ */
+ static const XalanDOMCharVectorType s_ampString;
+
+ /**
+ * The string "fnof".
*/
- static AttributesMapType
- createAttributesMap();
+ static const XalanDOMCharVectorType s_fnofString;
/**
- * Initialize the list of names for symbols, for example, "chi" for the
- * Greek letter Chi.
+ * Set the attribute characters what will require special mapping.
+ */
+ void
+ initAttrCharsMap();
+
+ /**
+ * Set the output characters what will require special mapping.
+ */
+ void
+ initCharsMap();
+
+ unsigned int
+ copyEntityIntoBuffer(
+ const XalanDOMChar* s,
+ unsigned int pos);
+
+ unsigned int
+ copyEntityIntoBuffer(
+ const XalanDOMString& s,
+ unsigned int pos)
+ {
+ return copyEntityIntoBuffer(c_wstr(s), pos);
+ }
+
+ unsigned int
+ copyEntityIntoBuffer(
+ const XalanDOMCharVectorType& s,
+ unsigned int pos)
+ {
+ return copyEntityIntoBuffer(c_wstr(s), pos);
+ }
+
+ /**
+ * Get an ElemDesc instance for the specified name.
*
- * @return vector of strings for symbol names
+ * @param name the name to search.
+ * @return a const reference to the ElemDesc instance.
*/
- static HTMLSymbolsVectorType
- createSymbols();
+ static const ElemDesc&
+ getElemDesc(const XalanDOMString& name);
-protected:
+ /**
+ * Initialize the map of element flags.
+ *
+ * @return map of element flags.
+ */
+ static ElementFlagsMapType
+ createElementFlagsMap();
/**
* Process an attribute.
@@ -241,39 +376,27 @@
virtual void
processAttribute(
const XalanDOMChar* name,
- const XalanDOMChar* value);
+ const XalanDOMChar* value,
+ const ElemDesc& elemDesc);
/**
- * Returns the specified <var>string</var> after substituting non ASCII
characters,
+ * Write the specified <var>string</var> after substituting non ASCII
characters,
* with <CODE>%HH</CODE>, where HH is the hex of the byte value.
*
* @param string String to convert to XML format.
* @param specials Chracters, should be represeted in chracter
referenfces.
* @param encoding CURRENTLY NOT IMPLEMENTED.
- * @return XML-formatted string.
- * @see #backReference
- * NOTE: return value destroyed on subsequent calls
- */
- const XalanDOMString
- prepAttrURI(
- const XalanDOMString& string,
- const XalanDOMString& specials,
- const XalanDOMString& encoding);
- // java: throws SAXException
-
-private:
+ */
+ void
+ writeAttrURI(
+ const XalanDOMChar* string,
+ const XalanDOMString encoding);
- static const EmptiesSetType s_empties;
- static const EmptiesSetType s_attrempties;
- static const HTMLAttributesVectorType s_HTMLlat1;
- static const HTMLSymbolsVectorType s_HTMLsymbol1;
- static const StringSetType s_nonblockelems;
- static const AttributesMapType s_attruris;
- static const StringSetType s_escapetb;
+ XalanDOMString m_currentElementName;
- XalanDOMString
m_currentElementName;
- bool m_inBlockElem;
+ bool m_inBlockElem;
+ BoolStackType m_isRawStack;
};
1.6 +2 -2 xml-xalan/c/src/XMLSupport/FormatterToText.cpp
Index: FormatterToText.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToText.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- FormatterToText.cpp 2000/03/21 03:22:45 1.5
+++ FormatterToText.cpp 2000/05/18 18:37:23 1.6
@@ -67,8 +67,8 @@
-FormatterToText::FormatterToText(
- Writer& pw) :
+FormatterToText::FormatterToText(Writer& pw) :
+ FormatterListener(OUTPUT_METHOD_TEXT),
m_pw(pw)
{
}
1.18 +929 -732 xml-xalan/c/src/XMLSupport/FormatterToXML.cpp
Index: FormatterToXML.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToXML.cpp,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- FormatterToXML.cpp 2000/05/15 15:52:48 1.17
+++ FormatterToXML.cpp 2000/05/18 18:37:23 1.18
@@ -10,33 +10,33 @@
* are met:
*
* 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
+ * notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
*
* 3. The end-user documentation included with the redistribution,
- * if any, must include the following acknowledgment:
- * "This product includes software developed by the
- * Apache Software Foundation (http://www.apache.org/)."
- * Alternately, this acknowledgment may appear in the software itself,
- * if and wherever such third-party acknowledgments normally appear.
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
- * not be used to endorse or promote products derived from this
- * software without prior written permission. For written
- * permission, please contact [EMAIL PROTECTED]
+ * not be used to endorse or promote products derived from this
+ * software without prior written permission. For written
+ * permission, please contact [EMAIL PROTECTED]
*
* 5. Products derived from this software may not be called "Apache",
- * nor may "Apache" appear in their name, without prior written
- * permission of the Apache Software Foundation.
+ * nor may "Apache" appear in their name, without prior written
+ * permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
@@ -61,10 +61,6 @@
-#include <string>
-
-
-
#include <sax/AttributeList.hpp>
#include <sax/SAXException.hpp>
@@ -74,80 +70,135 @@
#include <PlatformSupport/Writer.hpp>
+
+static XalanDOMChar theDefaultAttrSpecialChars[] = {'<', '>', '&',
'"', '\r', '\n' };
+
+
+const XalanDOMCharVectorType FormatterToXML::s_xsltNextIsRawString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("xslt-next-is-raw")));
+
+const XalanDOMCharVectorType FormatterToXML::s_formatterToDOMString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("formatter-to-dom")));
+
+const XalanDOMCharVectorType FormatterToXML::s_defaultMIMEEncoding =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("UTF-8")));
+
+const XalanDOMCharVectorType FormatterToXML::s_doctypeHeaderStartString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("<!DOCTYPE ")));
+
+const XalanDOMCharVectorType FormatterToXML::s_doctypeHeaderPublicString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("
PUBLIC \"")));
+
+const XalanDOMCharVectorType FormatterToXML::s_doctypeHeaderSystemString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("
SYSTEM \"")));
+
+const XalanDOMCharVectorType FormatterToXML::s_defaultVersionString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("1.0")));
-static XalanDOMString
theDefaultAttrSpecialChars(XALAN_STATIC_UCODE_STRING("<>&\"\r\n"));
+const XalanDOMCharVectorType FormatterToXML::s_xmlHeaderStartString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("<?xml
version=\"")));
+const XalanDOMCharVectorType FormatterToXML::s_xmlHeaderEncodingString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("\"
encoding=\"")));
-const XalanDOMString FormatterToXML::DEFAULT_MIME_ENCODING =
XALAN_STATIC_UCODE_STRING("UTF-8");
+const XalanDOMCharVectorType FormatterToXML::s_xmlHeaderStandaloneString =
+ MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("\"
standalone=\"")));
+const XalanDOMCharVectorType FormatterToXML::s_xmlHeaderEndString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("\"?>")));
-XalanDOMChar FormatterToXML::m_charBuf[MAXCHARBUF];
+const XalanDOMCharVectorType FormatterToXML::s_windows1250EncodingString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("WINDOWS-1250")));
-// This should be OK on all platforms ??
-XalanDOMChar FormatterToXML::m_lineSep =
'\n';
+const XalanDOMCharVectorType FormatterToXML::s_usASCIIEncodingString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("US-ASCII")));
-bool
FormatterToXML::m_javaEncodingIsISO = false;
+const XalanDOMCharVectorType FormatterToXML::s_asciiEncodingString =
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("ASCII")));
+const XalanDOMCharVectorType FormatterToXML::s_utf8EncodingString=
+
MakeXalanDOMCharVector(c_wstr(XALAN_STATIC_UCODE_STRING("UTF-8")));
+XalanDOMChar FormatterToXML::s_lineSep = '\n';
+
+
+bool
FormatterToXML::s_javaEncodingIsISO = false;
+
+
+const FormatterToXML::DOMCharBufferType::size_type
FormatterToXML::s_maxBufferSize = 8 * 1024;
+
+
FormatterToXML::FormatterToXML(
- Writer& writer,
- const XalanDOMString& /* version */,
- bool doIndent,
- int indent,
- const XalanDOMString& encoding,
- const XalanDOMString& /*mediaType */,
- const XalanDOMString& doctypeSystem,
- const XalanDOMString& doctypePublic,
- bool xmlDecl,
- const XalanDOMString& standalone) :
- FormatterListener(),
- m_attrSpecialChars(theDefaultAttrSpecialChars),
- m_currentIndent(0),
- m_doctypePublic(doctypePublic),
- m_doctypeSystem(doctypeSystem),
- m_doIndent(doIndent),
- m_elemStack(),
- m_encoding(encoding),
- m_standalone(standalone),
- m_escapeCData(false),
- m_indent(indent),
+ Writer& writer,
+ const XalanDOMString& version,
+ bool doIndent,
+ int indent,
+ const XalanDOMString& encoding,
+ const XalanDOMString& mediaType,
+ const XalanDOMString& doctypeSystem,
+ const XalanDOMString& doctypePublic,
+ bool xmlDecl,
+ const XalanDOMString& standalone,
+ eFormat format) :
+ FormatterListener(format),
+ m_writer(writer),
+ m_maxCharacter(0x7Fu),
+ m_attrCharsMap(),
+ m_charsMap(),
+ m_shouldWriteXMLHeader(xmlDecl),
m_ispreserve(false),
- m_isprevtext(false),
- m_level(0),
- m_maxCharacter(0x007F),
+ m_doIndent(doIndent),
+ m_startNewLine(false),
m_needToOutputDocTypeDecl(true),
+ m_isprevtext(false),
+ m_stripCData(false),
m_nextIsRaw(false),
+ m_inCData(false),
+ m_isUTF8(false),
+ m_doctypeSystem(doctypeSystem),
+ m_doctypePublic(doctypePublic),
+ m_encoding(isEmpty(encoding) == false ? encoding :
+ XalanDOMString(&s_defaultMIMEEncoding[0],
s_defaultMIMEEncoding.size() - 1)),
+ m_currentIndent(0),
+ m_indent(indent),
m_preserves(),
- m_shouldWriteXMLHeader(xmlDecl),
+ m_shouldFlush(true),
+ m_bytesEqualChars(false),
m_spaceBeforeClose(false),
- m_startNewLine(true),
- m_stripCData(false),
- m_version(),
- m_writer(writer)
+ m_escapeCData(false),
+ m_inEntityRef(false),
+ m_version(version),
+ m_standalone(standalone),
+ m_mediaType(mediaType),
+ m_attrSpecialChars(theDefaultAttrSpecialChars),
+ m_charBuf(s_maxBufferSize),
+ m_byteBuf(s_maxBufferSize),
+ m_pos(0),
+ m_level(0),
+ m_elemStack()
{
- if(! isEmpty(m_doctypePublic))
+ initCharsMap();
+
+ if(isEmpty(m_doctypePublic) == false)
{
- if(startsWith(m_doctypePublic,
XALAN_STATIC_UCODE_STRING("-//W3C//DTD XHTML")))
+ if(startsWith(
+ m_doctypePublic,
+ XALAN_STATIC_UCODE_STRING("-//W3C//DTD XHTML")) == true)
+ {
m_spaceBeforeClose = true;
+ }
}
- // Determine the last printable character based on the output format
- // @@ JMD: We don't have no OutputFormat class yet ...
- // java: m_maxCharacter = format.getLastPrintable();
+ m_isUTF8 = equals(m_encoding, s_utf8EncodingString); // ||
isEmpty(m_encoding);
- m_isUTF8 = equals(m_encoding, XALAN_STATIC_UCODE_STRING("UTF-8")) ||
isEmpty(m_encoding);
- if(isEmpty(m_encoding))
+ if (equals(m_encoding, s_windows1250EncodingString) == true ||
+ equals(m_encoding, s_usASCIIEncodingString) == true ||
+ equals(m_encoding, s_asciiEncodingString) == true)
{
-/*
- @@ JMD: Not supported yet:
- java:
- encoding = System.getProperty("file.encoding");
- encoding = (null != encoding) ?
- FormatterToXML.convertJava2MimeEncoding(encoding ) :
DEFAULT_MIME_ENCODING;
-*/
- m_encoding = DEFAULT_MIME_ENCODING;
+ m_bytesEqualChars = true;
}
+#if 0
DOMString2IntMapType::const_iterator it =
s_revsize.find(toUpperCase(m_encoding));
@@ -157,8 +208,9 @@
it = s_revsize.find(toUpperCase(m_encoding));
if (it != s_revsize.end())
{
- m_maxCharacter = (*it).second;
+ m_maxCharacter = (*it).second;
}
+#endif
}
@@ -170,26 +222,406 @@
void
-FormatterToXML::setDocumentLocator(const Locator* const /*
locator */)
+FormatterToXML::initAttrCharsMap()
{
- // I don't do anything with this yet.
+ memset(m_attrCharsMap, 0, sizeof(m_attrCharsMap));
+
+ const unsigned int nSpecials = length(m_attrSpecialChars);
+
+ for(unsigned int i = 0; i < nSpecials; ++i)
+ {
+ m_attrCharsMap[charAt(m_attrSpecialChars, i)] = 'S';
+ }
+
+ m_attrCharsMap[0x0A] = 'S';
+ m_attrCharsMap[0x0D] = 'S';
}
+void
+FormatterToXML::initCharsMap()
+{
+ initAttrCharsMap();
+
+ memset(m_charsMap, 0, sizeof(m_charsMap));
+ m_charsMap['\n'] = 'S';
+ m_charsMap['<'] = 'S';
+ m_charsMap['>'] = 'S';
+ m_charsMap['&'] = 'S';
+
+ memset(m_charsMap, 'S', 20);
+
+ m_charsMap[0x0A] = 'S';
+ m_charsMap[0x0D] = 'S';
+ m_charsMap[9] = '\0';
+
+ for(int i = m_maxCharacter; i < SPECIALSSIZE; ++i)
+ {
+ m_charsMap[i] = 'S';
+ }
+}
+
+
+
void
+FormatterToXML::outputDocTypeDecl(const XalanDOMString& name)
+{
+ accum(s_doctypeHeaderStartString); // "<!DOCTYPE "
+
+ accum(name);
+
+ if(length(m_doctypePublic) != 0)
+ {
+ accum(s_doctypeHeaderPublicString); // " PUBLIC \""
+ accum(m_doctypePublic);
+ accum('"');
+ accum(' ');
+ accum('"');
+ }
+ else
+ {
+ accum(s_doctypeHeaderSystemString); // " SYSTEM \""
+ }
+
+ accum(m_doctypeSystem);
+ accum('"');
+ accum('>');
+
+ outputLineSep();
+}
+
+
+
+void
+FormatterToXML::accum(char ch)
+{
+ if(m_bytesEqualChars == true)
+ {
+ m_byteBuf[m_pos++] = ch;
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushBytes();
+ }
+ }
+ else
+ {
+ m_charBuf[m_pos++] = ch;
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushChars();
+ }
+ }
+}
+
+
+
+void
+FormatterToXML::accum(XalanDOMChar ch)
+{
+ if(m_bytesEqualChars == true)
+ {
+ m_byteBuf[m_pos++] =
static_cast<ByteBufferType::value_type>(ch);
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushBytes();
+ }
+ }
+ else
+ {
+ m_charBuf[m_pos++] = ch;
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushChars();
+ }
+ }
+}
+
+
+
+void
+FormatterToXML::accum(
+ const XalanDOMChar chars[],
+ unsigned int start,
+ unsigned int length)
+{
+ const DOMCharBufferType::size_type n = start + length;
+
+ if(m_bytesEqualChars == true)
+ {
+ for(DOMCharBufferType::size_type i = start; i < n; ++i)
+ {
+ m_byteBuf[m_pos++] =
static_cast<ByteBufferType::value_type>(chars[i]);
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushBytes();
+ }
+ }
+ }
+ else
+ {
+ for(DOMCharBufferType::size_type i = start; i < n; ++i)
+ {
+ m_charBuf[m_pos++] = chars[i];
+
+ if(m_pos == s_maxBufferSize)
+ {
+ flushChars();
+ }
+ }
+ }
+}
+
+
+
+void
+FormatterToXML::accum(const XalanDOMString& str)
+{
+ accum(c_wstr(str), 0, length(str));
+}
+
+
+
+void
+FormatterToXML::accum(const XalanDOMCharVectorType& theVector)
+{
+ accum(c_wstr(theVector), 0, theVector.size() - 1);
+}
+
+
+
+void
+FormatterToXML::throwInvalidUTF16SurrogateException(XalanDOMChar ch)
+{
+ const XalanDOMString theMessage("Invalid UTF-16 surrogate detected:
" +
+
UnsignedLongToHexDOMString(ch) +
+ "
?");
+
+ throw SAXException(c_wstr(theMessage));
+}
+
+
+
+void
+FormatterToXML::throwInvalidUTF16SurrogateException(
+ XalanDOMChar ch,
+ unsigned int next)
+{
+ const XalanDOMString theMessage("Invalid UTF-16 surrogate detected:
" +
+
UnsignedLongToHexDOMString(ch) +
+
UnsignedLongToHexDOMString(next) +
+ "
?");
+
+ throw SAXException(c_wstr(theMessage));
+}
+
+
+
+void
+FormatterToXML::accumDefaultEscape(
+ XalanDOMChar ch,
+ unsigned int i,
+ const XalanDOMChar chars[],
+ unsigned int len,
+ bool escLF)
+{
+ if(!accumDefaultEntity(ch, i, chars, len, escLF))
+ {
+ if (0xd800 <= ch && ch < 0xdc00)
+ {
+ // UTF-16 surrogate
+ unsigned int next = 0;
+
+ if (i + 1 >= len)
+ {
+ throwInvalidUTF16SurrogateException(ch);
+ }
+ else
+ {
+ next = chars[++i];
+
+ if (!(0xdc00 <= next && next < 0xe000))
+ {
+ throwInvalidUTF16SurrogateException(ch,
next);
+ }
+
+ next = ((ch-0xd800) << 10) + next - 0xdc00 +
0x00010000;
+ }
+
+ writeNumberedEntityReference(next);
+ }
+ else
+ {
+ if(ch > m_maxCharacter || (ch < SPECIALSSIZE &&
m_attrCharsMap[ch] == 'S'))
+ {
+ writeNumberedEntityReference(ch);
+ }
+ else
+ {
+ accum(ch);
+ }
+ }
+ }
+}
+
+
+
+bool
+FormatterToXML::accumDefaultEntity(
+ XalanDOMChar ch,
+ unsigned int i,
+ const XalanDOMChar chars[],
+ unsigned int len,
+ bool escLF)
+{
+ if (escLF == false &&
+ 0x0D == ch &&
+ i + 1 < len &&
+ 0x0A == chars[i + 1])
+ {
+ outputLineSep();
+
+ i++;
+ }
+ else if (escLF == false &&
+ 0x0A == ch &&
+ i + 1 < len &&
+ 0x0D == chars[i + 1])
+ {
+ outputLineSep();
+
+ i++;
+ }
+ else if (escLF == false && 0x0D == ch)
+ {
+ outputLineSep();
+
+ i++;
+ }
+ else if (escLF == false && '\n' == ch)
+ {
+ outputLineSep();
+ }
+ else if ('<' == ch)
+ {
+ accum('&');
+ accum('l');
+ accum('t');
+ accum(';');
+ }
+ else if ('>' == ch)
+ {
+ accum('&');
+ accum('g');
+ accum('t');
+ accum(';');
+ }
+ else if ('&' == ch)
+ {
+ accum('&');
+ accum('a');
+ accum('m');
+ accum('p');
+ accum(';');
+ }
+ else if ('"' == ch)
+ {
+ accum('&');
+ accum('q');
+ accum('u');
+ accum('o');
+ accum('t');
+ accum(';');
+ }
+ else if ('\'' == ch)
+ {
+ accum('&');
+ accum('a');
+ accum('p');
+ accum('o');
+ accum('s');
+ accum(';');
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+}
+
+
+
+void
+FormatterToXML::flushBytes()
+{
+ m_writer.write(&m_byteBuf[0], 0, m_pos);
+
+ m_pos = 0;
+}
+
+
+
+void
+FormatterToXML::flushChars()
+{
+ m_writer.write(&m_charBuf[0], 0, m_pos);
+
+ m_pos = 0;
+}
+
+
+
+void
+FormatterToXML::flush()
+{
+ if(m_bytesEqualChars == true)
+ {
+ flushBytes();
+ }
+ else
+ {
+ flushChars();
+ }
+}
+
+
+
+void
+FormatterToXML::flushWriter()
+{
+ m_writer.flush();
+}
+
+
+
+void
+FormatterToXML::setDocumentLocator(const Locator* const /* locator */)
+{
+ // I don't do anything with this yet.
+}
+
+
+
+void
FormatterToXML::startDocument()
{
- try
+ if(m_inEntityRef == false)
{
m_needToOutputDocTypeDecl = true;
m_startNewLine = false;
- if(m_shouldWriteXMLHeader)
+ if(m_shouldWriteXMLHeader == true)
{
- XalanDOMString encoding = m_encoding;
- if(isEmpty(encoding))
+ XalanDOMString encoding = m_encoding;
+
+ if(isEmpty(encoding) == true)
{
/*
java:
@@ -205,28 +637,31 @@
*/
encoding =
XALAN_STATIC_UCODE_STRING("ISO-8859-1");
}
+
+ accum(s_xmlHeaderStartString); // "<?xml version=\""
- XalanDOMString version = (isEmpty(m_version)) ?
XALAN_STATIC_UCODE_STRING("1.0") : m_version;
+ if (length(m_version) != 0)
+ {
+ accum(m_version);
+ }
+ else
+ {
+ accum(s_defaultVersionString);
+ }
- m_writer.write(XALAN_STATIC_UCODE_STRING("<?xml
version=\""));
- m_writer.write(version);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\"
encoding=\""));
- m_writer.write(encoding);
+ accum(s_xmlHeaderEncodingString); // "\"
encoding=\""
+ accum(encoding);
if (length(m_standalone) != 0)
{
- m_writer.write(XALAN_STATIC_UCODE_STRING("\"
standalone=\""));
- m_writer.write(m_standalone);
+ accum(s_xmlHeaderStandaloneString);
+ accum(m_standalone);
}
- m_writer.write(XALAN_STATIC_UCODE_STRING("\"?>"));
- m_writer.write(m_lineSep);
- }
- }
- // java: catch(IOException ioe)
- catch(...)
- {
- throw SAXException("IO error");
+ accum(s_xmlHeaderEndString);
+
+ outputLineSep();
+ }
}
}
@@ -235,14 +670,13 @@
void
FormatterToXML::endDocument()
{
- try
+ if(m_doIndent == true && m_isprevtext == false)
{
- m_writer.flush();
+ outputLineSep();
}
- catch(...)
- {
- throw SAXException();
- }
+
+ flush();
+ flushWriter();
}
@@ -252,43 +686,38 @@
const XMLCh* const name,
AttributeList& attrs)
{
- try
+ if(m_inEntityRef == false)
{
- if((true == m_needToOutputDocTypeDecl) && (!
isEmpty(m_doctypeSystem)))
+ if(true == m_needToOutputDocTypeDecl &&
+ isEmpty(m_doctypeSystem) == false)
{
- m_writer.write(XALAN_STATIC_UCODE_STRING("<!DOCTYPE "));
- m_writer.write(name);
- if(! isEmpty(m_doctypePublic))
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING("
PUBLIC \""));
- m_writer.write(m_doctypePublic);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- if(isEmpty(m_doctypePublic))
- m_writer.write(XALAN_STATIC_UCODE_STRING("
SYSTEM \""));
- else
- m_writer.write(XALAN_STATIC_UCODE_STRING("
\""));
- m_writer.write(m_doctypeSystem);
- m_writer.write(XALAN_STATIC_UCODE_STRING("\">"));
- m_writer.write(m_lineSep);
+ outputDocTypeDecl(name);
+
+ m_needToOutputDocTypeDecl = false;
}
- m_needToOutputDocTypeDecl = false;
+
writeParentTagEnd();
+
m_ispreserve = false;
- if (shouldIndent() && m_startNewLine)
+
+ if (shouldIndent() == true &&
+ m_startNewLine == true)
{
- indent(m_writer, m_currentIndent);
+ indent(m_currentIndent);
}
+
m_startNewLine = true;
+
+ accum('<');
+ accum(name);
- m_writer.write('<');
- m_writer.write(name);
+ const unsigned int nAttrs = attrs.getLength();
- int nAttrs = attrs.getLength();
- for (int i = 0; i < nAttrs ; i++)
+ for (unsigned int i = 0; i < nAttrs ; i++)
{
processAttribute(attrs.getName(i), attrs.getValue(i));
}
+
// Flag the current element as not yet having any children.
openElementForChildren();
@@ -296,11 +725,6 @@
m_isprevtext = false;
}
- // java: catch(IOException ioe)
- catch(...)
- {
- throw SAXException("IO error");
- }
}
@@ -308,45 +732,91 @@
void
FormatterToXML::endElement(const XMLCh* const name)
{
- try
+ m_currentIndent -= m_indent;
+
+ const bool hasChildNodes = childNodesWereAdded();
+
+ if (hasChildNodes == true)
{
- m_currentIndent -= m_indent;
+ if (shouldIndent() == true)
+ {
+ indent(m_currentIndent);
+ }
+
+ accum('<');
+ accum('/');
+ accum(name);
+ }
+ else
+ {
+ if(m_spaceBeforeClose == true)
+ {
+ accum(' ');
+ }
+
+ accum('/');
+ }
- const bool hasChildNodes = childNodesWereAdded();
+ accum('>');
- if (hasChildNodes == true)
+ if (hasChildNodes == true)
+ {
+ if (m_preserves.size() == 0)
{
- if (shouldIndent() == true)
- indent(m_writer, m_currentIndent);
- m_writer.write(XALAN_STATIC_UCODE_STRING("</"));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
+ m_ispreserve = false;
}
else
{
- if(m_spaceBeforeClose)
- m_writer.write(XALAN_STATIC_UCODE_STRING("
/>"));
- else
- m_writer.write(XALAN_STATIC_UCODE_STRING("/>"));
+ m_ispreserve = m_preserves.top();
+
+ m_preserves.pop();
}
+ }
- if (hasChildNodes == true)
+ m_isprevtext = false;
+}
+
+
+
+void
+FormatterToXML::processingInstruction(
+ const XMLCh* const target,
+ const XMLCh* const data)
+{
+ if(m_inEntityRef == false)
+ {
+ // Use a fairly nasty hack to tell if the next node is supposed
to be
+ // unescaped text.
+ if(equals(target, c_wstr(s_xsltNextIsRawString)) == true
+ && equals(data, c_wstr(s_formatterToDOMString)) == true)
+ {
+ m_nextIsRaw = true;
+ }
+ else
{
- if (m_preserves.size() == 0)
+ writeParentTagEnd();
+
+ if (shouldIndent() == true)
{
- m_ispreserve = false;
+ indent(m_currentIndent);
}
- else
+
+ accum('<');
+ accum('?');
+ accum(target);
+
+ if (length(data) > 0 && !isSpace(data[0]))
{
- m_ispreserve = m_preserves.top();
- m_preserves.pop();
+ accum(' ');
}
+
+ accum(data);
+
+ accum('?');
+ accum('>');
+
+ m_startNewLine = true;
}
- m_isprevtext = false;
- }
- catch(...)
- {
- throw SAXException();
}
}
@@ -357,223 +827,222 @@
const XMLCh* const chars,
const unsigned int length)
{
- if(0 == length)
- return;
-
- if(m_nextIsRaw)
+ if(m_inEntityRef == false && length != 0)
{
- m_nextIsRaw = false;
- charactersRaw (chars, length);
- return;
- }
-
- try
- {
- writeParentTagEnd();
- m_ispreserve = true;
- int pos = 0;
- int end = length;
- for (int i = 0; i < end; i ++)
+ if(m_inCData == true)
{
- const XMLCh ch = chars[i];
- const int chNum = ch;
- if ('\n' == ch)
- {
- m_charBuf[pos++] = m_lineSep;
- }
- else if ('<' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("lt"), pos);
- }
- else if ('>' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("gt"), pos);
- }
- else if ('&' == ch)
- {
- pos =
copyEntityIntoBuf(XALAN_STATIC_UCODE_STRING("amp"), pos);
- }
- // Regular old ASCII character
- else if((((chNum >= 20) && (chNum <= 126))
- || (chNum == 10)
- || (chNum == 13)
- || (chNum == 9)))
- {
- // System.out.println("ch: "+ch);
- m_charBuf[pos++] = ch;
- }
- else if((chNum >= 20) && (ch <= m_maxCharacter))
- {
- // System.out.println("ch(2): "+ch);
- // Hope this is right...
- m_charBuf[pos++] = ch;
- }
- else
+ cdata(chars, length);
+ }
+ else if(m_nextIsRaw)
+ {
+ m_nextIsRaw = false;
+
+ charactersRaw(chars, length);
+ }
+ else
+ {
+ writeParentTagEnd();
+
+ m_ispreserve = true;
+
+ for (unsigned int i = 0; i < length; ++i)
{
- copyBigCharIntoBuf(chars, i, pos, length);
+ const XalanDOMChar ch = chars[i];
+
+ if(ch < SPECIALSSIZE && m_charsMap[ch] != 'S')
+ {
+ accum(ch);
+ }
+ else
+ {
+ accumDefaultEscape(ch, i, chars,
length, false);
+ }
}
- // Use 80 as a best guess safe buffer
- if(pos > MAXSAFECHARBUF)
+
+ if (m_isprevtext == false)
{
- m_writer.write(m_charBuf, 0, pos);
- pos = 0;
+ m_isprevtext = true;
}
}
-
- // System.out.println(new String(m_charBuf, 0, pos));
- m_writer.write(m_charBuf, 0, pos);
- m_isprevtext = true;
- }
- // java: catch(IOException ioe)
- catch(...)
- {
- throw SAXException("IO error");
}
-
}
+
+
void
FormatterToXML::charactersRaw(
const XMLCh* const chars,
const unsigned int length)
{
- try
+ if(m_inEntityRef == false)
{
writeParentTagEnd();
+
m_ispreserve = true;
- m_writer.write(chars, 0, length);
- m_writer.flush();
- }
- // java: catch(IOException ioe)
- catch(...)
- {
- throw SAXException();
+
+ accum(chars, 0, length);
}
}
-void FormatterToXML::copyBigCharIntoBuf(
- const XMLCh* const chars, // Character
string to process
- int& i,
// Index into 'chars'
- int& pos,
// Index in m_charBuf
- int length,
// Length of 'chars' string
- XalanDOMChar* theBuffer /* m_charBuf */
// Buffer to write to
- )
-/*
- * Processes a non-ASCII character either in hexadecimal format (&#Xnnn;) if
- * the character is in the range 0xd800 to 0xdc00 or decimal format (&#nnn;),
- * and places the result in member 'm_charBuf.' Side effect, indices 'i' and
- * 'pos' are incremented. On exit, 'theBuffer' will contain a null
terminated
- * Unicode string.
- */
+
+
+void
+FormatterToXML::writeAttrString(
+ const XalanDOMChar* string,
+ const XalanDOMString& /* encoding */)
{
- XalanDOMString msg(XALAN_STATIC_UCODE_STRING("Invalid UTF-16 surrogate
detected: "));
- XalanDOMString ds;
+ const unsigned int len = length(string);
- const int c = chars[i];
+ for (unsigned int i = 0; i < len; i ++)
+ {
+ const XalanDOMChar ch = string[i];
- if (0xd800 <= c && c < 0xdc00)
- {
- // UTF-16 surrogate
- int next;
- if (i+1 >= length)
- {
- msg = append(msg, LongToHexDOMString(c));
- msg = append(msg, XALAN_STATIC_UCODE_STRING(" ?"));
- throw SAXException(c_wstr(msg));
- }
- else
+ if(ch < SPECIALSSIZE &&
+ m_attrCharsMap[ch] != 'S')
{
- next = chars[++i];
- if (!(0xdc00 <= next && next < 0xe000))
- {
- msg = append(msg, LongToHexDOMString(c));
- msg = append(msg, XALAN_STATIC_UCODE_STRING("
"));
- msg = append(msg, LongToHexDOMString(next));
- throw SAXException(c_wstr(msg));
- }
- next = ((c-0xd800)<<10)+next-0xdc00+0x00010000;
- }
- theBuffer[pos++] = '&';
- theBuffer[pos++] = '#';
- theBuffer[pos++] = 'x';
- ds = LongToHexDOMString(next);
- const XalanDOMChar* pb = c_wstr(ds);
- int nIntStr = ds.length();
- for(int k = 0; k < nIntStr; k++)
- {
- theBuffer[pos++] = *(pb+k);
+ accum(ch);
}
- theBuffer[pos++] = ';';
- }
- else
- {
- theBuffer[pos++] = '&';
- theBuffer[pos++] = '#';
- ds = LongToDOMString(c);
- const XalanDOMChar* pb = c_wstr(ds);
- int nIntStr = ds.length();
- for(int k = 0; k < nIntStr; k++)
+ else
{
- theBuffer[pos++] = *(pb+k);
+ accumDefaultEscape(ch, i, string, len, true);
}
- theBuffer[pos++] = ';';
- }
- theBuffer[pos] = 0; // null terminate
+ }
}
-void FormatterToXML::writeBigChar(const XalanDOMChar* const ch, int& i, int
end)
-/*
- * Writes a non-ASCII character either in hexadecimal format (&#Xnnn;) if the
- * character is in the range 0xd800 to 0xdc00 or decimal format (&#nnn;); as
a
- * side effect the current character index (i) is incremented
- */
-{
- XalanDOMChar buffer[32]; // Should be big enough
- int pos = 0;
- copyBigCharIntoBuf(ch, i, pos, end, buffer);
- m_writer.write(buffer);
-}
+
-void FormatterToXML::writeNormalizedChars(
- const XalanDOMChar* const ch,
- int start, int length,
- bool isCData)
+void
+FormatterToXML::writeNormalizedChars(
+ const XalanDOMChar ch[],
+ unsigned int start,
+ unsigned int length,
+ bool isCData)
{
- int end = start+length;
- for(int i = start; i < end; i++)
- {
- XalanDOMChar c = ch[i];
- if('\n' == c)
+ unsigned int end = start + length;
+
+ for(unsigned int i = start; i < end; i++)
+ {
+ const XalanDOMChar c = ch[i];
+
+ if (0x0D == c &&
+ i + 1 < end &&
+ 0x0A == ch[i + 1])
+ {
+ outputLineSep();
+
+ i++;
+ }
+ else if (0x0A == c &&
+ i + 1 < end &&
+ 0x0D == ch[i + 1])
+ {
+ outputLineSep();
+
+ i++;
+ }
+ else if('\n' == c)
{
- m_writer.write(m_lineSep);
+ outputLineSep();
}
- else if(isCData && (c > m_maxCharacter))
+ else if(isCData == true && c > m_maxCharacter)
{
if(i != 0)
-
m_writer.write(XALAN_STATIC_UCODE_STRING("]]>"));
- writeBigChar(ch, i, end);
- // @@ JMD: this differs from java
- // java: if((i != 0) && (i < (end-1)))
- if( (i < (end-1)))
-
m_writer.write(XALAN_STATIC_UCODE_STRING("<![CDATA["));
+ {
+ accum(XALAN_STATIC_UCODE_STRING("]]>"));
+ }
+
+ // This needs to go into a function...
+ if (0xd800 <= ((int)c) && ((int)c) < 0xdc00)
+ {
+ // UTF-16 surrogate
+ unsigned int next = 0;
+
+ if (i + 1 >= end)
+ {
+ throwInvalidUTF16SurrogateException(c);
+ }
+ else
+ {
+ next = ch[++i];
+
+ if (!(0xdc00 <= next && next < 0xe000))
+ {
+
throwInvalidUTF16SurrogateException(c, next);
+ }
+
+ next = ((c-0xd800) << 10) + next -
0xdc00 + 0x00010000;
+ }
+
+ writeNumberedEntityReference(next);
+ }
+ else
+ {
+ writeNumberedEntityReference(c);
+ }
+
+ if(i != 0 && i < end - 1)
+ {
+ accum(XALAN_STATIC_UCODE_STRING("<![CDATA["));
+ }
}
- else if(isCData && ((i < (end-2)) && (']' == c) &&
- (']' == ch[i+1]) && ('>' == ch[i+2])))
+ else if(isCData == true &&
+ i < end - 2 &&
+ ']' == c &&
+ ']' == ch[i + 1] &&
+ '>' == ch[ i + 2])
{
-
m_writer.write(XALAN_STATIC_UCODE_STRING("]]]]><![CDATA[>"));
- i+=2;
+ accum(XALAN_STATIC_UCODE_STRING("]]]]><![CDATA[>"));
+
+ i += 2;
}
else
{
if(c <= m_maxCharacter)
+ {
+ accum(c);
+ }
+ // This needs to go into a function...
+ else if (0xd800 <= c && c < 0xdc00)
{
- m_writer.write(c);
+ // UTF-16 surrogate
+ unsigned int next = 0;
+
+ if (i + 1 >= end)
+ {
+ throwInvalidUTF16SurrogateException(c);
+ }
+ else
+ {
+ next = ch[++i];
+
+ if (!(0xdc00 <= next && next < 0xe000))
+ {
+
throwInvalidUTF16SurrogateException(c, next);
+ }
+
+ next = ((c - 0xd800) << 10) + next -
0xdc00 + 0x00010000;
+ }
+
+ writeNumberedEntityReference(next);
}
else
- writeBigChar(ch, i, end);
+ {
+ writeNumberedEntityReference(c);
+ }
}
- }
+ }
+}
+
+
+
+void
+FormatterToXML::writeNumberedEntityReference(unsigned long theNumber)
+{
+ accum('&');
+ accum('#');
+ accum(UnsignedLongToDOMString(theNumber));
+ accum(';');
}
@@ -581,23 +1050,16 @@
void
FormatterToXML::entityReference(const XMLCh* const name)
{
- try
- {
- writeParentTagEnd();
+ writeParentTagEnd();
- if (shouldIndent() == true)
- {
- indent(m_writer, m_currentIndent);
- }
-
- m_writer.write(XALAN_STATIC_UCODE_STRING("&"));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING(";"));
- }
- catch(...)
+ if (shouldIndent() == true)
{
- throw SAXException();
+ indent(m_currentIndent);
}
+
+ m_writer.write('&');
+ m_writer.write(name);
+ m_writer.write(';');
}
@@ -606,66 +1068,10 @@
FormatterToXML::ignorableWhitespace(
const XMLCh* const chars,
const unsigned int length)
-{
- characters(chars, length);
-}
-
-void
-FormatterToXML::processingInstruction(
- const XMLCh* const target,
- const XMLCh* const data)
-{
- processingInstruction( target, data, false);
-}
-
-void
-FormatterToXML::processingInstruction(
- const XMLCh* const target,
- const XMLCh* const data,
- bool isHTML)
{
-// @@ Need to add this --
-// if(m_inEntityRef)
-// return;
-
- // Use a fairly nasty hack to tell if the next node is supposed to be
- // unescaped text.
- if(equals(target, XALAN_STATIC_UCODE_STRING("xslt-next-is-raw"))
- && equals(data, XALAN_STATIC_UCODE_STRING("formatter-to-dom")))
- {
- m_nextIsRaw = true;
- }
- else
+ if (length > 0)
{
- try
- {
- writeParentTagEnd();
-
- if (shouldIndent() == true)
- {
- indent(m_writer, m_currentIndent);
- }
-
- m_writer.write(XALAN_STATIC_UCODE_STRING("<?"));
- m_writer.write(target);
-
- if (length(data) > 0 && !isSpace(data[0]))
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(" "));
- }
-
- m_writer.write(data);
- if (isHTML)
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- else
- m_writer.write(XALAN_STATIC_UCODE_STRING("?>"));
-
- m_startNewLine = true;
- }
- catch(...)
- {
- throw SAXException();
- }
+ characters(chars, length);
}
}
@@ -682,25 +1088,28 @@
void
FormatterToXML::comment(const XMLCh* const data)
{
- try
+ if(m_inEntityRef == false)
{
writeParentTagEnd();
if (shouldIndent() == true)
{
- indent(m_writer, m_currentIndent);
+ indent(m_currentIndent);
}
- m_writer.write(XALAN_STATIC_UCODE_STRING("<!--"));
- m_writer.write(data);
- m_writer.write(XALAN_STATIC_UCODE_STRING("-->"));
+ accum('<');
+ accum('!');
+ accum('-');
+ accum('-');
+ accum(data);
+
+ accum('-');
+ accum('-');
+ accum('>');
+
m_startNewLine = true;
}
- catch(...)
- {
- throw SAXException();
- }
}
@@ -708,17 +1117,16 @@
void
FormatterToXML::cdata(
const XMLCh* const ch,
- const unsigned int length)
+ const unsigned int length)
{
+ if(m_nextIsRaw == true)
+ {
+ m_nextIsRaw = false;
- try
+ charactersRaw(ch, length);
+ }
+ else
{
- if(m_nextIsRaw)
- {
- m_nextIsRaw = false;
- charactersRaw (ch, length);
- return;
- }
if(m_escapeCData) // Should normally always be false.
{
characters(ch, length);
@@ -726,32 +1134,37 @@
else
{
writeParentTagEnd();
+
m_ispreserve = true;
- if (shouldIndent())
- indent(m_writer, m_currentIndent);
- if(!m_stripCData)
+
+ if (shouldIndent() == true)
{
- if(((length >= 1) && (ch[0] <= m_maxCharacter)))
+ indent(m_currentIndent);
+ }
+
+ if(m_stripCData == false)
+ {
+ if(length >= 1 &&
+ ch[0] <= m_maxCharacter)
{
-
m_writer.write(XALAN_STATIC_UCODE_STRING("<![CDATA["));
+
accum(XALAN_STATIC_UCODE_STRING("<![CDATA["));
}
}
- // m_writer.write(ch, 0, length);
+
writeNormalizedChars(ch, 0, length, !m_stripCData);
- if(!m_stripCData)
+
+ if(m_stripCData == false)
{
- if(((length >= 1) && (ch[(length)-1] <=
m_maxCharacter)))
+ if(length >= 1 &&
+ ch[length - 1] <= m_maxCharacter)
{
-
m_writer.write(XALAN_STATIC_UCODE_STRING("]]>"));
+ accum(']');
+ accum(']');
+ accum('>');
}
}
}
}
- // java: catch(IOException ioe)
- catch(...)
- {
- throw SAXException("IO error");
- }
}
@@ -759,31 +1172,24 @@
void
FormatterToXML::writeParentTagEnd()
{
- try
+ if(!m_elemStack.empty())
{
- if(!m_elemStack.empty())
+ // See if the parent element has already been flagged as having
children.
+ if(false == m_elemStack.top())
{
- // See if the parent element has already been flagged
as having children.
- if(false == m_elemStack.top())
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(">"));
- m_isprevtext = false;
+ accum('>');
+ m_isprevtext = false;
- m_elemStack.pop();
- m_elemStack.push(true);
+ m_elemStack.pop();
+ m_elemStack.push(true);
- m_preserves.push(m_ispreserve);
- }
+ m_preserves.push(m_ispreserve);
}
}
- catch(...)
- {
- throw SAXException();
- }
}
-
+
void
FormatterToXML::openElementForChildren()
{
@@ -811,248 +1217,38 @@
void
FormatterToXML::processAttribute(
- const XalanDOMChar* name,
- const XalanDOMChar* value)
-{
- try
- {
- m_writer.write(XALAN_STATIC_UCODE_STRING(" "));
- m_writer.write(name);
- m_writer.write(XALAN_STATIC_UCODE_STRING("=\""));
- m_writer.write(prepAttrString(value, m_attrSpecialChars,
m_encoding));
- m_writer.write(XALAN_STATIC_UCODE_STRING("\""));
- }
- catch(...)
- {
- throw SAXException();
- }
-}
-
-
-
-XalanDOMString
-FormatterToXML::prepAttrString(
- const XalanDOMChar* string,
- const XalanDOMString& specials,
- const XalanDOMString& /* encoding */)
-{
- const unsigned int theLength = length(string);
- const unsigned int theSpecialsLength = length(specials);
-
- // we'll do the work into a buffer pre-allocated to
- // twice the size of the original string, giving some
- // room to grow without reallocating.
- //
- // Whem XalanDOMString has gets a better += operator
- // for XalanDOMChar and XalanDOMChar*, a more straightforward
- // solution will give good performance
-#if !defined(XALAN_NO_NAMESPACES)
- using std::vector;
-#endif
-
- vector<XalanDOMChar> vec;
-
- vec.reserve(theLength * 2);
-
- for (unsigned int i = 0; i < theLength; i ++)
- {
- const XalanDOMChar ch = charAt(string, i);
-
- const int chNum = ch;
-
- const unsigned int index = indexOf(specials, ch);
-
- if (index < theSpecialsLength)
- {
- vec.push_back('&');
- vec.push_back('#');
- const DOMString ds = LongToDOMString(ch);
- const unsigned int dsLen = length(ds);
- const XMLCh* pb = c_wstr(ds);
- for(unsigned int k = 0; k < dsLen; k++)
- vec.push_back(*pb++);
- vec.push_back(';');
- }
- else if (0xd800 <= chNum && chNum < 0xdc00)
- {
- // UTF-16 surrogate
- int next = 0;
-
- if (i + 1 >= theLength)
- {
- throw SAXException();
-
- // $$$ ToDo: Fix this!!!
-// throw new SAXException("Invalid UTF-16
surrogate detected: "
-// +Integer.toHexString(ch)+ " ?");
- }
- else
- {
- next = charAt(string, ++i);
-
- if (!(0xdc00 <= next && next < 0xe000))
- {
- throw SAXException();
-
- // $$$ ToDo: Fix this!!!
-// throw new SAXException("Invalid UTF-16
surrogate detected: "
-// +Integer.toHexString(ch)+"
"+Integer.toHexString(next));
- }
-
- next = ((ch-0xd800)<<10) + next - 0xdc00 +
0x00010000;
- }
-
- vec.push_back('&');
- vec.push_back('#');
- vec.push_back('x');
-
- const XalanDOMString num = LongToHexDOMString(next);
- const unsigned int numLength = length(num);
-
- for (unsigned int k=0; k < numLength; k++)
- vec.push_back(charAt(num, k));
-
- vec.push_back(';');
- }
-/*
- else if (null != ctbc && !ctbc.canConvert(ch))
- {
- sb.append("&#x");
- sb.append(Integer.toString((int)ch, 16));
- sb.append(";");
- }
-*/
- else
- {
- vec.push_back(ch);
- }
- }
-
- vec.push_back(0);
-
- if (vec.size() == 1)
- {
- // Uh oh, we have to fake out XalanDOMString and
- // give it an extra null...
- vec.push_back(0);
- }
-
- return XalanDOMString(vec.begin(), vec.size() - 1);
-}
-
-
-
-bool
-FormatterToXML::shouldIndent() const
+ const XalanDOMChar* name,
+ const XalanDOMChar* value)
{
- return m_doIndent && (!m_ispreserve && !m_isprevtext);
+ accum(' ');
+ accum(name);
+ accum('=');
+ accum('"');
+ writeAttrString(value, m_encoding);
+ accum('"');
}
void
-FormatterToXML::printSpace(
- Writer& pw,
- int n)
+FormatterToXML::indent(int n)
{
- try
+ if(m_startNewLine == true)
{
- for (int i = 0; i < n; i++)
- {
- pw.write(' ');
- }
+ outputLineSep();
}
- catch(...)
+
+ if(m_doIndent == true)
{
- throw SAXException();
+ printSpace(n);
}
}
-
-void
-FormatterToXML::indent(
- Writer& pw,
- int n)
-{
- try
- {
- if(m_startNewLine == true)
- {
- pw.write('\n');
- }
- if(m_doIndent == true)
- {
- printSpace(pw, n);
- }
- }
- catch(...)
- {
- throw SAXException();
- }
-}
+#if 0
-int FormatterToXML::copyEntityIntoBuf(
- const XalanDOMString& s,
- int pos)
-{
- const unsigned int l = length(s);
- m_charBuf[pos++] = '&';
- for(unsigned int i = 0; i < l; i++)
- {
- m_charBuf[pos++] = charAt(s, i);
- }
- m_charBuf[pos++] = ';';
- return pos;
-}
-int FormatterToXML::copyUTF16IntoBuf(
- const XalanDOMChar* const chars, //
Character string to process
- int& i,
// Index into 'chars'
- int& pos,
// Index in m_charBuf
- int length
// Length of 'chars' string
- )
-/*
- * Processes a UTF-16 surrogate character sequence, and places the result in
- * member 'm_charBuf.' Side effect, indices 'i' and 'pos' are incremented.
- * Method consumes two characters from the input buffer
- */
-{
- XalanDOMString msg(XALAN_STATIC_UCODE_STRING("Invalid UTF-16 surrogate
detected: "));
- // UTF-16 surrogate
- int next;
- const int ch = chars[i];
- if (i+1 >= length)
- {
- msg = append(msg, LongToHexDOMString(ch));
- throw SAXException(c_wstr(msg));
- }
- else
- {
- next = chars[++i];
- if (!(0xdc00 <= next && next < 0xe000))
- {
- msg = append(msg, LongToHexDOMString(ch));
- msg = append(msg, XALAN_STATIC_UCODE_STRING(" "));
- msg = append(msg, LongToHexDOMString(next));
- throw SAXException(c_wstr(msg));
- }
- next = ((ch-0xd800)<<10)+next-0xdc00+0x00010000;
- }
- m_charBuf[pos++] = '&';
- m_charBuf[pos++] = '#';
- XalanDOMString ds;
- ds = LongToDOMString(ch);
- const XalanDOMChar* pb = c_wstr(ds);
- int nIntStr = ds.length();
- for(int k = 0; k < nIntStr; k++)
- {
- m_charBuf[pos++] = pb[k];
- }
- m_charBuf[pos++] = ';';
- return pos;
-}
FormatterToXML::DOMStringMapType FormatterToXML::s_enchash;
FormatterToXML::DOMStringMapType FormatterToXML::s_revhash;
@@ -1111,7 +1307,7 @@
unsigned int dashindex = (encoding != null ?
encoding.indexOf('-') : -1);
if(3 == dashindex)
{
- String ISOprefix = new String(encoding.toCharArray(),
0, 3);
+ String ISOprefix = new
String(encoding.toCharArray(), 0, 3);
if (ISOprefix.equals("ISO") == true)
javaEncodingIsISO = true;
}
@@ -1128,54 +1324,54 @@
// Make a table to maximum character sizes before we
// need to resort to escaping in the XML.
// TODO: To tell the truth, I'm guessing a bit here.
- // s_revsize.insert(make_pair("CP1252", 0xFF)); // Windows
Latin-1
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("WINDOWS-1250")),
0xFF)); // Windows 1250 Peter Smolik
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF-8")),
0xFFFF)); // Universal Transformation Format 8
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")),
0x7F));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-2")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-3")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-4")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-5")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-6")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-7")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-8")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-9")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-JP")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("SHIFT_JIS")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-JP")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("BIG5")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-KR")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-KR")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8-R")),
0xFFFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-US")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CA")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NL")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-DK")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NO")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FI")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-SE")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IT")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ES")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-GB")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FR")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR1")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-HE")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CH")),
0xFF));
+ // s_revsize.insert(make_pair("CP1252", 0xFF)); //
Windows Latin-1
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("WINDOWS-1250")),
0xFF)); // Windows 1250 Peter Smolik
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF-8")),
0xFFFF)); // Universal Transformation Format 8
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")),
0x7F));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-2")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-3")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-4")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-5")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-6")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-7")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-8")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-9")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-JP")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("SHIFT_JIS")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-JP")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("BIG5")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-KR")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-KR")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8-R")),
0xFFFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-US")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CA")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NL")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-DK")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NO")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FI")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-SE")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IT")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ES")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-GB")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FR")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR1")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-HE")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CH")),
0xFF));
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ROECE")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-YU")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IS")),
0xFF));
-
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR2")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-YU")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IS")),
0xFF));
+
s_revsize.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR2")),
0xFF));
- // <preferred MIME name>, <Java encoding name>
+ // <preferred MIME name>, <Java encoding name>
// s_enchash.insert(make_pair("ISO 8859-1", "CP1252")); // Close
enough, I guess
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("WINDOWS-1250")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP1250")))); // Peter Smolik
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF-8")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF8"))));
if(useISOPrefix)
{
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")),
- XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1")))); //
?
+ XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1"))));
// ?
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1"))));
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-2")),
@@ -1198,7 +1394,7 @@
else
{
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")),
- XalanDOMString(XALAN_STATIC_UCODE_STRING("8859_1")))); // ?
+ XalanDOMString(XALAN_STATIC_UCODE_STRING("8859_1")))); // ?
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("8859_1"))));
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-2")),
@@ -1218,41 +1414,41 @@
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-9")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("8859_9"))));
}
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-JP")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("JIS"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("SHIFT_JIS")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("SJIS"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-JP")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("EUCJIS"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("BIG5")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("Big5"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-KR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("KSC5601"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-KR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO2022KR"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8-R")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8_R"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-US")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CA")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NL")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-DK")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP277"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NO")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP277"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FI")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP278"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-SE")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP278"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IT")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP280"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ES")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP284"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-GB")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP285"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP297"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP420"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-HE")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP424"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CH")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP500"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-JP")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("JIS"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("SHIFT_JIS")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("SJIS"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-JP")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("EUCJIS"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("GB2312"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("BIG5")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("Big5"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EUC-KR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("KSC5601"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-2022-KR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO2022KR"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8-R")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("KOI8_R"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-US")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CA")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NL")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP037"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-DK")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP277"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-NO")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP277"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FI")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP278"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-SE")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP278"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IT")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP280"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ES")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP284"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-GB")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP285"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-FR")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP297"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP420"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-HE")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP424"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-CH")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP500"))));
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-ROECE")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP870"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-YU")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP870"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IS")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP871"))));
-
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR2")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP918"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-YU")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP870"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IS")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP871"))));
+
s_enchash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR2")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("CP918"))));
// j:CNS11643 -> EUC-TW?
// ISO-2022-CN? ISO-2022-CN-EXT?
- // <Java encoding name>, <preferred MIME name>
+ // <Java encoding name>, <preferred MIME name>
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("CP1252")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1")))); // Close enough, I
guess
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("CP1250")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("windows-1250")))); // Peter Smolik
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF8")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("UTF-8"))));
-
//s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")))); // ?
+
//s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("US-ASCII")))); // ?
if(useISOPrefix)
{
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO8859_1")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("ISO-8859-1"))));
@@ -1304,3 +1500,4 @@
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("CP871")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-IS"))));
s_revhash.insert(make_pair(XalanDOMString(XALAN_STATIC_UCODE_STRING("CP918")),
XalanDOMString(XALAN_STATIC_UCODE_STRING("EBCDIC-CP-AR2"))));
}
+#endif
\ No newline at end of file
1.11 +565 -199 xml-xalan/c/src/XMLSupport/FormatterToXML.hpp
Index: FormatterToXML.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/FormatterToXML.hpp,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- FormatterToXML.hpp 2000/05/15 15:52:47 1.10
+++ FormatterToXML.hpp 2000/05/18 18:37:23 1.11
@@ -67,15 +67,15 @@
#include <stack>
#include <vector>
-#include <map>
+//#include <map>
-#include <sax/AttributeList.hpp>
+#include <XalanDOM/XalanDOMString.hpp>
-#include <XalanDOM/XalanDOMString.hpp>
+#include <PlatformSupport/DOMStringHelper.hpp>
@@ -84,6 +84,7 @@
+class AttributeList;
class Writer;
@@ -95,52 +96,7 @@
{
public:
-#if defined(XALAN_NO_NAMESPACES)
-# define XALAN_STD
-#else
-# define XALAN_STD std::
-#endif
- typedef XALAN_STD map<XalanDOMString, XalanDOMString>
DOMStringMapType;
- typedef XALAN_STD map<XalanDOMString, int>
DOMString2IntMapType;
- typedef XALAN_STD stack<bool>
BoolStackType;
-#undef XALAN_STD
-
- /**
- * These are characters that will be escaped in the output.
- */
- XalanDOMString m_attrSpecialChars;
-
- static const XalanDOMString DEFAULT_MIME_ENCODING;
-
- /**
- * If true, cdata sections are simply stripped of their
- * CDATA brackets, without escaping.
- */
- bool m_stripCData;
-
- /**
- * If true, characters in cdata sections are
- * escaped, instead of being writted out as
- * cdata sections.
- */
- bool m_escapeCData;
-
- /**
- * If true, XML header should be written to output.
- */
- bool
m_shouldWriteXMLHeader;
-
/**
- * Number of spaces to indent, default is 2.
- */
- int m_indent;
-
- /**
- * Tells the XML version, for writing out to the XML decl.
- */
- XalanDOMString m_version;
-
- /**
* Constructor for customized encoding and doctype.
*
* @param writer character output stream to use
@@ -157,35 +113,25 @@
* declaration
* @param standalone true if the XSLT processor should output a
* standalone document declaration
+ *
+ * @param format should be used only by derived
classes.
*/
FormatterToXML(
- Writer& writer,
- const XalanDOMString& version,
- bool doIndent,
- int indent,
- const XalanDOMString& encoding,
- const XalanDOMString& mediaType,
- const XalanDOMString& doctypeSystem,
- const XalanDOMString& doctypePublic,
- bool xmlDecl,
- const XalanDOMString& standalone);
+ Writer& writer,
+ const XalanDOMString& version = XalanDOMString(),
+ bool doIndent =
false,
+ int indent
= 0,
+ const XalanDOMString& encoding = XalanDOMString(),
+ const XalanDOMString& mediaType = XalanDOMString(),
+ const XalanDOMString& doctypeSystem =
XalanDOMString(),
+ const XalanDOMString& doctypePublic =
XalanDOMString(),
+ bool xmlDecl = true,
+ const XalanDOMString& standalone = XalanDOMString(),
+ eFormat format =
OUTPUT_METHOD_XML);
virtual
~FormatterToXML();
- /**
- * Normalize the characters, but don't escape.
- *
- * @param ch pointer to characters from the XML document
- * @param start starting offset
- * @return length of array
- * @param isCData true if characters are CDATA
- */
- void writeNormalizedChars(
- const XalanDOMChar* ch,
- int start,
- int length,
- bool isCData);
// These methods are inherited from FormatterListener ...
@@ -241,194 +187,440 @@
const XMLCh* const ch,
const unsigned int length);
-protected:
+#if 0
+ /**
+ * Convert a MIME charset name, also known as an XML encoding name, to a
Java encoding name.
+ * @param mimeCharsetName Case insensitive MIME charset name:
<code>UTF-8, US-ASCII, ISO-8859-1,
+ * ISO-8859-2, ISO-8859-3, ISO-8859-4,
ISO-8859-5, ISO-8859-6,
+ * ISO-8859-7, ISO-8859-8, ISO-8859-9,
ISO-2022-JP, Shift_JIS,
+ * EUC-JP, GB2312, Big5, EUC-KR, ISO-2022-KR,
KOI8-R,
+ * EBCDIC-CP-US, EBCDIC-CP-CA, EBCDIC-CP-NL,
EBCDIC-CP-DK,
+ * EBCDIC-CP-NO, EBCDIC-CP-FI, EBCDIC-CP-SE,
EBCDIC-CP-IT,
+ * EBCDIC-CP-ES, EBCDIC-CP-GB, EBCDIC-CP-FR,
EBCDIC-CP-AR1,
+ * EBCDIC-CP-HE, EBCDIC-CP-CH, EBCDIC-CP-ROECE,
EBCDIC-CP-YU,
+ * EBCDIC-CP-IS and EBCDIC-CP-AR2</code>.
+ * @return Java encoding name, or <var>null</var> if
<var>mimeCharsetName</var>
+ * is unknown.
+ * @see #reverse
+ */
+
+ static const XalanDOMString
+ convertMime2JavaEncoding(const XalanDOMString& mimeCharsetName);
+
+ static const XalanDOMString
+ convertJava2MimeEncoding(const XalanDOMString& encoding);
+
+#endif
- void FormatterToXML::copyBigCharIntoBuf(
- const XalanDOMChar* chars,
// Character string to process
- int& i,
// Index into 'chars'
- int& pos,
// Index in m_charBuf
- int length,
// Length of 'chars' string
- XalanDOMChar* buf = m_charBuf
// Buffer to write to
- );
+ const Writer&
+ getWriter() const
+ {
+ return m_writer;
+ }
+
+ Writer&
+ getWriter()
+ {
+ return m_writer;
+ }
+
+ const XalanDOMString&
+ getDoctypeSystem() const
+ {
+ return m_doctypeSystem;
+ }
+
+ const XalanDOMString&
+ getDoctypePublic() const
+ {
+ return m_doctypePublic;
+ }
+
+ const XalanDOMString&
+ getEncoding() const
+ {
+ return m_encoding;
+ }
+
+ const XalanDOMString&
+ getMediaType() const
+ {
+ return m_mediaType;
+ }
+
+ const XalanDOMString&
+ getVersion() const
+ {
+ return m_version;
+ }
+
+ const XalanDOMString&
+ getStandalone() const
+ {
+ return m_standalone;
+ }
+ bool
+ getShouldWriteXMLHeader() const
+ {
+ return m_shouldWriteXMLHeader;
+ }
+
void
- writeBigChar(
- const XalanDOMChar* ch,
- int& i,
- int end);
+ setShouldWriteXMLHeader(bool b)
+ {
+ m_shouldWriteXMLHeader = b;
+ }
+ bool
+ getStripCData() const
+ {
+ return m_stripCData;
+ }
+
void
- writeParentTagEnd();
-
+ setStripCData(bool b)
+ {
+ m_stripCData = b;
+ }
+
+ bool
+ getEscapeCData() const
+ {
+ return m_escapeCData;
+ }
+
void
- openElementForChildren();
+ setEscapeCData(bool b)
+ {
+ m_escapeCData = b;
+ }
bool
- childNodesWereAdded();
+ getDoIndent() const
+ {
+ return m_doIndent;
+ }
+
+ int
+ getIndent() const
+ {
+ return m_indent;
+ }
+protected:
+
+ /**
+ * The writer where the XML will be written.
+ */
+ Writer& m_writer;
+
/**
- * Process an attribute.
- * @param name The name of the attribute.
- * @param value The value of the attribute.
+ * Output a line break.
*/
void
- processAttribute(
- const XalanDOMChar* name,
- const XalanDOMChar* value);
+ outputLineSep()
+ {
+ accum(s_lineSep);
+ }
/**
- * Returns the specified <var>string</var> after substituting
<VAR>specials</VAR>,
- * and UTF-16 surrogates for chracter references <CODE>&#xnn</CODE>.
+ * Append a character to the buffer.
*
- * @param string String to convert to XML format.
- * @param specials Chracters, should be represeted in chracter
referenfces.
- * @param encoding CURRENTLY NOT IMPLEMENTED.
- * @return XML-formatted string.
- * @see #backReference
+ * @ch the character to append.
*/
- static XalanDOMString
- prepAttrString(
- const XalanDOMChar* string,
- const XalanDOMString& specials,
- const XalanDOMString& encoding);
-
- virtual bool
- shouldIndent() const;
-
+ void
+ accum(char ch);
+
/**
- * Prints <var>n</var> spaces.
- * @param pw The character output stream to use.
- * @param n Number of spaces to print.
- * @exception IOException Thrown if <var>pw</var> is invalid.
+ * Append a wide character to the buffer.
+ *
+ * @ch the character to append.
*/
- static void
- printSpace(
- Writer& pw,
- int n);
+ void
+ accum(XalanDOMChar ch);
+
+ /**
+ * Append an array of wide character to the buffer.
+ *
+ * @chars the array to append
+ * @start the offset into the array to start from
+ * @length the number of characters to append
+ */
+ void
+ accum(
+ const XalanDOMChar chars[],
+ unsigned int start,
+ unsigned int length);
+
+ /**
+ * Append a string to the buffer.
+ *
+ * @param str the string to append
+ */
+ void
+ accum(const XalanDOMString& str);
+
+ /**
+ * Append a vector of wide characters to the buffer.
+ *
+ * @param theVector the vector to append
+ */
+ void
+ accum(const XalanDOMCharVectorType& theVector);
+
+ /**
+ * Escape and accum a character.
+ */
+ void
+ accumDefaultEscape(
+ XalanDOMChar ch,
+ unsigned int i,
+ const XalanDOMChar chars[],
+ unsigned int len,
+ bool escLF);
+
+ /**
+ * Handle one of the default entities, return false if it
+ * is not a default entity.
+ */
+ bool
+ accumDefaultEntity(
+ XalanDOMChar ch,
+ unsigned int i,
+ const XalanDOMChar chars[],
+ unsigned int len,
+ bool escLF);
+
+ /**
+ * Set the attribute characters what will require special mapping.
+ */
+ void
+ initAttrCharsMap();
+
+ /**
+ * Set the output characters what will require special mapping.
+ */
+ void
+ initCharsMap();
+
+ /**
+ * Flush the byte buffer.
+ */
+ void
+ flushBytes();
/**
+ * Flush the char buffer.
+ */
+ void
+ flushChars();
+
+ void
+ flush();
+
+ void
+ flushWriter();
+
+ void
+ openElementForChildren();
+
+ bool
+ childNodesWereAdded();
+
+ bool
+ shouldIndent() const
+ {
+ return m_doIndent && (!m_ispreserve && !m_isprevtext);
+ }
+
+ /**
+ * Check to see if a parent's ">" has been written, and, if
+ * it has not, write it.
+ */
+ void
+ writeParentTagEnd();
+
+ /**
* Prints a newline character and <var>n</var> spaces.
- * @param pw The character output stream to use.
* @param n Number of spaces to print.
- * @exception IOException Thrown if <var>pw</var> is invalid.
*/
void
- indent(
- Writer& pw,
- int n);
- /**
- * Convert a MIME charset name, also known as an XML encoding name, to a
Java encoding name.
- * @param mimeCharsetName Case insensitive MIME charset name:
<code>UTF-8, US-ASCII, ISO-8859-1,
- * ISO-8859-2, ISO-8859-3, ISO-8859-4,
ISO-8859-5, ISO-8859-6,
- * ISO-8859-7, ISO-8859-8, ISO-8859-9,
ISO-2022-JP, Shift_JIS,
- * EUC-JP, GB2312, Big5, EUC-KR, ISO-2022-KR,
KOI8-R,
- * EBCDIC-CP-US, EBCDIC-CP-CA, EBCDIC-CP-NL,
EBCDIC-CP-DK,
- * EBCDIC-CP-NO, EBCDIC-CP-FI, EBCDIC-CP-SE,
EBCDIC-CP-IT,
- * EBCDIC-CP-ES, EBCDIC-CP-GB, EBCDIC-CP-FR,
EBCDIC-CP-AR1,
- * EBCDIC-CP-HE, EBCDIC-CP-CH, EBCDIC-CP-ROECE,
EBCDIC-CP-YU,
- * EBCDIC-CP-IS and EBCDIC-CP-AR2</code>.
- * @return Java encoding name, or <var>null</var> if
<var>mimeCharsetName</var>
- * is unknown.
- * @see #reverse
- */
+ indent(int n);
- static const XalanDOMString
- convertMime2JavaEncoding(const XalanDOMString& mimeCharsetName);
+ /**
+ * Write normalized characters to the writer.
+ * @param ch the string to write.
+ * @param start the start offset into the string.
+ * @param length the length of the string.
+ * @param isCData true if writing CDATA.
+ */
+ virtual void
+ writeNormalizedChars(
+ const XalanDOMChar ch[],
+ unsigned int start,
+ unsigned int length,
+ bool isCData);
- static const XalanDOMString
- convertJava2MimeEncoding(const XalanDOMString& encoding);
+ /**
+ * Write a number into the buffer as an entity
+ * reference.
+ * @param theNumber the number to write.
+ */
+ void
+ writeNumberedEntityReference(unsigned long theNumber);
- static void
- initEncodings();
+ /**
+ * Write an attribute string.
+ * @param string The string to write.
+ * @param encoding The current encoding.
+ */
+ virtual void
+ writeAttrString(
+ const XalanDOMChar* string,
+ const XalanDOMString& encoding);
-protected:
+ /**
+ * Throw an exception when an invalid
+ * surrogate is encountered.
+ * @param ch The first character in the surrogate
+ */
+ static void
+ throwInvalidUTF16SurrogateException(XalanDOMChar ch);
- enum { MAXCHARBUF = 4096, MAXSAFECHARBUF = MAXCHARBUF - 256 };
+ /**
+ * Throw an exception when an invalid
+ * surrogate is encountered.
+ * @param ch The first character in the surrogate
+ * @param next The next character in the surrogate
+ */
+ static void
+ throwInvalidUTF16SurrogateException(
+ XalanDOMChar ch,
+ unsigned int next);
- static XalanDOMChar m_charBuf[MAXCHARBUF];
- static XalanDOMChar m_lineSep;
- bool m_needToOutputDocTypeDecl;
- Writer& m_writer;
+ enum eDummy { SPECIALSSIZE = 256};
/**
- * The maximum character value before we have to resort
+ * The maximum character size before we have to resort
* to escaping.
*/
- unsigned int m_maxCharacter;
-
+ XalanDOMChar m_maxCharacter;
+
+ XalanDOMChar m_attrCharsMap[SPECIALSSIZE];
+
+ XalanDOMChar m_charsMap[SPECIALSSIZE];
+
/**
- * The character encoding. Not currently used.
+ * If true, XML header should be written to output.
*/
- XalanDOMString m_encoding;
+ bool m_shouldWriteXMLHeader;
/**
- * Test for standalone part of header.
+ * State flag to tell if preservation of whitespace
+ * is important.
*/
- const XalanDOMString m_standalone;
+ bool m_ispreserve;
/**
- * Tell if the next text should be raw.
+ * Flag to tell if indenting (pretty-printing) is on.
*/
- bool m_nextIsRaw;
+ bool m_doIndent;
- /**
- * A stack of Boolean objects that tell if the given element
- * has children.
- */
- BoolStackType m_elemStack;
+ /**
+ * Flag to signal that a newline should be added.
+ */
+ bool m_startNewLine;
- bool m_ispreserve;
- BoolStackType m_preserves;
+ /**
+ * Flag to tell that we need to add the doctype decl,
+ * which we can't do until the first element is
+ * encountered.
+ */
+ bool m_needToOutputDocTypeDecl;
+
/**
* State flag that tells if the previous node processed
* was text, so we can tell if we should preserve whitespace.
*/
- bool m_isprevtext;
- bool m_doIndent;
- int m_currentIndent;
- int m_level;
- XalanDOMString m_doctypeSystem;
- XalanDOMString m_doctypePublic;
- bool m_startNewLine;
+ bool m_isprevtext;
- /**
- * Assume java encoding names are the same as the ISO encoding names if
this is true.
- */
- static bool m_javaEncodingIsISO;
+ /**
+ * If true, cdata sections are simply stripped of their
+ * CDATA brackets, without escaping.
+ */
+ bool m_stripCData;
+
+ /**
+ * Tell if the next text should be raw.
+ */
+ bool m_nextIsRaw;
+
+ /**
+ * Tells if we're in CData section.
+ */
+ bool m_inCData;
/**
* Flag to quickly tell if the encoding is UTF8.
*/
- bool m_isUTF8;
+ bool m_isUTF8;
- /**
- * Add space before '/>' for XHTML.
- */
- bool m_spaceBeforeClose;
+ /**
+ * The System ID for the doc type.
+ */
+ const XalanDOMString m_doctypeSystem;
- static DOMStringMapType s_enchash;
- static DOMStringMapType s_revhash;
+ /**
+ * The public ID for the doc type.
+ */
+ const XalanDOMString m_doctypePublic;
+
+ /**
+ * The character encoding. Not currently used.
+ */
+ const XalanDOMString m_encoding;
- static DOMString2IntMapType s_revsize;
+ /**
+ * Flag to keep track of the indent amount.
+ */
+ int m_currentIndent;
+ /**
+ * Amount to indent.
+ */
+ int m_indent;
+
+ /**
+ * The text "xslt-next-is-raw".
+ */
+ static const XalanDOMCharVectorType s_xsltNextIsRawString;
- int copyEntityIntoBuf(
- const XalanDOMString& s,
- int pos);
-
- int copyUTF16IntoBuf(
- const XalanDOMChar* chars,
- int& i,
// Index into 'chars'
- int& pos,
// Index in m_charBuf
- int length
// Length of 'chars' string
- );
+ /**
+ * The string "formatter-to-dom".
+ */
+ static const XalanDOMCharVectorType s_formatterToDOMString;
- void FormatterToXML::processingInstruction(
- const XMLCh* const target,
- const XMLCh* const data,
- bool isHTML);
+#if defined(XALAN_NO_NAMESPACES)
+// typedef map<XalanDOMString, XalanDOMString>
DOMStringMapType;
+// typedef map<XalanDOMString, int>
DOMString2IntMapType;
+ typedef stack<bool>
BoolStackType;
+ typedef vector<XalanDOMChar>
DOMCharBufferType;
+ typedef vector<char>
ByteBufferType;
+#else
+// typedef std::map<XalanDOMString, XalanDOMString>
DOMStringMapType;
+// typedef std::map<XalanDOMString, int>
DOMString2IntMapType;
+ typedef std::stack<bool>
BoolStackType;
+ typedef std::vector<XalanDOMChar>
DOMCharBufferType;
+ typedef std::vector<char>
ByteBufferType;
+#endif
+
+ /**
+ * Stack to keep track of whether or not we need to
+ * preserve whitespace.
+ */
+ BoolStackType m_preserves;
-
private:
// These are not implemented.
@@ -439,6 +631,180 @@
bool
operator==(const FormatterToXML&) const;
+
+ /**
+ * Initialize the static codings table.
+ */
+ static void
+ initEncodings();
+
+ /**
+ * Output the doc type declaration.
+ *
+ * @param name the name of the doctype.
+ */
+ void
+ outputDocTypeDecl(const XalanDOMString& name);
+
+ /**
+ * Process an attribute.
+ * @param name The name of the attribute.
+ * @param value The value of the attribute.
+ */
+ void
+ processAttribute(
+ const XalanDOMChar* name,
+ const XalanDOMChar* value);
+
+ /**
+ * Prints <var>n</var> spaces.
+ * @param n Number of spaces to print.
+ */
+ void
+ printSpace(int n)
+ {
+ for (int i = 0; i < n; i ++)
+ {
+ accum(' ');
+ }
+ }
+
+ // Data members...
+ bool m_shouldFlush;
+ bool m_bytesEqualChars;
+
+ /**
+ * Add space before '/>' for XHTML.
+ */
+ bool m_spaceBeforeClose;
+
+ /**
+ * If true, characters in cdata sections are
+ * escaped, instead of being writted out as
+ * cdata sections.
+ */
+ bool m_escapeCData;
+
+ /**
+ * Tells if we're in an EntityRef event.
+ */
+ bool m_inEntityRef;
+
+ /**
+ * Assume java encoding names are the same as the ISO encoding names if
this is true.
+ */
+ static bool s_javaEncodingIsISO;
+
+ /**
+ * Tells the XML version, for writing out to the XML decl.
+ */
+ const XalanDOMString m_version;
+
+ /**
+ * Text for standalone part of header.
+ */
+ const XalanDOMString m_standalone;
+
+ /**
+ * The media type. Not used right now.
+ */
+ const XalanDOMString m_mediaType;
+
+ /**
+ * These are characters that will be escaped in the output.
+ */
+ const XalanDOMString m_attrSpecialChars;
+
+ /**
+ * The default MIME encoding.
+ */
+ static const XalanDOMCharVectorType s_defaultMIMEEncoding;
+
+ /**
+ * The string "<!DOCTYPE ".
+ */
+ static const XalanDOMCharVectorType
s_doctypeHeaderStartString;
+
+ /**
+ * The string " PUBLIC \"".
+ */
+ static const XalanDOMCharVectorType
s_doctypeHeaderPublicString;
+
+ /**
+ * The string " SYSTEM \"".
+ */
+ static const XalanDOMCharVectorType
s_doctypeHeaderSystemString;
+
+ /**
+ * The string "<?xml version=\"".
+ */
+ static const XalanDOMCharVectorType s_xmlHeaderStartString;
+
+ /**
+ * The string "<?xml version=\"".
+ */
+ static const XalanDOMCharVectorType
s_xmlHeaderEncodingString;
+
+ /**
+ * The string "\" standalone=\"".
+ */
+ static const XalanDOMCharVectorType
s_xmlHeaderStandaloneString;
+
+ /**
+ * The string "\"?>".
+ */
+ static const XalanDOMCharVectorType s_xmlHeaderEndString;
+
+ /**
+ * The string "1.0".
+ */
+ static const XalanDOMCharVectorType s_defaultVersionString;
+
+ /**
+ * The string "WINDOWS-1250".
+ */
+ static const XalanDOMCharVectorType
s_windows1250EncodingString;
+
+ /**
+ * The string "US-ASCII".
+ */
+ static const XalanDOMCharVectorType s_usASCIIEncodingString;
+
+ /**
+ * The string "ASCII".
+ */
+ static const XalanDOMCharVectorType s_asciiEncodingString;
+
+ /**
+ * The string "UTF-8".
+ */
+ static const XalanDOMCharVectorType s_utf8EncodingString;
+
+
+ DOMCharBufferType m_charBuf;
+
+ ByteBufferType m_byteBuf;
+
+ ByteBufferType::size_type m_pos;
+
+ static const DOMCharBufferType::size_type s_maxBufferSize;
+
+ /**
+ * Current level of indent.
+ */
+ int m_level;
+
+ /**
+ * A stack of Boolean objects that tell if the given element
+ * has children.
+ */
+ BoolStackType m_elemStack;
+
+ /**
+ * Use the system line seperator to write line breaks. This should
+ * always be '\n'.
+ */
+ static XalanDOMChar s_lineSep;
};
1.6 +14 -24 xml-xalan/c/src/XMLSupport/XMLParserLiaisonDefault.cpp
Index: XMLParserLiaisonDefault.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XMLSupport/XMLParserLiaisonDefault.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- XMLParserLiaisonDefault.cpp 2000/04/11 14:43:02 1.5
+++ XMLParserLiaisonDefault.cpp 2000/05/18 18:37:23 1.6
@@ -224,18 +224,17 @@
XALAN_STATIC_UCODE_STRING("http://www.w3.org/TR/REC-html40";)) == true)
{
FormatterToHTML* const htmlFormatVisitor =
- new FormatterToHTML(pw,
- XalanDOMString(),
- format,
- m_Indent,
+ new FormatterToHTML(
+ pw,
XalanDOMString(), //
encoding
XalanDOMString(), //
media type
- // @@ JMD: ??
- // was: "<!DOCTYPE html PUBLIC
\"-//W3C//DTD HTML 4.0 Transitional//EN\">\n",
XalanDOMString(), //
doctypeSystem
XalanDOMString(), //
doctypePublic
- false, // xmlDecl
- XalanDOMString()); //
standalone,
+ format,
+ m_Indent,
+ XalanDOMString(), //
version
+ XalanDOMString(), //
standalone
+ false); // xmlDecl
#if defined(XALAN_OLD_AUTO_PTR)
@@ -243,8 +242,6 @@
#else
visitor.reset(htmlFormatVisitor);
#endif
-
- htmlFormatVisitor->m_attrSpecialChars = m_SpecialCharacters;
}
else
{
@@ -265,8 +262,6 @@
#else
visitor.reset(fToXML);
#endif
-
- fToXML->m_attrSpecialChars = m_SpecialCharacters;
}
if(visitor.get() != 0)
@@ -289,18 +284,17 @@
XALAN_STATIC_UCODE_STRING("http://www.w3.org/TR/REC-html40";)) == true)
{
FormatterToHTML* const htmlFormatVisitor =
- new FormatterToHTML(pw,
- XalanDOMString(),
- format,
- m_Indent,
+ new FormatterToHTML(
+ pw,
XalanDOMString(), //
encoding
XalanDOMString(), //
media type
- // @@ JMD: ??
- // was: "<!DOCTYPE html PUBLIC
\"-//W3C//DTD HTML 4.0 Transitional//EN\">\n",
XalanDOMString(), //
doctypeSystem
XalanDOMString(), //
doctypePublic
- false, // xmlDecl
- XalanDOMString()); //
standalone
+ format,
+ m_Indent,
+ XalanDOMString(), //
version
+ XalanDOMString(), //
standalone
+ false); // xmlDecl
if (m_fOwnListener == true)
{
@@ -309,8 +303,6 @@
m_FormatterListener = htmlFormatVisitor;
m_fOwnListener = true;
-
- htmlFormatVisitor->m_attrSpecialChars = m_SpecialCharacters;
}
else if(0 == m_FormatterListener)
{
@@ -325,8 +317,6 @@
XalanDOMString(), // doctypePublic
true, //
xmlDecl
XalanDOMString()); // standalone
-
- fToXML->m_attrSpecialChars = m_SpecialCharacters;
m_FormatterListener = fToXML;
m_fOwnListener = true;
