DOMSerializerImpl


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