1 /*
   2  * Copyright (c) 2015, 2016 Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xml.internal.serializer.dom3;
  22 
  23 import com.sun.org.apache.xerces.internal.util.XML11Char;
  24 import com.sun.org.apache.xerces.internal.util.XMLChar;
  25 import com.sun.org.apache.xml.internal.serializer.OutputPropertiesFactory;
  26 import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
  27 import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;
  28 import com.sun.org.apache.xml.internal.serializer.utils.Utils;
  29 import java.io.IOException;
  30 import java.io.Writer;
  31 import java.util.Collections;
  32 import java.util.Enumeration;
  33 import java.util.HashMap;
  34 import java.util.Map;
  35 import java.util.Properties;
  36 import org.w3c.dom.Attr;
  37 import org.w3c.dom.CDATASection;
  38 import org.w3c.dom.Comment;
  39 import org.w3c.dom.DOMError;
  40 import org.w3c.dom.DOMErrorHandler;
  41 import org.w3c.dom.Document;
  42 import org.w3c.dom.DocumentType;
  43 import org.w3c.dom.Element;
  44 import org.w3c.dom.Entity;
  45 import org.w3c.dom.EntityReference;
  46 import org.w3c.dom.NamedNodeMap;
  47 import org.w3c.dom.Node;
  48 import org.w3c.dom.NodeList;
  49 import org.w3c.dom.ProcessingInstruction;
  50 import org.w3c.dom.Text;
  51 import org.w3c.dom.ls.LSSerializerFilter;
  52 import org.w3c.dom.traversal.NodeFilter;
  53 import org.xml.sax.Locator;
  54 import org.xml.sax.SAXException;
  55 import org.xml.sax.ext.LexicalHandler;
  56 import org.xml.sax.helpers.LocatorImpl;
  57 
  58 /**
  59  * Built on org.apache.xml.serializer.TreeWalker and adds functionality to
  60  * traverse and serialize a DOM Node (Level 2 or Level 3) as specified in
  61  * the DOM Level 3 LS Recommedation by evaluating and applying DOMConfiguration
  62  * parameters and filters if any during serialization.
  63  *
  64  * @xsl.usage internal
  65  */
  66 final class DOM3TreeWalker {
  67 
  68     /**
  69      * The SerializationHandler, it extends ContentHandler and when
  70      * this class is instantiated via the constructor provided, a
  71      * SerializationHandler object is passed to it.
  72      */
  73     private SerializationHandler fSerializer = null;
  74 
  75     /** We do not need DOM2Helper since DOM Level 3 LS applies to DOM Level 2 or newer */
  76 
  77     /** Locator object for this TreeWalker          */
  78     private LocatorImpl fLocator = new LocatorImpl();
  79 
  80     /** ErrorHandler */
  81     private DOMErrorHandler fErrorHandler = null;
  82 
  83     /** LSSerializerFilter */
  84     private LSSerializerFilter fFilter = null;
  85 
  86     /** If the serializer is an instance of a LexicalHandler */
  87     private LexicalHandler fLexicalHandler = null;
  88 
  89     private int fWhatToShowFilter;
  90 
  91     /** New Line character to use in serialization */
  92     private String fNewLine = null;
  93 
  94     /** DOMConfiguration Properties */
  95     private Properties fDOMConfigProperties = null;
  96 
  97     /** Keeps track if we are in an entity reference when entities=true */
  98     private boolean fInEntityRef = false;
  99 
 100     /** Stores the version of the XML document to be serialize */
 101     private String fXMLVersion = null;
 102 
 103     /** XML Version, default 1.0 */
 104     private boolean fIsXMLVersion11 = false;
 105 
 106     /** Is the Node a Level 3 DOM node */
 107     private boolean fIsLevel3DOM = false;
 108 
 109     /** DOM Configuration Parameters */
 110     private int fFeatures = 0;
 111 
 112     /** Flag indicating whether following text to be processed is raw text          */
 113     boolean fNextIsRaw = false;
 114 
 115     //
 116     private static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
 117 
 118     //
 119     private static final String XMLNS_PREFIX = "xmlns";
 120 
 121     //
 122     private static final String XML_URI = "http://www.w3.org/XML/1998/namespace";
 123 
 124     //
 125     private static final String XML_PREFIX = "xml";
 126 
 127     /** stores namespaces in scope */
 128     protected NamespaceSupport fNSBinder;
 129 
 130     /** stores all namespace bindings on the current element */
 131     protected NamespaceSupport fLocalNSBinder;
 132 
 133     /** stores the current element depth */
 134     private int fElementDepth = 0;
 135 
 136     // ***********************************************************************
 137     // DOMConfiguration paramter settings
 138     // ***********************************************************************
 139     // Parameter canonical-form, true [optional] - NOT SUPPORTED
 140     private final static int CANONICAL = 0x1 << 0;
 141 
 142     // Parameter cdata-sections, true [required] (default)
 143     private final static int CDATA = 0x1 << 1;
 144 
 145     // Parameter check-character-normalization, true [optional] - NOT SUPPORTED
 146     private final static int CHARNORMALIZE = 0x1 << 2;
 147 
 148     // Parameter comments, true [required] (default)
 149     private final static int COMMENTS = 0x1 << 3;
 150 
 151     // Parameter datatype-normalization, true [optional] - NOT SUPPORTED
 152     private final static int DTNORMALIZE = 0x1 << 4;
 153 
 154     // Parameter element-content-whitespace, true [required] (default) - value - false [optional] NOT SUPPORTED
 155     private final static int ELEM_CONTENT_WHITESPACE = 0x1 << 5;
 156 
 157     // Parameter entities, true [required] (default)
 158     private final static int ENTITIES = 0x1 << 6;
 159 
 160     // Parameter infoset, true [required] (default), false has no effect --> True has no effect for the serializer
 161     private final static int INFOSET = 0x1 << 7;
 162 
 163     // Parameter namespaces, true [required] (default)
 164     private final static int NAMESPACES = 0x1 << 8;
 165 
 166     // Parameter namespace-declarations, true [required] (default)
 167     private final static int NAMESPACEDECLS = 0x1 << 9;
 168 
 169     // Parameter normalize-characters, true [optional] - NOT SUPPORTED
 170     private final static int NORMALIZECHARS = 0x1 << 10;
 171 
 172     // Parameter split-cdata-sections, true [required] (default)
 173     private final static int SPLITCDATA = 0x1 << 11;
 174 
 175     // Parameter validate, true [optional] - NOT SUPPORTED
 176     private final static int VALIDATE = 0x1 << 12;
 177 
 178     // Parameter validate-if-schema, true [optional] - NOT SUPPORTED
 179     private final static int SCHEMAVALIDATE = 0x1 << 13;
 180 
 181     // Parameter split-cdata-sections, true [required] (default)
 182     private final static int WELLFORMED = 0x1 << 14;
 183 
 184     // Parameter discard-default-content, true [required] (default)
 185     // Not sure how this will be used in level 2 Documents
 186     private final static int DISCARDDEFAULT = 0x1 << 15;
 187 
 188     // Parameter format-pretty-print, true [optional]
 189     private final static int PRETTY_PRINT = 0x1 << 16;
 190 
 191     // Parameter ignore-unknown-character-denormalizations, true [required] (default)
 192     // We currently do not support XML 1.1 character normalization
 193     private final static int IGNORE_CHAR_DENORMALIZE = 0x1 << 17;
 194 
 195     // Parameter discard-default-content, true [required] (default)
 196     private final static int XMLDECL = 0x1 << 18;
 197 
 198     /**
 199      * Constructor.
 200      * @param   contentHandler serialHandler The implemention of the SerializationHandler interface
 201      */
 202     DOM3TreeWalker(
 203         SerializationHandler serialHandler,
 204         DOMErrorHandler errHandler,
 205         LSSerializerFilter filter,
 206         String newLine) {
 207         fSerializer = serialHandler;
 208         //fErrorHandler = errHandler == null ? new DOMErrorHandlerImpl() : errHandler; // Should we be using the default?
 209         fErrorHandler = errHandler;
 210         fFilter = filter;
 211         fLexicalHandler = null;
 212         fNewLine = newLine;
 213 
 214         fNSBinder = new NamespaceSupport();
 215         fLocalNSBinder = new NamespaceSupport();
 216 
 217         fDOMConfigProperties = fSerializer.getOutputFormat();
 218         fSerializer.setDocumentLocator(fLocator);
 219         initProperties(fDOMConfigProperties);
 220     }
 221 
 222     /**
 223      * Perform a pre-order traversal non-recursive style.
 224      *
 225      * Note that TreeWalker assumes that the subtree is intended to represent
 226      * a complete (though not necessarily well-formed) document and, during a
 227      * traversal, startDocument and endDocument will always be issued to the
 228      * SAX listener.
 229      *
 230      * @param pos Node in the tree where to start traversal
 231      *
 232      * @throws TransformerException
 233      */
 234     public void traverse(Node pos) throws org.xml.sax.SAXException {
 235         this.fSerializer.startDocument();
 236 
 237         // Determine if the Node is a DOM Level 3 Core Node.
 238         if (pos.getNodeType() != Node.DOCUMENT_NODE) {
 239             Document ownerDoc = pos.getOwnerDocument();
 240             if (ownerDoc != null
 241                 && ownerDoc.getImplementation().hasFeature("Core", "3.0")) {
 242                 fIsLevel3DOM = true;
 243             }
 244         } else {
 245             if (((Document) pos)
 246                 .getImplementation()
 247                 .hasFeature("Core", "3.0")) {
 248                 fIsLevel3DOM = true;
 249             }
 250         }
 251 
 252         if (fSerializer instanceof LexicalHandler) {
 253             fLexicalHandler = ((LexicalHandler) this.fSerializer);
 254         }
 255 
 256         if (fFilter != null)
 257             fWhatToShowFilter = fFilter.getWhatToShow();
 258 
 259         Node top = pos;
 260 
 261         while (null != pos) {
 262             startNode(pos);
 263 
 264             Node nextNode = null;
 265 
 266             nextNode = pos.getFirstChild();
 267 
 268             while (null == nextNode) {
 269                 endNode(pos);
 270 
 271                 if (top.equals(pos))
 272                     break;
 273 
 274                 nextNode = pos.getNextSibling();
 275 
 276                 if (null == nextNode) {
 277                     pos = pos.getParentNode();
 278 
 279                     if ((null == pos) || (top.equals(pos))) {
 280                         if (null != pos)
 281                             endNode(pos);
 282 
 283                         nextNode = null;
 284 
 285                         break;
 286                     }
 287                 }
 288             }
 289 
 290             pos = nextNode;
 291         }
 292         this.fSerializer.endDocument();
 293     }
 294 
 295     /**
 296      * Perform a pre-order traversal non-recursive style.
 297 
 298      * Note that TreeWalker assumes that the subtree is intended to represent
 299      * a complete (though not necessarily well-formed) document and, during a
 300      * traversal, startDocument and endDocument will always be issued to the
 301      * SAX listener.
 302      *
 303      * @param pos Node in the tree where to start traversal
 304      * @param top Node in the tree where to end traversal
 305      *
 306      * @throws TransformerException
 307      */
 308     public void traverse(Node pos, Node top) throws org.xml.sax.SAXException {
 309 
 310         this.fSerializer.startDocument();
 311 
 312         // Determine if the Node is a DOM Level 3 Core Node.
 313         if (pos.getNodeType() != Node.DOCUMENT_NODE) {
 314             Document ownerDoc = pos.getOwnerDocument();
 315             if (ownerDoc != null
 316                 && ownerDoc.getImplementation().hasFeature("Core", "3.0")) {
 317                 fIsLevel3DOM = true;
 318             }
 319         } else {
 320             if (((Document) pos)
 321                 .getImplementation()
 322                 .hasFeature("Core", "3.0")) {
 323                 fIsLevel3DOM = true;
 324             }
 325         }
 326 
 327         if (fSerializer instanceof LexicalHandler) {
 328             fLexicalHandler = ((LexicalHandler) this.fSerializer);
 329         }
 330 
 331         if (fFilter != null)
 332             fWhatToShowFilter = fFilter.getWhatToShow();
 333 
 334         while (null != pos) {
 335             startNode(pos);
 336 
 337             Node nextNode = null;
 338 
 339             nextNode = pos.getFirstChild();
 340 
 341             while (null == nextNode) {
 342                 endNode(pos);
 343 
 344                 if ((null != top) && top.equals(pos))
 345                     break;
 346 
 347                 nextNode = pos.getNextSibling();
 348 
 349                 if (null == nextNode) {
 350                     pos = pos.getParentNode();
 351 
 352                     if ((null == pos) || ((null != top) && top.equals(pos))) {
 353                         nextNode = null;
 354 
 355                         break;
 356                     }
 357                 }
 358             }
 359 
 360             pos = nextNode;
 361         }
 362         this.fSerializer.endDocument();
 363     }
 364 
 365     /**
 366      * Optimized dispatch of characters.
 367      */
 368     private final void dispatachChars(Node node)
 369         throws org.xml.sax.SAXException {
 370         if (fSerializer != null) {


 371             String data = ((Text) node).getData();
 372             this.fSerializer.characters(data.toCharArray(), 0, data.length());
 373         }
 374     }
 375 
 376     /**
 377      * Start processing given node
 378      *
 379      * @param node Node to process
 380      *
 381      * @throws org.xml.sax.SAXException
 382      */
 383     protected void startNode(Node node) throws org.xml.sax.SAXException {
 384         if (node instanceof Locator) {
 385             Locator loc = (Locator) node;
 386             fLocator.setColumnNumber(loc.getColumnNumber());
 387             fLocator.setLineNumber(loc.getLineNumber());
 388             fLocator.setPublicId(loc.getPublicId());
 389             fLocator.setSystemId(loc.getSystemId());
 390         } else {
 391             fLocator.setColumnNumber(0);
 392             fLocator.setLineNumber(0);
 393         }
 394 
 395         switch (node.getNodeType()) {
 396             case Node.DOCUMENT_TYPE_NODE :
 397                 serializeDocType((DocumentType) node, true);
 398                 break;
 399             case Node.COMMENT_NODE :
 400                 serializeComment((Comment) node);
 401                 break;
 402             case Node.DOCUMENT_FRAGMENT_NODE :
 403                 // Children are traversed
 404                 break;
 405             case Node.DOCUMENT_NODE :
 406                 break;
 407             case Node.ELEMENT_NODE :
 408                 serializeElement((Element) node, true);
 409                 break;
 410             case Node.PROCESSING_INSTRUCTION_NODE :
 411                 serializePI((ProcessingInstruction) node);
 412                 break;
 413             case Node.CDATA_SECTION_NODE :
 414                 serializeCDATASection((CDATASection) node);
 415                 break;
 416             case Node.TEXT_NODE :
 417                 serializeText((Text) node);
 418                 break;
 419             case Node.ENTITY_REFERENCE_NODE :
 420                 serializeEntityReference((EntityReference) node, true);
 421                 break;
 422             default :
 423                 }
 424     }
 425 
 426     /**
 427      * End processing of given node
 428      *
 429      *
 430      * @param node Node we just finished processing
 431      *
 432      * @throws org.xml.sax.SAXException
 433      */
 434     protected void endNode(Node node) throws org.xml.sax.SAXException {
 435 
 436         switch (node.getNodeType()) {
 437             case Node.DOCUMENT_NODE :
 438                 break;
 439             case Node.DOCUMENT_TYPE_NODE :
 440                 serializeDocType((DocumentType) node, false);
 441                 break;
 442             case Node.ELEMENT_NODE :
 443                 serializeElement((Element) node, false);
 444                 break;
 445             case Node.CDATA_SECTION_NODE :
 446                 break;
 447             case Node.ENTITY_REFERENCE_NODE :
 448                 serializeEntityReference((EntityReference) node, false);
 449                 break;
 450             default :
 451                 }
 452     }
 453 
 454     // ***********************************************************************
 455     // Node serialization methods
 456     // ***********************************************************************
 457     /**
 458      * Applies a filter on the node to serialize
 459      *
 460      * @param node The Node to serialize
 461      * @return True if the node is to be serialized else false if the node
 462      *         is to be rejected or skipped.
 463      */
 464     protected boolean applyFilter(Node node, int nodeType) {
 465         if (fFilter != null && (fWhatToShowFilter & nodeType) != 0) {
 466 
 467             short code = fFilter.acceptNode(node);
 468             switch (code) {
 469                 case NodeFilter.FILTER_REJECT :
 470                 case NodeFilter.FILTER_SKIP :
 471                     return false; // skip the node
 472                 default : // fall through..
 473             }
 474         }
 475         return true;
 476     }
 477 
 478     /**
 479      * Serializes a Document Type Node.
 480      *
 481      * @param node The Docuemnt Type Node to serialize
 482      * @param bStart Invoked at the start or end of node.  Default true.
 483      */
 484     protected void serializeDocType(DocumentType node, boolean bStart)
 485         throws SAXException {
 486         // The DocType and internalSubset can not be modified in DOM and is
 487         // considered to be well-formed as the outcome of successful parsing.
 488         String docTypeName = node.getNodeName();
 489         String publicId = node.getPublicId();
 490         String systemId = node.getSystemId();
 491         String internalSubset = node.getInternalSubset();
 492 
 493         //DocumentType nodes are never passed to the filter
 494 
 495         if (internalSubset != null && !"".equals(internalSubset)) {
 496 
 497             if (bStart) {
 498                 try {
 499                     // The Serializer does not provide a way to write out the
 500                     // DOCTYPE internal subset via an event call, so we write it
 501                     // out here.
 502                     Writer writer = fSerializer.getWriter();
 503                     StringBuffer dtd = new StringBuffer();
 504 
 505                     dtd.append("<!DOCTYPE ");
 506                     dtd.append(docTypeName);
 507                     if (null != publicId) {
 508                         dtd.append(" PUBLIC \"");
 509                         dtd.append(publicId);
 510                         dtd.append('\"');
 511                     }
 512 
 513                     if (null != systemId) {
 514                         if (null == publicId) {
 515                             dtd.append(" SYSTEM \"");
 516                         } else {
 517                             dtd.append(" \"");
 518                         }
 519                         dtd.append(systemId);
 520                         dtd.append('\"');
 521                     }
 522 
 523                     dtd.append(" [ ");
 524 
 525                     dtd.append(fNewLine);
 526                     dtd.append(internalSubset);
 527                     dtd.append("]>");
 528                     dtd.append(fNewLine);
 529 
 530                     writer.write(dtd.toString());
 531                     writer.flush();
 532 
 533                 } catch (IOException e) {
 534                     throw new SAXException(Utils.messages.createMessage(
 535                             MsgKey.ER_WRITING_INTERNAL_SUBSET, null), e);
 536                 }
 537             } // else if !bStart do nothing
 538 
 539         } else {
 540 
 541             if (bStart) {
 542                 if (fLexicalHandler != null) {
 543                     fLexicalHandler.startDTD(docTypeName, publicId, systemId);
 544                 }
 545             } else {
 546                 if (fLexicalHandler != null) {
 547                     fLexicalHandler.endDTD();
 548                 }
 549             }
 550         }
 551     }
 552 
 553     /**
 554      * Serializes a Comment Node.
 555      *
 556      * @param node The Comment Node to serialize
 557      */
 558     protected void serializeComment(Comment node) throws SAXException {
 559         // comments=true
 560         if ((fFeatures & COMMENTS) != 0) {
 561             String data = node.getData();
 562 
 563             // well-formed=true
 564             if ((fFeatures & WELLFORMED) != 0) {
 565                 isCommentWellFormed(data);
 566             }
 567 
 568             if (fLexicalHandler != null) {
 569                 // apply the LSSerializer filter after the operations requested by the
 570                 // DOMConfiguration parameters have been applied
 571                 if (!applyFilter(node, NodeFilter.SHOW_COMMENT)) {
 572                     return;
 573                 }
 574 
 575                 fLexicalHandler.comment(data.toCharArray(), 0, data.length());
 576             }
 577         }
 578     }
 579 
 580     /**
 581      * Serializes an Element Node.
 582      *
 583      * @param node The Element Node to serialize
 584      * @param bStart Invoked at the start or end of node.
 585      */
 586     protected void serializeElement(Element node, boolean bStart)
 587         throws SAXException {
 588         if (bStart) {
 589             fElementDepth++;
 590 
 591             // We use the Xalan specific startElement and starPrefixMapping calls
 592             // (and addAttribute and namespaceAfterStartElement) as opposed to
 593             // SAX specific, for performance reasons as they reduce the overhead
 594             // of creating an AttList object upfront.
 595 
 596             // well-formed=true
 597             if ((fFeatures & WELLFORMED) != 0) {
 598                 isElementWellFormed(node);
 599             }
 600 
 601             // REVISIT: We apply the LSSerializer filter for elements before
 602             // namesapce fixup
 603             if (!applyFilter(node, NodeFilter.SHOW_ELEMENT)) {
 604                 return;
 605             }
 606 
 607             // namespaces=true, record and fixup namspaced element
 608             if ((fFeatures & NAMESPACES) != 0) {
 609                 fNSBinder.pushContext();
 610                 fLocalNSBinder.reset();
 611 
 612                 recordLocalNSDecl(node);
 613                 fixupElementNS(node);
 614             }
 615 
 616             // Namespace normalization
 617             fSerializer.startElement(
 618                         node.getNamespaceURI(),
 619                     node.getLocalName(),
 620                     node.getNodeName());
 621 
 622             serializeAttList(node);
 623 
 624         } else {
 625                 fElementDepth--;
 626 
 627             // apply the LSSerializer filter
 628             if (!applyFilter(node, NodeFilter.SHOW_ELEMENT)) {
 629                 return;
 630             }
 631 
 632             this.fSerializer.endElement(
 633                 node.getNamespaceURI(),
 634                 node.getLocalName(),
 635                 node.getNodeName());
 636             // since endPrefixMapping was not used by SerializationHandler it was removed
 637             // for performance reasons.
 638 
 639             if ((fFeatures & NAMESPACES) != 0 ) {
 640                     fNSBinder.popContext();
 641             }
 642 
 643         }
 644     }
 645 
 646     /**
 647      * Serializes the Attr Nodes of an Element.
 648      *
 649      * @param node The OwnerElement whose Attr Nodes are to be serialized.
 650      */
 651     protected void serializeAttList(Element node) throws SAXException {
 652         NamedNodeMap atts = node.getAttributes();
 653         int nAttrs = atts.getLength();
 654 
 655         for (int i = 0; i < nAttrs; i++) {
 656             Node attr = atts.item(i);
 657 
 658             String localName = attr.getLocalName();
 659             String attrName = attr.getNodeName();
 660             String attrPrefix = attr.getPrefix() == null ? "" : attr.getPrefix();
 661             String attrValue = attr.getNodeValue();
 662 
 663             // Determine the Attr's type.
 664             String type = null;
 665             if (fIsLevel3DOM) {
 666                 type = ((Attr) attr).getSchemaTypeInfo().getTypeName();
 667             }
 668             type = type == null ? "CDATA" : type;
 669 
 670             String attrNS = attr.getNamespaceURI();
 671             if (attrNS !=null && attrNS.length() == 0) {
 672                 attrNS=null;
 673                 // we must remove prefix for this attribute
 674                 attrName=attr.getLocalName();
 675             }
 676 
 677             boolean isSpecified = ((Attr) attr).getSpecified();
 678             boolean addAttr = true;
 679             boolean applyFilter = false;
 680             boolean xmlnsAttr =
 681                 attrName.equals("xmlns") || attrName.startsWith("xmlns:");
 682 
 683             // well-formed=true
 684             if ((fFeatures & WELLFORMED) != 0) {
 685                 isAttributeWellFormed(attr);
 686             }
 687 
 688             //-----------------------------------------------------------------
 689             // start Attribute namespace fixup
 690             //-----------------------------------------------------------------
 691             // namespaces=true, normalize all non-namespace attributes
 692             // Step 3. Attribute
 693             if ((fFeatures & NAMESPACES) != 0 && !xmlnsAttr) {
 694 
 695                         // If the Attr has a namespace URI
 696                         if (attrNS != null) {
 697                                 attrPrefix = attrPrefix == null ? "" : attrPrefix;
 698 
 699                                 String declAttrPrefix = fNSBinder.getPrefix(attrNS);
 700                                 String declAttrNS = fNSBinder.getURI(attrPrefix);
 701 
 702                                 // attribute has no prefix (default namespace decl does not apply to
 703                                 // attributes)
 704                                 // OR
 705                                 // attribute prefix is not declared
 706                                 // OR
 707                                 // conflict: attribute has a prefix that conflicts with a binding
 708                                 if ("".equals(attrPrefix) || "".equals(declAttrPrefix)
 709                                                 || !attrPrefix.equals(declAttrPrefix)) {
 710 
 711                                         // namespaceURI matches an in scope declaration of one or
 712                                         // more prefixes
 713                                         if (declAttrPrefix != null && !"".equals(declAttrPrefix)) {
 714                                                 // pick the prefix that was found and change attribute's
 715                                                 // prefix and nodeName.
 716                                                 attrPrefix = declAttrPrefix;
 717 
 718                                                 if (declAttrPrefix.length() > 0 ) {
 719                                                         attrName = declAttrPrefix + ":" + localName;
 720                                                 } else {
 721                                                         attrName = localName;
 722                                                 }
 723                                         } else {
 724                                                 // The current prefix is not null and it has no in scope
 725                                                 // declaration
 726                                                 if (attrPrefix != null && !"".equals(attrPrefix)
 727                                                                 && declAttrNS == null) {
 728                                                         // declare this prefix
 729                                                         if ((fFeatures & NAMESPACEDECLS) != 0) {
 730                                                                 fSerializer.addAttribute(XMLNS_URI, attrPrefix,
 731                                                                                 XMLNS_PREFIX + ":" + attrPrefix, "CDATA",
 732                                                                                 attrNS);
 733                                                                 fNSBinder.declarePrefix(attrPrefix, attrNS);
 734                                                                 fLocalNSBinder.declarePrefix(attrPrefix, attrNS);
 735                                                         }
 736                                                 } else {
 737                                                         // find a prefix following the pattern "NS" +index
 738                                                         // (starting at 1)
 739                                                         // make sure this prefix is not declared in the current
 740                                                         // scope.
 741                                                         int counter = 1;
 742                                                         attrPrefix = "NS" + counter++;
 743 
 744                                                         while (fLocalNSBinder.getURI(attrPrefix) != null) {
 745                                                                 attrPrefix = "NS" + counter++;
 746                                                         }
 747                                                         // change attribute's prefix and Name
 748                                                         attrName = attrPrefix + ":" + localName;
 749 
 750                                                         // create a local namespace declaration attribute
 751                                                         // Add the xmlns declaration attribute
 752                                                         if ((fFeatures & NAMESPACEDECLS) != 0) {
 753 
 754                                                                 fSerializer.addAttribute(XMLNS_URI, attrPrefix,
 755                                                                                 XMLNS_PREFIX + ":" + attrPrefix, "CDATA",
 756                                                                                 attrNS);
 757                                                         fNSBinder.declarePrefix(attrPrefix, attrNS);
 758                                                         fLocalNSBinder.declarePrefix(attrPrefix, attrNS);
 759                                                         }
 760                                                 }
 761                                         }
 762                                 }
 763 
 764                         } else { // if the Attr has no namespace URI
 765                                 // Attr has no localName
 766                                 if (localName == null) {
 767                                         // DOM Level 1 node!
 768                                         String msg = Utils.messages.createMessage(
 769                                                         MsgKey.ER_NULL_LOCAL_ELEMENT_NAME,
 770                                                         new Object[] { attrName });
 771 
 772                                         if (fErrorHandler != null) {
 773                                                 fErrorHandler
 774                                                                 .handleError(new DOMErrorImpl(
 775                                                                                 DOMError.SEVERITY_ERROR, msg,
 776                                                                                 MsgKey.ER_NULL_LOCAL_ELEMENT_NAME, null,
 777                                                                                 null, null));
 778                                         }
 779 
 780                                 } else { // uri=null and no colon
 781                                         // attr has no namespace URI and no prefix
 782                                         // no action is required, since attrs don't use default
 783                                 }
 784                         }
 785 
 786             }
 787 
 788 
 789             // discard-default-content=true
 790             // Default attr's are not passed to the filter and this contraint
 791             // is applied only when discard-default-content=true
 792             // What about default xmlns attributes???? check for xmlnsAttr
 793             if ((((fFeatures & DISCARDDEFAULT) != 0) && isSpecified)
 794                 || ((fFeatures & DISCARDDEFAULT) == 0)) {
 795                 applyFilter = true;
 796             } else {
 797                 addAttr = false;
 798             }
 799 
 800             if (applyFilter) {
 801                 // apply the filter for Attributes that are not default attributes
 802                 // or namespace decl attributes
 803                 if (fFilter != null
 804                     && (fFilter.getWhatToShow() & NodeFilter.SHOW_ATTRIBUTE)
 805                         != 0) {
 806 
 807                     if (!xmlnsAttr) {
 808                         short code = fFilter.acceptNode(attr);
 809                         switch (code) {
 810                             case NodeFilter.FILTER_REJECT :
 811                             case NodeFilter.FILTER_SKIP :
 812                                 addAttr = false;
 813                                 break;
 814                             default : //fall through..
 815                         }
 816                     }
 817                 }
 818             }
 819 
 820             // if the node is a namespace node
 821             if (addAttr && xmlnsAttr) {
 822                 // If namespace-declarations=true, add the node , else don't add it
 823                 if ((fFeatures & NAMESPACEDECLS) != 0) {
 824                         // The namespace may have been fixed up, in that case don't add it.
 825                         if (localName != null && !"".equals(localName)) {
 826                                 fSerializer.addAttribute(attrNS, localName, attrName, type, attrValue);
 827                         }
 828                 }
 829             } else if (
 830                 addAttr && !xmlnsAttr) { // if the node is not a namespace node
 831                 // If namespace-declarations=true, add the node with the Attr nodes namespaceURI
 832                 // else add the node setting it's namespace to null or else the serializer will later
 833                 // attempt to add a xmlns attr for the prefixed attribute
 834                 if (((fFeatures & NAMESPACEDECLS) != 0) && (attrNS != null)) {
 835                     fSerializer.addAttribute(
 836                         attrNS,
 837                         localName,
 838                         attrName,
 839                         type,
 840                         attrValue);
 841                 } else {
 842                     fSerializer.addAttribute(
 843                         "",
 844                         localName,
 845                         attrName,
 846                         type,
 847                         attrValue);
 848                 }
 849             }
 850 
 851             //
 852             if (xmlnsAttr && ((fFeatures & NAMESPACEDECLS) != 0)) {
 853                 int index;
 854                 // Use "" instead of null, as Xerces likes "" for the
 855                 // name of the default namespace.  Fix attributed
 856                 // to "Steven Murray" <smurray@ebt.com>.
 857                 String prefix =
 858                     (index = attrName.indexOf(":")) < 0
 859                         ? ""
 860                         : attrName.substring(index + 1);
 861 
 862                 if (!"".equals(prefix)) {
 863                     fSerializer.namespaceAfterStartElement(prefix, attrValue);
 864                 }
 865             }
 866         }
 867 
 868     }
 869 
 870     /**
 871      * Serializes an ProcessingInstruction Node.
 872      *
 873      * @param node The ProcessingInstruction Node to serialize
 874      */
 875     protected void serializePI(ProcessingInstruction node)
 876         throws SAXException {
 877         ProcessingInstruction pi = node;
 878         String name = pi.getNodeName();
 879 
 880         // well-formed=true
 881         if ((fFeatures & WELLFORMED) != 0) {
 882             isPIWellFormed(node);
 883         }
 884 
 885         // apply the LSSerializer filter
 886         if (!applyFilter(node, NodeFilter.SHOW_PROCESSING_INSTRUCTION)) {
 887             return;
 888         }
 889 
 890         // String data = pi.getData();
 891         if (name.equals("xslt-next-is-raw")) {
 892             fNextIsRaw = true;
 893         } else {
 894             this.fSerializer.processingInstruction(name, pi.getData());
 895         }
 896     }
 897 
 898     /**
 899      * Serializes an CDATASection Node.
 900      *
 901      * @param node The CDATASection Node to serialize
 902      */
 903     protected void serializeCDATASection(CDATASection node)
 904         throws SAXException {
 905         // well-formed=true
 906         if ((fFeatures & WELLFORMED) != 0) {
 907             isCDATASectionWellFormed(node);
 908         }
 909 
 910         // cdata-sections = true
 911         if ((fFeatures & CDATA) != 0) {
 912 
 913             // split-cdata-sections = true
 914             // Assumption: This parameter has an effect only when
 915                         // cdata-sections=true
 916             // ToStream, by default splits cdata-sections. Hence the check
 917                         // below.
 918             String nodeValue = node.getNodeValue();
 919             int endIndex = nodeValue.indexOf("]]>");
 920             if ((fFeatures & SPLITCDATA) != 0) {
 921                 if (endIndex >= 0) {
 922                     // The first node split will contain the ]] markers
 923                     String relatedData = nodeValue.substring(0, endIndex + 2);
 924 
 925                     String msg =
 926                         Utils.messages.createMessage(
 927                             MsgKey.ER_CDATA_SECTIONS_SPLIT,
 928                             null);
 929 
 930                     if (fErrorHandler != null) {
 931                         fErrorHandler.handleError(
 932                             new DOMErrorImpl(
 933                                 DOMError.SEVERITY_WARNING,
 934                                 msg,
 935                                 MsgKey.ER_CDATA_SECTIONS_SPLIT,
 936                                 null,
 937                                 relatedData,
 938                                 null));
 939                     }
 940                 }
 941             } else {
 942                 if (endIndex >= 0) {
 943                     // The first node split will contain the ]] markers
 944                     String relatedData = nodeValue.substring(0, endIndex + 2);
 945 
 946                     String msg =
 947                         Utils.messages.createMessage(
 948                             MsgKey.ER_CDATA_SECTIONS_SPLIT,
 949                             null);
 950 
 951                     if (fErrorHandler != null) {
 952                         fErrorHandler.handleError(
 953                             new DOMErrorImpl(
 954                                 DOMError.SEVERITY_ERROR,
 955                                 msg,
 956                                 MsgKey.ER_CDATA_SECTIONS_SPLIT));
 957                     }
 958                     // Report an error and return.  What error???
 959                     return;
 960                 }
 961             }
 962 
 963             // apply the LSSerializer filter
 964             if (!applyFilter(node, NodeFilter.SHOW_CDATA_SECTION)) {
 965                 return;
 966             }
 967 
 968             // splits the cdata-section
 969             if (fLexicalHandler != null) {
 970                 fLexicalHandler.startCDATA();
 971             }
 972             dispatachChars(node);
 973             if (fLexicalHandler != null) {
 974                 fLexicalHandler.endCDATA();
 975             }
 976         } else {
 977             dispatachChars(node);
 978         }
 979     }
 980 
 981     /**
 982      * Serializes an Text Node.
 983      *
 984      * @param node The Text Node to serialize
 985      */
 986     protected void serializeText(Text node) throws SAXException {
 987         if (fNextIsRaw) {
 988             fNextIsRaw = false;
 989             fSerializer.processingInstruction(
 990                 javax.xml.transform.Result.PI_DISABLE_OUTPUT_ESCAPING,
 991                 "");
 992             dispatachChars(node);
 993             fSerializer.processingInstruction(
 994                 javax.xml.transform.Result.PI_ENABLE_OUTPUT_ESCAPING,
 995                 "");
 996         } else {
 997             // keep track of dispatch or not to avoid duplicaiton of filter code
 998             boolean bDispatch = false;
 999 
1000             // well-formed=true
1001             if ((fFeatures & WELLFORMED) != 0) {
1002                 isTextWellFormed(node);
1003             }
1004 
1005             // if the node is whitespace
1006             // Determine the Attr's type.
1007             boolean isElementContentWhitespace = false;
1008             if (fIsLevel3DOM) {
1009                 isElementContentWhitespace =
1010                        node.isElementContentWhitespace();
1011             }
1012 
1013             if (isElementContentWhitespace) {
1014                 // element-content-whitespace=true
1015                 if ((fFeatures & ELEM_CONTENT_WHITESPACE) != 0) {
1016                     bDispatch = true;
1017                 }
1018             } else {
1019                 bDispatch = true;
1020             }
1021 
1022             // apply the LSSerializer filter
1023             if (!applyFilter(node, NodeFilter.SHOW_TEXT)) {
1024                 return;
1025             }
1026 
1027             if (bDispatch) {
1028                 dispatachChars(node);
1029             }
1030         }
1031     }
1032 
1033     /**
1034      * Serializes an EntityReference Node.
1035      *
1036      * @param node The EntityReference Node to serialize
1037      * @param bStart Inicates if called from start or endNode
1038      */
1039     protected void serializeEntityReference(
1040         EntityReference node,
1041         boolean bStart)
1042         throws SAXException {
1043         if (bStart) {
1044             EntityReference eref = node;
1045             // entities=true
1046             if ((fFeatures & ENTITIES) != 0) {
1047 
1048                 // perform well-formedness and other checking only if
1049                 // entities = true
1050 
1051                 // well-formed=true
1052                 if ((fFeatures & WELLFORMED) != 0) {
1053                     isEntityReferneceWellFormed(node);
1054                 }
1055 
1056                 // check "unbound-prefix-in-entity-reference" [fatal]
1057                 // Raised if the configuration parameter "namespaces" is set to true
1058                 if ((fFeatures & NAMESPACES) != 0) {
1059                     checkUnboundPrefixInEntRef(node);
1060                 }
1061 
1062                 // The filter should not apply in this case, since the
1063                 // EntityReference is not being expanded.
1064                 // should we pass entity reference nodes to the filter???
1065             }
1066 
1067             // if "entities" is true, or EntityReference node has no children,
1068             // it will be serialized as the form "&entityName;" in the output.
1069             if (fLexicalHandler != null && ((fFeatures & ENTITIES) != 0 || !node.hasChildNodes())) {
1070 
1071                 // startEntity outputs only Text but not Element, Attr, Comment
1072                 // and PI child nodes.  It does so by setting the m_inEntityRef
1073                 // in ToStream and using this to decide if a node is to be
1074                 // serialized or not.
1075                 fLexicalHandler.startEntity(eref.getNodeName());
1076             }
1077 
1078         } else {
1079             EntityReference eref = node;
1080             // entities=true or false,
1081             if (fLexicalHandler != null) {
1082                 fLexicalHandler.endEntity(eref.getNodeName());
1083             }
1084         }
1085     }
1086 
1087 
1088     // ***********************************************************************
1089     // Methods to check well-formedness
1090     // ***********************************************************************
1091     /**
1092      * Taken from org.apache.xerces.dom.CoreDocumentImpl
1093      *
1094      * Check the string against XML's definition of acceptable names for
1095      * elements and attributes and so on using the XMLCharacterProperties
1096      * utility class
1097      */
1098     protected boolean isXMLName(String s, boolean xml11Version) {
1099 
1100         if (s == null) {
1101             return false;
1102         }
1103         if (!xml11Version)
1104             return XMLChar.isValidName(s);
1105         else
1106             return XML11Char.isXML11ValidName(s);
1107     }
1108 
1109     /**
1110      * Taken from org.apache.xerces.dom.CoreDocumentImpl
1111      *
1112      * Checks if the given qualified name is legal with respect
1113      * to the version of XML to which this document must conform.
1114      *
1115      * @param prefix prefix of qualified name
1116      * @param local local part of qualified name
1117      */
1118     protected boolean isValidQName(
1119         String prefix,
1120         String local,
1121         boolean xml11Version) {
1122 
1123         // check that both prefix and local part match NCName
1124         if (local == null)
1125             return false;
1126         boolean validNCName = false;
1127 
1128         if (!xml11Version) {
1129             validNCName =
1130                 (prefix == null || XMLChar.isValidNCName(prefix))
1131                     && XMLChar.isValidNCName(local);
1132         } else {
1133             validNCName =
1134                 (prefix == null || XML11Char.isXML11ValidNCName(prefix))
1135                     && XML11Char.isXML11ValidNCName(local);
1136         }
1137 
1138         return validNCName;
1139     }
1140 
1141     /**
1142      * Checks if a XML character is well-formed
1143      *
1144      * @param characters A String of characters to be checked for Well-Formedness
1145      * @param refInvalidChar A reference to the character to be returned that was determined invalid.
1146      */
1147     protected boolean isWFXMLChar(String chardata, Character refInvalidChar) {
1148         if (chardata == null || (chardata.length() == 0)) {
1149             return true;
1150         }
1151 
1152         char[] dataarray = chardata.toCharArray();
1153         int datalength = dataarray.length;
1154 
1155         // version of the document is XML 1.1
1156         if (fIsXMLVersion11) {
1157             //we need to check all characters as per production rules of XML11
1158             int i = 0;
1159             while (i < datalength) {
1160                 if (XML11Char.isXML11Invalid(dataarray[i++])) {
1161                     // check if this is a supplemental character
1162                     char ch = dataarray[i - 1];
1163                     if (XMLChar.isHighSurrogate(ch) && i < datalength) {
1164                         char ch2 = dataarray[i++];
1165                         if (XMLChar.isLowSurrogate(ch2)
1166                             && XMLChar.isSupplemental(
1167                                 XMLChar.supplemental(ch, ch2))) {
1168                             continue;
1169                         }
1170                     }
1171                     // Reference to invalid character which is returned
1172                     refInvalidChar = new Character(ch);
1173                     return false;
1174                 }
1175             }
1176         } // version of the document is XML 1.0
1177         else {
1178             // we need to check all characters as per production rules of XML 1.0
1179             int i = 0;
1180             while (i < datalength) {
1181                 if (XMLChar.isInvalid(dataarray[i++])) {
1182                     // check if this is a supplemental character
1183                     char ch = dataarray[i - 1];
1184                     if (XMLChar.isHighSurrogate(ch) && i < datalength) {
1185                         char ch2 = dataarray[i++];
1186                         if (XMLChar.isLowSurrogate(ch2)
1187                             && XMLChar.isSupplemental(
1188                                 XMLChar.supplemental(ch, ch2))) {
1189                             continue;
1190                         }
1191                     }
1192                     // Reference to invalid character which is returned
1193                     refInvalidChar = new Character(ch);
1194                     return false;
1195                 }
1196             }
1197         } // end-else fDocument.isXMLVersion()
1198 
1199         return true;
1200     } // isXMLCharWF
1201 
1202     /**
1203      * Checks if a XML character is well-formed.  If there is a problem with
1204      * the character a non-null Character is returned else null is returned.
1205      *
1206      * @param characters A String of characters to be checked for Well-Formedness
1207      * @return Character A reference to the character to be returned that was determined invalid.
1208      */
1209     protected Character isWFXMLChar(String chardata) {
1210         Character refInvalidChar;
1211         if (chardata == null || (chardata.length() == 0)) {
1212             return null;
1213         }
1214 
1215         char[] dataarray = chardata.toCharArray();
1216         int datalength = dataarray.length;
1217 
1218         // version of the document is XML 1.1
1219         if (fIsXMLVersion11) {
1220             //we need to check all characters as per production rules of XML11
1221             int i = 0;
1222             while (i < datalength) {
1223                 if (XML11Char.isXML11Invalid(dataarray[i++])) {
1224                     // check if this is a supplemental character
1225                     char ch = dataarray[i - 1];
1226                     if (XMLChar.isHighSurrogate(ch) && i < datalength) {
1227                         char ch2 = dataarray[i++];
1228                         if (XMLChar.isLowSurrogate(ch2)
1229                             && XMLChar.isSupplemental(
1230                                 XMLChar.supplemental(ch, ch2))) {
1231                             continue;
1232                         }
1233                     }
1234                     // Reference to invalid character which is returned
1235                     refInvalidChar = new Character(ch);
1236                     return refInvalidChar;
1237                 }
1238             }
1239         } // version of the document is XML 1.0
1240         else {
1241             // we need to check all characters as per production rules of XML 1.0
1242             int i = 0;
1243             while (i < datalength) {
1244                 if (XMLChar.isInvalid(dataarray[i++])) {
1245                     // check if this is a supplemental character
1246                     char ch = dataarray[i - 1];
1247                     if (XMLChar.isHighSurrogate(ch) && i < datalength) {
1248                         char ch2 = dataarray[i++];
1249                         if (XMLChar.isLowSurrogate(ch2)
1250                             && XMLChar.isSupplemental(
1251                                 XMLChar.supplemental(ch, ch2))) {
1252                             continue;
1253                         }
1254                     }
1255                     // Reference to invalid character which is returned
1256                     refInvalidChar = new Character(ch);
1257                     return refInvalidChar;
1258                 }
1259             }
1260         } // end-else fDocument.isXMLVersion()
1261 
1262         return null;
1263     } // isXMLCharWF
1264 
1265     /**
1266      * Checks if a comment node is well-formed
1267      *
1268      * @param data The contents of the comment node
1269      * @return a boolean indiacating if the comment is well-formed or not.
1270      */
1271     protected void isCommentWellFormed(String data) {
1272         if (data == null || (data.length() == 0)) {
1273             return;
1274         }
1275 
1276         char[] dataarray = data.toCharArray();
1277         int datalength = dataarray.length;
1278 
1279         // version of the document is XML 1.1
1280         if (fIsXMLVersion11) {
1281             // we need to check all chracters as per production rules of XML11
1282             int i = 0;
1283             while (i < datalength) {
1284                 char c = dataarray[i++];
1285                 if (XML11Char.isXML11Invalid(c)) {
1286                     // check if this is a supplemental character
1287                     if (XMLChar.isHighSurrogate(c) && i < datalength) {
1288                         char c2 = dataarray[i++];
1289                         if (XMLChar.isLowSurrogate(c2)
1290                             && XMLChar.isSupplemental(
1291                                 XMLChar.supplemental(c, c2))) {
1292                             continue;
1293                         }
1294                     }
1295                     String msg =
1296                         Utils.messages.createMessage(
1297                             MsgKey.ER_WF_INVALID_CHARACTER_IN_COMMENT,
1298                             new Object[] { new Character(c)});
1299 
1300                     if (fErrorHandler != null) {
1301                         fErrorHandler.handleError(
1302                             new DOMErrorImpl(
1303                                 DOMError.SEVERITY_FATAL_ERROR,
1304                                 msg,
1305                                 MsgKey.ER_WF_INVALID_CHARACTER,
1306                                 null,
1307                                 null,
1308                                 null));
1309                     }
1310                 } else if (c == '-' && i < datalength && dataarray[i] == '-') {
1311                     String msg =
1312                         Utils.messages.createMessage(
1313                             MsgKey.ER_WF_DASH_IN_COMMENT,
1314                             null);
1315 
1316                     if (fErrorHandler != null) {
1317                         fErrorHandler.handleError(
1318                             new DOMErrorImpl(
1319                                 DOMError.SEVERITY_FATAL_ERROR,
1320                                 msg,
1321                                 MsgKey.ER_WF_INVALID_CHARACTER,
1322                                 null,
1323                                 null,
1324                                 null));
1325                     }
1326                 }
1327             }
1328         } // version of the document is XML 1.0
1329         else {
1330             // we need to check all chracters as per production rules of XML 1.0
1331             int i = 0;
1332             while (i < datalength) {
1333                 char c = dataarray[i++];
1334                 if (XMLChar.isInvalid(c)) {
1335                     // check if this is a supplemental character
1336                     if (XMLChar.isHighSurrogate(c) && i < datalength) {
1337                         char c2 = dataarray[i++];
1338                         if (XMLChar.isLowSurrogate(c2)
1339                             && XMLChar.isSupplemental(
1340                                 XMLChar.supplemental(c, c2))) {
1341                             continue;
1342                         }
1343                     }
1344                     String msg =
1345                         Utils.messages.createMessage(
1346                             MsgKey.ER_WF_INVALID_CHARACTER_IN_COMMENT,
1347                             new Object[] { new Character(c)});
1348 
1349                     if (fErrorHandler != null) {
1350                         fErrorHandler.handleError(
1351                             new DOMErrorImpl(
1352                                 DOMError.SEVERITY_FATAL_ERROR,
1353                                 msg,
1354                                 MsgKey.ER_WF_INVALID_CHARACTER,
1355                                 null,
1356                                 null,
1357                                 null));
1358                     }
1359                 } else if (c == '-' && i < datalength && dataarray[i] == '-') {
1360                     String msg =
1361                         Utils.messages.createMessage(
1362                             MsgKey.ER_WF_DASH_IN_COMMENT,
1363                             null);
1364 
1365                     if (fErrorHandler != null) {
1366                         fErrorHandler.handleError(
1367                             new DOMErrorImpl(
1368                                 DOMError.SEVERITY_FATAL_ERROR,
1369                                 msg,
1370                                 MsgKey.ER_WF_INVALID_CHARACTER,
1371                                 null,
1372                                 null,
1373                                 null));
1374                     }
1375                 }
1376             }
1377         }
1378         return;
1379     }
1380 
1381     /**
1382      * Checks if an element node is well-formed, by checking its Name for well-formedness.
1383      *
1384      * @param data The contents of the comment node
1385      * @return a boolean indiacating if the comment is well-formed or not.
1386      */
1387     protected void isElementWellFormed(Node node) {
1388         boolean isNameWF = false;
1389         if ((fFeatures & NAMESPACES) != 0) {
1390             isNameWF =
1391                 isValidQName(
1392                     node.getPrefix(),
1393                     node.getLocalName(),
1394                     fIsXMLVersion11);
1395         } else {
1396             isNameWF = isXMLName(node.getNodeName(), fIsXMLVersion11);
1397         }
1398 
1399         if (!isNameWF) {
1400             String msg =
1401                 Utils.messages.createMessage(
1402                     MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1403                     new Object[] { "Element", node.getNodeName()});
1404 
1405             if (fErrorHandler != null) {
1406                 fErrorHandler.handleError(
1407                     new DOMErrorImpl(
1408                         DOMError.SEVERITY_FATAL_ERROR,
1409                         msg,
1410                         MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1411                         null,
1412                         null,
1413                         null));
1414             }
1415         }
1416     }
1417 
1418     /**
1419      * Checks if an attr node is well-formed, by checking it's Name and value
1420      * for well-formedness.
1421      *
1422      * @param data The contents of the comment node
1423      * @return a boolean indiacating if the comment is well-formed or not.
1424      */
1425     protected void isAttributeWellFormed(Node node) {
1426         boolean isNameWF = false;
1427         if ((fFeatures & NAMESPACES) != 0) {
1428             isNameWF =
1429                 isValidQName(
1430                     node.getPrefix(),
1431                     node.getLocalName(),
1432                     fIsXMLVersion11);
1433         } else {
1434             isNameWF = isXMLName(node.getNodeName(), fIsXMLVersion11);
1435         }
1436 
1437         if (!isNameWF) {
1438             String msg =
1439                 Utils.messages.createMessage(
1440                     MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1441                     new Object[] { "Attr", node.getNodeName()});
1442 
1443             if (fErrorHandler != null) {
1444                 fErrorHandler.handleError(
1445                     new DOMErrorImpl(
1446                         DOMError.SEVERITY_FATAL_ERROR,
1447                         msg,
1448                         MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1449                         null,
1450                         null,
1451                         null));
1452             }
1453         }
1454 
1455         // Check the Attr's node value
1456         // WFC: No < in Attribute Values
1457         String value = node.getNodeValue();
1458         if (value.indexOf('<') >= 0) {
1459             String msg =
1460                 Utils.messages.createMessage(
1461                     MsgKey.ER_WF_LT_IN_ATTVAL,
1462                     new Object[] {
1463                         ((Attr) node).getOwnerElement().getNodeName(),
1464                         node.getNodeName()});
1465 
1466             if (fErrorHandler != null) {
1467                 fErrorHandler.handleError(
1468                     new DOMErrorImpl(
1469                         DOMError.SEVERITY_FATAL_ERROR,
1470                         msg,
1471                         MsgKey.ER_WF_LT_IN_ATTVAL,
1472                         null,
1473                         null,
1474                         null));
1475             }
1476         }
1477 
1478         // we need to loop through the children of attr nodes and check their values for
1479         // well-formedness
1480         NodeList children = node.getChildNodes();
1481         for (int i = 0; i < children.getLength(); i++) {
1482             Node child = children.item(i);
1483             // An attribute node with no text or entity ref child for example
1484             // doc.createAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:ns");
1485             // followes by
1486             // element.setAttributeNodeNS(attribute);
1487             // can potentially lead to this situation.  If the attribute
1488             // was a prefix Namespace attribute declaration then then DOM Core
1489             // should have some exception defined for this.
1490             if (child == null) {
1491                 // we should probably report an error
1492                 continue;
1493             }
1494             switch (child.getNodeType()) {
1495                 case Node.TEXT_NODE :
1496                     isTextWellFormed((Text) child);
1497                     break;
1498                 case Node.ENTITY_REFERENCE_NODE :
1499                     isEntityReferneceWellFormed((EntityReference) child);
1500                     break;
1501                 default :
1502             }
1503         }
1504 
1505         // TODO:
1506         // WFC: Check if the attribute prefix is bound to
1507         // http://www.w3.org/2000/xmlns/
1508 
1509         // WFC: Unique Att Spec
1510         // Perhaps pass a seen boolean value to this method.  serializeAttList will determine
1511         // if the attr was seen before.
1512     }
1513 
1514     /**
1515      * Checks if a PI node is well-formed, by checking it's Name and data
1516      * for well-formedness.
1517      *
1518      * @param data The contents of the comment node
1519      */
1520     protected void isPIWellFormed(ProcessingInstruction node) {
1521         // Is the PI Target a valid XML name
1522         if (!isXMLName(node.getNodeName(), fIsXMLVersion11)) {
1523             String msg =
1524                 Utils.messages.createMessage(
1525                     MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1526                     new Object[] { "ProcessingInstruction", node.getTarget()});
1527 
1528             if (fErrorHandler != null) {
1529                 fErrorHandler.handleError(
1530                     new DOMErrorImpl(
1531                         DOMError.SEVERITY_FATAL_ERROR,
1532                         msg,
1533                         MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1534                         null,
1535                         null,
1536                         null));
1537             }
1538         }
1539 
1540         // Does the PI Data carry valid XML characters
1541 
1542         // REVISIT: Should we check if the PI DATA contains a ?> ???
1543         Character invalidChar = isWFXMLChar(node.getData());
1544         if (invalidChar != null) {
1545             String msg =
1546                 Utils.messages.createMessage(
1547                     MsgKey.ER_WF_INVALID_CHARACTER_IN_PI,
1548                     new Object[] { Integer.toHexString(Character.getNumericValue(invalidChar.charValue())) });
1549 
1550             if (fErrorHandler != null) {
1551                 fErrorHandler.handleError(
1552                     new DOMErrorImpl(
1553                         DOMError.SEVERITY_FATAL_ERROR,
1554                         msg,
1555                         MsgKey.ER_WF_INVALID_CHARACTER,
1556                         null,
1557                         null,
1558                         null));
1559             }
1560         }
1561     }
1562 
1563     /**
1564      * Checks if an CDATASection node is well-formed, by checking it's data
1565      * for well-formedness.  Note that the presence of a CDATA termination mark
1566      * in the contents of a CDATASection is handled by the parameter
1567      * spli-cdata-sections
1568      *
1569      * @param data The contents of the comment node
1570      */
1571     protected void isCDATASectionWellFormed(CDATASection node) {
1572         // Does the data valid XML character data
1573         Character invalidChar = isWFXMLChar(node.getData());
1574         //if (!isWFXMLChar(node.getData(), invalidChar)) {
1575         if (invalidChar != null) {
1576             String msg =
1577                 Utils.messages.createMessage(
1578                     MsgKey.ER_WF_INVALID_CHARACTER_IN_CDATA,
1579                     new Object[] { Integer.toHexString(Character.getNumericValue(invalidChar.charValue())) });
1580 
1581             if (fErrorHandler != null) {
1582                 fErrorHandler.handleError(
1583                     new DOMErrorImpl(
1584                         DOMError.SEVERITY_FATAL_ERROR,
1585                         msg,
1586                         MsgKey.ER_WF_INVALID_CHARACTER,
1587                         null,
1588                         null,
1589                         null));
1590             }
1591         }
1592     }
1593 
1594     /**
1595      * Checks if an Text node is well-formed, by checking if it contains invalid
1596      * XML characters.
1597      *
1598      * @param data The contents of the comment node
1599      */
1600     protected void isTextWellFormed(Text node) {
1601         // Does the data valid XML character data
1602         Character invalidChar = isWFXMLChar(node.getData());
1603         if (invalidChar != null) {
1604             String msg =
1605                 Utils.messages.createMessage(
1606                     MsgKey.ER_WF_INVALID_CHARACTER_IN_TEXT,
1607                     new Object[] { Integer.toHexString(Character.getNumericValue(invalidChar.charValue())) });
1608 
1609             if (fErrorHandler != null) {
1610                 fErrorHandler.handleError(
1611                     new DOMErrorImpl(
1612                         DOMError.SEVERITY_FATAL_ERROR,
1613                         msg,
1614                         MsgKey.ER_WF_INVALID_CHARACTER,
1615                         null,
1616                         null,
1617                         null));
1618             }
1619         }
1620     }
1621 
1622     /**
1623      * Checks if an EntityRefernece node is well-formed, by checking it's node name.  Then depending
1624      * on whether it is referenced in Element content or in an Attr Node, checks if the EntityReference
1625      * references an unparsed entity or a external entity and if so throws raises the
1626      * appropriate well-formedness error.
1627      *
1628      * @param data The contents of the comment node
1629      * @parent The parent of the EntityReference Node
1630      */
1631     protected void isEntityReferneceWellFormed(EntityReference node) {
1632         // Is the EntityReference name a valid XML name
1633         if (!isXMLName(node.getNodeName(), fIsXMLVersion11)) {
1634             String msg =
1635                 Utils.messages.createMessage(
1636                     MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1637                     new Object[] { "EntityReference", node.getNodeName()});
1638 
1639             if (fErrorHandler != null) {
1640                 fErrorHandler.handleError(
1641                     new DOMErrorImpl(
1642                         DOMError.SEVERITY_FATAL_ERROR,
1643                         msg,
1644                         MsgKey.ER_WF_INVALID_CHARACTER_IN_NODE_NAME,
1645                         null,
1646                         null,
1647                         null));
1648             }
1649         }
1650 
1651         // determine the parent node
1652         Node parent = node.getParentNode();
1653 
1654         // Traverse the declared entities and check if the nodeName and namespaceURI
1655         // of the EntityReference matches an Entity.  If so, check the if the notationName
1656         // is not null, if so, report an error.
1657         DocumentType docType = node.getOwnerDocument().getDoctype();
1658         if (docType != null) {
1659             NamedNodeMap entities = docType.getEntities();
1660             for (int i = 0; i < entities.getLength(); i++) {
1661                 Entity ent = (Entity) entities.item(i);
1662 
1663                 String nodeName =
1664                     node.getNodeName() == null ? "" : node.getNodeName();
1665                 String nodeNamespaceURI =
1666                     node.getNamespaceURI() == null
1667                         ? ""
1668                         : node.getNamespaceURI();
1669                 String entName =
1670                     ent.getNodeName() == null ? "" : ent.getNodeName();
1671                 String entNamespaceURI =
1672                     ent.getNamespaceURI() == null ? "" : ent.getNamespaceURI();
1673                 // If referenced in Element content
1674                 // WFC: Parsed Entity
1675                 if (parent.getNodeType() == Node.ELEMENT_NODE) {
1676                     if (entNamespaceURI.equals(nodeNamespaceURI)
1677                         && entName.equals(nodeName)) {
1678 
1679                         if (ent.getNotationName() != null) {
1680                             String msg =
1681                                 Utils.messages.createMessage(
1682                                     MsgKey.ER_WF_REF_TO_UNPARSED_ENT,
1683                                     new Object[] { node.getNodeName()});
1684 
1685                             if (fErrorHandler != null) {
1686                                 fErrorHandler.handleError(
1687                                     new DOMErrorImpl(
1688                                         DOMError.SEVERITY_FATAL_ERROR,
1689                                         msg,
1690                                         MsgKey.ER_WF_REF_TO_UNPARSED_ENT,
1691                                         null,
1692                                         null,
1693                                         null));
1694                             }
1695                         }
1696                     }
1697                 } // end if WFC: Parsed Entity
1698 
1699                 // If referenced in an Attr value
1700                 // WFC: No External Entity References
1701                 if (parent.getNodeType() == Node.ATTRIBUTE_NODE) {
1702                     if (entNamespaceURI.equals(nodeNamespaceURI)
1703                         && entName.equals(nodeName)) {
1704 
1705                         if (ent.getPublicId() != null
1706                             || ent.getSystemId() != null
1707                             || ent.getNotationName() != null) {
1708                             String msg =
1709                                 Utils.messages.createMessage(
1710                                     MsgKey.ER_WF_REF_TO_EXTERNAL_ENT,
1711                                     new Object[] { node.getNodeName()});
1712 
1713                             if (fErrorHandler != null) {
1714                                 fErrorHandler.handleError(
1715                                     new DOMErrorImpl(
1716                                         DOMError.SEVERITY_FATAL_ERROR,
1717                                         msg,
1718                                         MsgKey.ER_WF_REF_TO_EXTERNAL_ENT,
1719                                         null,
1720                                         null,
1721                                         null));
1722                             }
1723                         }
1724                     }
1725                 } //end if WFC: No External Entity References
1726             }
1727         }
1728     } // isEntityReferneceWellFormed
1729 
1730     /**
1731      * If the configuration parameter "namespaces" is set to true, this methods
1732      * checks if an entity whose replacement text contains unbound namespace
1733      * prefixes is referenced in a location where there are no bindings for
1734      * the namespace prefixes and if so raises a LSException with the error-type
1735      * "unbound-prefix-in-entity-reference"
1736      *
1737      * @param Node, The EntityReference nodes whose children are to be checked
1738      */
1739     protected void checkUnboundPrefixInEntRef(Node node) {
1740         Node child, next;
1741         for (child = node.getFirstChild(); child != null; child = next) {
1742             next = child.getNextSibling();
1743 
1744             if (child.getNodeType() == Node.ELEMENT_NODE) {
1745 
1746                 //If a NamespaceURI is not declared for the current
1747                 //node's prefix, raise a fatal error.
1748                 String prefix = child.getPrefix();
1749                 if (prefix != null
1750                                 && fNSBinder.getURI(prefix) == null) {
1751                     String msg =
1752                         Utils.messages.createMessage(
1753                             MsgKey.ER_ELEM_UNBOUND_PREFIX_IN_ENTREF,
1754                             new Object[] {
1755                                 node.getNodeName(),
1756                                 child.getNodeName(),
1757                                 prefix });
1758 
1759                     if (fErrorHandler != null) {
1760                         fErrorHandler.handleError(
1761                             new DOMErrorImpl(
1762                                 DOMError.SEVERITY_FATAL_ERROR,
1763                                 msg,
1764                                 MsgKey.ER_ELEM_UNBOUND_PREFIX_IN_ENTREF,
1765                                 null,
1766                                 null,
1767                                 null));
1768                     }
1769                 }
1770 
1771                 NamedNodeMap attrs = child.getAttributes();
1772 
1773                 for (int i = 0; i < attrs.getLength(); i++) {
1774                     String attrPrefix = attrs.item(i).getPrefix();
1775                     if (attrPrefix != null
1776                                 && fNSBinder.getURI(attrPrefix) == null) {
1777                         String msg =
1778                             Utils.messages.createMessage(
1779                                 MsgKey.ER_ATTR_UNBOUND_PREFIX_IN_ENTREF,
1780                                 new Object[] {
1781                                     node.getNodeName(),
1782                                     child.getNodeName(),
1783                                     attrs.item(i)});
1784 
1785                         if (fErrorHandler != null) {
1786                             fErrorHandler.handleError(
1787                                 new DOMErrorImpl(
1788                                     DOMError.SEVERITY_FATAL_ERROR,
1789                                     msg,
1790                                     MsgKey.ER_ATTR_UNBOUND_PREFIX_IN_ENTREF,
1791                                     null,
1792                                     null,
1793                                     null));
1794                         }
1795                     }
1796                 }
1797             }
1798 
1799             if (child.hasChildNodes()) {
1800                 checkUnboundPrefixInEntRef(child);
1801             }
1802         }
1803     }
1804 
1805     // ***********************************************************************
1806     // Namespace normalization
1807     // ***********************************************************************
1808     /**
1809      * Records local namespace declarations, to be used for normalization later
1810      *
1811      * @param Node, The element node, whose namespace declarations are to be recorded
1812      */
1813     protected void recordLocalNSDecl(Node node) {
1814         NamedNodeMap atts = ((Element) node).getAttributes();
1815         int length = atts.getLength();
1816 
1817         for (int i = 0; i < length; i++) {
1818             Node attr = atts.item(i);
1819 
1820             String localName = attr.getLocalName();
1821             String attrPrefix = attr.getPrefix();
1822             String attrValue = attr.getNodeValue();
1823             String attrNS = attr.getNamespaceURI();
1824 
1825             localName =
1826                 localName == null
1827                     || XMLNS_PREFIX.equals(localName) ? "" : localName;
1828             attrPrefix = attrPrefix == null ? "" : attrPrefix;
1829             attrValue = attrValue == null ? "" : attrValue;
1830             attrNS = attrNS == null ? "" : attrNS;
1831 
1832             // check if attribute is a namespace decl
1833             if (XMLNS_URI.equals(attrNS)) {
1834 
1835                 // No prefix may be bound to http://www.w3.org/2000/xmlns/.
1836                 if (XMLNS_URI.equals(attrValue)) {
1837                     String msg =
1838                         Utils.messages.createMessage(
1839                             MsgKey.ER_NS_PREFIX_CANNOT_BE_BOUND,
1840                             new Object[] { attrPrefix, XMLNS_URI });
1841 
1842                     if (fErrorHandler != null) {
1843                         fErrorHandler.handleError(
1844                             new DOMErrorImpl(
1845                                 DOMError.SEVERITY_ERROR,
1846                                 msg,
1847                                 MsgKey.ER_NS_PREFIX_CANNOT_BE_BOUND,
1848                                 null,
1849                                 null,
1850                                 null));
1851                     }
1852                 } else {
1853                     // store the namespace-declaration
1854                         if (XMLNS_PREFIX.equals(attrPrefix) ) {
1855                         // record valid decl
1856                         if (attrValue.length() != 0) {
1857                             fNSBinder.declarePrefix(localName, attrValue);
1858                         } else {
1859                             // Error; xmlns:prefix=""
1860                         }
1861                     } else { // xmlns
1862                         // empty prefix is always bound ("" or some string)
1863                         fNSBinder.declarePrefix("", attrValue);
1864                     }
1865                 }
1866 
1867             }
1868         }
1869     }
1870 
1871     /**
1872      * Fixes an element's namespace
1873      *
1874      * @param Node, The element node, whose namespace is to be fixed
1875      */
1876     protected void fixupElementNS(Node node) throws SAXException {
1877         String namespaceURI = ((Element) node).getNamespaceURI();
1878         String prefix = ((Element) node).getPrefix();
1879         String localName = ((Element) node).getLocalName();
1880 
1881         if (namespaceURI != null) {
1882             //if ( Element's prefix/namespace pair (or default namespace,
1883             // if no prefix) are within the scope of a binding )
1884             prefix = prefix == null ? "" : prefix;
1885             String inScopeNamespaceURI = fNSBinder.getURI(prefix);
1886 
1887             if ((inScopeNamespaceURI != null
1888                 && inScopeNamespaceURI.equals(namespaceURI))) {
1889                 // do nothing, declaration in scope is inherited
1890 
1891             } else {
1892                 // Create a local namespace declaration attr for this namespace,
1893                 // with Element's current prefix (or a default namespace, if
1894                 // no prefix). If there's a conflicting local declaration
1895                 // already present, change its value to use this namespace.
1896 
1897                 // Add the xmlns declaration attribute
1898                 //fNSBinder.pushNamespace(prefix, namespaceURI, fElementDepth);
1899                 if ((fFeatures & NAMESPACEDECLS) != 0) {
1900                     if ("".equals(prefix) || "".equals(namespaceURI)) {
1901                         ((Element)node).setAttributeNS(XMLNS_URI, XMLNS_PREFIX, namespaceURI);
1902                     } else {
1903                         ((Element)node).setAttributeNS(XMLNS_URI, XMLNS_PREFIX + ":" + prefix, namespaceURI);
1904                     }
1905                 }
1906                 fLocalNSBinder.declarePrefix(prefix, namespaceURI);
1907                 fNSBinder.declarePrefix(prefix, namespaceURI);
1908 
1909             }
1910         } else {
1911             // Element has no namespace
1912             // DOM Level 1
1913             if (localName == null || "".equals(localName)) {
1914                 //  DOM Level 1 node!
1915                 String msg =
1916                     Utils.messages.createMessage(
1917                         MsgKey.ER_NULL_LOCAL_ELEMENT_NAME,
1918                         new Object[] { node.getNodeName()});
1919 
1920                 if (fErrorHandler != null) {
1921                     fErrorHandler.handleError(
1922                         new DOMErrorImpl(
1923                             DOMError.SEVERITY_ERROR,
1924                             msg,
1925                             MsgKey.ER_NULL_LOCAL_ELEMENT_NAME,
1926                             null,
1927                             null,
1928                             null));
1929                 }
1930             } else {
1931                 namespaceURI = fNSBinder.getURI("");
1932                 if (namespaceURI !=null && namespaceURI.length() > 0) {
1933                     ((Element)node).setAttributeNS(XMLNS_URI, XMLNS_PREFIX, "");
1934                         fLocalNSBinder.declarePrefix("", "");
1935                     fNSBinder.declarePrefix("", "");
1936                 }
1937             }
1938         }
1939     }
1940     /**
1941      * This table is a quick lookup of a property key (String) to the integer that
1942      * is the bit to flip in the fFeatures field, so the integers should have
1943      * values 1,2,4,8,16...
1944      *
1945      */
1946     private static final Map<String, Integer> fFeatureMap;
1947     static {
1948 
1949         // Initialize the mappings of property keys to bit values (Integer objects)
1950         // or mappings to a String object "", which indicates we are interested
1951         // in the property, but it does not have a simple bit value to flip
1952 
1953         Map<String, Integer> featureMap = new HashMap<>();
1954         // cdata-sections
1955         featureMap.put(
1956             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_CDATA_SECTIONS,
1957             CDATA);
1958 
1959         // comments
1960         featureMap.put(
1961             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_COMMENTS,
1962             COMMENTS);
1963 
1964         // element-content-whitespace
1965         featureMap.put(
1966             DOMConstants.S_DOM3_PROPERTIES_NS
1967                 + DOMConstants.DOM_ELEMENT_CONTENT_WHITESPACE,
1968             ELEM_CONTENT_WHITESPACE);
1969 
1970         // entities
1971         featureMap.put(
1972             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_ENTITIES,
1973             ENTITIES);
1974 
1975         // namespaces
1976         featureMap.put(
1977             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_NAMESPACES,
1978             NAMESPACES);
1979 
1980         // namespace-declarations
1981         featureMap.put(
1982             DOMConstants.S_DOM3_PROPERTIES_NS
1983                 + DOMConstants.DOM_NAMESPACE_DECLARATIONS,
1984             NAMESPACEDECLS);
1985 
1986         // split-cdata-sections
1987         featureMap.put(
1988             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_SPLIT_CDATA,
1989             SPLITCDATA);
1990 
1991         // discard-default-content
1992         featureMap.put(
1993             DOMConstants.S_DOM3_PROPERTIES_NS + DOMConstants.DOM_WELLFORMED,
1994             WELLFORMED);
1995 
1996         // discard-default-content
1997         featureMap.put(
1998             DOMConstants.S_DOM3_PROPERTIES_NS
1999                 + DOMConstants.DOM_DISCARD_DEFAULT_CONTENT,
2000             DISCARDDEFAULT);
2001 
2002         fFeatureMap = Collections.unmodifiableMap(featureMap);
2003     }
2004 
2005     /**
2006      * Initializes fFeatures based on the DOMConfiguration Parameters set.
2007      *
2008      * @param properties DOMConfiguraiton properties that were set and which are
2009      * to be used while serializing the DOM.
2010      */
2011     protected void initProperties(Properties properties) {
2012 
2013         for (Enumeration keys = properties.keys(); keys.hasMoreElements();) {
2014 
2015             final String key = (String) keys.nextElement();
2016 
2017             // caonical-form
2018             // Other features will be enabled or disabled when this is set to true or false.
2019 
2020             // error-handler; set via the constructor
2021 
2022             // infoset
2023             // Other features will be enabled or disabled when this is set to true
2024 
2025             // A quick lookup for the given set of properties (cdata-sections ...)
2026             final Integer bitFlag = fFeatureMap.get(key);
2027             if (bitFlag != null) {
2028                 // Dealing with a property that has a simple bit value that
2029                 // we need to set
2030 
2031                 // cdata-sections
2032                 // comments
2033                 // element-content-whitespace
2034                 // entities
2035                 // namespaces
2036                 // namespace-declarations
2037                 // split-cdata-sections
2038                 // well-formed
2039                 // discard-default-content
2040                 if ((properties.getProperty(key).endsWith("yes"))) {
2041                     fFeatures = fFeatures | bitFlag;
2042                 } else {
2043                     fFeatures = fFeatures & ~bitFlag;
2044                 }
2045             } else {
2046                 /**
2047                  * Other properties that have a bit more complex value
2048                  * than the features in the above map.
2049                  */
2050                 if ((DOMConstants.S_DOM3_PROPERTIES_NS
2051                     + DOMConstants.DOM_FORMAT_PRETTY_PRINT)
2052                     .equals(key)) {
2053                     // format-pretty-print; set internally on the serializers via xsl:output properties in LSSerializer
2054                     if ((properties.getProperty(key).endsWith("yes"))) {
2055                         fSerializer.setIndent(true);
2056                         fSerializer.setIndentAmount(4);
2057                     } else {
2058                         fSerializer.setIndent(false);
2059                     }
2060                 } else if ((DOMConstants.S_XSL_OUTPUT_OMIT_XML_DECL).equals(key)) {
2061                     // omit-xml-declaration; set internally on the serializers via xsl:output properties in LSSerializer
2062                     if ((properties.getProperty(key).endsWith("yes"))) {
2063                         fSerializer.setOmitXMLDeclaration(true);
2064                     } else {
2065                         fSerializer.setOmitXMLDeclaration(false);
2066                     }
2067                 } else if ((DOMConstants.S_XERCES_PROPERTIES_NS
2068                             + DOMConstants.S_XML_VERSION).equals(key)) {
2069                     // Retreive the value of the XML Version attribute via the xml-version
2070                     String version = properties.getProperty(key);
2071                     if ("1.1".equals(version)) {
2072                         fIsXMLVersion11 = true;
2073                         fSerializer.setVersion(version);
2074                     } else {
2075                         fSerializer.setVersion("1.0");
2076                     }
2077                 } else if ((DOMConstants.S_XSL_OUTPUT_ENCODING).equals(key)) {
2078                     // Retreive the value of the XML Encoding attribute
2079                     String encoding = properties.getProperty(key);
2080                     if (encoding != null) {
2081                         fSerializer.setEncoding(encoding);
2082                     }
2083                 } else if ((OutputPropertiesFactory.S_KEY_ENTITIES).equals(key)) {
2084                     // Retreive the value of the XML Encoding attribute
2085                     String entities = properties.getProperty(key);
2086                     if (DOMConstants.S_XSL_VALUE_ENTITIES.equals(entities)) {
2087                         fSerializer.setDTDEntityExpansion(false);
2088                     }
2089                 }
2090             }
2091         }
2092         // Set the newLine character to use
2093         if (fNewLine != null) {
2094             fSerializer.setOutputProperty(OutputPropertiesFactory.S_KEY_LINE_SEPARATOR, fNewLine);
2095         }
2096     }
2097 
2098 } //TreeWalker
--- EOF ---