DOMSerializerImpl.java revision 877:65d615f71e81
1/* 2 * reserved comment block 3 * DO NOT REMOVE OR ALTER! 4 */ 5/* 6 * Licensed to the Apache Software Foundation (ASF) under one or more 7 * contributor license agreements. See the NOTICE file distributed with 8 * this work for additional information regarding copyright ownership. 9 * The ASF licenses this file to You under the Apache License, Version 2.0 10 * (the "License"); you may not use this file except in compliance with 11 * the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 */ 21package com.sun.org.apache.xml.internal.serialize; 22 23import java.io.IOException; 24import java.io.OutputStream; 25import java.io.StringWriter; 26import java.io.UnsupportedEncodingException; 27import java.io.Writer; 28import java.lang.reflect.Method; 29import java.util.ArrayList; 30 31import com.sun.org.apache.xerces.internal.dom.CoreDocumentImpl; 32import com.sun.org.apache.xerces.internal.dom.DOMErrorImpl; 33import com.sun.org.apache.xerces.internal.dom.DOMLocatorImpl; 34import com.sun.org.apache.xerces.internal.dom.DOMMessageFormatter; 35import com.sun.org.apache.xerces.internal.dom.DOMNormalizer; 36import com.sun.org.apache.xerces.internal.dom.DOMStringListImpl; 37import com.sun.org.apache.xerces.internal.impl.Constants; 38import com.sun.org.apache.xerces.internal.impl.XMLEntityManager; 39import com.sun.org.apache.xerces.internal.util.DOMUtil; 40import com.sun.org.apache.xerces.internal.util.NamespaceSupport; 41import com.sun.org.apache.xerces.internal.util.SymbolTable; 42import com.sun.org.apache.xerces.internal.util.XML11Char; 43import com.sun.org.apache.xerces.internal.util.XMLChar; 44import org.w3c.dom.Attr; 45import org.w3c.dom.Comment; 46import org.w3c.dom.DOMConfiguration; 47import org.w3c.dom.DOMError; 48import org.w3c.dom.DOMErrorHandler; 49import org.w3c.dom.DOMException; 50import org.w3c.dom.DOMStringList; 51import org.w3c.dom.Document; 52import org.w3c.dom.DocumentFragment; 53import org.w3c.dom.Element; 54import org.w3c.dom.NamedNodeMap; 55import org.w3c.dom.Node; 56import org.w3c.dom.ProcessingInstruction; 57import org.w3c.dom.ls.LSException; 58import org.w3c.dom.ls.LSOutput; 59import org.w3c.dom.ls.LSSerializer; 60import org.w3c.dom.ls.LSSerializerFilter; 61 62/** 63 * EXPERIMENTAL: Implemenatation of DOM Level 3 org.w3c.ls.LSSerializer by 64 * delegating serialization calls to <CODE>XMLSerializer</CODE>. LSSerializer 65 * provides an API for serializing (writing) a DOM document out in an XML 66 * document. The XML data is written to an output stream. During serialization 67 * of XML data, namespace fixup is done when possible as defined in DOM Level 3 68 * Core, Appendix B. 69 * 70 * @author Elena Litani, IBM 71 * @author Gopal Sharma, Sun Microsystems 72 * @author Arun Yadav, Sun Microsystems 73 * @author Sunitha Reddy, Sun Microsystems 74 * 75 * @deprecated As of JDK 9, Xerces 2.9.0, replaced by 76 * {@link com.sun.org.apache.xml.internal.serializer.dom3.LSSerializerImpl} 77 */ 78public class DOMSerializerImpl implements LSSerializer, DOMConfiguration { 79 80 // TODO: When DOM Level 3 goes to REC replace method calls using 81 // reflection for: getXmlEncoding, getInputEncoding and getXmlEncoding 82 // with regular static calls on the Document object. 83 // data 84 // serializer 85 private XMLSerializer serializer; 86 87 // XML 1.1 serializer 88 private XML11Serializer xml11Serializer; 89 90 //Recognized parameters 91 private DOMStringList fRecognizedParameters; 92 93 /** 94 * REVISIT: Currently we handle 3 different configurations, would be nice 95 * just have one configuration that has different recognized parameters 96 * depending if it is used in Core/LS. 97 */ 98 protected short features = 0; 99 100 protected final static short NAMESPACES = 0x1 << 0; 101 protected final static short WELLFORMED = 0x1 << 1; 102 protected final static short ENTITIES = 0x1 << 2; 103 protected final static short CDATA = 0x1 << 3; 104 protected final static short SPLITCDATA = 0x1 << 4; 105 protected final static short COMMENTS = 0x1 << 5; 106 protected final static short DISCARDDEFAULT = 0x1 << 6; 107 protected final static short INFOSET = 0x1 << 7; 108 protected final static short XMLDECL = 0x1 << 8; 109 protected final static short NSDECL = 0x1 << 9; 110 protected final static short DOM_ELEMENT_CONTENT_WHITESPACE = 0x1 << 10; 111 protected final static short PRETTY_PRINT = 0x1 << 11; 112 113 // well-formness checking 114 private DOMErrorHandler fErrorHandler = null; 115 private final DOMErrorImpl fError = new DOMErrorImpl(); 116 private final DOMLocatorImpl fLocator = new DOMLocatorImpl(); 117 118 /** 119 * Constructs a new LSSerializer. The constructor turns on the namespace 120 * support in <code>XMLSerializer</code> and initializes the following 121 * fields: fNSBinder, fLocalNSBinder, fSymbolTable, fEmptySymbol, 122 * fXmlSymbol, fXmlnsSymbol, fNamespaceCounter, fFeatures. 123 */ 124 public DOMSerializerImpl() { 125 // set default features 126 features |= NAMESPACES; 127 features |= ENTITIES; 128 features |= COMMENTS; 129 features |= CDATA; 130 features |= SPLITCDATA; 131 features |= WELLFORMED; 132 features |= NSDECL; 133 features |= DOM_ELEMENT_CONTENT_WHITESPACE; 134 features |= DISCARDDEFAULT; 135 features |= XMLDECL; 136 137 serializer = new XMLSerializer(); 138 initSerializer(serializer); 139 } 140 141 // 142 // LSSerializer methods 143 // 144 public DOMConfiguration getDomConfig() { 145 return this; 146 } 147 148 /** 149 * DOM L3-EXPERIMENTAL: Setter for boolean and object parameters 150 */ 151 public void setParameter(String name, Object value) throws DOMException { 152 if (value instanceof Boolean) { 153 boolean state = ((Boolean) value).booleanValue(); 154 if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) { 155 if (state) { 156 features &= ~ENTITIES; 157 features &= ~CDATA; 158 features |= NAMESPACES; 159 features |= NSDECL; 160 features |= WELLFORMED; 161 features |= COMMENTS; 162 } 163 // false does not have any effect 164 } else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) { 165 features 166 = (short) (state ? features | XMLDECL : features & ~XMLDECL); 167 } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) { 168 features 169 = (short) (state 170 ? features | NAMESPACES 171 : features & ~NAMESPACES); 172 serializer.fNamespaces = state; 173 } else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) { 174 features 175 = (short) (state 176 ? features | SPLITCDATA 177 : features & ~SPLITCDATA); 178 } else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) { 179 features 180 = (short) (state 181 ? features | DISCARDDEFAULT 182 : features & ~DISCARDDEFAULT); 183 } else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) { 184 features 185 = (short) (state 186 ? features | WELLFORMED 187 : features & ~WELLFORMED); 188 } else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) { 189 features 190 = (short) (state 191 ? features | ENTITIES 192 : features & ~ENTITIES); 193 } else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) { 194 features 195 = (short) (state 196 ? features | CDATA 197 : features & ~CDATA); 198 } else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) { 199 features 200 = (short) (state 201 ? features | COMMENTS 202 : features & ~COMMENTS); 203 } else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) { 204 features 205 = (short) (state 206 ? features | PRETTY_PRINT 207 : features & ~PRETTY_PRINT); 208 } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM) 209 || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA) 210 || name.equalsIgnoreCase(Constants.DOM_VALIDATE) 211 || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION) 212 || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) { 213 // || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) { 214 // true is not supported 215 if (state) { 216 String msg 217 = DOMMessageFormatter.formatMessage( 218 DOMMessageFormatter.DOM_DOMAIN, 219 "FEATURE_NOT_SUPPORTED", 220 new Object[]{name}); 221 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg); 222 } 223 } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) { 224 //namespace-declaration has effect only if namespaces is true 225 features 226 = (short) (state 227 ? features | NSDECL 228 : features & ~NSDECL); 229 serializer.fNamespacePrefixes = state; 230 } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE) 231 || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) { 232 // false is not supported 233 if (!state) { 234 String msg 235 = DOMMessageFormatter.formatMessage( 236 DOMMessageFormatter.DOM_DOMAIN, 237 "FEATURE_NOT_SUPPORTED", 238 new Object[]{name}); 239 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg); 240 } 241 } else { 242 String msg 243 = DOMMessageFormatter.formatMessage( 244 DOMMessageFormatter.DOM_DOMAIN, 245 "FEATURE_NOT_FOUND", 246 new Object[]{name}); 247 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg); 248 } 249 } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) { 250 if (value == null || value instanceof DOMErrorHandler) { 251 fErrorHandler = (DOMErrorHandler) value; 252 } else { 253 String msg 254 = DOMMessageFormatter.formatMessage( 255 DOMMessageFormatter.DOM_DOMAIN, 256 "TYPE_MISMATCH_ERR", 257 new Object[]{name}); 258 throw new DOMException(DOMException.TYPE_MISMATCH_ERR, msg); 259 } 260 } else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER) 261 || name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION) 262 || name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE) 263 || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS) 264 && value != null) { 265 String msg 266 = DOMMessageFormatter.formatMessage( 267 DOMMessageFormatter.DOM_DOMAIN, 268 "FEATURE_NOT_SUPPORTED", 269 new Object[]{name}); 270 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg); 271 } else { 272 String msg 273 = DOMMessageFormatter.formatMessage( 274 DOMMessageFormatter.DOM_DOMAIN, 275 "FEATURE_NOT_FOUND", 276 new Object[]{name}); 277 throw new DOMException(DOMException.NOT_FOUND_ERR, msg); 278 } 279 } 280 281 /** 282 * DOM L3-EXPERIMENTAL: Check if parameter can be set 283 */ 284 public boolean canSetParameter(String name, Object state) { 285 if (state == null) { 286 return true; 287 } 288 289 if (state instanceof Boolean) { 290 boolean value = ((Boolean) state).booleanValue(); 291 if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES) 292 || name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA) 293 || name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT) 294 || name.equalsIgnoreCase(Constants.DOM_XMLDECL) 295 || name.equalsIgnoreCase(Constants.DOM_WELLFORMED) 296 || name.equalsIgnoreCase(Constants.DOM_INFOSET) 297 || name.equalsIgnoreCase(Constants.DOM_ENTITIES) 298 || name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS) 299 || name.equalsIgnoreCase(Constants.DOM_COMMENTS) 300 || name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT) 301 || name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) { 302 // both values supported 303 return true; 304 } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM) 305 || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA) 306 || name.equalsIgnoreCase(Constants.DOM_VALIDATE) 307 || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION) 308 || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) { 309 // || name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) { 310 // true is not supported 311 return !value; 312 } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE) 313 || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) { 314 // false is not supported 315 return value; 316 } 317 } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER) 318 && state == null || state instanceof DOMErrorHandler) { 319 return true; 320 } 321 322 return false; 323 } 324 325 /** 326 * DOM Level 3 Core CR - Experimental. 327 * 328 * The list of the parameters supported by this 329 * <code>DOMConfiguration</code> object and for which at least one value can 330 * be set by the application. Note that this list can also contain parameter 331 * names defined outside this specification. 332 */ 333 public DOMStringList getParameterNames() { 334 335 if (fRecognizedParameters == null) { 336 ArrayList parameters = new ArrayList(); 337 338 //Add DOM recognized parameters 339 //REVISIT: Would have been nice to have a list of 340 //recognized parameters. 341 parameters.add(Constants.DOM_NAMESPACES); 342 parameters.add(Constants.DOM_SPLIT_CDATA); 343 parameters.add(Constants.DOM_DISCARD_DEFAULT_CONTENT); 344 parameters.add(Constants.DOM_XMLDECL); 345 parameters.add(Constants.DOM_CANONICAL_FORM); 346 parameters.add(Constants.DOM_VALIDATE_IF_SCHEMA); 347 parameters.add(Constants.DOM_VALIDATE); 348 parameters.add(Constants.DOM_CHECK_CHAR_NORMALIZATION); 349 parameters.add(Constants.DOM_DATATYPE_NORMALIZATION); 350 parameters.add(Constants.DOM_FORMAT_PRETTY_PRINT); 351 //parameters.add(Constants.DOM_NORMALIZE_CHARACTERS); 352 parameters.add(Constants.DOM_WELLFORMED); 353 parameters.add(Constants.DOM_INFOSET); 354 parameters.add(Constants.DOM_NAMESPACE_DECLARATIONS); 355 parameters.add(Constants.DOM_ELEMENT_CONTENT_WHITESPACE); 356 parameters.add(Constants.DOM_ENTITIES); 357 parameters.add(Constants.DOM_CDATA_SECTIONS); 358 parameters.add(Constants.DOM_COMMENTS); 359 parameters.add(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS); 360 parameters.add(Constants.DOM_ERROR_HANDLER); 361 //parameters.add(Constants.DOM_SCHEMA_LOCATION); 362 //parameters.add(Constants.DOM_SCHEMA_TYPE); 363 364 //Add recognized xerces features and properties 365 fRecognizedParameters = new DOMStringListImpl(parameters); 366 } 367 368 return fRecognizedParameters; 369 } 370 371 /** 372 * DOM L3-EXPERIMENTAL: Getter for boolean and object parameters 373 */ 374 public Object getParameter(String name) throws DOMException { 375 if (name.equalsIgnoreCase(Constants.DOM_NORMALIZE_CHARACTERS)) { 376 return null; 377 } else if (name.equalsIgnoreCase(Constants.DOM_COMMENTS)) { 378 return ((features & COMMENTS) != 0) ? Boolean.TRUE : Boolean.FALSE; 379 } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACES)) { 380 return (features & NAMESPACES) != 0 ? Boolean.TRUE : Boolean.FALSE; 381 } else if (name.equalsIgnoreCase(Constants.DOM_XMLDECL)) { 382 return (features & XMLDECL) != 0 ? Boolean.TRUE : Boolean.FALSE; 383 } else if (name.equalsIgnoreCase(Constants.DOM_CDATA_SECTIONS)) { 384 return (features & CDATA) != 0 ? Boolean.TRUE : Boolean.FALSE; 385 } else if (name.equalsIgnoreCase(Constants.DOM_ENTITIES)) { 386 return (features & ENTITIES) != 0 ? Boolean.TRUE : Boolean.FALSE; 387 } else if (name.equalsIgnoreCase(Constants.DOM_SPLIT_CDATA)) { 388 return (features & SPLITCDATA) != 0 ? Boolean.TRUE : Boolean.FALSE; 389 } else if (name.equalsIgnoreCase(Constants.DOM_WELLFORMED)) { 390 return (features & WELLFORMED) != 0 ? Boolean.TRUE : Boolean.FALSE; 391 } else if (name.equalsIgnoreCase(Constants.DOM_NAMESPACE_DECLARATIONS)) { 392 return (features & NSDECL) != 0 ? Boolean.TRUE : Boolean.FALSE; 393 } else if (name.equalsIgnoreCase(Constants.DOM_ELEMENT_CONTENT_WHITESPACE) 394 || name.equalsIgnoreCase(Constants.DOM_IGNORE_UNKNOWN_CHARACTER_DENORMALIZATIONS)) { 395 return Boolean.TRUE; 396 } else if (name.equalsIgnoreCase(Constants.DOM_DISCARD_DEFAULT_CONTENT)) { 397 return ((features & DISCARDDEFAULT) != 0) ? Boolean.TRUE : Boolean.FALSE; 398 } else if (name.equalsIgnoreCase(Constants.DOM_FORMAT_PRETTY_PRINT)) { 399 return ((features & PRETTY_PRINT) != 0) ? Boolean.TRUE : Boolean.FALSE; 400 } else if (name.equalsIgnoreCase(Constants.DOM_INFOSET)) { 401 if ((features & ENTITIES) == 0 402 && (features & CDATA) == 0 403 && (features & NAMESPACES) != 0 404 && (features & NSDECL) != 0 405 && (features & WELLFORMED) != 0 406 && (features & COMMENTS) != 0) { 407 return Boolean.TRUE; 408 } 409 return Boolean.FALSE; 410 } else if (name.equalsIgnoreCase(Constants.DOM_CANONICAL_FORM) 411 || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA) 412 || name.equalsIgnoreCase(Constants.DOM_CHECK_CHAR_NORMALIZATION) 413 || name.equalsIgnoreCase(Constants.DOM_VALIDATE) 414 || name.equalsIgnoreCase(Constants.DOM_VALIDATE_IF_SCHEMA) 415 || name.equalsIgnoreCase(Constants.DOM_DATATYPE_NORMALIZATION)) { 416 return Boolean.FALSE; 417 } else if (name.equalsIgnoreCase(Constants.DOM_ERROR_HANDLER)) { 418 return fErrorHandler; 419 } else if (name.equalsIgnoreCase(Constants.DOM_RESOURCE_RESOLVER) 420 || name.equalsIgnoreCase(Constants.DOM_SCHEMA_LOCATION) 421 || name.equalsIgnoreCase(Constants.DOM_SCHEMA_TYPE)) { 422 String msg 423 = DOMMessageFormatter.formatMessage( 424 DOMMessageFormatter.DOM_DOMAIN, 425 "FEATURE_NOT_SUPPORTED", 426 new Object[]{name}); 427 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg); 428 } else { 429 String msg 430 = DOMMessageFormatter.formatMessage( 431 DOMMessageFormatter.DOM_DOMAIN, 432 "FEATURE_NOT_FOUND", 433 new Object[]{name}); 434 throw new DOMException(DOMException.NOT_FOUND_ERR, msg); 435 } 436 } 437 438 /** 439 * DOM L3 EXPERIMENTAL: Serialize the specified node as described above in 440 * the description of <code>LSSerializer</code>. The result of serializing 441 * the node is returned as a string. Writing a Document or Entity node 442 * produces a serialized form that is well formed XML. Writing other node 443 * types produces a fragment of text in a form that is not fully defined by 444 * this document, but that should be useful to a human for debugging or 445 * diagnostic purposes. 446 * 447 * @param wnode The node to be written. 448 * @return Returns the serialized data 449 * @exception DOMException DOMSTRING_SIZE_ERR: The resulting string is too 450 * long to fit in a <code>DOMString</code>. 451 * @exception LSException SERIALIZE_ERR: Unable to serialize the node. DOM 452 * applications should attach a <code>DOMErrorHandler</code> using the 453 * parameter "<i>error-handler</i>" to get details on error. 454 */ 455 public String writeToString(Node wnode) throws DOMException, LSException { 456 // determine which serializer to use: 457 XMLSerializer ser = null; 458 String ver = _getXmlVersion(wnode); 459 if (ver != null && ver.equals("1.1")) { 460 if (xml11Serializer == null) { 461 xml11Serializer = new XML11Serializer(); 462 initSerializer(xml11Serializer); 463 } 464 // copy setting from "main" serializer to XML 1.1 serializer 465 copySettings(serializer, xml11Serializer); 466 ser = xml11Serializer; 467 } else { 468 ser = serializer; 469 } 470 471 StringWriter destination = new StringWriter(); 472 try { 473 prepareForSerialization(ser, wnode); 474 ser._format.setEncoding("UTF-16"); 475 ser.setOutputCharStream(destination); 476 if (wnode.getNodeType() == Node.DOCUMENT_NODE) { 477 ser.serialize((Document) wnode); 478 } else if (wnode.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) { 479 ser.serialize((DocumentFragment) wnode); 480 } else if (wnode.getNodeType() == Node.ELEMENT_NODE) { 481 ser.serialize((Element) wnode); 482 } else if (wnode.getNodeType() == Node.TEXT_NODE 483 || wnode.getNodeType() == Node.COMMENT_NODE 484 || wnode.getNodeType() == Node.ENTITY_REFERENCE_NODE 485 || wnode.getNodeType() == Node.CDATA_SECTION_NODE 486 || wnode.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) { 487 ser.serialize(wnode); 488 } else { 489 String msg = DOMMessageFormatter.formatMessage( 490 DOMMessageFormatter.SERIALIZER_DOMAIN, 491 "unable-to-serialize-node", null); 492 if (ser.fDOMErrorHandler != null) { 493 DOMErrorImpl error = new DOMErrorImpl(); 494 error.fType = "unable-to-serialize-node"; 495 error.fMessage = msg; 496 error.fSeverity = DOMError.SEVERITY_FATAL_ERROR; 497 ser.fDOMErrorHandler.handleError(error); 498 } 499 throw new LSException(LSException.SERIALIZE_ERR, msg); 500 } 501 } catch (LSException lse) { 502 // Rethrow LSException. 503 throw lse; 504 } catch (RuntimeException e) { 505 if (e == DOMNormalizer.abort) { 506 // stopped at user request 507 return null; 508 } 509 throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace(); 510 } catch (IOException ioe) { 511 // REVISIT: A generic IOException doesn't provide enough information 512 // to determine that the serialized document is too large to fit 513 // into a string. This could have thrown for some other reason. -- mrglavas 514 String msg = DOMMessageFormatter.formatMessage( 515 DOMMessageFormatter.DOM_DOMAIN, 516 "STRING_TOO_LONG", 517 new Object[]{ioe.getMessage()}); 518 throw new DOMException(DOMException.DOMSTRING_SIZE_ERR, msg); 519 } finally { 520 ser.clearDocumentState(); 521 } 522 return destination.toString(); 523 } 524 525 /** 526 * DOM L3 EXPERIMENTAL: The end-of-line sequence of characters to be used in 527 * the XML being written out. The only permitted values are these: 528 * <dl> 529 * <dt><code>null</code></dt> 530 * <dd> 531 * Use a default end-of-line sequence. DOM implementations should choose the 532 * default to match the usual convention for text files in the environment 533 * being used. Implementations must choose a default sequence that matches 534 * one of those allowed by 2.11 "End-of-Line Handling". </dd> 535 * <dt>CR</dt> 536 * <dd>The carriage-return character (#xD).</dd> 537 * <dt>CR-LF</dt> 538 * <dd> The carriage-return and line-feed characters (#xD #xA). </dd> 539 * <dt>LF</dt> 540 * <dd> The line-feed character (#xA). </dd> 541 * </dl> 542 * <br>The default value for this attribute is <code>null</code>. 543 */ 544 public void setNewLine(String newLine) { 545 serializer._format.setLineSeparator(newLine); 546 } 547 548 /** 549 * DOM L3 EXPERIMENTAL: The end-of-line sequence of characters to be used in 550 * the XML being written out. The only permitted values are these: 551 * <dl> 552 * <dt><code>null</code></dt> 553 * <dd> 554 * Use a default end-of-line sequence. DOM implementations should choose the 555 * default to match the usual convention for text files in the environment 556 * being used. Implementations must choose a default sequence that matches 557 * one of those allowed by 2.11 "End-of-Line Handling". </dd> 558 * <dt>CR</dt> 559 * <dd>The carriage-return character (#xD).</dd> 560 * <dt>CR-LF</dt> 561 * <dd> The carriage-return and line-feed characters (#xD #xA). </dd> 562 * <dt>LF</dt> 563 * <dd> The line-feed character (#xA). </dd> 564 * </dl> 565 * <br>The default value for this attribute is <code>null</code>. 566 */ 567 public String getNewLine() { 568 return serializer._format.getLineSeparator(); 569 } 570 571 /** 572 * When the application provides a filter, the serializer will call out to 573 * the filter before serializing each Node. Attribute nodes are never passed 574 * to the filter. The filter implementation can choose to remove the node 575 * from the stream or to terminate the serialization early. 576 */ 577 public LSSerializerFilter getFilter() { 578 return serializer.fDOMFilter; 579 } 580 581 /** 582 * When the application provides a filter, the serializer will call out to 583 * the filter before serializing each Node. Attribute nodes are never passed 584 * to the filter. The filter implementation can choose to remove the node 585 * from the stream or to terminate the serialization early. 586 */ 587 public void setFilter(LSSerializerFilter filter) { 588 serializer.fDOMFilter = filter; 589 } 590 591 // this initializes a newly-created serializer 592 private void initSerializer(XMLSerializer ser) { 593 ser.fNSBinder = new NamespaceSupport(); 594 ser.fLocalNSBinder = new NamespaceSupport(); 595 ser.fSymbolTable = new SymbolTable(); 596 } 597 598 // copies all settings that could have been modified 599 // by calls to LSSerializer methods from one serializer to another. 600 // IMPORTANT: if new methods are implemented or more settings of 601 // the serializer are made alterable, this must be 602 // reflected in this method! 603 private void copySettings(XMLSerializer src, XMLSerializer dest) { 604 dest.fDOMErrorHandler = fErrorHandler; 605 dest._format.setEncoding(src._format.getEncoding()); 606 dest._format.setLineSeparator(src._format.getLineSeparator()); 607 dest.fDOMFilter = src.fDOMFilter; 608 }//copysettings 609 610 /** 611 * Serialize the specified node as described above in the general 612 * description of the <code>LSSerializer</code> interface. The output is 613 * written to the supplied <code>LSOutput</code>. 614 * <br> When writing to a <code>LSOutput</code>, the encoding is found by 615 * looking at the encoding information that is reachable through the 616 * <code>LSOutput</code> and the item to be written (or its owner document) 617 * in this order: 618 * <ol> 619 * <li> <code>LSOutput.encoding</code>, 620 * </li> 621 * <li> 622 * <code>Document.actualEncoding</code>, 623 * </li> 624 * <li> 625 * <code>Document.xmlEncoding</code>. 626 * </li> 627 * </ol> 628 * <br> If no encoding is reachable through the above properties, a default 629 * encoding of "UTF-8" will be used. 630 * <br> If the specified encoding is not supported an "unsupported-encoding" 631 * error is raised. 632 * <br> If no output is specified in the <code>LSOutput</code>, a 633 * "no-output-specified" error is raised. 634 * 635 * @param node The node to serialize. 636 * @param destination The destination for the serialized DOM. 637 * @return Returns <code>true</code> if <code>node</code> was successfully 638 * serialized and <code>false</code> in case the node couldn't be 639 * serialized. 640 */ 641 public boolean write(Node node, LSOutput destination) throws LSException { 642 643 if (node == null) { 644 return false; 645 } 646 647 XMLSerializer ser = null; 648 String ver = _getXmlVersion(node); 649 //determine which serializer to use: 650 if (ver != null && ver.equals("1.1")) { 651 if (xml11Serializer == null) { 652 xml11Serializer = new XML11Serializer(); 653 initSerializer(xml11Serializer); 654 } 655 //copy setting from "main" serializer to XML 1.1 serializer 656 copySettings(serializer, xml11Serializer); 657 ser = xml11Serializer; 658 } else { 659 ser = serializer; 660 } 661 662 String encoding = null; 663 if ((encoding = destination.getEncoding()) == null) { 664 encoding = _getInputEncoding(node); 665 if (encoding == null) { 666 encoding = _getXmlEncoding(node); 667 if (encoding == null) { 668 encoding = "UTF-8"; 669 } 670 } 671 } 672 try { 673 prepareForSerialization(ser, node); 674 ser._format.setEncoding(encoding); 675 OutputStream outputStream = destination.getByteStream(); 676 Writer writer = destination.getCharacterStream(); 677 String uri = destination.getSystemId(); 678 if (writer == null) { 679 if (outputStream == null) { 680 if (uri == null) { 681 String msg = DOMMessageFormatter.formatMessage( 682 DOMMessageFormatter.SERIALIZER_DOMAIN, 683 "no-output-specified", null); 684 if (ser.fDOMErrorHandler != null) { 685 DOMErrorImpl error = new DOMErrorImpl(); 686 error.fType = "no-output-specified"; 687 error.fMessage = msg; 688 error.fSeverity = DOMError.SEVERITY_FATAL_ERROR; 689 ser.fDOMErrorHandler.handleError(error); 690 } 691 throw new LSException(LSException.SERIALIZE_ERR, msg); 692 } else { 693 ser.setOutputByteStream(XMLEntityManager.createOutputStream(uri)); 694 } 695 } else { 696 // byte stream was specified 697 ser.setOutputByteStream(outputStream); 698 } 699 } else { 700 // character stream is specified 701 ser.setOutputCharStream(writer); 702 } 703 704 if (node.getNodeType() == Node.DOCUMENT_NODE) { 705 ser.serialize((Document) node); 706 } else if (node.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) { 707 ser.serialize((DocumentFragment) node); 708 } else if (node.getNodeType() == Node.ELEMENT_NODE) { 709 ser.serialize((Element) node); 710 } else if (node.getNodeType() == Node.TEXT_NODE 711 || node.getNodeType() == Node.COMMENT_NODE 712 || node.getNodeType() == Node.ENTITY_REFERENCE_NODE 713 || node.getNodeType() == Node.CDATA_SECTION_NODE 714 || node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) { 715 ser.serialize(node); 716 } else { 717 return false; 718 } 719 } catch (UnsupportedEncodingException ue) { 720 if (ser.fDOMErrorHandler != null) { 721 DOMErrorImpl error = new DOMErrorImpl(); 722 error.fException = ue; 723 error.fType = "unsupported-encoding"; 724 error.fMessage = ue.getMessage(); 725 error.fSeverity = DOMError.SEVERITY_FATAL_ERROR; 726 ser.fDOMErrorHandler.handleError(error); 727 } 728 throw new LSException(LSException.SERIALIZE_ERR, 729 DOMMessageFormatter.formatMessage( 730 DOMMessageFormatter.SERIALIZER_DOMAIN, 731 "unsupported-encoding", null)); 732 //return false; 733 } catch (LSException lse) { 734 // Rethrow LSException. 735 throw lse; 736 } catch (RuntimeException e) { 737 if (e == DOMNormalizer.abort) { 738 // stopped at user request 739 return false; 740 } 741 throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace(); 742 } catch (Exception e) { 743 if (ser.fDOMErrorHandler != null) { 744 DOMErrorImpl error = new DOMErrorImpl(); 745 error.fException = e; 746 error.fMessage = e.getMessage(); 747 error.fSeverity = DOMError.SEVERITY_ERROR; 748 ser.fDOMErrorHandler.handleError(error); 749 750 } 751 throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace(); 752 } finally { 753 ser.clearDocumentState(); 754 } 755 return true; 756 757 } //write 758 759 /** 760 * Serialize the specified node as described above in the general 761 * description of the <code>LSSerializer</code> interface. The output is 762 * written to the supplied URI. 763 * <br> When writing to a URI, the encoding is found by looking at the 764 * encoding information that is reachable through the item to be written (or 765 * its owner document) in this order: 766 * <ol> 767 * <li> 768 * <code>Document.inputEncoding</code>, 769 * </li> 770 * <li> 771 * <code>Document.xmlEncoding</code>. 772 * </li> 773 * </ol> 774 * <br> If no encoding is reachable through the above properties, a default 775 * encoding of "UTF-8" will be used. 776 * <br> If the specified encoding is not supported an "unsupported-encoding" 777 * error is raised. 778 * 779 * @param node The node to serialize. 780 * @param URI The URI to write to. 781 * @return Returns <code>true</code> if <code>node</code> was successfully 782 * serialized and <code>false</code> in case the node couldn't be 783 * serialized. 784 */ 785 public boolean writeToURI(Node node, String URI) throws LSException { 786 if (node == null) { 787 return false; 788 } 789 790 XMLSerializer ser = null; 791 String ver = _getXmlVersion(node); 792 793 if (ver != null && ver.equals("1.1")) { 794 if (xml11Serializer == null) { 795 xml11Serializer = new XML11Serializer(); 796 initSerializer(xml11Serializer); 797 } 798 // copy setting from "main" serializer to XML 1.1 serializer 799 copySettings(serializer, xml11Serializer); 800 ser = xml11Serializer; 801 } else { 802 ser = serializer; 803 } 804 805 String encoding = _getInputEncoding(node); 806 if (encoding == null) { 807 encoding = _getXmlEncoding(node); 808 if (encoding == null) { 809 encoding = "UTF-8"; 810 } 811 } 812 813 try { 814 prepareForSerialization(ser, node); 815 ser._format.setEncoding(encoding); 816 ser.setOutputByteStream(XMLEntityManager.createOutputStream(URI)); 817 818 if (node.getNodeType() == Node.DOCUMENT_NODE) { 819 ser.serialize((Document) node); 820 } else if (node.getNodeType() == Node.DOCUMENT_FRAGMENT_NODE) { 821 ser.serialize((DocumentFragment) node); 822 } else if (node.getNodeType() == Node.ELEMENT_NODE) { 823 ser.serialize((Element) node); 824 } else if (node.getNodeType() == Node.TEXT_NODE 825 || node.getNodeType() == Node.COMMENT_NODE 826 || node.getNodeType() == Node.ENTITY_REFERENCE_NODE 827 || node.getNodeType() == Node.CDATA_SECTION_NODE 828 || node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) { 829 ser.serialize(node); 830 } else { 831 return false; 832 } 833 } catch (LSException lse) { 834 // Rethrow LSException. 835 throw lse; 836 } catch (RuntimeException e) { 837 if (e == DOMNormalizer.abort) { 838 // stopped at user request 839 return false; 840 } 841 throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace(); 842 } catch (Exception e) { 843 if (ser.fDOMErrorHandler != null) { 844 DOMErrorImpl error = new DOMErrorImpl(); 845 error.fException = e; 846 error.fMessage = e.getMessage(); 847 error.fSeverity = DOMError.SEVERITY_ERROR; 848 ser.fDOMErrorHandler.handleError(error); 849 } 850 throw (LSException) DOMUtil.createLSException(LSException.SERIALIZE_ERR, e).fillInStackTrace(); 851 } finally { 852 ser.clearDocumentState(); 853 } 854 return true; 855 } //writeURI 856 857 // 858 // Private methods 859 // 860 private void prepareForSerialization(XMLSerializer ser, Node node) { 861 ser.reset(); 862 ser.features = features; 863 ser.fDOMErrorHandler = fErrorHandler; 864 ser.fNamespaces = (features & NAMESPACES) != 0; 865 ser.fNamespacePrefixes = (features & NSDECL) != 0; 866 ser._format.setIndenting((features & PRETTY_PRINT) != 0); 867 ser._format.setOmitComments((features & COMMENTS) == 0); 868 ser._format.setOmitXMLDeclaration((features & XMLDECL) == 0); 869 870 if ((features & WELLFORMED) != 0) { 871 // REVISIT: this is inefficient implementation of well-formness. Instead, we should check 872 // well-formness as we serialize the tree 873 Node next, root; 874 root = node; 875 Method versionChanged; 876 boolean verifyNames = true; 877 Document document = (node.getNodeType() == Node.DOCUMENT_NODE) 878 ? (Document) node 879 : node.getOwnerDocument(); 880 try { 881 versionChanged = document.getClass().getMethod("isXMLVersionChanged()", new Class[]{}); 882 if (versionChanged != null) { 883 verifyNames = ((Boolean) versionChanged.invoke(document, (Object[]) null)).booleanValue(); 884 } 885 } catch (Exception e) { 886 //no way to test the version... 887 //ignore the exception 888 } 889 if (node.getFirstChild() != null) { 890 while (node != null) { 891 verify(node, verifyNames, false); 892 // Move down to first child 893 next = node.getFirstChild(); 894 // No child nodes, so walk tree 895 while (next == null) { 896 // Move to sibling if possible. 897 next = node.getNextSibling(); 898 if (next == null) { 899 node = node.getParentNode(); 900 if (root == node) { 901 next = null; 902 break; 903 } 904 next = node.getNextSibling(); 905 } 906 } 907 node = next; 908 } 909 } else { 910 verify(node, verifyNames, false); 911 } 912 } 913 } 914 915 private void verify(Node node, boolean verifyNames, boolean xml11Version) { 916 917 int type = node.getNodeType(); 918 fLocator.fRelatedNode = node; 919 boolean wellformed; 920 switch (type) { 921 case Node.DOCUMENT_NODE: { 922 break; 923 } 924 case Node.DOCUMENT_TYPE_NODE: { 925 break; 926 } 927 case Node.ELEMENT_NODE: { 928 if (verifyNames) { 929 if ((features & NAMESPACES) != 0) { 930 wellformed = CoreDocumentImpl.isValidQName(node.getPrefix(), node.getLocalName(), xml11Version); 931 } else { 932 wellformed = CoreDocumentImpl.isXMLName(node.getNodeName(), xml11Version); 933 } 934 if (!wellformed) { 935 if (fErrorHandler != null) { 936 String msg = DOMMessageFormatter.formatMessage( 937 DOMMessageFormatter.DOM_DOMAIN, 938 "wf-invalid-character-in-node-name", 939 new Object[]{"Element", node.getNodeName()}); 940 DOMNormalizer.reportDOMError(fErrorHandler, fError, fLocator, msg, DOMError.SEVERITY_FATAL_ERROR, 941 "wf-invalid-character-in-node-name"); 942 } 943 } 944 } 945 946 NamedNodeMap attributes = (node.hasAttributes()) ? node.getAttributes() : null; 947 if (attributes != null) { 948 for (int i = 0; i < attributes.getLength(); ++i) { 949 Attr attr = (Attr) attributes.item(i); 950 fLocator.fRelatedNode = attr; 951 DOMNormalizer.isAttrValueWF(fErrorHandler, fError, fLocator, 952 attributes, attr, attr.getValue(), xml11Version); 953 if (verifyNames) { 954 wellformed = CoreDocumentImpl.isXMLName(attr.getNodeName(), xml11Version); 955 if (!wellformed) { 956 String msg 957 = DOMMessageFormatter.formatMessage( 958 DOMMessageFormatter.DOM_DOMAIN, 959 "wf-invalid-character-in-node-name", 960 new Object[]{"Attr", node.getNodeName()}); 961 DOMNormalizer.reportDOMError(fErrorHandler, fError, fLocator, msg, DOMError.SEVERITY_FATAL_ERROR, 962 "wf-invalid-character-in-node-name"); 963 } 964 } 965 } 966 967 } 968 969 break; 970 } 971 972 case Node.COMMENT_NODE: { 973 // only verify well-formness if comments included in the tree 974 if ((features & COMMENTS) != 0) { 975 DOMNormalizer.isCommentWF(fErrorHandler, fError, fLocator, ((Comment) node).getData(), xml11Version); 976 } 977 break; 978 } 979 case Node.ENTITY_REFERENCE_NODE: { 980 // only if entity is preserved in the tree 981 if (verifyNames && (features & ENTITIES) != 0) { 982 CoreDocumentImpl.isXMLName(node.getNodeName(), xml11Version); 983 } 984 break; 985 986 } 987 case Node.CDATA_SECTION_NODE: { 988 // verify content 989 DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, node.getNodeValue(), xml11Version); 990 // the ]]> string will be checked during serialization 991 break; 992 } 993 case Node.TEXT_NODE: { 994 DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, node.getNodeValue(), xml11Version); 995 break; 996 } 997 case Node.PROCESSING_INSTRUCTION_NODE: { 998 ProcessingInstruction pinode = (ProcessingInstruction) node; 999 String target = pinode.getTarget(); 1000 if (verifyNames) { 1001 if (xml11Version) { 1002 wellformed = XML11Char.isXML11ValidName(target); 1003 } else { 1004 wellformed = XMLChar.isValidName(target); 1005 } 1006 1007 if (!wellformed) { 1008 String msg 1009 = DOMMessageFormatter.formatMessage( 1010 DOMMessageFormatter.DOM_DOMAIN, 1011 "wf-invalid-character-in-node-name", 1012 new Object[]{"Element", node.getNodeName()}); 1013 DOMNormalizer.reportDOMError( 1014 fErrorHandler, 1015 fError, 1016 fLocator, 1017 msg, 1018 DOMError.SEVERITY_FATAL_ERROR, 1019 "wf-invalid-character-in-node-name"); 1020 } 1021 } 1022 DOMNormalizer.isXMLCharWF(fErrorHandler, fError, fLocator, pinode.getData(), xml11Version); 1023 break; 1024 } 1025 } 1026 fLocator.fRelatedNode = null; 1027 } 1028 1029 private String _getXmlVersion(Node node) { 1030 Document doc = (node.getNodeType() == Node.DOCUMENT_NODE) 1031 ? (Document) node : node.getOwnerDocument(); 1032 if (doc != null) { 1033 try { 1034 return doc.getXmlVersion(); 1035 } // The VM ran out of memory or there was some other serious problem. Re-throw. 1036 catch (VirtualMachineError | ThreadDeath vme) { 1037 throw vme; 1038 } // Ignore all other exceptions and errors 1039 catch (Throwable t) { 1040 } 1041 } 1042 return null; 1043 } 1044 1045 private String _getInputEncoding(Node node) { 1046 Document doc = (node.getNodeType() == Node.DOCUMENT_NODE) 1047 ? (Document) node : node.getOwnerDocument(); 1048 if (doc != null) { 1049 try { 1050 return doc.getInputEncoding(); 1051 } // The VM ran out of memory or there was some other serious problem. Re-throw. 1052 catch (VirtualMachineError | ThreadDeath vme) { 1053 throw vme; 1054 } // Ignore all other exceptions and errors 1055 catch (Throwable t) { 1056 } 1057 } 1058 return null; 1059 } 1060 1061 private String _getXmlEncoding(Node node) { 1062 Document doc = (node.getNodeType() == Node.DOCUMENT_NODE) 1063 ? (Document) node : node.getOwnerDocument(); 1064 if (doc != null) { 1065 try { 1066 return doc.getXmlEncoding(); 1067 } // The VM ran out of memory or there was some other serious problem. Re-throw. 1068 catch (VirtualMachineError | ThreadDeath vme) { 1069 throw vme; 1070 } // Ignore all other exceptions and errors 1071 catch (Throwable t) { 1072 } 1073 } 1074 return null; 1075 } 1076 1077} //DOMSerializerImpl 1078