Back to index...

	/*
	* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
	*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.sun.org.apache.xml.internal.serialize;

	import com.sun.org.apache.xerces.internal.dom.AbortException;
	import com.sun.org.apache.xerces.internal.dom.CoreDocumentImpl;
	import com.sun.org.apache.xerces.internal.dom.DOMErrorImpl;
	import com.sun.org.apache.xerces.internal.dom.DOMLocatorImpl;
	import com.sun.org.apache.xerces.internal.dom.DOMMessageFormatter;
	import com.sun.org.apache.xerces.internal.dom.DOMNormalizer;
	import com.sun.org.apache.xerces.internal.dom.DOMStringListImpl;
	import com.sun.org.apache.xerces.internal.impl.Constants;
	import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;
	import com.sun.org.apache.xerces.internal.util.DOMUtil;
	import com.sun.org.apache.xerces.internal.util.NamespaceSupport;
	import com.sun.org.apache.xerces.internal.util.SymbolTable;
	import com.sun.org.apache.xerces.internal.util.XML11Char;
	import com.sun.org.apache.xerces.internal.util.XMLChar;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.StringWriter;
	import java.io.UnsupportedEncodingException;
	import java.io.Writer;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.List;
	import org.w3c.dom.Attr;
	import org.w3c.dom.Comment;
	import org.w3c.dom.DOMConfiguration;
	import org.w3c.dom.DOMError;
	import org.w3c.dom.DOMErrorHandler;
	import org.w3c.dom.DOMException;
	import org.w3c.dom.DOMStringList;
	import org.w3c.dom.Document;
	import org.w3c.dom.DocumentFragment;
	import org.w3c.dom.Element;
	import org.w3c.dom.NamedNodeMap;
	import org.w3c.dom.Node;
	import org.w3c.dom.ProcessingInstruction;
	import org.w3c.dom.ls.LSException;
	import org.w3c.dom.ls.LSOutput;
	import org.w3c.dom.ls.LSSerializer;
	import org.w3c.dom.ls.LSSerializerFilter;

	/**
	* EXPERIMENTAL: Implemenatation of DOM Level 3 org.w3c.ls.LSSerializer by
	* delegating serialization calls to <CODE>XMLSerializer</CODE>. LSSerializer
	* provides an API for serializing (writing) a DOM document out in an XML
	* document. The XML data is written to an output stream. During serialization
	* of XML data, namespace fixup is done when possible as defined in DOM Level 3
	* Core, Appendix B.
	*
	* @author Elena Litani, IBM
	* @author Gopal Sharma, Sun Microsystems
	* @author Arun Yadav, Sun Microsystems
	* @author Sunitha Reddy, Sun Microsystems
	*
	* @deprecated As of JDK 9, Xerces 2.9.0, replaced by
	* {@link com.sun.org.apache.xml.internal.serializer.dom3.LSSerializerImpl}
	*
	* @LastModified: Oct 2017
	*/
	@Deprecated
	public class DOMSerializerImpl implements LSSerializer, DOMConfiguration {

	// TODO: When DOM Level 3 goes to REC replace method calls using
	// reflection for: getXmlEncoding, getInputEncoding and getXmlEncoding
	// with regular static calls on the Document object.
	// data
	// serializer
	private XMLSerializer serializer;

	// XML 1.1 serializer
	private XML11Serializer xml11Serializer;

	//Recognized parameters
	private DOMStringList fRecognizedParameters;

	/**
	* REVISIT: Currently we handle 3 different configurations, would be nice
	* just have one configuration that has different recognized parameters
	* depending if it is used in Core/LS.
	*/
	protected short features = 0;

	protected final static short NAMESPACES = 0x1 << 0;
	protected final static short WELLFORMED = 0x1 << 1;
	protected final static short ENTITIES = 0x1 << 2;
	protected final static short CDATA = 0x1 << 3;
	protected final static short SPLITCDATA = 0x1 << 4;
	protected final static short COMMENTS = 0x1 << 5;
	protected final static short DISCARDDEFAULT = 0x1 << 6;
	protected final static short INFOSET = 0x1 << 7;
	protected final static short XMLDECL = 0x1 << 8;
	protected final static short NSDECL = 0x1 << 9;
	protected final static short DOM_ELEMENT_CONTENT_WHITESPACE = 0x1 << 10;
	protected final static short PRETTY_PRINT = 0x1 << 11;

	// well-formness checking
	private DOMErrorHandler fErrorHandler = null;
	private final DOMErrorImpl fError = new DOMErrorImpl();
	private final DOMLocatorImpl fLocator = new DOMLocatorImpl();

	/**
	* Constructs a new LSSerializer. The constructor turns on the namespace
	* support in <code>XMLSerializer</code> and initializes the following
	* fields: fNSBinder, fLocalNSBinder, fSymbolTable, fEmptySymbol,
	* fXmlSymbol, fXmlnsSymbol, fNamespaceCounter, fFeatures.
	*/
	public DOMSerializerImpl() {
	// set default features
	features \|= NAMESPACES;
	features \|= ENTITIES;
	features \|= COMMENTS;
	features \|= CDATA;
	features \|= SPLITCDATA;
	features \|= WELLFORMED;
	features \|= NSDECL;
	features \|= DOM_ELEMENT_CONTENT_WHITESPACE;
	features \|= DISCARDDEFAULT;
	features \|= XMLDECL;

	serializer = new XMLSerializer();
	initSerializer(serializer);
	}

	//
	// LSSerializer methods
	//
	public DOMConfiguration getDomConfig() {
	return this;
	}

	/**
	* DOM L3-EXPERIMENTAL: Setter for boolean and object parameters
	*/
	public void setParameter(String name, Object value) throws DOMException {
	if (value instanceof Boolean) {
	boolean state = ((Boolean) value).booleanValue();
	if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) {
	if (state) {
	features &= ~ENTITIES;
	features &= ~CDATA;
	features \|= NAMESPACES;
	features \|= NSDECL;
	features \|= WELLFORMED;
	features \|= COMMENTS;
	}
	// false does not have any effect
	} else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) {
	features
	= (short) (state ? features \| XMLDECL : features & ~XMLDECL);
	} else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) {
	features
	= (short) (state
	? features \| NAMESPACES
	: features & ~NAMESPACES);
	serializer.fNamespaces = state;
	} else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) {
	features
	= (short) (state
	? features \| SPLITCDATA
	: features & ~SPLITCDATA);
	} else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) {
	features
	= (short) (state
	? features \| DISCARDDEFAULT
	: features & ~DISCARDDEFAULT);
	} else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) {
	features
	= (short) (state
	? features \| WELLFORMED
	: features & ~WELLFORMED);
	} else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) {
	features
	= (short) (state
	? features \| ENTITIES
	: features & ~ENTITIES);
	} else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) {
	features
	= (short) (state
	? features \| CDATA
	: features & ~CDATA);
	} else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) {
	features
	= (short) (state
	? features \| COMMENTS
	: features & ~COMMENTS);
	} else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) {
	features
	= (short) (state
	? features \| PRETTY_PRINT
	: features & ~PRETTY_PRINT);
	} else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE)
	\|\| name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {
	// \|\| name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {
	// true is not supported
	if (state) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_SUPPORTED",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	}
	} else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {
	//namespace-declaration has effect only if namespaces is true
	features
	= (short) (state
	? features \| NSDECL
	: features & ~NSDECL);
	serializer.fNamespacePrefixes = state;
	} else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)
	\|\| name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	// false is not supported
	if (!state) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_SUPPORTED",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	}
	} else {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_FOUND",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	}
	} else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) {
	if (value == null \|\| value instanceof DOMErrorHandler) {
	fErrorHandler = (DOMErrorHandler) value;
	} else {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"TYPE_MISMATCH_ERR",
	new Object[]{name});
	throw new DOMException(DOMException.TYPE_MISMATCH_ERR, msg);
	}
	} else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER)
	\|\| name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION)
	\|\| name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE)
	\|\| name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)
	&& value != null) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_SUPPORTED",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_FOUND",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_FOUND_ERR, msg);
	}
	}

	/**
	* DOM L3-EXPERIMENTAL: Check if parameter can be set
	*/
	public boolean canSetParameter(String name, Object state) {
	if (state == null) {
	return true;
	}

	if (state instanceof Boolean) {
	boolean value = ((Boolean) state).booleanValue();
	if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)
	\|\| name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)
	\|\| name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)
	\|\| name.equalsIgnoreCase(Constants.DOM_XMLDECL)
	\|\| name.equalsIgnoreCase(Constants.DOM_WELLFORMED)
	\|\| name.equalsIgnoreCase(Constants.DOM_INFOSET)
	\|\| name.equalsIgnoreCase(Constants.DOM_ENTITIES)
	\|\| name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)
	\|\| name.equalsIgnoreCase(Constants.DOM_COMMENTS)
	\|\| name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)
	\|\| name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {
	// both values supported
	return true;
	} else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE)
	\|\| name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {
	// \|\| name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {
	// true is not supported
	return !value;
	} else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)
	\|\| name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	// false is not supported
	return value;
	}
	} else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)
	&& state == null \|\| state instanceof DOMErrorHandler) {
	return true;
	}

	return false;
	}

	/**
	* DOM Level 3 Core CR - Experimental.
	*
	* The list of the parameters supported by this
	* <code>DOMConfiguration</code> object and for which at least one value can
	* be set by the application. Note that this list can also contain parameter
	* names defined outside this specification.
	*/
	public DOMStringList getParameterNames() {

	if (fRecognizedParameters == null) {
	List<String> parameters = new ArrayList<>();

	//Add DOM recognized parameters
	//REVISIT: Would have been nice to have a list of
	//recognized parameters.
	parameters.add(Constants.DOM_NAMESPACES);
	parameters.add(Constants.DOM_SPLIT_CDATA);
	parameters.add(Constants.DOM_DISCARD_DEFAULT_CONTENT);
	parameters.add(Constants.DOM_XMLDECL);
	parameters.add(Constants.DOM_CANONICAL_FORM);
	parameters.add(Constants.DOM_VALIDATE_IF_SCHEMA);
	parameters.add(Constants.DOM_VALIDATE);
	parameters.add(Constants.DOM_CHECK_CHAR_NORMALIZATION);
	parameters.add(Constants.DOM_DATATYPE_NORMALIZATION);
	parameters.add(Constants.DOM_FORMAT_PRETTY_PRINT);
	//parameters.add(Constants.DOM_NORMALIZE_CHARACTERS);
	parameters.add(Constants.DOM_WELLFORMED);
	parameters.add(Constants.DOM_INFOSET);
	parameters.add(Constants.DOM_NAMESPACE_DECLARATIONS);
	parameters.add(Constants.DOM_ELEMENT_CONTENT_WHITESPACE);
	parameters.add(Constants.DOM_ENTITIES);
	parameters.add(Constants.DOM_CDATA_SECTIONS);
	parameters.add(Constants.DOM_COMMENTS);
	parameters.add(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS);
	parameters.add(Constants.DOM_ERROR_HANDLER);
	//parameters.add(Constants.DOM_SCHEMA_LOCATION);
	//parameters.add(Constants.DOM_SCHEMA_TYPE);

	//Add recognized xerces features and properties
	fRecognizedParameters = new DOMStringListImpl(parameters);
	}

	return fRecognizedParameters;
	}

	/**
	* DOM L3-EXPERIMENTAL: Getter for boolean and object parameters
	*/
	public Object getParameter(String name) throws DOMException {
	if (name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) {
	return null;
	} else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) {
	return ((features & COMMENTS) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) {
	return (features & NAMESPACES) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) {
	return (features & XMLDECL) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) {
	return (features & CDATA) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) {
	return (features & ENTITIES) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) {
	return (features & SPLITCDATA) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) {
	return (features & WELLFORMED) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) {
	return (features & NSDECL) != 0 ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE)
	\|\| name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) {
	return Boolean.TRUE;
	} else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) {
	return ((features & DISCARDDEFAULT) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) {
	return ((features & PRETTY_PRINT) != 0) ? Boolean.TRUE : Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) {
	if ((features & ENTITIES) == 0
	&& (features & CDATA) == 0
	&& (features & NAMESPACES) != 0
	&& (features & NSDECL) != 0
	&& (features & WELLFORMED) != 0
	&& (features & COMMENTS) != 0) {
	return Boolean.TRUE;
	}
	return Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE)
	\|\| name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA)
	\|\| name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) {
	return Boolean.FALSE;
	} else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) {
	return fErrorHandler;
	} else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER)
	\|\| name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION)
	\|\| name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE)) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_SUPPORTED",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
	} else {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"FEATURE_NOT_FOUND",
	new Object[]{name});
	throw new DOMException(DOMException.NOT_FOUND_ERR, msg);
	}
	}

	/**
	* DOM L3 EXPERIMENTAL: Serialize the specified node as described above in
	* the description of <code>LSSerializer</code>. The result of serializing
	* the node is returned as a string. Writing a Document or Entity node
	* produces a serialized form that is well formed XML. Writing other node
	* types produces a fragment of text in a form that is not fully defined by
	* this document, but that should be useful to a human for debugging or
	* diagnostic purposes.
	*
	* @param wnode The node to be written.
	* @return Returns the serialized data
	* @exception DOMException DOMSTRING_SIZE_ERR: The resulting string is too
	* long to fit in a <code>DOMString</code>.
	* @exception LSException SERIALIZE_ERR: Unable to serialize the node. DOM
	* applications should attach a <code>DOMErrorHandler</code> using the
	* parameter "<i>error-handler</i>" to get details on error.
	*/
	public String writeToString(Node wnode) throws DOMException, LSException {
	// determine which serializer to use:
	XMLSerializer ser = null;
	String ver = _getXmlVersion(wnode);
	if (ver != null && ver.equals("1.1")) {
	if (xml11Serializer == null) {
	xml11Serializer = new XML11Serializer();
	initSerializer(xml11Serializer);
	}
	// copy setting from "main" serializer to XML 1.1 serializer
	copySettings(serializer, xml11Serializer);
	ser = xml11Serializer;
	} else {
	ser = serializer;
	}

	StringWriter destination = new StringWriter();
	try {
	prepareForSerialization(ser, wnode);
	ser._format.setEncoding("UTF-16");
	ser.setOutputCharStream(destination);
	if (wnode.getNodeType() == Node.DOCUMENT_NODE) {
	ser.serialize((Document) wnode);
	} else if (wnode.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {
	ser.serialize((DocumentFragment) wnode);
	} else if (wnode.getNodeType() == Node.ELEMENT_NODE) {
	ser.serialize((Element) wnode);
	} else if (wnode.getNodeType() == Node.TEXT_NODE
	\|\| wnode.getNodeType() == Node.COMMENT_NODE
	\|\| wnode.getNodeType() == Node.ENTITY_REFERENCE_NODE
	\|\| wnode.getNodeType() == Node.CDATA_SECTION_NODE
	\|\| wnode.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
	ser.serialize(wnode);
	} else {
	String msg = DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.SERIALIZER_DOMAIN,
	"unable-to-serialize-node", null);
	if (ser.fDOMErrorHandler != null) {
	DOMErrorImpl error = new DOMErrorImpl();
	error.fType = "unable-to-serialize-node";
	error.fMessage = msg;
	error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
	ser.fDOMErrorHandler.handleError(error);
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);
	}
	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (AbortException e) {
	return null;
	} catch (RuntimeException e) {
	throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace();
	} catch (IOException ioe) {
	// REVISIT: A generic IOException doesn't provide enough information
	// to determine that the serialized document is too large to fit
	// into a string. This could have thrown for some other reason. -- mrglavas
	String msg = DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"STRING_TOO_LONG",
	new Object[]{ioe.getMessage()});
	throw new DOMException(DOMException.DOMSTRING_SIZE_ERR, msg);
	} finally {
	ser.clearDocumentState();
	}
	return destination.toString();
	}

	/**
	* DOM L3 EXPERIMENTAL: The end-of-line sequence of characters to be used in
	* the XML being written out. The only permitted values are these:
	* <dl>
	* <dt><code>null</code></dt>
	* <dd>
	* Use a default end-of-line sequence. DOM implementations should choose the
	* default to match the usual convention for text files in the environment
	* being used. Implementations must choose a default sequence that matches
	* one of those allowed by 2.11 "End-of-Line Handling". </dd>
	* <dt>CR</dt>
	* <dd>The carriage-return character (#xD).</dd>
	* <dt>CR-LF</dt>
	* <dd> The carriage-return and line-feed characters (#xD #xA). </dd>
	* <dt>LF</dt>
	* <dd> The line-feed character (#xA). </dd>
	* </dl>
	* <br>The default value for this attribute is <code>null</code>.
	*/
	public void setNewLine(String newLine) {
	serializer._format.setLineSeparator(newLine);
	}

	/**
	* DOM L3 EXPERIMENTAL: The end-of-line sequence of characters to be used in
	* the XML being written out. The only permitted values are these:
	* <dl>
	* <dt><code>null</code></dt>
	* <dd>
	* Use a default end-of-line sequence. DOM implementations should choose the
	* default to match the usual convention for text files in the environment
	* being used. Implementations must choose a default sequence that matches
	* one of those allowed by 2.11 "End-of-Line Handling". </dd>
	* <dt>CR</dt>
	* <dd>The carriage-return character (#xD).</dd>
	* <dt>CR-LF</dt>
	* <dd> The carriage-return and line-feed characters (#xD #xA). </dd>
	* <dt>LF</dt>
	* <dd> The line-feed character (#xA). </dd>
	* </dl>
	* <br>The default value for this attribute is <code>null</code>.
	*/
	public String getNewLine() {
	return serializer._format.getLineSeparator();
	}

	/**
	* When the application provides a filter, the serializer will call out to
	* the filter before serializing each Node. Attribute nodes are never passed
	* to the filter. The filter implementation can choose to remove the node
	* from the stream or to terminate the serialization early.
	*/
	public LSSerializerFilter getFilter() {
	return serializer.fDOMFilter;
	}

	/**
	* When the application provides a filter, the serializer will call out to
	* the filter before serializing each Node. Attribute nodes are never passed
	* to the filter. The filter implementation can choose to remove the node
	* from the stream or to terminate the serialization early.
	*/
	public void setFilter(LSSerializerFilter filter) {
	serializer.fDOMFilter = filter;
	}

	// this initializes a newly-created serializer
	private void initSerializer(XMLSerializer ser) {
	ser.fNSBinder = new NamespaceSupport();
	ser.fLocalNSBinder = new NamespaceSupport();
	ser.fSymbolTable = new SymbolTable();
	}

	// copies all settings that could have been modified
	// by calls to LSSerializer methods from one serializer to another.
	// IMPORTANT: if new methods are implemented or more settings of
	// the serializer are made alterable, this must be
	// reflected in this method!
	private void copySettings(XMLSerializer src, XMLSerializer dest) {
	dest.fDOMErrorHandler = fErrorHandler;
	dest._format.setEncoding(src._format.getEncoding());
	dest._format.setLineSeparator(src._format.getLineSeparator());
	dest.fDOMFilter = src.fDOMFilter;
	}//copysettings

	/**
	* Serialize the specified node as described above in the general
	* description of the <code>LSSerializer</code> interface. The output is
	* written to the supplied <code>LSOutput</code>.
	* <br> When writing to a <code>LSOutput</code>, the encoding is found by
	* looking at the encoding information that is reachable through the
	* <code>LSOutput</code> and the item to be written (or its owner document)
	* in this order:
	* <ol>
	* <li> <code>LSOutput.encoding</code>,
	* </li>
	* <li>
	* <code>Document.actualEncoding</code>,
	* </li>
	* <li>
	* <code>Document.xmlEncoding</code>.
	* </li>
	* </ol>
	* <br> If no encoding is reachable through the above properties, a default
	* encoding of "UTF-8" will be used.
	* <br> If the specified encoding is not supported an "unsupported-encoding"
	* error is raised.
	* <br> If no output is specified in the <code>LSOutput</code>, a
	* "no-output-specified" error is raised.
	*
	* @param node The node to serialize.
	* @param destination The destination for the serialized DOM.
	* @return Returns <code>true</code> if <code>node</code> was successfully
	* serialized and <code>false</code> in case the node couldn't be
	* serialized.
	*/
	public boolean write(Node node, LSOutput destination) throws LSException {

	if (node == null) {
	return false;
	}

	XMLSerializer ser = null;
	String ver = _getXmlVersion(node);
	//determine which serializer to use:
	if (ver != null && ver.equals("1.1")) {
	if (xml11Serializer == null) {
	xml11Serializer = new XML11Serializer();
	initSerializer(xml11Serializer);
	}
	//copy setting from "main" serializer to XML 1.1 serializer
	copySettings(serializer, xml11Serializer);
	ser = xml11Serializer;
	} else {
	ser = serializer;
	}

	String encoding = null;
	if ((encoding = destination.getEncoding()) == null) {
	encoding = _getInputEncoding(node);
	if (encoding == null) {
	encoding = _getXmlEncoding(node);
	if (encoding == null) {
	encoding = "UTF-8";
	}
	}
	}
	try {
	prepareForSerialization(ser, node);
	ser._format.setEncoding(encoding);
	OutputStream outputStream = destination.getByteStream();
	Writer writer = destination.getCharacterStream();
	String uri = destination.getSystemId();
	if (writer == null) {
	if (outputStream == null) {
	if (uri == null) {
	String msg = DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.SERIALIZER_DOMAIN,
	"no-output-specified", null);
	if (ser.fDOMErrorHandler != null) {
	DOMErrorImpl error = new DOMErrorImpl();
	error.fType = "no-output-specified";
	error.fMessage = msg;
	error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
	ser.fDOMErrorHandler.handleError(error);
	}
	throw new LSException(LSException.SERIALIZE_ERR, msg);
	} else {
	ser.setOutputByteStream(XMLEntityManager.createOutputStream(uri));
	}
	} else {
	// byte stream was specified
	ser.setOutputByteStream(outputStream);
	}
	} else {
	// character stream is specified
	ser.setOutputCharStream(writer);
	}

	if (node.getNodeType() == Node.DOCUMENT_NODE) {
	ser.serialize((Document) node);
	} else if (node.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {
	ser.serialize((DocumentFragment) node);
	} else if (node.getNodeType() == Node.ELEMENT_NODE) {
	ser.serialize((Element) node);
	} else if (node.getNodeType() == Node.TEXT_NODE
	\|\| node.getNodeType() == Node.COMMENT_NODE
	\|\| node.getNodeType() == Node.ENTITY_REFERENCE_NODE
	\|\| node.getNodeType() == Node.CDATA_SECTION_NODE
	\|\| node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
	ser.serialize(node);
	} else {
	return false;
	}
	} catch (UnsupportedEncodingException ue) {
	if (ser.fDOMErrorHandler != null) {
	DOMErrorImpl error = new DOMErrorImpl();
	error.fException = ue;
	error.fType = "unsupported-encoding";
	error.fMessage = ue.getMessage();
	error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
	ser.fDOMErrorHandler.handleError(error);
	}
	throw new LSException(LSException.SERIALIZE_ERR,
	DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.SERIALIZER_DOMAIN,
	"unsupported-encoding", null));
	//return false;
	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (AbortException e) {
	return false;
	} catch (RuntimeException e) {
	throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace();
	} catch (Exception e) {
	if (ser.fDOMErrorHandler != null) {
	DOMErrorImpl error = new DOMErrorImpl();
	error.fException = e;
	error.fMessage = e.getMessage();
	error.fSeverity = DOMError.SEVERITY_ERROR;
	ser.fDOMErrorHandler.handleError(error);

	}
	throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace();
	} finally {
	ser.clearDocumentState();
	}
	return true;

	} //write

	/**
	* Serialize the specified node as described above in the general
	* description of the <code>LSSerializer</code> interface. The output is
	* written to the supplied URI.
	* <br> When writing to a URI, the encoding is found by looking at the
	* encoding information that is reachable through the item to be written (or
	* its owner document) in this order:
	* <ol>
	* <li>
	* <code>Document.inputEncoding</code>,
	* </li>
	* <li>
	* <code>Document.xmlEncoding</code>.
	* </li>
	* </ol>
	* <br> If no encoding is reachable through the above properties, a default
	* encoding of "UTF-8" will be used.
	* <br> If the specified encoding is not supported an "unsupported-encoding"
	* error is raised.
	*
	* @param node The node to serialize.
	* @param URI The URI to write to.
	* @return Returns <code>true</code> if <code>node</code> was successfully
	* serialized and <code>false</code> in case the node couldn't be
	* serialized.
	*/
	public boolean writeToURI(Node node, String URI) throws LSException {
	if (node == null) {
	return false;
	}

	XMLSerializer ser = null;
	String ver = _getXmlVersion(node);

	if (ver != null && ver.equals("1.1")) {
	if (xml11Serializer == null) {
	xml11Serializer = new XML11Serializer();
	initSerializer(xml11Serializer);
	}
	// copy setting from "main" serializer to XML 1.1 serializer
	copySettings(serializer, xml11Serializer);
	ser = xml11Serializer;
	} else {
	ser = serializer;
	}

	String encoding = _getInputEncoding(node);
	if (encoding == null) {
	encoding = _getXmlEncoding(node);
	if (encoding == null) {
	encoding = "UTF-8";
	}
	}

	try {
	prepareForSerialization(ser, node);
	ser._format.setEncoding(encoding);
	ser.setOutputByteStream(XMLEntityManager.createOutputStream(URI));

	if (node.getNodeType() == Node.DOCUMENT_NODE) {
	ser.serialize((Document) node);
	} else if (node.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) {
	ser.serialize((DocumentFragment) node);
	} else if (node.getNodeType() == Node.ELEMENT_NODE) {
	ser.serialize((Element) node);
	} else if (node.getNodeType() == Node.TEXT_NODE
	\|\| node.getNodeType() == Node.COMMENT_NODE
	\|\| node.getNodeType() == Node.ENTITY_REFERENCE_NODE
	\|\| node.getNodeType() == Node.CDATA_SECTION_NODE
	\|\| node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
	ser.serialize(node);
	} else {
	return false;
	}
	} catch (LSException lse) {
	// Rethrow LSException.
	throw lse;
	} catch (AbortException e) {
	return false;
	} catch (RuntimeException e) {
	throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace();
	} catch (Exception e) {
	if (ser.fDOMErrorHandler != null) {
	DOMErrorImpl error = new DOMErrorImpl();
	error.fException = e;
	error.fMessage = e.getMessage();
	error.fSeverity = DOMError.SEVERITY_ERROR;
	ser.fDOMErrorHandler.handleError(error);
	}
	throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace();
	} finally {
	ser.clearDocumentState();
	}
	return true;
	} //writeURI

	//
	// Private methods
	//
	private void prepareForSerialization(XMLSerializer ser, Node node) {
	ser.reset();
	ser.features = features;
	ser.fDOMErrorHandler = fErrorHandler;
	ser.fNamespaces = (features & NAMESPACES) != 0;
	ser.fNamespacePrefixes = (features & NSDECL) != 0;
	ser._format.setIndenting((features & PRETTY_PRINT) != 0);
	ser._format.setOmitComments((features & COMMENTS) == 0);
	ser._format.setOmitXMLDeclaration((features & XMLDECL) == 0);

	if ((features & WELLFORMED) != 0) {
	// REVISIT: this is inefficient implementation of well-formness. Instead, we should check
	// well-formness as we serialize the tree
	Node next, root;
	root = node;
	Method versionChanged;
	boolean verifyNames = true;
	Document document = (node.getNodeType() == Node.DOCUMENT_NODE)
	? (Document) node
	: node.getOwnerDocument();
	try {
	versionChanged = document.getClass().getMethod("isXMLVersionChanged()", new Class<?>[]{});
	if (versionChanged != null) {
	verifyNames = ((Boolean) versionChanged.invoke(document, (Object[]) null)).booleanValue();
	}
	} catch (Exception e) {
	//no way to test the version...
	//ignore the exception
	}
	if (node.getFirstChild() != null) {
	while (node != null) {
	verify(node, verifyNames, false);
	// Move down to first child
	next = node.getFirstChild();
	// No child nodes, so walk tree
	while (next == null) {
	// Move to sibling if possible.
	next = node.getNextSibling();
	if (next == null) {
	node = node.getParentNode();
	if (root == node) {
	next = null;
	break;
	}
	next = node.getNextSibling();
	}
	}
	node = next;
	}
	} else {
	verify(node, verifyNames, false);
	}
	}
	}

	private void verify(Node node, boolean verifyNames, boolean xml11Version) {

	int type = node.getNodeType();
	fLocator.fRelatedNode = node;
	boolean wellformed;
	switch (type) {
	case Node.DOCUMENT_NODE: {
	break;
	}
	case Node.DOCUMENT_TYPE_NODE: {
	break;
	}
	case Node.ELEMENT_NODE: {
	if (verifyNames) {
	if ((features & NAMESPACES) != 0) {
	wellformed = CoreDocumentImpl.isValidQName(node.getPrefix(), node.getLocalName(), xml11Version);
	} else {
	wellformed = CoreDocumentImpl.isXMLName(node.getNodeName(), xml11Version);
	}
	if (!wellformed) {
	if (fErrorHandler != null) {
	String msg = DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"wf-invalid-character-in-node-name",
	new Object[]{"Element", node.getNodeName()});
	DOMNormalizer.reportDOMError(fErrorHandler, fError, fLocator, msg, DOMError.SEVERITY_FATAL_ERROR,
	"wf-invalid-character-in-node-name");
	}
	}
	}

	NamedNodeMap attributes = (node.hasAttributes()) ? node.getAttributes() : null;
	if (attributes != null) {
	for (int i = 0; i < attributes.getLength(); ++i) {
	Attr attr = (Attr) attributes.item(i);
	fLocator.fRelatedNode = attr;
	DOMNormalizer.isAttrValueWF(fErrorHandler, fError, fLocator,
	attributes, attr, attr.getValue(), xml11Version);
	if (verifyNames) {
	wellformed = CoreDocumentImpl.isXMLName(attr.getNodeName(), xml11Version);
	if (!wellformed) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"wf-invalid-character-in-node-name",
	new Object[]{"Attr", node.getNodeName()});
	DOMNormalizer.reportDOMError(fErrorHandler, fError, fLocator, msg, DOMError.SEVERITY_FATAL_ERROR,
	"wf-invalid-character-in-node-name");
	}
	}
	}

	}

	break;
	}

	case Node.COMMENT_NODE: {
	// only verify well-formness if comments included in the tree
	if ((features & COMMENTS) != 0) {
	DOMNormalizer.isCommentWF(fErrorHandler, fError, fLocator, ((Comment) node).getData(), xml11Version);
	}
	break;
	}
	case Node.ENTITY_REFERENCE_NODE: {
	// only if entity is preserved in the tree
	if (verifyNames && (features & ENTITIES) != 0) {
	CoreDocumentImpl.isXMLName(node.getNodeName(), xml11Version);
	}
	break;

	}
	case Node.CDATA_SECTION_NODE: {
	// verify content
	DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, node.getNodeValue(), xml11Version);
	// the ]]> string will be checked during serialization
	break;
	}
	case Node.TEXT_NODE: {
	DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, node.getNodeValue(), xml11Version);
	break;
	}
	case Node.PROCESSING_INSTRUCTION_NODE: {
	ProcessingInstruction pinode = (ProcessingInstruction) node;
	String target = pinode.getTarget();
	if (verifyNames) {
	if (xml11Version) {
	wellformed = XML11Char.isXML11ValidName(target);
	} else {
	wellformed = XMLChar.isValidName(target);
	}

	if (!wellformed) {
	String msg
	= DOMMessageFormatter.formatMessage(
	DOMMessageFormatter.DOM_DOMAIN,
	"wf-invalid-character-in-node-name",
	new Object[]{"Element", node.getNodeName()});
	DOMNormalizer.reportDOMError(
	fErrorHandler,
	fError,
	fLocator,
	msg,
	DOMError.SEVERITY_FATAL_ERROR,
	"wf-invalid-character-in-node-name");
	}
	}
	DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, pinode.getData(), xml11Version);
	break;
	}
	}
	fLocator.fRelatedNode = null;
	}

	private String _getXmlVersion(Node node) {
	Document doc = (node.getNodeType() == Node.DOCUMENT_NODE)
	? (Document) node : node.getOwnerDocument();
	if (doc != null) {
	try {
	return doc.getXmlVersion();
	} // The VM ran out of memory or there was some other serious problem. Re-throw.
	catch (VirtualMachineError \| ThreadDeath vme) {
	throw vme;
	} // Ignore all other exceptions and errors
	catch (Throwable t) {
	}
	}
	return null;
	}

	private String _getInputEncoding(Node node) {
	Document doc = (node.getNodeType() == Node.DOCUMENT_NODE)
	? (Document) node : node.getOwnerDocument();
	if (doc != null) {
	try {
	return doc.getInputEncoding();
	} // The VM ran out of memory or there was some other serious problem. Re-throw.
	catch (VirtualMachineError \| ThreadDeath vme) {
	throw vme;
	} // Ignore all other exceptions and errors
	catch (Throwable t) {
	}
	}
	return null;
	}

	private String _getXmlEncoding(Node node) {
	Document doc = (node.getNodeType() == Node.DOCUMENT_NODE)
	? (Document) node : node.getOwnerDocument();
	if (doc != null) {
	try {
	return doc.getXmlEncoding();
	} // The VM ran out of memory or there was some other serious problem. Re-throw.
	catch (VirtualMachineError \| ThreadDeath vme) {
	throw vme;
	} // Ignore all other exceptions and errors
	catch (Throwable t) {
	}
	}
	return null;
	}

	} //DOMSerializerImpl

Back to index...