1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * @LastModified: Oct 2017
   4  */
   5 /*
   6  * Licensed to the Apache Software Foundation (ASF) under one or more
   7  * contributor license agreements.  See the NOTICE file distributed with
   8  * this work for additional information regarding copyright ownership.
   9  * The ASF licenses this file to You under the Apache License, Version 2.0
  10  * (the "License"); you may not use this file except in compliance with
  11  * the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21 
  22 // Sep 14, 2000:
  23 //  Fixed problem with namespace handling. Contributed by
  24 //  David Blondeau <blondeau@intalio.com>
  25 // Sep 14, 2000:
  26 //  Fixed serializer to report IO exception directly, instead at
  27 //  the end of document processing.
  28 //  Reported by Patrick Higgins <phiggins@transzap.com>
  29 // Aug 21, 2000:
  30 //  Fixed bug in startDocument not calling prepare.
  31 //  Reported by Mikael Staldal <d96-mst-ingen-reklam@d.kth.se>
  32 // Aug 21, 2000:
  33 //  Added ability to omit DOCTYPE declaration.
  34 
  35 package com.sun.org.apache.xml.internal.serialize;
  36 
  37 import com.sun.org.apache.xerces.internal.dom.DOMMessageFormatter;
  38 import com.sun.org.apache.xerces.internal.util.NamespaceSupport;
  39 import com.sun.org.apache.xerces.internal.util.SymbolTable;
  40 import com.sun.org.apache.xerces.internal.util.XMLChar;
  41 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
  42 import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
  43 import java.io.IOException;
  44 import java.io.OutputStream;
  45 import java.io.Writer;
  46 import java.util.Map;
  47 import org.w3c.dom.Attr;
  48 import org.w3c.dom.DOMError;
  49 import org.w3c.dom.Document;
  50 import org.w3c.dom.Element;
  51 import org.w3c.dom.NamedNodeMap;
  52 import org.w3c.dom.Node;
  53 import org.w3c.dom.traversal.NodeFilter;
  54 import org.xml.sax.AttributeList;
  55 import org.xml.sax.Attributes;
  56 import org.xml.sax.SAXException;
  57 import org.xml.sax.helpers.AttributesImpl;
  58 
  59 /**
  60  * Implements an XML serializer supporting both DOM and SAX pretty
  61  * serializing. For usage instructions see {@link Serializer}.
  62  * <p>
  63  * If an output stream is used, the encoding is taken from the
  64  * output format (defaults to <tt>UTF-8</tt>). If a writer is
  65  * used, make sure the writer uses the same encoding (if applies)
  66  * as specified in the output format.
  67  * <p>
  68  * The serializer supports both DOM and SAX. SAX serializing is done by firing
  69  * SAX events and using the serializer as a document handler. DOM serializing is done
  70  * by calling {@link #serialize(Document)} or by using DOM Level 3
  71  * {@link org.w3c.dom.ls.LSSerializer} and
  72  * serializing with {@link org.w3c.dom.ls.LSSerializer#write},
  73  * {@link org.w3c.dom.ls.LSSerializer#writeToString}.
  74  * <p>
  75  * If an I/O exception occurs while serializing, the serializer
  76  * will not throw an exception directly, but only throw it
  77  * at the end of serializing (either DOM or SAX's {@link
  78  * org.xml.sax.DocumentHandler#endDocument}.
  79  * <p>
  80  * For elements that are not specified as whitespace preserving,
  81  * the serializer will potentially break long text lines at space
  82  * boundaries, indent lines, and serialize elements on separate
  83  * lines. Line terminators will be regarded as spaces, and
  84  * spaces at beginning of line will be stripped.
  85  *
  86  * @author <a href="mailto:arkin@intalio.com">Assaf Arkin</a>
  87  * @author <a href="mailto:rahul.srivastava@sun.com">Rahul Srivastava</a>
  88  * @author Elena Litani IBM
  89  * @see Serializer
  90  *
  91  * @deprecated As of JDK 9, Xerces 2.9.0, Xerces DOM L3 Serializer implementation
  92  * is replaced by that of Xalan. Main class
  93  * {@link com.sun.org.apache.xml.internal.serialize.DOMSerializerImpl} is replaced
  94  * by {@link com.sun.org.apache.xml.internal.serializer.dom3.LSSerializerImpl}.


  95  */
  96 @Deprecated
  97 public class XMLSerializer
  98 extends BaseMarkupSerializer {
  99 
 100     //
 101     // constants
 102     //
 103 
 104     protected static final boolean DEBUG = false;
 105 
 106     //
 107     // data
 108     //
 109 
 110     //
 111     // DOM Level 3 implementation: variables intialized in DOMSerializerImpl
 112     //
 113 
 114     /** stores namespaces in scope */
 115     protected NamespaceSupport fNSBinder;
 116 
 117     /** stores all namespace bindings on the current element */
 118     protected NamespaceSupport fLocalNSBinder;
 119 
 120     /** symbol table for serialization */
 121     protected SymbolTable fSymbolTable;
 122 
 123     protected final static String PREFIX = "NS";
 124 
 125     /**
 126      * Controls whether namespace fixup should be performed during
 127      * the serialization.
 128      * NOTE: if this field is set to true the following
 129      * fields need to be initialized: fNSBinder, fLocalNSBinder, fSymbolTable,
 130      * XMLSymbols.EMPTY_STRING, fXmlSymbol, fXmlnsSymbol
 131      */
 132     protected boolean fNamespaces = false;
 133 
 134     /**
 135      * Controls whether namespace prefixes will be printed out during serialization
 136      */
 137     protected boolean fNamespacePrefixes = true;
 138 
 139 
 140     private boolean fPreserveSpace;
 141 
 142 
 143     /**
 144      * Constructs a new serializer. The serializer cannot be used without
 145      * calling {@link #setOutputCharStream} or {@link #setOutputByteStream}
 146      * first.
 147      */
 148     public XMLSerializer() {
 149         super( new OutputFormat( Method.XML, null, false ) );
 150     }
 151 
 152 
 153     /**
 154      * Constructs a new serializer. The serializer cannot be used without
 155      * calling {@link #setOutputCharStream} or {@link #setOutputByteStream}
 156      * first.
 157      */
 158     public XMLSerializer( OutputFormat format ) {
 159         super( format != null ? format : new OutputFormat( Method.XML, null, false ) );
 160         _format.setMethod( Method.XML );
 161     }
 162 
 163 
 164     /**
 165      * Constructs a new serializer that writes to the specified writer
 166      * using the specified output format. If <tt>format</tt> is null,
 167      * will use a default output format.
 168      *
 169      * @param writer The writer to use
 170      * @param format The output format to use, null for the default
 171      */
 172     public XMLSerializer( Writer writer, OutputFormat format ) {
 173         super( format != null ? format : new OutputFormat( Method.XML, null, false ) );
 174         _format.setMethod( Method.XML );
 175         setOutputCharStream( writer );
 176     }
 177 
 178 
 179     /**
 180      * Constructs a new serializer that writes to the specified output
 181      * stream using the specified output format. If <tt>format</tt>
 182      * is null, will use a default output format.
 183      *
 184      * @param output The output stream to use
 185      * @param format The output format to use, null for the default
 186      */
 187     public XMLSerializer( OutputStream output, OutputFormat format ) {
 188         super( format != null ? format : new OutputFormat( Method.XML, null, false ) );
 189         _format.setMethod( Method.XML );
 190         setOutputByteStream( output );
 191     }
 192 
 193 
 194     public void setOutputFormat( OutputFormat format ) {
 195         super.setOutputFormat( format != null ? format : new OutputFormat( Method.XML, null, false ) );
 196     }
 197 
 198 
 199     /**
 200      * This methods turns on namespace fixup algorithm during
 201      * DOM serialization.
 202      * @see org.w3c.dom.ls.LSSerializer
 203      *
 204      * @param namespaces
 205      */
 206     public void setNamespaces (boolean namespaces){
 207         fNamespaces = namespaces;
 208         if (fNSBinder == null) {
 209             fNSBinder = new NamespaceSupport();
 210             fLocalNSBinder = new NamespaceSupport();
 211             fSymbolTable = new SymbolTable();
 212         }
 213     }
 214 
 215     //-----------------------------------------//
 216     // SAX content handler serializing methods //
 217     //-----------------------------------------//
 218 
 219 
 220     public void startElement( String namespaceURI, String localName,
 221                               String rawName, Attributes attrs )
 222     throws SAXException
 223     {
 224         int          i;
 225         boolean      preserveSpace;
 226         ElementState state;
 227         String       name;
 228         String       value;
 229 
 230         if (DEBUG) {
 231             System.out.println("==>startElement("+namespaceURI+","+localName+
 232                                ","+rawName+")");
 233         }
 234 
 235         try {
 236             if (_printer == null) {
 237                 String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN, "NoWriterSupplied", null);
 238                 throw new IllegalStateException(msg);
 239             }
 240 
 241             state = getElementState();
 242             if (isDocumentState()) {
 243                 // If this is the root element handle it differently.
 244                 // If the first root element in the document, serialize
 245                 // the document's DOCTYPE. Space preserving defaults
 246                 // to that of the output format.
 247                 if (! _started)
 248                     startDocument( ( localName == null || localName.length() == 0 ) ? rawName : localName );
 249             } else {
 250                 // For any other element, if first in parent, then
 251                 // close parent's opening tag and use the parnet's
 252                 // space preserving.
 253                 if (state.empty)
 254                     _printer.printText( '>' );
 255                 // Must leave CData section first
 256                 if (state.inCData) {
 257                     _printer.printText( "]]>" );
 258                     state.inCData = false;
 259                 }
 260                 // Indent this element on a new line if the first
 261                 // content of the parent element or immediately
 262                 // following an element or a comment
 263                 if (_indenting && ! state.preserveSpace &&
 264                     ( state.empty || state.afterElement || state.afterComment))
 265                     _printer.breakLine();
 266             }
 267             preserveSpace = state.preserveSpace;
 268 
 269             //We remove the namespaces from the attributes list so that they will
 270             //be in _prefixes
 271             attrs = extractNamespaces(attrs);
 272 
 273             // Do not change the current element state yet.
 274             // This only happens in endElement().
 275             if (rawName == null || rawName.length() == 0) {
 276                 if (localName == null) {
 277                     String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN, "NoName", null);
 278                     throw new SAXException(msg);
 279                 }
 280                 if (namespaceURI != null && ! namespaceURI.equals( "" )) {
 281                     String prefix;
 282                     prefix = getPrefix( namespaceURI );
 283                     if (prefix != null && prefix.length() > 0) {
 284                         rawName = prefix + ":" + localName;
 285                     }
 286                     else {
 287                         rawName = localName;
 288                     }
 289                 }
 290                 else {
 291                     rawName = localName;
 292                 }
 293             }
 294 
 295             _printer.printText( '<' );
 296             _printer.printText( rawName );
 297             _printer.indent();
 298 
 299             // For each attribute print it's name and value as one part,
 300             // separated with a space so the element can be broken on
 301             // multiple lines.
 302             if (attrs != null) {
 303                 for (i = 0 ; i < attrs.getLength() ; ++i) {
 304                     _printer.printSpace();
 305 
 306                     name = attrs.getQName( i );
 307                     if (name != null && name.length() == 0) {
 308                         String prefix;
 309                         String attrURI;
 310 
 311                         name = attrs.getLocalName( i );
 312                         attrURI = attrs.getURI( i );
 313                         if (( attrURI != null && attrURI.length() != 0 ) &&
 314                             ( namespaceURI == null || namespaceURI.length() == 0 ||
 315                               ! attrURI.equals( namespaceURI ) )) {
 316                             prefix = getPrefix( attrURI );
 317                             if (prefix != null && prefix.length() > 0)
 318                                 name = prefix + ":" + name;
 319                         }
 320                     }
 321 
 322                     value = attrs.getValue( i );
 323                     if (value == null)
 324                         value = "";
 325                     _printer.printText( name );
 326                     _printer.printText( "=\"" );
 327                     printEscaped( value );
 328                     _printer.printText( '"' );
 329 
 330                     // If the attribute xml:space exists, determine whether
 331                     // to preserve spaces in this and child nodes based on
 332                     // its value.
 333                     if (name.equals( "xml:space" )) {
 334                         if (value.equals( "preserve" ))
 335                             preserveSpace = true;
 336                         else
 337                             preserveSpace = _format.getPreserveSpace();
 338                     }
 339                 }
 340             }
 341 
 342             if (_prefixes != null) {
 343                 for (Map.Entry<String, String> entry : _prefixes.entrySet()) {
 344                     _printer.printSpace();
 345                     value = entry.getKey();
 346                     name = entry.getValue();
 347                     if (name.length() == 0) {
 348                         _printer.printText( "xmlns=\"" );
 349                         printEscaped( value );
 350                         _printer.printText( '"' );
 351                     }
 352                     else {
 353                         _printer.printText( "xmlns:" );
 354                         _printer.printText( name );
 355                         _printer.printText( "=\"" );
 356                         printEscaped( value );
 357                         _printer.printText( '"' );
 358                     }
 359                 }
 360             }
 361 
 362             // Now it's time to enter a new element state
 363             // with the tag name and space preserving.
 364             // We still do not change the curent element state.
 365             state = enterElementState( namespaceURI, localName, rawName, preserveSpace );
 366             name = ( localName == null || localName.length() == 0 ) ? rawName : namespaceURI + "^" + localName;
 367             state.doCData = _format.isCDataElement( name );
 368             state.unescaped = _format.isNonEscapingElement( name );
 369         } catch (IOException except) {
 370             throw new SAXException( except );
 371         }
 372     }
 373 
 374 
 375     public void endElement( String namespaceURI, String localName,
 376                             String rawName )
 377     throws SAXException
 378     {
 379         try {
 380             endElementIO( namespaceURI, localName, rawName );
 381         } catch (IOException except) {
 382             throw new SAXException( except );
 383         }
 384     }
 385 
 386 
 387     public void endElementIO( String namespaceURI, String localName,
 388                               String rawName )
 389     throws IOException
 390     {
 391         ElementState state;
 392         if (DEBUG) {
 393             System.out.println("==>endElement: " +rawName);
 394         }
 395         // Works much like content() with additions for closing
 396         // an element. Note the different checks for the closed
 397         // element's state and the parent element's state.
 398         _printer.unindent();
 399         state = getElementState();
 400         if (state.empty) {
 401             _printer.printText( "/>" );
 402         } else {
 403             // Must leave CData section first
 404             if (state.inCData)
 405                 _printer.printText( "]]>" );
 406             // This element is not empty and that last content was
 407             // another element, so print a line break before that
 408             // last element and this element's closing tag.
 409             if (_indenting && ! state.preserveSpace && (state.afterElement || state.afterComment))
 410                 _printer.breakLine();
 411             _printer.printText( "</" );
 412             _printer.printText( state.rawName );
 413             _printer.printText( '>' );
 414         }
 415         // Leave the element state and update that of the parent
 416         // (if we're not root) to not empty and after element.
 417         state = leaveElementState();
 418         state.afterElement = true;
 419         state.afterComment = false;
 420         state.empty = false;
 421         if (isDocumentState())
 422             _printer.flush();
 423     }
 424 
 425 
 426     //------------------------------------------//
 427     // SAX document handler serializing methods //
 428     //------------------------------------------//
 429 
 430 
 431     public void startElement( String tagName, AttributeList attrs )
 432     throws SAXException
 433     {
 434         int          i;
 435         boolean      preserveSpace;
 436         ElementState state;
 437         String       name;
 438         String       value;
 439 
 440 
 441         if (DEBUG) {
 442             System.out.println("==>startElement("+tagName+")");
 443         }
 444 
 445         try {
 446             if (_printer == null) {
 447                 String msg = DOMMessageFormatter.formatMessage(DOMMessageFormatter.SERIALIZER_DOMAIN, "NoWriterSupplied", null);
 448                 throw new IllegalStateException(msg);
 449             }
 450 
 451             state = getElementState();
 452             if (isDocumentState()) {
 453                 // If this is the root element handle it differently.
 454                 // If the first root element in the document, serialize
 455                 // the document's DOCTYPE. Space preserving defaults
 456                 // to that of the output format.
 457                 if (! _started)
 458                     startDocument( tagName );
 459             } else {
 460                 // For any other element, if first in parent, then
 461                 // close parent's opening tag and use the parnet's
 462                 // space preserving.
 463                 if (state.empty)
 464                     _printer.printText( '>' );
 465                 // Must leave CData section first
 466                 if (state.inCData) {
 467                     _printer.printText( "]]>" );
 468                     state.inCData = false;
 469                 }
 470                 // Indent this element on a new line if the first
 471                 // content of the parent element or immediately
 472                 // following an element.
 473                 if (_indenting && ! state.preserveSpace &&
 474                     ( state.empty || state.afterElement || state.afterComment))
 475                     _printer.breakLine();
 476             }
 477             preserveSpace = state.preserveSpace;
 478 
 479             // Do not change the current element state yet.
 480             // This only happens in endElement().
 481 
 482             _printer.printText( '<' );
 483             _printer.printText( tagName );
 484             _printer.indent();
 485 
 486             // For each attribute print it's name and value as one part,
 487             // separated with a space so the element can be broken on
 488             // multiple lines.
 489             if (attrs != null) {
 490                 for (i = 0 ; i < attrs.getLength() ; ++i) {
 491                     _printer.printSpace();
 492                     name = attrs.getName( i );
 493                     value = attrs.getValue( i );
 494                     if (value != null) {
 495                         _printer.printText( name );
 496                         _printer.printText( "=\"" );
 497                         printEscaped( value );
 498                         _printer.printText( '"' );
 499                     }
 500 
 501                     // If the attribute xml:space exists, determine whether
 502                     // to preserve spaces in this and child nodes based on
 503                     // its value.
 504                     if (name.equals( "xml:space" )) {
 505                         if (value.equals( "preserve" ))
 506                             preserveSpace = true;
 507                         else
 508                             preserveSpace = _format.getPreserveSpace();
 509                     }
 510                 }
 511             }
 512             // Now it's time to enter a new element state
 513             // with the tag name and space preserving.
 514             // We still do not change the curent element state.
 515             state = enterElementState( null, null, tagName, preserveSpace );
 516             state.doCData = _format.isCDataElement( tagName );
 517             state.unescaped = _format.isNonEscapingElement( tagName );
 518         } catch (IOException except) {
 519             throw new SAXException( except );
 520         }
 521 
 522     }
 523 
 524 
 525     public void endElement( String tagName )
 526     throws SAXException
 527     {
 528         endElement( null, null, tagName );
 529     }
 530 
 531 
 532 
 533     //------------------------------------------//
 534     // Generic node serializing methods methods //
 535     //------------------------------------------//
 536 
 537 
 538     /**
 539      * Called to serialize the document's DOCTYPE by the root element.
 540      * The document type declaration must name the root element,
 541      * but the root element is only known when that element is serialized,
 542      * and not at the start of the document.
 543      * <p>
 544      * This method will check if it has not been called before ({@link #_started}),
 545      * will serialize the document type declaration, and will serialize all
 546      * pre-root comments and PIs that were accumulated in the document
 547      * (see {@link #serializePreRoot}). Pre-root will be serialized even if
 548      * this is not the first root element of the document.
 549      */
 550     protected void startDocument( String rootTagName )
 551     throws IOException
 552     {
 553         int    i;
 554         String dtd;
 555 
 556         dtd = _printer.leaveDTD();
 557         if (! _started) {
 558 
 559             if (! _format.getOmitXMLDeclaration()) {
 560                 StringBuffer    buffer;
 561 
 562                 // Serialize the document declaration appreaing at the head
 563                 // of very XML document (unless asked not to).
 564                 buffer = new StringBuffer( "<?xml version=\"" );
 565                 if (_format.getVersion() != null)
 566                     buffer.append( _format.getVersion() );
 567                 else
 568                     buffer.append( "1.0" );
 569                 buffer.append( '"' );
 570                 String format_encoding =  _format.getEncoding();
 571                 if (format_encoding != null) {
 572                     buffer.append( " encoding=\"" );
 573                     buffer.append( format_encoding );
 574                     buffer.append( '"' );
 575                 }
 576                 if (_format.getStandalone() && _docTypeSystemId == null &&
 577                     _docTypePublicId == null)
 578                     buffer.append( " standalone=\"yes\"" );
 579                 buffer.append( "?>" );
 580                 _printer.printText( buffer );
 581                 _printer.breakLine();
 582             }
 583 
 584             if (! _format.getOmitDocumentType()) {
 585                 if (_docTypeSystemId != null) {
 586                     // System identifier must be specified to print DOCTYPE.
 587                     // If public identifier is specified print 'PUBLIC
 588                     // <public> <system>', if not, print 'SYSTEM <system>'.
 589                     _printer.printText( "<!DOCTYPE " );
 590                     _printer.printText( rootTagName );
 591                     if (_docTypePublicId != null) {
 592                         _printer.printText( " PUBLIC " );
 593                         printDoctypeURL( _docTypePublicId );
 594                         if (_indenting) {
 595                             _printer.breakLine();
 596                             for (i = 0 ; i < 18 + rootTagName.length() ; ++i)
 597                                 _printer.printText( " " );
 598                         } else
 599                             _printer.printText( " " );
 600                         printDoctypeURL( _docTypeSystemId );
 601                     } else {
 602                         _printer.printText( " SYSTEM " );
 603                         printDoctypeURL( _docTypeSystemId );
 604                     }
 605 
 606                     // If we accumulated any DTD contents while printing.
 607                     // this would be the place to print it.
 608                     if (dtd != null && dtd.length() > 0) {
 609                         _printer.printText( " [" );
 610                         printText( dtd, true, true );
 611                         _printer.printText( ']' );
 612                     }
 613 
 614                     _printer.printText( ">" );
 615                     _printer.breakLine();
 616                 } else if (dtd != null && dtd.length() > 0) {
 617                     _printer.printText( "<!DOCTYPE " );
 618                     _printer.printText( rootTagName );
 619                     _printer.printText( " [" );
 620                     printText( dtd, true, true );
 621                     _printer.printText( "]>" );
 622                     _printer.breakLine();
 623                 }
 624             }
 625         }
 626         _started = true;
 627         // Always serialize these, even if not te first root element.
 628         serializePreRoot();
 629     }
 630 
 631 
 632     /**
 633      * Called to serialize a DOM element. Equivalent to calling {@link
 634      * #startElement}, {@link #endElement} and serializing everything
 635      * inbetween, but better optimized.
 636      */
 637     protected void serializeElement( Element elem )
 638     throws IOException
 639     {
 640         Attr         attr;
 641         NamedNodeMap attrMap;
 642         int          i;
 643         Node         child;
 644         ElementState state;
 645         String       name;
 646         String       value;
 647         String       tagName;
 648 
 649         String prefix, localUri;
 650         String uri;
 651         if (fNamespaces) {
 652             // local binder stores namespace declaration
 653             // that has been printed out during namespace fixup of
 654             // the current element
 655             fLocalNSBinder.reset();
 656 
 657             // add new namespace context
 658             fNSBinder.pushContext();
 659         }
 660 
 661         if (DEBUG) {
 662             System.out.println("==>startElement: " +elem.getNodeName() +" ns="+elem.getNamespaceURI());
 663         }
 664         tagName = elem.getTagName();
 665         state = getElementState();
 666         if (isDocumentState()) {
 667             // If this is the root element handle it differently.
 668             // If the first root element in the document, serialize
 669             // the document's DOCTYPE. Space preserving defaults
 670             // to that of the output format.
 671 
 672             if (! _started) {
 673                 startDocument( tagName);
 674             }
 675         } else {
 676             // For any other element, if first in parent, then
 677             // close parent's opening tag and use the parent's
 678             // space preserving.
 679             if (state.empty)
 680                 _printer.printText( '>' );
 681             // Must leave CData section first
 682             if (state.inCData) {
 683                 _printer.printText( "]]>" );
 684                 state.inCData = false;
 685             }
 686             // Indent this element on a new line if the first
 687             // content of the parent element or immediately
 688             // following an element.
 689             if (_indenting && ! state.preserveSpace &&
 690                 ( state.empty || state.afterElement || state.afterComment))
 691                 _printer.breakLine();
 692         }
 693 
 694         // Do not change the current element state yet.
 695         // This only happens in endElement().
 696         fPreserveSpace = state.preserveSpace;
 697 
 698 
 699         int length = 0;
 700         attrMap = null;
 701         // retrieve attributes
 702         if (elem.hasAttributes()) {
 703             attrMap = elem.getAttributes();
 704             length = attrMap.getLength();
 705         }
 706 
 707         if (!fNamespaces) { // no namespace fixup should be performed
 708 
 709             // serialize element name
 710             _printer.printText( '<' );
 711             _printer.printText( tagName );
 712             _printer.indent();
 713 
 714             // For each attribute print it's name and value as one part,
 715             // separated with a space so the element can be broken on
 716             // multiple lines.
 717             for ( i = 0 ; i < length ; ++i ) {
 718                 attr = (Attr) attrMap.item( i );
 719                 name = attr.getName();
 720                 value = attr.getValue();
 721                 if ( value == null )
 722                     value = "";
 723                 printAttribute (name, value, attr.getSpecified(), attr);
 724             }
 725         } else { // do namespace fixup
 726 
 727             // REVISIT: some optimization could probably be done to avoid traversing
 728             //          attributes twice.
 729             //
 730 
 731             // ---------------------------------------
 732             // record all valid namespace declarations
 733             // before attempting to fix element's namespace
 734             // ---------------------------------------
 735 
 736             for (i = 0;i < length;i++) {
 737 
 738                 attr = (Attr) attrMap.item( i );
 739                 uri = attr.getNamespaceURI();
 740                 // check if attribute is a namespace decl
 741                 if (uri != null && uri.equals(NamespaceContext.XMLNS_URI)) {
 742 
 743                     value = attr.getNodeValue();
 744                     if (value == null) {
 745                         value=XMLSymbols.EMPTY_STRING;
 746                     }
 747 
 748                     if (value.equals(NamespaceContext.XMLNS_URI)) {
 749                         if (fDOMErrorHandler != null) {
 750                             String msg = DOMMessageFormatter.formatMessage(
 751                                 DOMMessageFormatter.XML_DOMAIN,"CantBindXMLNS",null );
 752                             modifyDOMError(msg,  DOMError.SEVERITY_ERROR, null, attr);
 753                             boolean continueProcess = fDOMErrorHandler.handleError(fDOMError);
 754                             if (!continueProcess) {
 755                                 // stop the namespace fixup and validation
 756                                 throw new RuntimeException(
 757                                     DOMMessageFormatter.formatMessage(
 758                                     DOMMessageFormatter.SERIALIZER_DOMAIN,
 759                                     "SerializationStopped", null));
 760                             }
 761                         }
 762                     } else {
 763                         prefix = attr.getPrefix();
 764                         prefix = (prefix == null ||
 765                                   prefix.length() == 0) ? XMLSymbols.EMPTY_STRING :fSymbolTable.addSymbol(prefix);
 766                         String localpart = fSymbolTable.addSymbol( attr.getLocalName());
 767                         if (prefix == XMLSymbols.PREFIX_XMLNS) { //xmlns:prefix
 768                             value = fSymbolTable.addSymbol(value);
 769                             // record valid decl
 770                             if (value.length() != 0) {
 771                                 fNSBinder.declarePrefix(localpart, value);
 772                             } else {
 773                                 // REVISIT: issue error on invalid declarations
 774                                 //          xmlns:foo = ""
 775                             }
 776                             continue;
 777                         }
 778                         // xmlns --- empty prefix is always bound ("" or some string)
 779                         value = fSymbolTable.addSymbol(value);
 780                         fNSBinder.declarePrefix(XMLSymbols.EMPTY_STRING, value);
 781                         continue;
 782                     }  // end-else: valid declaration
 783                 } // end-if: namespace declaration
 784             }  // end-for
 785 
 786             //-----------------------
 787             // get element uri/prefix
 788             //-----------------------
 789             uri = elem.getNamespaceURI();
 790             prefix = elem.getPrefix();
 791 
 792             //----------------------
 793             // output element name
 794             //----------------------
 795             // REVISIT: this could be removed if we always convert empty string to null
 796             //          for the namespaces.
 797             if ((uri !=null && prefix !=null ) && uri.length() == 0 && prefix.length()!=0) {
 798                 // uri is an empty string and element has some prefix
 799                 // the namespace alg later will fix up the namespace attributes
 800                 // remove element prefix
 801                 prefix = null;
 802                 _printer.printText( '<' );
 803                 _printer.printText( elem.getLocalName() );
 804                 _printer.indent();
 805             } else {
 806                 _printer.printText( '<' );
 807                 _printer.printText( tagName );
 808                 _printer.indent();
 809             }
 810 
 811 
 812             // ---------------------------------------------------------
 813             // Fix up namespaces for element: per DOM L3
 814             // Need to consider the following cases:
 815             //
 816             // case 1: <foo:elem xmlns:ns1="myURI" xmlns="default"/>
 817             // Assume "foo", "ns1" are declared on the parent. We should not miss
 818             // redeclaration for both "ns1" and default namespace. To solve this
 819             // we add a local binder that stores declaration only for current element.
 820             // This way we avoid outputing duplicate declarations for the same element
 821             // as well as we are not omitting redeclarations.
 822             //
 823             // case 2: <elem xmlns="" xmlns="default"/>
 824             // We need to bind default namespace to empty string, to be able to
 825             // omit duplicate declarations for the same element
 826             //
 827             // case 3: <xsl:stylesheet xmlns:xsl="http://xsl">
 828             // We create another element body bound to the "http://xsl" namespace
 829             // as well as namespace attribute rebounding xsl to another namespace.
 830             // <xsl:body xmlns:xsl="http://another">
 831             // Need to make sure that the new namespace decl value is changed to
 832             // "http://xsl"
 833             //
 834             // ---------------------------------------------------------
 835             // check if prefix/namespace is correct for current element
 836             // ---------------------------------------------------------
 837 
 838 
 839             if (uri != null) {  // Element has a namespace
 840                 uri = fSymbolTable.addSymbol(uri);
 841                 prefix = (prefix == null ||
 842                           prefix.length() == 0) ? XMLSymbols.EMPTY_STRING :fSymbolTable.addSymbol(prefix);
 843                 if (fNSBinder.getURI(prefix) == uri) {
 844                     // The xmlns:prefix=namespace or xmlns="default" was declared at parent.
 845                     // The binder always stores mapping of empty prefix to "".
 846                     // (NOTE: local binder does not store this kind of binding!)
 847                     // Thus the case where element was declared with uri="" (with or without a prefix)
 848                     // will be covered here.
 849 
 850                 } else {
 851                     // the prefix is either undeclared
 852                     // or
 853                     // conflict: the prefix is bound to another URI
 854                     if (fNamespacePrefixes) {
 855                         printNamespaceAttr(prefix, uri);
 856                     }
 857                     fLocalNSBinder.declarePrefix(prefix, uri);
 858                     fNSBinder.declarePrefix(prefix, uri);
 859                 }
 860             } else { // Element has no namespace
 861                 if (elem.getLocalName() == null) {
 862                     //  DOM Level 1 node!
 863                     if (fDOMErrorHandler != null) {
 864                         String msg = DOMMessageFormatter.formatMessage(
 865                             DOMMessageFormatter.DOM_DOMAIN, "NullLocalElementName",
 866                             new Object[]{elem.getNodeName()});
 867                         modifyDOMError(msg,DOMError.SEVERITY_ERROR, null, elem);
 868                         boolean continueProcess = fDOMErrorHandler.handleError(fDOMError);
 869                         // REVISIT: should we terminate upon request?
 870                         if (!continueProcess) {
 871                            throw new RuntimeException(
 872                                DOMMessageFormatter.formatMessage(
 873                                DOMMessageFormatter.SERIALIZER_DOMAIN,
 874                                "SerializationStopped", null));
 875                         }
 876                     }
 877                 } else { // uri=null and no colon (DOM L2 node)
 878                     uri = fNSBinder.getURI(XMLSymbols.EMPTY_STRING);
 879 
 880                     if (uri !=null && uri.length() > 0) {
 881                         // there is a default namespace decl that is bound to
 882                         // non-zero length uri, output xmlns=""
 883                         if (fNamespacePrefixes) {
 884                             printNamespaceAttr(XMLSymbols.EMPTY_STRING, XMLSymbols.EMPTY_STRING);
 885                         }
 886                         fLocalNSBinder.declarePrefix(XMLSymbols.EMPTY_STRING, XMLSymbols.EMPTY_STRING);
 887                         fNSBinder.declarePrefix(XMLSymbols.EMPTY_STRING, XMLSymbols.EMPTY_STRING);
 888                     }
 889                 }
 890             }
 891 
 892 
 893             // -----------------------------------------
 894             // Fix up namespaces for attributes: per DOM L3
 895             // check if prefix/namespace is correct the attributes
 896             // -----------------------------------------
 897 
 898             for (i = 0; i < length; i++) {
 899 
 900                 attr = (Attr) attrMap.item( i );
 901                 value = attr.getValue();
 902                 name = attr.getNodeName();
 903 
 904                 uri = attr.getNamespaceURI();
 905 
 906                 // Fix attribute that was declared with a prefix and namespace=""
 907                 if (uri !=null && uri.length() == 0) {
 908                     uri=null;
 909                     // we must remove prefix for this attribute
 910                     name=attr.getLocalName();
 911                 }
 912 
 913                 if (DEBUG) {
 914                     System.out.println("==>process attribute: "+attr.getNodeName());
 915                 }
 916                 // make sure that value is never null.
 917                 if (value == null) {
 918                     value=XMLSymbols.EMPTY_STRING;
 919                 }
 920 
 921                 if (uri != null) {  // attribute has namespace !=null
 922                     prefix = attr.getPrefix();
 923                     prefix = prefix == null ? XMLSymbols.EMPTY_STRING :fSymbolTable.addSymbol(prefix);
 924                     String localpart = fSymbolTable.addSymbol( attr.getLocalName());
 925 
 926 
 927 
 928                     // ---------------------------------------------------
 929                     // print namespace declarations namespace declarations
 930                     // ---------------------------------------------------
 931                     if (uri != null && uri.equals(NamespaceContext.XMLNS_URI)) {
 932                         // check if we need to output this declaration
 933                         prefix = attr.getPrefix();
 934                         prefix = (prefix == null ||
 935                                   prefix.length() == 0) ? XMLSymbols.EMPTY_STRING : fSymbolTable.addSymbol(prefix);
 936                         localpart = fSymbolTable.addSymbol( attr.getLocalName());
 937                         if (prefix == XMLSymbols.PREFIX_XMLNS) { //xmlns:prefix
 938                             localUri = fLocalNSBinder.getURI(localpart);  // local prefix mapping
 939                             value = fSymbolTable.addSymbol(value);
 940                             if (value.length() != 0 ) {
 941                                 if (localUri == null) {
 942                                     // declaration was not printed while fixing element namespace binding
 943 
 944                                     // If the DOM Level 3 namespace-prefixes feature is set to false
 945                                     // do not print xmlns attributes
 946                                     if (fNamespacePrefixes) {
 947                                         printNamespaceAttr(localpart, value);
 948                                     }
 949 
 950                                     // case 4: <elem xmlns:xx="foo" xx:attr=""/>
 951                                     // where attribute is bound to "bar".
 952                                     // If the xmlns:xx is output here first, later we should not
 953                                     // redeclare "xx" prefix. Instead we would pick up different prefix
 954                                     // for the attribute.
 955                                     // final: <elem xmlns:xx="foo" NS1:attr="" xmlns:NS1="bar"/>
 956                                     fLocalNSBinder.declarePrefix(localpart, value);
 957                                 }
 958                             } else {
 959                                 // REVISIT: issue error on invalid declarations
 960                                 //          xmlns:foo = ""
 961                             }
 962                             continue;
 963                         }
 964                         // xmlns --- empty prefix is always bound ("" or some string)
 965                         uri = fNSBinder.getURI(XMLSymbols.EMPTY_STRING);
 966                         localUri= fLocalNSBinder.getURI(XMLSymbols.EMPTY_STRING);
 967                         value = fSymbolTable.addSymbol(value);
 968                         if (localUri == null ) {
 969                             // declaration was not printed while fixing element namespace binding
 970                             if (fNamespacePrefixes) {
 971                                 printNamespaceAttr(XMLSymbols.EMPTY_STRING, value);
 972                             }
 973                             // case 4 does not apply here since attributes can't use
 974                             // default namespace
 975                         }
 976                         continue;
 977 
 978                     }
 979                     uri = fSymbolTable.addSymbol(uri);
 980 
 981                     // find if for this prefix a URI was already declared
 982                     String declaredURI =  fNSBinder.getURI(prefix);
 983 
 984                     if (prefix == XMLSymbols.EMPTY_STRING || declaredURI != uri) {
 985                         // attribute has no prefix (default namespace decl does not apply to attributes)
 986                         // OR
 987                         // attribute prefix is not declared
 988                         // OR
 989                         // conflict: attr URI does not match the prefix in scope
 990 
 991                         name  = attr.getNodeName();
 992                         // Find if any prefix for attributes namespace URI is available
 993                         // in the scope
 994                         String declaredPrefix = fNSBinder.getPrefix(uri);
 995 
 996                         if (declaredPrefix !=null && declaredPrefix !=XMLSymbols.EMPTY_STRING) {
 997                             // use the prefix that was found
 998                             prefix = declaredPrefix;
 999                             name=prefix+":"+localpart;
1000                         } else {
1001                             if (DEBUG) {
1002                                 System.out.println("==> cound not find prefix for the attribute: " +prefix);
1003                             }
1004 
1005                             if (prefix != XMLSymbols.EMPTY_STRING && fLocalNSBinder.getURI(prefix) == null) {
1006                                 // the current prefix is not null and it has no in scope declaration
1007 
1008                                 // use this prefix
1009                             } else {
1010                                 // find a prefix following the pattern "NS" +index (starting at 1)
1011                                 // make sure this prefix is not declared in the current scope.
1012                                 int counter = 1;
1013                                 prefix = fSymbolTable.addSymbol(PREFIX + counter++);
1014                                 while (fLocalNSBinder.getURI(prefix)!=null) {
1015                                     prefix = fSymbolTable.addSymbol(PREFIX +counter++);
1016                                 }
1017                                 name=prefix+":"+localpart;
1018                             }
1019                             // add declaration for the new prefix
1020                             if (fNamespacePrefixes) {
1021                                 printNamespaceAttr(prefix, uri);
1022                             }
1023                             value = fSymbolTable.addSymbol(value);
1024                             fLocalNSBinder.declarePrefix(prefix, value);
1025                             fNSBinder.declarePrefix(prefix, uri);
1026                         }
1027 
1028                         // change prefix for this attribute
1029                     }
1030 
1031                     printAttribute (name, (value==null)?XMLSymbols.EMPTY_STRING:value, attr.getSpecified(), attr);
1032                 } else { // attribute uri == null
1033                     if (attr.getLocalName() == null) {
1034                         if (fDOMErrorHandler != null) {
1035                             String msg = DOMMessageFormatter.formatMessage(
1036                                 DOMMessageFormatter.DOM_DOMAIN,
1037                                 "NullLocalAttrName", new Object[]{attr.getNodeName()});
1038                             modifyDOMError(msg, DOMError.SEVERITY_ERROR, null, attr);
1039                             boolean continueProcess = fDOMErrorHandler.handleError(fDOMError);
1040                             if (!continueProcess) {
1041                                 // stop the namespace fixup and validation
1042                                 throw new RuntimeException(
1043                                    DOMMessageFormatter.formatMessage(
1044                                    DOMMessageFormatter.SERIALIZER_DOMAIN,
1045                                    "SerializationStopped", null));
1046                             }
1047                         }
1048                         printAttribute (name, value, attr.getSpecified(), attr);
1049                     } else { // uri=null and no colon
1050 
1051                         // no fix up is needed: default namespace decl does not
1052                         // apply to attributes
1053                         printAttribute (name, value, attr.getSpecified(), attr);
1054                     }
1055                 }
1056             } // end loop for attributes
1057 
1058         }// end namespace fixup algorithm
1059 
1060 
1061         // If element has children, then serialize them, otherwise
1062         // serialize en empty tag.
1063         if (elem.hasChildNodes()) {
1064             // Enter an element state, and serialize the children
1065             // one by one. Finally, end the element.
1066             state = enterElementState( null, null, tagName, fPreserveSpace );
1067             state.doCData = _format.isCDataElement( tagName );
1068             state.unescaped = _format.isNonEscapingElement( tagName );
1069             child = elem.getFirstChild();
1070             while (child != null) {
1071                 serializeNode( child );
1072                 child = child.getNextSibling();
1073             }
1074             if (fNamespaces) {
1075                 fNSBinder.popContext();
1076             }
1077             endElementIO( null, null, tagName );
1078         } else {
1079             if (DEBUG) {
1080                 System.out.println("==>endElement: " +elem.getNodeName());
1081             }
1082             if (fNamespaces) {
1083                 fNSBinder.popContext();
1084             }
1085             _printer.unindent();
1086             _printer.printText( "/>" );
1087             // After element but parent element is no longer empty.
1088             state.afterElement = true;
1089             state.afterComment = false;
1090             state.empty = false;
1091             if (isDocumentState())
1092                 _printer.flush();
1093         }
1094     }
1095 
1096 
1097 
1098     /**
1099      * Serializes a namespace attribute with the given prefix and value for URI.
1100      * In case prefix is empty will serialize default namespace declaration.
1101      *
1102      * @param prefix
1103      * @param uri
1104      * @exception IOException
1105      */
1106 
1107     private void printNamespaceAttr(String prefix, String uri) throws IOException{
1108         _printer.printSpace();
1109         if (prefix == XMLSymbols.EMPTY_STRING) {
1110             if (DEBUG) {
1111                 System.out.println("=>add xmlns=\""+uri+"\" declaration");
1112             }
1113             _printer.printText( XMLSymbols.PREFIX_XMLNS );
1114         } else {
1115             if (DEBUG) {
1116                 System.out.println("=>add xmlns:"+prefix+"=\""+uri+"\" declaration");
1117             }
1118             _printer.printText( "xmlns:"+prefix );
1119         }
1120         _printer.printText( "=\"" );
1121         printEscaped( uri );
1122         _printer.printText( '"' );
1123     }
1124 
1125 
1126 
1127     /**
1128      * Prints attribute.
1129      * NOTE: xml:space attribute modifies output format
1130      *
1131      * @param name
1132      * @param value
1133      * @param isSpecified
1134      * @exception IOException
1135      */
1136     private void printAttribute (String name, String value, boolean isSpecified, Attr attr) throws IOException{
1137 
1138         if (isSpecified || (features & DOMSerializerImpl.DISCARDDEFAULT) == 0) {
1139             if (fDOMFilter !=null &&
1140                 (fDOMFilter.getWhatToShow() & NodeFilter.SHOW_ATTRIBUTE)!= 0) {
1141                 short code = fDOMFilter.acceptNode(attr);
1142                 switch (code) {
1143                     case NodeFilter.FILTER_REJECT:
1144                     case NodeFilter.FILTER_SKIP: {
1145                         return;
1146                     }
1147                     default: {
1148                         // fall through
1149                     }
1150                 }
1151             }
1152             _printer.printSpace();
1153             _printer.printText( name );
1154             _printer.printText( "=\"" );
1155             printEscaped( value );
1156             _printer.printText( '"' );
1157         }
1158 
1159         // If the attribute xml:space exists, determine whether
1160         // to preserve spaces in this and child nodes based on
1161         // its value.
1162         if (name.equals( "xml:space" )) {
1163             if (value.equals( "preserve" ))
1164                 fPreserveSpace = true;
1165             else
1166                 fPreserveSpace = _format.getPreserveSpace();
1167         }
1168     }
1169 
1170     protected String getEntityRef( int ch ) {
1171         // Encode special XML characters into the equivalent character references.
1172         // These five are defined by default for all XML documents.
1173         switch (ch) {
1174         case '<':
1175             return "lt";
1176         case '>':
1177             return "gt";
1178         case '"':
1179             return "quot";
1180         case '\'':
1181             return "apos";
1182         case '&':
1183             return "amp";
1184         }
1185         return null;
1186     }
1187 
1188 
1189     /** Retrieve and remove the namespaces declarations from the list of attributes.
1190      *
1191      */
1192     private Attributes extractNamespaces( Attributes attrs )
1193     throws SAXException
1194     {
1195         AttributesImpl attrsOnly;
1196         String         rawName;
1197         int            i;
1198         int            length;
1199 
1200         if (attrs == null) {
1201             return null;
1202         }
1203         length = attrs.getLength();
1204         attrsOnly = new AttributesImpl( attrs );
1205 
1206         for (i = length - 1 ; i >= 0 ; --i) {
1207             rawName = attrsOnly.getQName( i );
1208 
1209             //We have to exclude the namespaces declarations from the attributes
1210             //Append only when the feature http://xml.org/sax/features/namespace-prefixes"
1211             //is TRUE
1212             if (rawName.startsWith( "xmlns" )) {
1213                 if (rawName.length() == 5) {
1214                     startPrefixMapping( "", attrs.getValue( i ) );
1215                     attrsOnly.removeAttribute( i );
1216                 } else if (rawName.charAt(5) == ':') {
1217                     startPrefixMapping(rawName.substring(6), attrs.getValue(i));
1218                     attrsOnly.removeAttribute( i );
1219                 }
1220             }
1221         }
1222         return attrsOnly;
1223     }
1224 
1225     //
1226     // Printing attribute value
1227     //
1228     protected void printEscaped(String source) throws IOException {
1229         int length = source.length();
1230         for (int i = 0; i < length; ++i) {
1231             int ch = source.charAt(i);
1232             if (!XMLChar.isValid(ch)) {
1233                 if (++i < length) {
1234                     surrogates(ch, source.charAt(i), false);
1235                 } else {
1236                     fatalError("The character '" + (char) ch + "' is an invalid XML character");
1237                 }
1238                 continue;
1239             }
1240             // escape NL, CR, TAB
1241             if (ch == '\n' || ch == '\r' || ch == '\t') {
1242                 printHex(ch);
1243             } else if (ch == '<') {
1244                 _printer.printText("&lt;");
1245             } else if (ch == '&') {
1246                 _printer.printText("&amp;");
1247             } else if (ch == '"') {
1248                 _printer.printText("&quot;");
1249             } else if ((ch >= ' ' && _encodingInfo.isPrintable((char) ch))) {
1250                 _printer.printText((char) ch);
1251             } else {
1252                 printHex(ch);
1253             }
1254         }
1255     }
1256 
1257     /** print text data */
1258     protected void printXMLChar( int ch) throws IOException {
1259         if (ch == '\r') {
1260                         printHex(ch);
1261         } else if ( ch == '<') {
1262             _printer.printText("&lt;");
1263         } else if (ch == '&') {
1264             _printer.printText("&amp;");
1265         } else if (ch == '>'){
1266                 // character sequence "]]>" can't appear in content, therefore
1267                 // we should escape '>'
1268                         _printer.printText("&gt;");
1269         } else if ( ch == '\n' ||  ch == '\t' ||
1270                     ( ch >= ' ' && _encodingInfo.isPrintable((char)ch))) {
1271             _printer.printText((char)ch);
1272         } else {
1273                         printHex(ch);
1274         }
1275     }
1276 
1277     protected void printText( String text, boolean preserveSpace, boolean unescaped )
1278     throws IOException {
1279         int index;
1280         char ch;
1281         int length = text.length();
1282         if ( preserveSpace ) {
1283             // Preserving spaces: the text must print exactly as it is,
1284             // without breaking when spaces appear in the text and without
1285             // consolidating spaces. If a line terminator is used, a line
1286             // break will occur.
1287             for ( index = 0 ; index < length ; ++index ) {
1288                 ch = text.charAt( index );
1289                 if (!XMLChar.isValid(ch)) {
1290                     // check if it is surrogate
1291                     if (++index <length) {
1292                         surrogates(ch, text.charAt(index), true);
1293                     } else {
1294                         fatalError("The character '"+ch+"' is an invalid XML character");
1295                     }
1296                     continue;
1297                 }
1298                 if ( unescaped ) {
1299                     _printer.printText( ch );
1300                 } else {
1301                     printXMLChar( ch );
1302                 }
1303             }
1304         } else {
1305             // Not preserving spaces: print one part at a time, and
1306             // use spaces between parts to break them into different
1307             // lines. Spaces at beginning of line will be stripped
1308             // by printing mechanism. Line terminator is treated
1309             // no different than other text part.
1310             for ( index = 0 ; index < length ; ++index ) {
1311                 ch = text.charAt( index );
1312                 if (!XMLChar.isValid(ch)) {
1313                     // check if it is surrogate
1314                     if (++index <length) {
1315                         surrogates(ch, text.charAt(index), true);
1316                     } else {
1317                         fatalError("The character '"+ch+"' is an invalid XML character");
1318                     }
1319                     continue;
1320                 }
1321 
1322                 if ( unescaped ) {
1323                     _printer.printText( ch );
1324                 } else {
1325                     printXMLChar( ch );
1326                 }
1327             }
1328         }
1329     }
1330 
1331 
1332 
1333     protected void printText( char[] chars, int start, int length,
1334                               boolean preserveSpace, boolean unescaped ) throws IOException {
1335 
1336         if ( preserveSpace ) {
1337             // Preserving spaces: the text must print exactly as it is,
1338             // without breaking when spaces appear in the text and without
1339             // consolidating spaces. If a line terminator is used, a line
1340             // break will occur.
1341             while ( length-- > 0 ) {
1342                 char ch = chars[start++];
1343                 if (!XMLChar.isValid(ch)) {
1344                     // check if it is surrogate
1345                     if ( length-- > 0 ) {
1346                         surrogates(ch, chars[start++], true);
1347                     } else {
1348                         fatalError("The character '"+ch+"' is an invalid XML character");
1349                     }
1350                     continue;
1351                 }
1352                 if ( unescaped )
1353                     _printer.printText( ch );
1354                 else
1355                     printXMLChar( ch );
1356             }
1357         } else {
1358             // Not preserving spaces: print one part at a time, and
1359             // use spaces between parts to break them into different
1360             // lines. Spaces at beginning of line will be stripped
1361             // by printing mechanism. Line terminator is treated
1362             // no different than other text part.
1363             while ( length-- > 0 ) {
1364                 char ch = chars[start++];
1365                 if (!XMLChar.isValid(ch)) {
1366                     // check if it is surrogate
1367                     if ( length-- > 0 ) {
1368                         surrogates(ch, chars[start++], true);
1369                     } else {
1370                         fatalError("The character '"+ch+"' is an invalid XML character");
1371                     }
1372                     continue;
1373                 }
1374                 if ( unescaped )
1375                     _printer.printText( ch );
1376                 else
1377                     printXMLChar( ch );
1378             }
1379         }
1380     }
1381 
1382 
1383    /**
1384     * DOM Level 3:
1385     * Check a node to determine if it contains unbound namespace prefixes.
1386     *
1387     * @param node The node to check for unbound namespace prefices
1388     */
1389         protected void checkUnboundNamespacePrefixedNode (Node node) throws IOException{
1390 
1391                 if (fNamespaces) {
1392 
1393                         if (DEBUG) {
1394                             System.out.println("==>serializeNode("+node.getNodeName()+") [Entity Reference - Namespaces on]");
1395                                 System.out.println("==>Declared Prefix Count: " + fNSBinder.getDeclaredPrefixCount());
1396                                 System.out.println("==>Node Name: " + node.getNodeName());
1397                                 System.out.println("==>First Child Node Name: " + node.getFirstChild().getNodeName());
1398                                 System.out.println("==>First Child Node Prefix: " + node.getFirstChild().getPrefix());
1399                                 System.out.println("==>First Child Node NamespaceURI: " + node.getFirstChild().getNamespaceURI());
1400                         }
1401 
1402 
1403                         Node child, next;
1404                 for (child = node.getFirstChild(); child != null; child = next) {
1405                     next = child.getNextSibling();
1406                             if (DEBUG) {
1407                                 System.out.println("==>serializeNode("+child.getNodeName()+") [Child Node]");
1408                                 System.out.println("==>serializeNode("+child.getPrefix()+") [Child Node Prefix]");
1409                     }
1410 
1411                             //If a NamespaceURI is not declared for the current
1412                             //node's prefix, raise a fatal error.
1413                             String prefix = child.getPrefix();
1414                 prefix = (prefix == null ||
1415                         prefix.length() == 0) ? XMLSymbols.EMPTY_STRING : fSymbolTable.addSymbol(prefix);
1416                             if (fNSBinder.getURI(prefix) == null && prefix != null) {
1417                                         fatalError("The replacement text of the entity node '"
1418                                                                 + node.getNodeName()
1419                                                                 + "' contains an element node '"
1420                                                                 + child.getNodeName()
1421                                                                 + "' with an undeclared prefix '"
1422                                                                 + prefix + "'.");
1423                             }
1424 
1425                                 if (child.getNodeType() == Node.ELEMENT_NODE) {
1426 
1427                                         NamedNodeMap attrs = child.getAttributes();
1428 
1429                                         for (int i = 0; i< attrs.getLength(); i++ ) {
1430 
1431                                             String attrPrefix = attrs.item(i).getPrefix();
1432                         attrPrefix = (attrPrefix == null ||
1433                                 attrPrefix.length() == 0) ? XMLSymbols.EMPTY_STRING : fSymbolTable.addSymbol(attrPrefix);
1434                                             if (fNSBinder.getURI(attrPrefix) == null && attrPrefix != null) {
1435                                                         fatalError("The replacement text of the entity node '"
1436                                                                                 + node.getNodeName()
1437                                                                                 + "' contains an element node '"
1438                                                                                 + child.getNodeName()
1439                                                                                 + "' with an attribute '"
1440                                                                                 + attrs.item(i).getNodeName()
1441                                                                                 + "' an undeclared prefix '"
1442                                                                                 + attrPrefix + "'.");
1443                                             }
1444 
1445                                         }
1446 
1447                                 }
1448 
1449                                 if (child.hasChildNodes()) {
1450                                         checkUnboundNamespacePrefixedNode(child);
1451                                 }
1452                 }
1453                 }
1454         }
1455 
1456     public boolean reset() {
1457         super.reset();
1458         if (fNSBinder != null){
1459             fNSBinder.reset();
1460             // during serialization always have a mapping to empty string
1461             // so we assume there is a declaration.
1462             fNSBinder.declarePrefix(XMLSymbols.EMPTY_STRING, XMLSymbols.EMPTY_STRING);
1463         }
1464         return true;
1465     }
1466 
1467 }
--- EOF ---