You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1968 lines
64 KiB
1968 lines
64 KiB
/*
|
|
* Copyright (c) 2015, 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.
|
|
*/
|
|
|
|
// Sep 14, 2000:
|
|
// Fixed comments to preserve whitespaces and add a line break
|
|
// when indenting. Reported by Gervase Markham <gerv@gerv.net>
|
|
// Sep 14, 2000:
|
|
// Fixed serializer to report IO exception directly, instead at
|
|
// the end of document processing.
|
|
// Reported by Patrick Higgins <phiggins@transzap.com>
|
|
// Sep 13, 2000:
|
|
// CR in character data will print as �D;
|
|
// Aug 25, 2000:
|
|
// Fixed processing instruction printing inside element content
|
|
// to not escape content. Reported by Mikael Staldal
|
|
// <d96-mst@d.kth.se>
|
|
// Aug 25, 2000:
|
|
// Added ability to omit comments.
|
|
// Contributed by Anupam Bagchi <abagchi@jtcsv.com>
|
|
// Aug 26, 2000:
|
|
// Fixed bug in newline handling when preserving spaces.
|
|
// Contributed by Mike Dusseault <mdusseault@home.com>
|
|
// Aug 29, 2000:
|
|
// Fixed state.unescaped not being set to false when
|
|
// entering element state.
|
|
// Reported by Lowell Vaughn <lvaughn@agillion.com>
|
|
|
|
|
|
package com.sun.org.apache.xml.internal.serialize;
|
|
|
|
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.util.XMLChar;
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.Writer;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Vector;
|
|
|
|
import org.w3c.dom.DOMError;
|
|
import org.w3c.dom.DOMErrorHandler;
|
|
import org.w3c.dom.DOMImplementation;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.DocumentFragment;
|
|
import org.w3c.dom.DocumentType;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.Entity;
|
|
import org.w3c.dom.NamedNodeMap;
|
|
import org.w3c.dom.Node;
|
|
import org.w3c.dom.Notation;
|
|
import org.w3c.dom.ls.LSException;
|
|
import org.w3c.dom.ls.LSSerializerFilter;
|
|
import org.w3c.dom.traversal.NodeFilter;
|
|
import org.xml.sax.ContentHandler;
|
|
import org.xml.sax.DTDHandler;
|
|
import org.xml.sax.DocumentHandler;
|
|
import org.xml.sax.Locator;
|
|
import org.xml.sax.SAXException;
|
|
import org.xml.sax.ext.DeclHandler;
|
|
import org.xml.sax.ext.LexicalHandler;
|
|
|
|
/**
|
|
* Base class for a serializer supporting both DOM and SAX pretty
|
|
* serializing of XML/HTML/XHTML documents. Derives classes perform
|
|
* the method-specific serializing, this class provides the common
|
|
* serializing mechanisms.
|
|
* <p>
|
|
* The serializer must be initialized with the proper writer and
|
|
* output format before it can be used by calling {@link #setOutputCharStream}
|
|
* or {@link #setOutputByteStream} for the writer and {@link #setOutputFormat}
|
|
* for the output format.
|
|
* <p>
|
|
* The serializer can be reused any number of times, but cannot
|
|
* be used concurrently by two threads.
|
|
* <p>
|
|
* If an output stream is used, the encoding is taken from the
|
|
* output format (defaults to <tt>UTF-8</tt>). If a writer is
|
|
* used, make sure the writer uses the same encoding (if applies)
|
|
* as specified in the output format.
|
|
* <p>
|
|
* The serializer supports both DOM and SAX. DOM serializing is done
|
|
* by calling {@link #serialize(Document)} and SAX serializing is done by firing
|
|
* SAX events and using the serializer as a document handler.
|
|
* This also applies to derived class.
|
|
* <p>
|
|
* If an I/O exception occurs while serializing, the serializer
|
|
* will not throw an exception directly, but only throw it
|
|
* at the end of serializing (either DOM or SAX's {@link
|
|
* org.xml.sax.DocumentHandler#endDocument}.
|
|
* <p>
|
|
* For elements that are not specified as whitespace preserving,
|
|
* the serializer will potentially break long text lines at space
|
|
* boundaries, indent lines, and serialize elements on separate
|
|
* lines. Line terminators will be regarded as spaces, and
|
|
* spaces at beginning of line will be stripped.
|
|
* <p>
|
|
* When indenting, the serializer is capable of detecting seemingly
|
|
* element content, and serializing these elements indented on separate
|
|
* lines. An element is serialized indented when it is the first or
|
|
* last child of an element, or immediate following or preceding
|
|
* another element.
|
|
*
|
|
*
|
|
* @author <a href="mailto:arkin@intalio.com">Assaf Arkin</a>
|
|
* @author <a href="mailto:rahul.srivastava@sun.com">Rahul Srivastava</a>
|
|
* @author Elena Litani, IBM
|
|
* @author Sunitha Reddy, Sun Microsystems
|
|
* @see Serializer
|
|
* @see LSSerializer
|
|
*/
|
|
public abstract class BaseMarkupSerializer
|
|
implements ContentHandler, DocumentHandler, LexicalHandler,
|
|
DTDHandler, DeclHandler, DOMSerializer, Serializer
|
|
{
|
|
|
|
// DOM L3 implementation
|
|
protected short features = 0xFFFFFFFF;
|
|
protected DOMErrorHandler fDOMErrorHandler;
|
|
protected final DOMErrorImpl fDOMError = new DOMErrorImpl();
|
|
protected LSSerializerFilter fDOMFilter;
|
|
|
|
protected EncodingInfo _encodingInfo;
|
|
|
|
|
|
/**
|
|
* Holds array of all element states that have been entered.
|
|
* The array is automatically resized. When leaving an element,
|
|
* it's state is not removed but reused when later returning
|
|
* to the same nesting level.
|
|
*/
|
|
private ElementState[] _elementStates;
|
|
|
|
|
|
/**
|
|
* The index of the next state to place in the array,
|
|
* or one plus the index of the current state. When zero,
|
|
* we are in no state.
|
|
*/
|
|
private int _elementStateCount;
|
|
|
|
|
|
/**
|
|
* Vector holding comments and PIs that come before the root
|
|
* element (even after it), see {@link #serializePreRoot}.
|
|
*/
|
|
private Vector _preRoot;
|
|
|
|
|
|
/**
|
|
* If the document has been started (header serialized), this
|
|
* flag is set to true so it's not started twice.
|
|
*/
|
|
protected boolean _started;
|
|
|
|
|
|
/**
|
|
* True if the serializer has been prepared. This flag is set
|
|
* to false when the serializer is reset prior to using it,
|
|
* and to true after it has been prepared for usage.
|
|
*/
|
|
private boolean _prepared;
|
|
|
|
|
|
/**
|
|
* Association between namespace URIs (keys) and prefixes (values).
|
|
* Accumulated here prior to starting an element and placing this
|
|
* list in the element state.
|
|
*/
|
|
protected Map<String, String> _prefixes;
|
|
|
|
|
|
/**
|
|
* The system identifier of the document type, if known.
|
|
*/
|
|
protected String _docTypePublicId;
|
|
|
|
|
|
/**
|
|
* The system identifier of the document type, if known.
|
|
*/
|
|
protected String _docTypeSystemId;
|
|
|
|
|
|
/**
|
|
* The output format associated with this serializer. This will never
|
|
* be a null reference. If no format was passed to the constructor,
|
|
* the default one for this document type will be used. The format
|
|
* object is never changed by the serializer.
|
|
*/
|
|
protected OutputFormat _format;
|
|
|
|
|
|
/**
|
|
* The printer used for printing text parts.
|
|
*/
|
|
protected Printer _printer;
|
|
|
|
|
|
/**
|
|
* True if indenting printer.
|
|
*/
|
|
protected boolean _indenting;
|
|
|
|
/** Temporary buffer to store character data */
|
|
protected final StringBuffer fStrBuffer = new StringBuffer(40);
|
|
|
|
/**
|
|
* The underlying writer.
|
|
*/
|
|
private Writer _writer;
|
|
|
|
|
|
/**
|
|
* The output stream.
|
|
*/
|
|
private OutputStream _output;
|
|
|
|
/** Current node that is being processed */
|
|
protected Node fCurrentNode = null;
|
|
|
|
|
|
|
|
//--------------------------------//
|
|
// Constructor and initialization //
|
|
//--------------------------------//
|
|
|
|
|
|
/**
|
|
* Protected constructor can only be used by derived class.
|
|
* Must initialize the serializer before serializing any document,
|
|
* by calling {@link #setOutputCharStream} or {@link #setOutputByteStream}
|
|
* first
|
|
*/
|
|
protected BaseMarkupSerializer( OutputFormat format )
|
|
{
|
|
int i;
|
|
|
|
_elementStates = new ElementState[ 10 ];
|
|
for ( i = 0 ; i < _elementStates.length ; ++i )
|
|
_elementStates[ i ] = new ElementState();
|
|
_format = format;
|
|
}
|
|
|
|
|
|
public DocumentHandler asDocumentHandler()
|
|
throws IOException
|
|
{
|
|
prepare();
|
|
return this;
|
|
}
|
|
|
|
|
|
public ContentHandler asContentHandler()
|
|
throws IOException
|
|
{
|
|
prepare();
|
|
return this;
|
|
}
|
|
|
|
|
|
public DOMSerializer asDOMSerializer()
|
|
throws IOException
|
|
{
|
|
prepare();
|
|
return this;
|
|
}
|
|
|
|
|
|
public void setOutputByteStream( OutputStream output )
|
|
{
|
|
if ( output == null ) {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"ArgumentIsNull", new Object[]{"output"});
|
|
throw new NullPointerException(msg);
|
|
}
|
|
_output = output;
|
|
_writer = null;
|
|
reset();
|
|
}
|
|
|
|
|
|
public void setOutputCharStream( Writer writer )
|
|
{
|
|
if ( writer == null ) {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"ArgumentIsNull", new Object[]{"writer"});
|
|
throw new NullPointerException(msg);
|
|
}
|
|
_writer = writer;
|
|
_output = null;
|
|
reset();
|
|
}
|
|
|
|
|
|
public void setOutputFormat( OutputFormat format )
|
|
{
|
|
if ( format == null ) {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"ArgumentIsNull", new Object[]{"format"});
|
|
throw new NullPointerException(msg);
|
|
}
|
|
_format = format;
|
|
reset();
|
|
}
|
|
|
|
|
|
public boolean reset()
|
|
{
|
|
if ( _elementStateCount > 1 ) {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"ResetInMiddle", null);
|
|
throw new IllegalStateException(msg);
|
|
}
|
|
_prepared = false;
|
|
fCurrentNode = null;
|
|
fStrBuffer.setLength(0);
|
|
return true;
|
|
}
|
|
|
|
|
|
protected void prepare()
|
|
throws IOException
|
|
{
|
|
if ( _prepared )
|
|
return;
|
|
|
|
if ( _writer == null && _output == null ) {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"NoWriterSupplied", null);
|
|
throw new IOException(msg);
|
|
}
|
|
// If the output stream has been set, use it to construct
|
|
// the writer. It is possible that the serializer has been
|
|
// reused with the same output stream and different encoding.
|
|
|
|
_encodingInfo = _format.getEncodingInfo();
|
|
|
|
if ( _output != null ) {
|
|
_writer = _encodingInfo.getWriter(_output);
|
|
}
|
|
|
|
if ( _format.getIndenting() ) {
|
|
_indenting = true;
|
|
_printer = new IndentPrinter( _writer, _format );
|
|
} else {
|
|
_indenting = false;
|
|
_printer = new Printer( _writer, _format );
|
|
}
|
|
|
|
ElementState state;
|
|
|
|
_elementStateCount = 0;
|
|
state = _elementStates[ 0 ];
|
|
state.namespaceURI = null;
|
|
state.localName = null;
|
|
state.rawName = null;
|
|
state.preserveSpace = _format.getPreserveSpace();
|
|
state.empty = true;
|
|
state.afterElement = false;
|
|
state.afterComment = false;
|
|
state.doCData = state.inCData = false;
|
|
state.prefixes = null;
|
|
|
|
_docTypePublicId = _format.getDoctypePublic();
|
|
_docTypeSystemId = _format.getDoctypeSystem();
|
|
_started = false;
|
|
_prepared = true;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------//
|
|
// DOM document serializing methods //
|
|
//----------------------------------//
|
|
|
|
|
|
/**
|
|
* Serializes the DOM element using the previously specified
|
|
* writer and output format. Throws an exception only if
|
|
* an I/O exception occured while serializing.
|
|
*
|
|
* @param elem The element to serialize
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
public void serialize( Element elem )
|
|
throws IOException
|
|
{
|
|
reset();
|
|
prepare();
|
|
serializeNode( elem );
|
|
_printer.flush();
|
|
if ( _printer.getException() != null )
|
|
throw _printer.getException();
|
|
}
|
|
|
|
/**
|
|
* Serializes a node using the previously specified
|
|
* writer and output format. Throws an exception only if
|
|
* an I/O exception occured while serializing.
|
|
*
|
|
* @param node Node to serialize
|
|
* @throws IOException An I/O exception occured while serializing
|
|
*/
|
|
public void serialize( Node node ) throws IOException {
|
|
reset();
|
|
prepare();
|
|
serializeNode( node );
|
|
//Print any PIs and Comments which appeared in 'node'
|
|
serializePreRoot();
|
|
_printer.flush();
|
|
if ( _printer.getException() != null )
|
|
throw _printer.getException();
|
|
}
|
|
|
|
/**
|
|
* Serializes the DOM document fragmnt using the previously specified
|
|
* writer and output format. Throws an exception only if
|
|
* an I/O exception occured while serializing.
|
|
*
|
|
* @param elem The element to serialize
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
public void serialize( DocumentFragment frag )
|
|
throws IOException
|
|
{
|
|
reset();
|
|
prepare();
|
|
serializeNode( frag );
|
|
_printer.flush();
|
|
if ( _printer.getException() != null )
|
|
throw _printer.getException();
|
|
}
|
|
|
|
|
|
/**
|
|
* Serializes the DOM document using the previously specified
|
|
* writer and output format. Throws an exception only if
|
|
* an I/O exception occured while serializing.
|
|
*
|
|
* @param doc The document to serialize
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
public void serialize( Document doc )
|
|
throws IOException
|
|
{
|
|
reset();
|
|
prepare();
|
|
serializeNode( doc );
|
|
serializePreRoot();
|
|
_printer.flush();
|
|
if ( _printer.getException() != null )
|
|
throw _printer.getException();
|
|
}
|
|
|
|
|
|
//------------------------------------------//
|
|
// SAX document handler serializing methods //
|
|
//------------------------------------------//
|
|
|
|
|
|
public void startDocument()
|
|
throws SAXException
|
|
{
|
|
try {
|
|
prepare();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except.toString() );
|
|
}
|
|
// Nothing to do here. All the magic happens in startDocument(String)
|
|
}
|
|
|
|
|
|
public void characters( char[] chars, int start, int length )
|
|
throws SAXException
|
|
{
|
|
ElementState state;
|
|
|
|
try {
|
|
state = content();
|
|
|
|
// Check if text should be print as CDATA section or unescaped
|
|
// based on elements listed in the output format (the element
|
|
// state) or whether we are inside a CDATA section or entity.
|
|
|
|
if ( state.inCData || state.doCData ) {
|
|
int saveIndent;
|
|
|
|
// Print a CDATA section. The text is not escaped, but ']]>'
|
|
// appearing in the code must be identified and dealt with.
|
|
// The contents of a text node is considered space preserving.
|
|
if ( ! state.inCData ) {
|
|
_printer.printText( "<![CDATA[" );
|
|
state.inCData = true;
|
|
}
|
|
saveIndent = _printer.getNextIndent();
|
|
_printer.setNextIndent( 0 );
|
|
char ch;
|
|
final int end = start + length;
|
|
for ( int index = start ; index < end; ++index ) {
|
|
ch = chars[index];
|
|
if ( ch == ']' && index + 2 < end &&
|
|
chars[ index + 1 ] == ']' && chars[ index + 2 ] == '>' ) {
|
|
_printer.printText("]]]]><![CDATA[>");
|
|
index +=2;
|
|
continue;
|
|
}
|
|
if (!XMLChar.isValid(ch)) {
|
|
// check if it is surrogate
|
|
if (++index < end) {
|
|
surrogates(ch, chars[index]);
|
|
}
|
|
else {
|
|
fatalError("The character '"+(char)ch+"' is an invalid XML character");
|
|
}
|
|
continue;
|
|
} else {
|
|
if ( ( ch >= ' ' && _encodingInfo.isPrintable((char)ch) && ch != 0xF7 ) ||
|
|
ch == '\n' || ch == '\r' || ch == '\t' ) {
|
|
_printer.printText((char)ch);
|
|
} else {
|
|
// The character is not printable -- split CDATA section
|
|
_printer.printText("]]>&#x");
|
|
_printer.printText(Integer.toHexString(ch));
|
|
_printer.printText(";<![CDATA[");
|
|
}
|
|
}
|
|
}
|
|
_printer.setNextIndent( saveIndent );
|
|
|
|
} else {
|
|
|
|
int saveIndent;
|
|
|
|
if ( state.preserveSpace ) {
|
|
// If preserving space then hold of indentation so no
|
|
// excessive spaces are printed at line breaks, escape
|
|
// the text content without replacing spaces and print
|
|
// the text breaking only at line breaks.
|
|
saveIndent = _printer.getNextIndent();
|
|
_printer.setNextIndent( 0 );
|
|
printText( chars, start, length, true, state.unescaped );
|
|
_printer.setNextIndent( saveIndent );
|
|
} else {
|
|
printText( chars, start, length, false, state.unescaped );
|
|
}
|
|
}
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void ignorableWhitespace( char[] chars, int start, int length )
|
|
throws SAXException
|
|
{
|
|
int i;
|
|
|
|
try {
|
|
content();
|
|
|
|
// Print ignorable whitespaces only when indenting, after
|
|
// all they are indentation. Cancel the indentation to
|
|
// not indent twice.
|
|
if ( _indenting ) {
|
|
_printer.setThisIndent( 0 );
|
|
for ( i = start ; length-- > 0 ; ++i )
|
|
_printer.printText( chars[ i ] );
|
|
}
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public final void processingInstruction( String target, String code )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
processingInstructionIO( target, code );
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
public void processingInstructionIO( String target, String code )
|
|
throws IOException
|
|
{
|
|
int index;
|
|
ElementState state;
|
|
|
|
state = content();
|
|
|
|
// Create the processing instruction textual representation.
|
|
// Make sure we don't have '?>' inside either target or code.
|
|
index = target.indexOf( "?>" );
|
|
if ( index >= 0 )
|
|
fStrBuffer.append( "<?" ).append( target.substring( 0, index ) );
|
|
else
|
|
fStrBuffer.append( "<?" ).append( target );
|
|
if ( code != null ) {
|
|
fStrBuffer.append( ' ' );
|
|
index = code.indexOf( "?>" );
|
|
if ( index >= 0 )
|
|
fStrBuffer.append( code.substring( 0, index ) );
|
|
else
|
|
fStrBuffer.append( code );
|
|
}
|
|
fStrBuffer.append( "?>" );
|
|
|
|
// If before the root element (or after it), do not print
|
|
// the PI directly but place it in the pre-root vector.
|
|
if ( isDocumentState() ) {
|
|
if ( _preRoot == null )
|
|
_preRoot = new Vector();
|
|
_preRoot.addElement( fStrBuffer.toString() );
|
|
} else {
|
|
_printer.indent();
|
|
printText( fStrBuffer.toString(), true, true );
|
|
_printer.unindent();
|
|
if ( _indenting )
|
|
state.afterElement = true;
|
|
}
|
|
|
|
fStrBuffer.setLength(0);
|
|
}
|
|
|
|
|
|
public void comment( char[] chars, int start, int length )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
comment( new String( chars, start, length ) );
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void comment( String text )
|
|
throws IOException
|
|
{
|
|
int index;
|
|
ElementState state;
|
|
|
|
if ( _format.getOmitComments() )
|
|
return;
|
|
|
|
state = content();
|
|
// Create the processing comment textual representation.
|
|
// Make sure we don't have '-->' inside the comment.
|
|
index = text.indexOf( "-->" );
|
|
if ( index >= 0 )
|
|
fStrBuffer.append( "<!--" ).append( text.substring( 0, index ) ).append( "-->" );
|
|
else
|
|
fStrBuffer.append( "<!--" ).append( text ).append( "-->" );
|
|
|
|
// If before the root element (or after it), do not print
|
|
// the comment directly but place it in the pre-root vector.
|
|
if ( isDocumentState() ) {
|
|
if ( _preRoot == null )
|
|
_preRoot = new Vector();
|
|
_preRoot.addElement( fStrBuffer.toString() );
|
|
} else {
|
|
// Indent this element on a new line if the first
|
|
// content of the parent element or immediately
|
|
// following an element.
|
|
if ( _indenting && ! state.preserveSpace)
|
|
_printer.breakLine();
|
|
_printer.indent();
|
|
printText( fStrBuffer.toString(), true, true );
|
|
_printer.unindent();
|
|
if ( _indenting )
|
|
state.afterElement = true;
|
|
}
|
|
|
|
fStrBuffer.setLength(0);
|
|
state.afterComment = true;
|
|
state.afterElement = false;
|
|
}
|
|
|
|
|
|
public void startCDATA()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.doCData = true;
|
|
}
|
|
|
|
|
|
public void endCDATA()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.doCData = false;
|
|
}
|
|
|
|
|
|
public void startNonEscaping()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.unescaped = true;
|
|
}
|
|
|
|
|
|
public void endNonEscaping()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.unescaped = false;
|
|
}
|
|
|
|
|
|
public void startPreserving()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.preserveSpace = true;
|
|
}
|
|
|
|
|
|
public void endPreserving()
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
state.preserveSpace = false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Called at the end of the document to wrap it up.
|
|
* Will flush the output stream and throw an exception
|
|
* if any I/O error occured while serializing.
|
|
*
|
|
* @throws SAXException An I/O exception occured during
|
|
* serializing
|
|
*/
|
|
public void endDocument()
|
|
throws SAXException
|
|
{
|
|
try {
|
|
// Print all the elements accumulated outside of
|
|
// the root element.
|
|
serializePreRoot();
|
|
// Flush the output, this is necessary for fStrBuffered output.
|
|
_printer.flush();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void startEntity( String name )
|
|
{
|
|
// ???
|
|
}
|
|
|
|
|
|
public void endEntity( String name )
|
|
{
|
|
// ???
|
|
}
|
|
|
|
|
|
public void setDocumentLocator( Locator locator )
|
|
{
|
|
// Nothing to do
|
|
}
|
|
|
|
|
|
//-----------------------------------------//
|
|
// SAX content handler serializing methods //
|
|
//-----------------------------------------//
|
|
|
|
|
|
public void skippedEntity ( String name )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
endCDATA();
|
|
content();
|
|
_printer.printText( '&' );
|
|
_printer.printText( name );
|
|
_printer.printText( ';' );
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void startPrefixMapping( String prefix, String uri )
|
|
throws SAXException
|
|
{
|
|
if ( _prefixes == null )
|
|
_prefixes = new HashMap<>();
|
|
_prefixes.put( uri, prefix == null ? "" : prefix );
|
|
}
|
|
|
|
|
|
public void endPrefixMapping( String prefix )
|
|
throws SAXException
|
|
{
|
|
}
|
|
|
|
|
|
//------------------------------------------//
|
|
// SAX DTD/Decl handler serializing methods //
|
|
//------------------------------------------//
|
|
|
|
|
|
public final void startDTD( String name, String publicId, String systemId )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
_docTypePublicId = publicId;
|
|
_docTypeSystemId = systemId;
|
|
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void endDTD()
|
|
{
|
|
// Nothing to do here, all the magic occurs in startDocument(String).
|
|
}
|
|
|
|
|
|
public void elementDecl( String name, String model )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
_printer.printText( "<!ELEMENT " );
|
|
_printer.printText( name );
|
|
_printer.printText( ' ' );
|
|
_printer.printText( model );
|
|
_printer.printText( '>' );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void attributeDecl( String eName, String aName, String type,
|
|
String valueDefault, String value )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
_printer.printText( "<!ATTLIST " );
|
|
_printer.printText( eName );
|
|
_printer.printText( ' ' );
|
|
_printer.printText( aName );
|
|
_printer.printText( ' ' );
|
|
_printer.printText( type );
|
|
if ( valueDefault != null ) {
|
|
_printer.printText( ' ' );
|
|
_printer.printText( valueDefault );
|
|
}
|
|
if ( value != null ) {
|
|
_printer.printText( " \"" );
|
|
printEscaped( value );
|
|
_printer.printText( '"' );
|
|
}
|
|
_printer.printText( '>' );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void internalEntityDecl( String name, String value )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
_printer.printText( "<!ENTITY " );
|
|
_printer.printText( name );
|
|
_printer.printText( " \"" );
|
|
printEscaped( value );
|
|
_printer.printText( "\">" );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void externalEntityDecl( String name, String publicId, String systemId )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
unparsedEntityDecl( name, publicId, systemId, null );
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void unparsedEntityDecl( String name, String publicId,
|
|
String systemId, String notationName )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
if ( publicId == null ) {
|
|
_printer.printText( "<!ENTITY " );
|
|
_printer.printText( name );
|
|
_printer.printText( " SYSTEM " );
|
|
printDoctypeURL( systemId );
|
|
} else {
|
|
_printer.printText( "<!ENTITY " );
|
|
_printer.printText( name );
|
|
_printer.printText( " PUBLIC " );
|
|
printDoctypeURL( publicId );
|
|
_printer.printText( ' ' );
|
|
printDoctypeURL( systemId );
|
|
}
|
|
if ( notationName != null ) {
|
|
_printer.printText( " NDATA " );
|
|
_printer.printText( notationName );
|
|
}
|
|
_printer.printText( '>' );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
public void notationDecl( String name, String publicId, String systemId )
|
|
throws SAXException
|
|
{
|
|
try {
|
|
_printer.enterDTD();
|
|
if ( publicId != null ) {
|
|
_printer.printText( "<!NOTATION " );
|
|
_printer.printText( name );
|
|
_printer.printText( " PUBLIC " );
|
|
printDoctypeURL( publicId );
|
|
if ( systemId != null ) {
|
|
_printer.printText( ' ' );
|
|
printDoctypeURL( systemId );
|
|
}
|
|
} else {
|
|
_printer.printText( "<!NOTATION " );
|
|
_printer.printText( name );
|
|
_printer.printText( " SYSTEM " );
|
|
printDoctypeURL( systemId );
|
|
}
|
|
_printer.printText( '>' );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
} catch ( IOException except ) {
|
|
throw new SAXException( except );
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------//
|
|
// Generic node serializing methods methods //
|
|
//------------------------------------------//
|
|
|
|
|
|
/**
|
|
* Serialize the DOM node. This method is shared across XML, HTML and XHTML
|
|
* serializers and the differences are masked out in a separate {@link
|
|
* #serializeElement}.
|
|
*
|
|
* @param node The node to serialize
|
|
* @see #serializeElement
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
protected void serializeNode( Node node )
|
|
throws IOException
|
|
{
|
|
fCurrentNode = node;
|
|
|
|
// Based on the node type call the suitable SAX handler.
|
|
// Only comments entities and documents which are not
|
|
// handled by SAX are serialized directly.
|
|
switch ( node.getNodeType() ) {
|
|
case Node.TEXT_NODE : {
|
|
String text;
|
|
|
|
text = node.getNodeValue();
|
|
if ( text != null ) {
|
|
if (fDOMFilter !=null &&
|
|
(fDOMFilter.getWhatToShow() & NodeFilter.SHOW_TEXT)!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT:
|
|
case NodeFilter.FILTER_SKIP: {
|
|
break;
|
|
}
|
|
default: {
|
|
characters(text);
|
|
}
|
|
}
|
|
}
|
|
else if ( !_indenting || getElementState().preserveSpace
|
|
|| (text.replace('\n',' ').trim().length() != 0))
|
|
characters( text );
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Node.CDATA_SECTION_NODE : {
|
|
String text = node.getNodeValue();
|
|
if ((features & DOMSerializerImpl.CDATA) != 0) {
|
|
if (text != null) {
|
|
if (fDOMFilter != null
|
|
&& (fDOMFilter.getWhatToShow()
|
|
& NodeFilter.SHOW_CDATA_SECTION)
|
|
!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT :
|
|
case NodeFilter.FILTER_SKIP :
|
|
{
|
|
// skip the CDATA node
|
|
return;
|
|
}
|
|
default :
|
|
{
|
|
//fall through..
|
|
}
|
|
}
|
|
}
|
|
startCDATA();
|
|
characters(text);
|
|
endCDATA();
|
|
}
|
|
} else {
|
|
// transform into a text node
|
|
characters(text);
|
|
}
|
|
break;
|
|
}
|
|
case Node.COMMENT_NODE : {
|
|
String text;
|
|
|
|
if ( ! _format.getOmitComments() ) {
|
|
text = node.getNodeValue();
|
|
if ( text != null ) {
|
|
|
|
if (fDOMFilter !=null &&
|
|
(fDOMFilter.getWhatToShow() & NodeFilter.SHOW_COMMENT)!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT:
|
|
case NodeFilter.FILTER_SKIP: {
|
|
// skip the comment node
|
|
return;
|
|
}
|
|
default: {
|
|
// fall through
|
|
}
|
|
}
|
|
}
|
|
comment( text );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Node.ENTITY_REFERENCE_NODE : {
|
|
Node child;
|
|
|
|
endCDATA();
|
|
content();
|
|
|
|
if (((features & DOMSerializerImpl.ENTITIES) != 0)
|
|
|| (node.getFirstChild() == null)) {
|
|
if (fDOMFilter !=null &&
|
|
(fDOMFilter.getWhatToShow() & NodeFilter.SHOW_ENTITY_REFERENCE)!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT:{
|
|
return; // remove the node
|
|
}
|
|
case NodeFilter.FILTER_SKIP: {
|
|
child = node.getFirstChild();
|
|
while ( child != null ) {
|
|
serializeNode( child );
|
|
child = child.getNextSibling();
|
|
}
|
|
return;
|
|
}
|
|
|
|
default: {
|
|
// fall through
|
|
}
|
|
}
|
|
}
|
|
checkUnboundNamespacePrefixedNode(node);
|
|
|
|
_printer.printText("&");
|
|
_printer.printText(node.getNodeName());
|
|
_printer.printText(";");
|
|
}
|
|
else {
|
|
child = node.getFirstChild();
|
|
while ( child != null ) {
|
|
serializeNode( child );
|
|
child = child.getNextSibling();
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case Node.PROCESSING_INSTRUCTION_NODE : {
|
|
|
|
if (fDOMFilter !=null &&
|
|
(fDOMFilter.getWhatToShow() & NodeFilter.SHOW_PROCESSING_INSTRUCTION)!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT:
|
|
case NodeFilter.FILTER_SKIP: {
|
|
return; // skip this node
|
|
}
|
|
default: { // fall through
|
|
}
|
|
}
|
|
}
|
|
processingInstructionIO( node.getNodeName(), node.getNodeValue() );
|
|
break;
|
|
}
|
|
case Node.ELEMENT_NODE : {
|
|
|
|
if (fDOMFilter !=null &&
|
|
(fDOMFilter.getWhatToShow() & NodeFilter.SHOW_ELEMENT)!= 0) {
|
|
short code = fDOMFilter.acceptNode(node);
|
|
switch (code) {
|
|
case NodeFilter.FILTER_REJECT: {
|
|
return;
|
|
}
|
|
case NodeFilter.FILTER_SKIP: {
|
|
Node child = node.getFirstChild();
|
|
while ( child != null ) {
|
|
serializeNode( child );
|
|
child = child.getNextSibling();
|
|
}
|
|
return; // skip this node
|
|
}
|
|
|
|
default: { // fall through
|
|
}
|
|
}
|
|
}
|
|
serializeElement( (Element) node );
|
|
break;
|
|
}
|
|
case Node.DOCUMENT_NODE : {
|
|
DocumentType docType;
|
|
DOMImplementation domImpl;
|
|
NamedNodeMap map;
|
|
Entity entity;
|
|
Notation notation;
|
|
int i;
|
|
|
|
serializeDocument();
|
|
|
|
// If there is a document type, use the SAX events to
|
|
// serialize it.
|
|
docType = ( (Document) node ).getDoctype();
|
|
if (docType != null) {
|
|
// DOM Level 2 (or higher)
|
|
domImpl = ( (Document) node ).getImplementation();
|
|
try {
|
|
String internal;
|
|
|
|
_printer.enterDTD();
|
|
_docTypePublicId = docType.getPublicId();
|
|
_docTypeSystemId = docType.getSystemId();
|
|
internal = docType.getInternalSubset();
|
|
if ( internal != null && internal.length() > 0 )
|
|
_printer.printText( internal );
|
|
endDTD();
|
|
}
|
|
// DOM Level 1 -- does implementation have methods?
|
|
catch (NoSuchMethodError nsme) {
|
|
Class docTypeClass = docType.getClass();
|
|
|
|
String docTypePublicId = null;
|
|
String docTypeSystemId = null;
|
|
try {
|
|
java.lang.reflect.Method getPublicId = docTypeClass.getMethod("getPublicId", (Class[]) null);
|
|
if (getPublicId.getReturnType().equals(String.class)) {
|
|
docTypePublicId = (String)getPublicId.invoke(docType, (Object[]) null);
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
// ignore
|
|
}
|
|
try {
|
|
java.lang.reflect.Method getSystemId = docTypeClass.getMethod("getSystemId", (Class[]) null);
|
|
if (getSystemId.getReturnType().equals(String.class)) {
|
|
docTypeSystemId = (String)getSystemId.invoke(docType, (Object[]) null);
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
// ignore
|
|
}
|
|
_printer.enterDTD();
|
|
_docTypePublicId = docTypePublicId;
|
|
_docTypeSystemId = docTypeSystemId;
|
|
endDTD();
|
|
}
|
|
|
|
serializeDTD(docType.getName());
|
|
|
|
}
|
|
_started = true;
|
|
|
|
// !! Fall through
|
|
}
|
|
case Node.DOCUMENT_FRAGMENT_NODE : {
|
|
Node child;
|
|
|
|
// By definition this will happen if the node is a document,
|
|
// document fragment, etc. Just serialize its contents. It will
|
|
// work well for other nodes that we do not know how to serialize.
|
|
child = node.getFirstChild();
|
|
while ( child != null ) {
|
|
serializeNode( child );
|
|
child = child.getNextSibling();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/* Serializes XML Declaration, according to 'xml-declaration' property.
|
|
*/
|
|
protected void serializeDocument()throws IOException {
|
|
int i;
|
|
|
|
String dtd = _printer.leaveDTD();
|
|
if (! _started) {
|
|
|
|
if (! _format.getOmitXMLDeclaration()) {
|
|
StringBuffer buffer;
|
|
|
|
// Serialize the document declaration appreaing at the head
|
|
// of very XML document (unless asked not to).
|
|
buffer = new StringBuffer( "<?xml version=\"" );
|
|
if (_format.getVersion() != null)
|
|
buffer.append( _format.getVersion() );
|
|
else
|
|
buffer.append( "1.0" );
|
|
buffer.append( '"' );
|
|
String format_encoding = _format.getEncoding();
|
|
if (format_encoding != null) {
|
|
buffer.append( " encoding=\"" );
|
|
buffer.append( format_encoding );
|
|
buffer.append( '"' );
|
|
}
|
|
if (_format.getStandalone() && _docTypeSystemId == null &&
|
|
_docTypePublicId == null)
|
|
buffer.append( " standalone=\"yes\"" );
|
|
buffer.append( "?>" );
|
|
_printer.printText( buffer );
|
|
_printer.breakLine();
|
|
}
|
|
}
|
|
|
|
// Always serialize these, even if not te first root element.
|
|
serializePreRoot();
|
|
|
|
}
|
|
|
|
/* Serializes DTD, if present.
|
|
*/
|
|
protected void serializeDTD(String name) throws IOException{
|
|
|
|
String dtd = _printer.leaveDTD();
|
|
if (! _format.getOmitDocumentType()) {
|
|
if (_docTypeSystemId != null) {
|
|
// System identifier must be specified to print DOCTYPE.
|
|
// If public identifier is specified print 'PUBLIC
|
|
// <public> <system>', if not, print 'SYSTEM <system>'.
|
|
_printer.printText( "<!DOCTYPE " );
|
|
_printer.printText( name );
|
|
if (_docTypePublicId != null) {
|
|
_printer.printText( " PUBLIC " );
|
|
printDoctypeURL( _docTypePublicId );
|
|
if (_indenting) {
|
|
_printer.breakLine();
|
|
for (int i = 0 ; i < 18 + name.length() ; ++i)
|
|
_printer.printText( " " );
|
|
} else
|
|
_printer.printText( " " );
|
|
printDoctypeURL( _docTypeSystemId );
|
|
} else {
|
|
_printer.printText( " SYSTEM " );
|
|
printDoctypeURL( _docTypeSystemId );
|
|
}
|
|
|
|
// If we accumulated any DTD contents while printing.
|
|
// this would be the place to print it.
|
|
if (dtd != null && dtd.length() > 0) {
|
|
_printer.printText( " [" );
|
|
printText( dtd, true, true );
|
|
_printer.printText( ']' );
|
|
}
|
|
|
|
_printer.printText( ">" );
|
|
_printer.breakLine();
|
|
} else if (dtd != null && dtd.length() > 0) {
|
|
_printer.printText( "<!DOCTYPE " );
|
|
_printer.printText( name );
|
|
_printer.printText( " [" );
|
|
printText( dtd, true, true );
|
|
_printer.printText( "]>" );
|
|
_printer.breakLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Must be called by a method about to print any type of content.
|
|
* If the element was just opened, the opening tag is closed and
|
|
* will be matched to a closing tag. Returns the current element
|
|
* state with <tt>empty</tt> and <tt>afterElement</tt> set to false.
|
|
*
|
|
* @return The current element state
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
protected ElementState content()
|
|
throws IOException
|
|
{
|
|
ElementState state;
|
|
|
|
state = getElementState();
|
|
if ( ! isDocumentState() ) {
|
|
// Need to close CData section first
|
|
if ( state.inCData && ! state.doCData ) {
|
|
_printer.printText( "]]>" );
|
|
state.inCData = false;
|
|
}
|
|
// If this is the first content in the element,
|
|
// change the state to not-empty and close the
|
|
// opening element tag.
|
|
if ( state.empty ) {
|
|
_printer.printText( '>' );
|
|
state.empty = false;
|
|
}
|
|
// Except for one content type, all of them
|
|
// are not last element. That one content
|
|
// type will take care of itself.
|
|
state.afterElement = false;
|
|
// Except for one content type, all of them
|
|
// are not last comment. That one content
|
|
// type will take care of itself.
|
|
state.afterComment = false;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
|
|
/**
|
|
* Called to print the text contents in the prevailing element format.
|
|
* Since this method is capable of printing text as CDATA, it is used
|
|
* for that purpose as well. White space handling is determined by the
|
|
* current element state. In addition, the output format can dictate
|
|
* whether the text is printed as CDATA or unescaped.
|
|
*
|
|
* @param text The text to print
|
|
* @param unescaped True is should print unescaped
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
protected void characters( String text )
|
|
throws IOException
|
|
{
|
|
ElementState state;
|
|
|
|
state = content();
|
|
// Check if text should be print as CDATA section or unescaped
|
|
// based on elements listed in the output format (the element
|
|
// state) or whether we are inside a CDATA section or entity.
|
|
|
|
if ( state.inCData || state.doCData ) {
|
|
int index;
|
|
int saveIndent;
|
|
|
|
// Print a CDATA section. The text is not escaped, but ']]>'
|
|
// appearing in the code must be identified and dealt with.
|
|
// The contents of a text node is considered space preserving.
|
|
if ( ! state.inCData ) {
|
|
_printer.printText("<![CDATA[");
|
|
state.inCData = true;
|
|
}
|
|
saveIndent = _printer.getNextIndent();
|
|
_printer.setNextIndent( 0 );
|
|
printCDATAText( text);
|
|
_printer.setNextIndent( saveIndent );
|
|
|
|
} else {
|
|
|
|
int saveIndent;
|
|
|
|
if ( state.preserveSpace ) {
|
|
// If preserving space then hold of indentation so no
|
|
// excessive spaces are printed at line breaks, escape
|
|
// the text content without replacing spaces and print
|
|
// the text breaking only at line breaks.
|
|
saveIndent = _printer.getNextIndent();
|
|
_printer.setNextIndent( 0 );
|
|
printText( text, true, state.unescaped );
|
|
_printer.setNextIndent( saveIndent );
|
|
} else {
|
|
printText( text, false, state.unescaped );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the suitable entity reference for this character value,
|
|
* or null if no such entity exists. Calling this method with <tt>'&'</tt>
|
|
* will return <tt>"&amp;"</tt>.
|
|
*
|
|
* @param ch Character value
|
|
* @return Character entity name, or null
|
|
*/
|
|
protected abstract String getEntityRef( int ch );
|
|
|
|
|
|
/**
|
|
* Called to serializee the DOM element. The element is serialized based on
|
|
* the serializer's method (XML, HTML, XHTML).
|
|
*
|
|
* @param elem The element to serialize
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
protected abstract void serializeElement( Element elem )
|
|
throws IOException;
|
|
|
|
|
|
/**
|
|
* Comments and PIs cannot be serialized before the root element,
|
|
* because the root element serializes the document type, which
|
|
* generally comes first. Instead such PIs and comments are
|
|
* accumulated inside a vector and serialized by calling this
|
|
* method. Will be called when the root element is serialized
|
|
* and when the document finished serializing.
|
|
*
|
|
* @throws IOException An I/O exception occured while
|
|
* serializing
|
|
*/
|
|
protected void serializePreRoot()
|
|
throws IOException
|
|
{
|
|
int i;
|
|
|
|
if ( _preRoot != null ) {
|
|
for ( i = 0 ; i < _preRoot.size() ; ++i ) {
|
|
printText( (String) _preRoot.elementAt( i ), true, true );
|
|
if ( _indenting )
|
|
_printer.breakLine();
|
|
}
|
|
_preRoot.removeAllElements();
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------//
|
|
// Text pretty printing and formatting methods //
|
|
//---------------------------------------------//
|
|
|
|
protected void printCDATAText( String text ) throws IOException {
|
|
int length = text.length();
|
|
char ch;
|
|
|
|
for ( int index = 0 ; index < length; ++index ) {
|
|
ch = text.charAt( index );
|
|
if (ch == ']'
|
|
&& index + 2 < length
|
|
&& text.charAt(index + 1) == ']'
|
|
&& text.charAt(index + 2) == '>') { // check for ']]>'
|
|
if (fDOMErrorHandler != null) {
|
|
// REVISIT: this means that if DOM Error handler is not registered we don't report any
|
|
// fatal errors and might serialize not wellformed document
|
|
if ((features & DOMSerializerImpl.SPLITCDATA) == 0) {
|
|
String msg = DOMMessageFormatter.formatMessage(
|
|
DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"EndingCDATA",
|
|
null);
|
|
if ((features & DOMSerializerImpl.WELLFORMED) != 0) {
|
|
// issue fatal error
|
|
modifyDOMError(msg, DOMError.SEVERITY_FATAL_ERROR, "wf-invalid-character", fCurrentNode);
|
|
fDOMErrorHandler.handleError(fDOMError);
|
|
throw new LSException(LSException.SERIALIZE_ERR, msg);
|
|
}
|
|
else {
|
|
// issue error
|
|
modifyDOMError(msg, DOMError.SEVERITY_ERROR, "cdata-section-not-splitted", fCurrentNode);
|
|
if (!fDOMErrorHandler.handleError(fDOMError)) {
|
|
throw new LSException(LSException.SERIALIZE_ERR, msg);
|
|
}
|
|
}
|
|
} else {
|
|
// issue warning
|
|
String msg =
|
|
DOMMessageFormatter.formatMessage(
|
|
DOMMessageFormatter.SERIALIZER_DOMAIN,
|
|
"SplittingCDATA",
|
|
null);
|
|
modifyDOMError(
|
|
msg,
|
|
DOMError.SEVERITY_WARNING,
|
|
null, fCurrentNode);
|
|
fDOMErrorHandler.handleError(fDOMError);
|
|
}
|
|
}
|
|
// split CDATA section
|
|
_printer.printText("]]]]><![CDATA[>");
|
|
index += 2;
|
|
continue;
|
|
}
|
|
|
|
if (!XMLChar.isValid(ch)) {
|
|
// check if it is surrogate
|
|
if (++index <length) {
|
|
surrogates(ch, text.charAt(index));
|
|
}
|
|
else {
|
|
fatalError("The character '"+(char)ch+"' is an invalid XML character");
|
|
}
|
|
continue;
|
|
} else {
|
|
if ( ( ch >= ' ' && _encodingInfo.isPrintable((char)ch) && ch != 0xF7 ) ||
|
|
ch == '\n' || ch == '\r' || ch == '\t' ) {
|
|
_printer.printText((char)ch);
|
|
} else {
|
|
|
|
// The character is not printable -- split CDATA section
|
|
_printer.printText("]]>&#x");
|
|
_printer.printText(Integer.toHexString(ch));
|
|
_printer.printText(";<![CDATA[");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected void surrogates(int high, int low) throws IOException{
|
|
if (XMLChar.isHighSurrogate(high)) {
|
|
if (!XMLChar.isLowSurrogate(low)) {
|
|
//Invalid XML
|
|
fatalError("The character '"+(char)low+"' is an invalid XML character");
|
|
}
|
|
else {
|
|
int supplemental = XMLChar.supplemental((char)high, (char)low);
|
|
if (!XMLChar.isValid(supplemental)) {
|
|
//Invalid XML
|
|
fatalError("The character '"+(char)supplemental+"' is an invalid XML character");
|
|
}
|
|
else {
|
|
if (content().inCData ) {
|
|
_printer.printText("]]>&#x");
|
|
_printer.printText(Integer.toHexString(supplemental));
|
|
_printer.printText(";<![CDATA[");
|
|
}
|
|
else {
|
|
printHex(supplemental);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fatalError("The character '"+(char)high+"' is an invalid XML character");
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Called to print additional text with whitespace handling.
|
|
* If spaces are preserved, the text is printed as if by calling
|
|
* {@link #printText(String,boolean,boolean)} with a call to {@link Printer#breakLine}
|
|
* for each new line. If spaces are not preserved, the text is
|
|
* broken at space boundaries if longer than the line width;
|
|
* Multiple spaces are printed as such, but spaces at beginning
|
|
* of line are removed.
|
|
*
|
|
* @param text The text to print
|
|
* @param preserveSpace Space preserving flag
|
|
* @param unescaped Print unescaped
|
|
*/
|
|
protected void printText( char[] chars, int start, int length,
|
|
boolean preserveSpace, boolean unescaped )
|
|
throws IOException
|
|
{
|
|
int index;
|
|
char ch;
|
|
|
|
if ( preserveSpace ) {
|
|
// Preserving spaces: the text must print exactly as it is,
|
|
// without breaking when spaces appear in the text and without
|
|
// consolidating spaces. If a line terminator is used, a line
|
|
// break will occur.
|
|
while ( length-- > 0 ) {
|
|
ch = chars[ start ];
|
|
++start;
|
|
if ( ch == '\n' || ch == '\r' || unescaped )
|
|
_printer.printText( ch );
|
|
else
|
|
printEscaped( ch );
|
|
}
|
|
} else {
|
|
// Not preserving spaces: print one part at a time, and
|
|
// use spaces between parts to break them into different
|
|
// lines. Spaces at beginning of line will be stripped
|
|
// by printing mechanism. Line terminator is treated
|
|
// no different than other text part.
|
|
while ( length-- > 0 ) {
|
|
ch = chars[ start ];
|
|
++start;
|
|
if ( ch == ' ' || ch == '\f' || ch == '\t' || ch == '\n' || ch == '\r' )
|
|
_printer.printSpace();
|
|
else if ( unescaped )
|
|
_printer.printText( ch );
|
|
else
|
|
printEscaped( ch );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected void printText( String text, boolean preserveSpace, boolean unescaped )
|
|
throws IOException
|
|
{
|
|
int index;
|
|
char ch;
|
|
|
|
if ( preserveSpace ) {
|
|
// Preserving spaces: the text must print exactly as it is,
|
|
// without breaking when spaces appear in the text and without
|
|
// consolidating spaces. If a line terminator is used, a line
|
|
// break will occur.
|
|
for ( index = 0 ; index < text.length() ; ++index ) {
|
|
ch = text.charAt( index );
|
|
if ( ch == '\n' || ch == '\r' || unescaped )
|
|
_printer.printText( ch );
|
|
else
|
|
printEscaped( ch );
|
|
}
|
|
} else {
|
|
// Not preserving spaces: print one part at a time, and
|
|
// use spaces between parts to break them into different
|
|
// lines. Spaces at beginning of line will be stripped
|
|
// by printing mechanism. Line terminator is treated
|
|
// no different than other text part.
|
|
for ( index = 0 ; index < text.length() ; ++index ) {
|
|
ch = text.charAt( index );
|
|
if ( ch == ' ' || ch == '\f' || ch == '\t' || ch == '\n' || ch == '\r' )
|
|
_printer.printSpace();
|
|
else if ( unescaped )
|
|
_printer.printText( ch );
|
|
else
|
|
printEscaped( ch );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Print a document type public or system identifier URL.
|
|
* Encapsulates the URL in double quotes, escapes non-printing
|
|
* characters and print it equivalent to {@link #printText}.
|
|
*
|
|
* @param url The document type url to print
|
|
*/
|
|
protected void printDoctypeURL( String url )
|
|
throws IOException
|
|
{
|
|
int i;
|
|
|
|
_printer.printText( '"' );
|
|
for( i = 0 ; i < url.length() ; ++i ) {
|
|
if ( url.charAt( i ) == '"' || url.charAt( i ) < 0x20 || url.charAt( i ) > 0x7F ) {
|
|
_printer.printText( '%' );
|
|
_printer.printText( Integer.toHexString( url.charAt( i ) ) );
|
|
} else
|
|
_printer.printText( url.charAt( i ) );
|
|
}
|
|
_printer.printText( '"' );
|
|
}
|
|
|
|
|
|
protected void printEscaped( int ch )
|
|
throws IOException
|
|
{
|
|
String charRef;
|
|
// If there is a suitable entity reference for this
|
|
// character, print it. The list of available entity
|
|
// references is almost but not identical between
|
|
// XML and HTML.
|
|
charRef = getEntityRef( ch );
|
|
if ( charRef != null ) {
|
|
_printer.printText( '&' );
|
|
_printer.printText( charRef );
|
|
_printer.printText( ';' );
|
|
} else if ( ( ch >= ' ' && _encodingInfo.isPrintable((char)ch) && ch != 0xF7 ) ||
|
|
ch == '\n' || ch == '\r' || ch == '\t' ) {
|
|
// Non printables are below ASCII space but not tab or line
|
|
// terminator, ASCII delete, or above a certain Unicode threshold.
|
|
if (ch < 0x10000) {
|
|
_printer.printText((char)ch );
|
|
} else {
|
|
_printer.printText((char)(((ch-0x10000)>>10)+0xd800));
|
|
_printer.printText((char)(((ch-0x10000)&0x3ff)+0xdc00));
|
|
}
|
|
} else {
|
|
printHex(ch);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Escapes chars
|
|
*/
|
|
final void printHex( int ch) throws IOException {
|
|
_printer.printText( "&#x" );
|
|
_printer.printText(Integer.toHexString(ch));
|
|
_printer.printText( ';' );
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Escapes a string so it may be printed as text content or attribute
|
|
* value. Non printable characters are escaped using character references.
|
|
* Where the format specifies a deault entity reference, that reference
|
|
* is used (e.g. <tt>&lt;</tt>).
|
|
*
|
|
* @param source The string to escape
|
|
*/
|
|
protected void printEscaped( String source )
|
|
throws IOException
|
|
{
|
|
for ( int i = 0 ; i < source.length() ; ++i ) {
|
|
int ch = source.charAt(i);
|
|
if ((ch & 0xfc00) == 0xd800 && i+1 < source.length()) {
|
|
int lowch = source.charAt(i+1);
|
|
if ((lowch & 0xfc00) == 0xdc00) {
|
|
ch = 0x10000 + ((ch-0xd800)<<10) + lowch-0xdc00;
|
|
i++;
|
|
}
|
|
}
|
|
printEscaped(ch);
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------//
|
|
// Element state handling methods //
|
|
//--------------------------------//
|
|
|
|
|
|
/**
|
|
* Return the state of the current element.
|
|
*
|
|
* @return Current element state
|
|
*/
|
|
protected ElementState getElementState()
|
|
{
|
|
return _elementStates[ _elementStateCount ];
|
|
}
|
|
|
|
|
|
/**
|
|
* Enter a new element state for the specified element.
|
|
* Tag name and space preserving is specified, element
|
|
* state is initially empty.
|
|
*
|
|
* @return Current element state, or null
|
|
*/
|
|
protected ElementState enterElementState( String namespaceURI, String localName,
|
|
String rawName, boolean preserveSpace )
|
|
{
|
|
ElementState state;
|
|
|
|
if ( _elementStateCount + 1 == _elementStates.length ) {
|
|
ElementState[] newStates;
|
|
|
|
// Need to create a larger array of states. This does not happen
|
|
// often, unless the document is really deep.
|
|
newStates = new ElementState[ _elementStates.length + 10 ];
|
|
for ( int i = 0 ; i < _elementStates.length ; ++i )
|
|
newStates[ i ] = _elementStates[ i ];
|
|
for ( int i = _elementStates.length ; i < newStates.length ; ++i )
|
|
newStates[ i ] = new ElementState();
|
|
_elementStates = newStates;
|
|
}
|
|
|
|
++_elementStateCount;
|
|
state = _elementStates[ _elementStateCount ];
|
|
state.namespaceURI = namespaceURI;
|
|
state.localName = localName;
|
|
state.rawName = rawName;
|
|
state.preserveSpace = preserveSpace;
|
|
state.empty = true;
|
|
state.afterElement = false;
|
|
state.afterComment = false;
|
|
state.doCData = state.inCData = false;
|
|
state.unescaped = false;
|
|
state.prefixes = _prefixes;
|
|
|
|
_prefixes = null;
|
|
return state;
|
|
}
|
|
|
|
|
|
/**
|
|
* Leave the current element state and return to the
|
|
* state of the parent element. If this was the root
|
|
* element, return to the state of the document.
|
|
*
|
|
* @return Previous element state
|
|
*/
|
|
protected ElementState leaveElementState()
|
|
{
|
|
if ( _elementStateCount > 0 ) {
|
|
/*Corrected by David Blondeau (blondeau@intalio.com)*/
|
|
_prefixes = null;
|
|
//_prefixes = _elementStates[ _elementStateCount ].prefixes;
|
|
-- _elementStateCount;
|
|
return _elementStates[ _elementStateCount ];
|
|
} else {
|
|
String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN, "Internal", null);
|
|
throw new IllegalStateException(msg);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns true if in the state of the document.
|
|
* Returns true before entering any element and after
|
|
* leaving the root element.
|
|
*
|
|
* @return True if in the state of the document
|
|
*/
|
|
protected boolean isDocumentState()
|
|
{
|
|
return _elementStateCount == 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the namespace prefix for the specified URI.
|
|
* If the URI has been mapped to a prefix, returns the
|
|
* prefix, otherwise returns null.
|
|
*
|
|
* @param namespaceURI The namespace URI
|
|
* @return The namespace prefix if known, or null
|
|
*/
|
|
protected String getPrefix( String namespaceURI )
|
|
{
|
|
String prefix;
|
|
|
|
if ( _prefixes != null ) {
|
|
prefix = _prefixes.get( namespaceURI );
|
|
if ( prefix != null )
|
|
return prefix;
|
|
}
|
|
if ( _elementStateCount == 0 )
|
|
return null;
|
|
else {
|
|
for ( int i = _elementStateCount ; i > 0 ; --i ) {
|
|
if ( _elementStates[ i ].prefixes != null ) {
|
|
prefix = (String) _elementStates[ i ].prefixes.get( namespaceURI );
|
|
if ( prefix != null )
|
|
return prefix;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* The method modifies global DOM error object
|
|
*
|
|
* @param message
|
|
* @param severity
|
|
* @param type
|
|
* @return a DOMError
|
|
*/
|
|
protected DOMError modifyDOMError(String message, short severity, String type, Node node){
|
|
fDOMError.reset();
|
|
fDOMError.fMessage = message;
|
|
fDOMError.fType = type;
|
|
fDOMError.fSeverity = severity;
|
|
fDOMError.fLocator = new DOMLocatorImpl(-1, -1, -1, node, null);
|
|
return fDOMError;
|
|
|
|
}
|
|
|
|
|
|
protected void fatalError(String message) throws IOException{
|
|
if (fDOMErrorHandler != null) {
|
|
modifyDOMError(message, DOMError.SEVERITY_FATAL_ERROR, null, fCurrentNode);
|
|
fDOMErrorHandler.handleError(fDOMError);
|
|
}
|
|
else {
|
|
throw new IOException(message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DOM level 3:
|
|
* Check a node to determine if it contains unbound namespace prefixes.
|
|
*
|
|
* @param node The node to check for unbound namespace prefices
|
|
*/
|
|
protected void checkUnboundNamespacePrefixedNode (Node node) throws IOException{
|
|
|
|
}
|
|
}
|