• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the  "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 /*
19  * $Id: DOMBuilder.java 472634 2006-11-08 20:43:55Z jycli $
20  */
21 package org.apache.xml.utils;
22 
23 import java.util.Stack;
24 import java.util.Vector;
25 
26 import org.apache.xml.res.XMLErrorResources;
27 import org.apache.xml.res.XMLMessages;
28 
29 import org.w3c.dom.Document;
30 import org.w3c.dom.DocumentFragment;
31 import org.w3c.dom.Element;
32 import org.w3c.dom.Node;
33 import org.w3c.dom.Text;
34 import org.w3c.dom.CDATASection;
35 
36 import org.xml.sax.Attributes;
37 import org.xml.sax.ContentHandler;
38 import org.xml.sax.Locator;
39 import org.xml.sax.ext.LexicalHandler;
40 /**
41  * This class takes SAX events (in addition to some extra events
42  * that SAX doesn't handle yet) and adds the result to a document
43  * or document fragment.
44  * @xsl.usage general
45  */
46 public class DOMBuilder
47         implements ContentHandler, LexicalHandler
48 {
49 
50   /** Root document          */
51   public Document m_doc;
52 
53   /** Current node           */
54   protected Node m_currentNode = null;
55 
56   /** The root node          */
57   protected Node m_root = null;
58 
59   /** The next sibling node  */
60   protected Node m_nextSibling = null;
61 
62   /** First node of document fragment or null if not a DocumentFragment     */
63   public DocumentFragment m_docFrag = null;
64 
65   /** Vector of element nodes          */
66   protected Stack m_elemStack = new Stack();
67 
68   /** Namespace support */
69   protected Vector m_prefixMappings = new Vector();
70 
71   /**
72    * DOMBuilder instance constructor... it will add the DOM nodes
73    * to the document fragment.
74    *
75    * @param doc Root document
76    * @param node Current node
77    */
DOMBuilder(Document doc, Node node)78   public DOMBuilder(Document doc, Node node)
79   {
80     m_doc = doc;
81     m_currentNode = m_root = node;
82 
83     if (node instanceof Element)
84       m_elemStack.push(node);
85   }
86 
87   /**
88    * DOMBuilder instance constructor... it will add the DOM nodes
89    * to the document fragment.
90    *
91    * @param doc Root document
92    * @param docFrag Document fragment
93    */
DOMBuilder(Document doc, DocumentFragment docFrag)94   public DOMBuilder(Document doc, DocumentFragment docFrag)
95   {
96     m_doc = doc;
97     m_docFrag = docFrag;
98   }
99 
100   /**
101    * DOMBuilder instance constructor... it will add the DOM nodes
102    * to the document.
103    *
104    * @param doc Root document
105    */
DOMBuilder(Document doc)106   public DOMBuilder(Document doc)
107   {
108     m_doc = doc;
109   }
110 
111   /**
112    * Get the root document or DocumentFragment of the DOM being created.
113    *
114    * @return The root document or document fragment if not null
115    */
getRootDocument()116   public Node getRootDocument()
117   {
118     return (null != m_docFrag) ? (Node) m_docFrag : (Node) m_doc;
119   }
120 
121   /**
122    * Get the root node of the DOM tree.
123    */
getRootNode()124   public Node getRootNode()
125   {
126     return m_root;
127   }
128 
129   /**
130    * Get the node currently being processed.
131    *
132    * @return the current node being processed
133    */
getCurrentNode()134   public Node getCurrentNode()
135   {
136     return m_currentNode;
137   }
138 
139   /**
140    * Set the next sibling node, which is where the result nodes
141    * should be inserted before.
142    *
143    * @param nextSibling the next sibling node.
144    */
setNextSibling(Node nextSibling)145   public void setNextSibling(Node nextSibling)
146   {
147     m_nextSibling = nextSibling;
148   }
149 
150   /**
151    * Return the next sibling node.
152    *
153    * @return the next sibling node.
154    */
getNextSibling()155   public Node getNextSibling()
156   {
157     return m_nextSibling;
158   }
159 
160   /**
161    * Return null since there is no Writer for this class.
162    *
163    * @return null
164    */
getWriter()165   public java.io.Writer getWriter()
166   {
167     return null;
168   }
169 
170   /**
171    * Append a node to the current container.
172    *
173    * @param newNode New node to append
174    */
append(Node newNode)175   protected void append(Node newNode) throws org.xml.sax.SAXException
176   {
177 
178     Node currentNode = m_currentNode;
179 
180     if (null != currentNode)
181     {
182       if (currentNode == m_root && m_nextSibling != null)
183         currentNode.insertBefore(newNode, m_nextSibling);
184       else
185         currentNode.appendChild(newNode);
186 
187       // System.out.println(newNode.getNodeName());
188     }
189     else if (null != m_docFrag)
190     {
191       if (m_nextSibling != null)
192         m_docFrag.insertBefore(newNode, m_nextSibling);
193       else
194         m_docFrag.appendChild(newNode);
195     }
196     else
197     {
198       boolean ok = true;
199       short type = newNode.getNodeType();
200 
201       if (type == Node.TEXT_NODE)
202       {
203         String data = newNode.getNodeValue();
204 
205         if ((null != data) && (data.trim().length() > 0))
206         {
207           throw new org.xml.sax.SAXException(
208             XMLMessages.createXMLMessage(
209               XMLErrorResources.ER_CANT_OUTPUT_TEXT_BEFORE_DOC, null));  //"Warning: can't output text before document element!  Ignoring...");
210         }
211 
212         ok = false;
213       }
214       else if (type == Node.ELEMENT_NODE)
215       {
216         if (m_doc.getDocumentElement() != null)
217         {
218           ok = false;
219 
220           throw new org.xml.sax.SAXException(
221             XMLMessages.createXMLMessage(
222               XMLErrorResources.ER_CANT_HAVE_MORE_THAN_ONE_ROOT, null));  //"Can't have more than one root on a DOM!");
223         }
224       }
225 
226       if (ok)
227       {
228         if (m_nextSibling != null)
229           m_doc.insertBefore(newNode, m_nextSibling);
230         else
231           m_doc.appendChild(newNode);
232       }
233     }
234   }
235 
236   /**
237    * Receive an object for locating the origin of SAX document events.
238    *
239    * <p>SAX parsers are strongly encouraged (though not absolutely
240    * required) to supply a locator: if it does so, it must supply
241    * the locator to the application by invoking this method before
242    * invoking any of the other methods in the ContentHandler
243    * interface.</p>
244    *
245    * <p>The locator allows the application to determine the end
246    * position of any document-related event, even if the parser is
247    * not reporting an error.  Typically, the application will
248    * use this information for reporting its own errors (such as
249    * character content that does not match an application's
250    * business rules).  The information returned by the locator
251    * is probably not sufficient for use with a search engine.</p>
252    *
253    * <p>Note that the locator will return correct information only
254    * during the invocation of the events in this interface.  The
255    * application should not attempt to use it at any other time.</p>
256    *
257    * @param locator An object that can return the location of
258    *                any SAX document event.
259    * @see org.xml.sax.Locator
260    */
setDocumentLocator(Locator locator)261   public void setDocumentLocator(Locator locator)
262   {
263 
264     // No action for the moment.
265   }
266 
267   /**
268    * Receive notification of the beginning of a document.
269    *
270    * <p>The SAX parser will invoke this method only once, before any
271    * other methods in this interface or in DTDHandler (except for
272    * setDocumentLocator).</p>
273    */
startDocument()274   public void startDocument() throws org.xml.sax.SAXException
275   {
276 
277     // No action for the moment.
278   }
279 
280   /**
281    * Receive notification of the end of a document.
282    *
283    * <p>The SAX parser will invoke this method only once, and it will
284    * be the last method invoked during the parse.  The parser shall
285    * not invoke this method until it has either abandoned parsing
286    * (because of an unrecoverable error) or reached the end of
287    * input.</p>
288    */
endDocument()289   public void endDocument() throws org.xml.sax.SAXException
290   {
291 
292     // No action for the moment.
293   }
294 
295   /**
296    * Receive notification of the beginning of an element.
297    *
298    * <p>The Parser will invoke this method at the beginning of every
299    * element in the XML document; there will be a corresponding
300    * endElement() event for every startElement() event (even when the
301    * element is empty). All of the element's content will be
302    * reported, in order, before the corresponding endElement()
303    * event.</p>
304    *
305    * <p>If the element name has a namespace prefix, the prefix will
306    * still be attached.  Note that the attribute list provided will
307    * contain only attributes with explicit values (specified or
308    * defaulted): #IMPLIED attributes will be omitted.</p>
309    *
310    *
311    * @param ns The namespace of the node
312    * @param localName The local part of the qualified name
313    * @param name The element name.
314    * @param atts The attributes attached to the element, if any.
315    * @see #endElement
316    * @see org.xml.sax.Attributes
317    */
startElement( String ns, String localName, String name, Attributes atts)318   public void startElement(
319           String ns, String localName, String name, Attributes atts)
320             throws org.xml.sax.SAXException
321   {
322 
323     Element elem;
324 
325 	// Note that the namespace-aware call must be used to correctly
326 	// construct a Level 2 DOM, even for non-namespaced nodes.
327     if ((null == ns) || (ns.length() == 0))
328       elem = m_doc.createElementNS(null,name);
329     else
330       elem = m_doc.createElementNS(ns, name);
331 
332     append(elem);
333 
334     try
335     {
336       int nAtts = atts.getLength();
337 
338       if (0 != nAtts)
339       {
340         for (int i = 0; i < nAtts; i++)
341         {
342 
343           //System.out.println("type " + atts.getType(i) + " name " + atts.getLocalName(i) );
344           // First handle a possible ID attribute
345           if (atts.getType(i).equalsIgnoreCase("ID"))
346             setIDAttribute(atts.getValue(i), elem);
347 
348           String attrNS = atts.getURI(i);
349 
350           if("".equals(attrNS))
351             attrNS = null; // DOM represents no-namespace as null
352 
353           // System.out.println("attrNS: "+attrNS+", localName: "+atts.getQName(i)
354           //                   +", qname: "+atts.getQName(i)+", value: "+atts.getValue(i));
355           // Crimson won't let us set an xmlns: attribute on the DOM.
356           String attrQName = atts.getQName(i);
357 
358           // In SAX, xmlns[:] attributes have an empty namespace, while in DOM they
359           // should have the xmlns namespace
360           if (attrQName.startsWith("xmlns:") || attrQName.equals("xmlns")) {
361             attrNS = "http://www.w3.org/2000/xmlns/";
362           }
363 
364           // ALWAYS use the DOM Level 2 call!
365           elem.setAttributeNS(attrNS,attrQName, atts.getValue(i));
366         }
367       }
368 
369       /*
370        * Adding namespace nodes to the DOM tree;
371        */
372       int nDecls = m_prefixMappings.size();
373 
374       String prefix, declURL;
375 
376       for (int i = 0; i < nDecls; i += 2)
377       {
378         prefix = (String) m_prefixMappings.elementAt(i);
379 
380         if (prefix == null)
381           continue;
382 
383         declURL = (String) m_prefixMappings.elementAt(i + 1);
384 
385         elem.setAttributeNS("http://www.w3.org/2000/xmlns/", prefix, declURL);
386       }
387 
388       m_prefixMappings.clear();
389 
390       // append(elem);
391 
392       m_elemStack.push(elem);
393 
394       m_currentNode = elem;
395 
396       // append(elem);
397     }
398     catch(java.lang.Exception de)
399     {
400       // de.printStackTrace();
401       throw new org.xml.sax.SAXException(de);
402     }
403 
404   }
405 
406   /**
407 
408 
409 
410    * Receive notification of the end of an element.
411    *
412    * <p>The SAX parser will invoke this method at the end of every
413    * element in the XML document; there will be a corresponding
414    * startElement() event for every endElement() event (even when the
415    * element is empty).</p>
416    *
417    * <p>If the element name has a namespace prefix, the prefix will
418    * still be attached to the name.</p>
419    *
420    *
421    * @param ns the namespace of the element
422    * @param localName The local part of the qualified name of the element
423    * @param name The element name
424    */
endElement(String ns, String localName, String name)425   public void endElement(String ns, String localName, String name)
426           throws org.xml.sax.SAXException
427   {
428     m_elemStack.pop();
429     m_currentNode = m_elemStack.isEmpty() ? null : (Node)m_elemStack.peek();
430   }
431 
432   /**
433    * Set an ID string to node association in the ID table.
434    *
435    * @param id The ID string.
436    * @param elem The associated ID.
437    */
setIDAttribute(String id, Element elem)438   public void setIDAttribute(String id, Element elem)
439   {
440 
441     // Do nothing. This method is meant to be overiden.
442   }
443 
444   /**
445    * Receive notification of character data.
446    *
447    * <p>The Parser will call this method to report each chunk of
448    * character data.  SAX parsers may return all contiguous character
449    * data in a single chunk, or they may split it into several
450    * chunks; however, all of the characters in any single event
451    * must come from the same external entity, so that the Locator
452    * provides useful information.</p>
453    *
454    * <p>The application must not attempt to read from the array
455    * outside of the specified range.</p>
456    *
457    * <p>Note that some parsers will report whitespace using the
458    * ignorableWhitespace() method rather than this one (validating
459    * parsers must do so).</p>
460    *
461    * @param ch The characters from the XML document.
462    * @param start The start position in the array.
463    * @param length The number of characters to read from the array.
464    * @see #ignorableWhitespace
465    * @see org.xml.sax.Locator
466    */
characters(char ch[], int start, int length)467   public void characters(char ch[], int start, int length) throws org.xml.sax.SAXException
468   {
469     if(isOutsideDocElem()
470        && org.apache.xml.utils.XMLCharacterRecognizer.isWhiteSpace(ch, start, length))
471       return;  // avoid DOM006 Hierarchy request error
472 
473     if (m_inCData)
474     {
475       cdata(ch, start, length);
476 
477       return;
478     }
479 
480     String s = new String(ch, start, length);
481     Node childNode;
482     childNode =  m_currentNode != null ? m_currentNode.getLastChild(): null;
483     if( childNode != null && childNode.getNodeType() == Node.TEXT_NODE ){
484        ((Text)childNode).appendData(s);
485     }
486     else{
487        Text text = m_doc.createTextNode(s);
488        append(text);
489     }
490   }
491 
492   /**
493    * If available, when the disable-output-escaping attribute is used,
494    * output raw text without escaping.  A PI will be inserted in front
495    * of the node with the name "lotusxsl-next-is-raw" and a value of
496    * "formatter-to-dom".
497    *
498    * @param ch Array containing the characters
499    * @param start Index to start of characters in the array
500    * @param length Number of characters in the array
501    */
charactersRaw(char ch[], int start, int length)502   public void charactersRaw(char ch[], int start, int length)
503           throws org.xml.sax.SAXException
504   {
505     if(isOutsideDocElem()
506        && org.apache.xml.utils.XMLCharacterRecognizer.isWhiteSpace(ch, start, length))
507       return;  // avoid DOM006 Hierarchy request error
508 
509 
510     String s = new String(ch, start, length);
511 
512     append(m_doc.createProcessingInstruction("xslt-next-is-raw",
513                                              "formatter-to-dom"));
514     append(m_doc.createTextNode(s));
515   }
516 
517   /**
518    * Report the beginning of an entity.
519    *
520    * The start and end of the document entity are not reported.
521    * The start and end of the external DTD subset are reported
522    * using the pseudo-name "[dtd]".  All other events must be
523    * properly nested within start/end entity events.
524    *
525    * @param name The name of the entity.  If it is a parameter
526    *        entity, the name will begin with '%'.
527    * @see #endEntity
528    * @see org.xml.sax.ext.DeclHandler#internalEntityDecl
529    * @see org.xml.sax.ext.DeclHandler#externalEntityDecl
530    */
startEntity(String name)531   public void startEntity(String name) throws org.xml.sax.SAXException
532   {
533 
534     // Almost certainly the wrong behavior...
535     // entityReference(name);
536   }
537 
538   /**
539    * Report the end of an entity.
540    *
541    * @param name The name of the entity that is ending.
542    * @see #startEntity
543    */
endEntity(String name)544   public void endEntity(String name) throws org.xml.sax.SAXException{}
545 
546   /**
547    * Receive notivication of a entityReference.
548    *
549    * @param name name of the entity reference
550    */
entityReference(String name)551   public void entityReference(String name) throws org.xml.sax.SAXException
552   {
553     append(m_doc.createEntityReference(name));
554   }
555 
556   /**
557    * Receive notification of ignorable whitespace in element content.
558    *
559    * <p>Validating Parsers must use this method to report each chunk
560    * of ignorable whitespace (see the W3C XML 1.0 recommendation,
561    * section 2.10): non-validating parsers may also use this method
562    * if they are capable of parsing and using content models.</p>
563    *
564    * <p>SAX parsers may return all contiguous whitespace in a single
565    * chunk, or they may split it into several chunks; however, all of
566    * the characters in any single event must come from the same
567    * external entity, so that the Locator provides useful
568    * information.</p>
569    *
570    * <p>The application must not attempt to read from the array
571    * outside of the specified range.</p>
572    *
573    * @param ch The characters from the XML document.
574    * @param start The start position in the array.
575    * @param length The number of characters to read from the array.
576    * @see #characters
577    */
ignorableWhitespace(char ch[], int start, int length)578   public void ignorableWhitespace(char ch[], int start, int length)
579           throws org.xml.sax.SAXException
580   {
581     if(isOutsideDocElem())
582       return;  // avoid DOM006 Hierarchy request error
583 
584     String s = new String(ch, start, length);
585 
586     append(m_doc.createTextNode(s));
587   }
588 
589   /**
590    * Tell if the current node is outside the document element.
591    *
592    * @return true if the current node is outside the document element.
593    */
isOutsideDocElem()594    private boolean isOutsideDocElem()
595    {
596       return (null == m_docFrag) && m_elemStack.size() == 0 && (null == m_currentNode || m_currentNode.getNodeType() == Node.DOCUMENT_NODE);
597    }
598 
599   /**
600    * Receive notification of a processing instruction.
601    *
602    * <p>The Parser will invoke this method once for each processing
603    * instruction found: note that processing instructions may occur
604    * before or after the main document element.</p>
605    *
606    * <p>A SAX parser should never report an XML declaration (XML 1.0,
607    * section 2.8) or a text declaration (XML 1.0, section 4.3.1)
608    * using this method.</p>
609    *
610    * @param target The processing instruction target.
611    * @param data The processing instruction data, or null if
612    *        none was supplied.
613    */
processingInstruction(String target, String data)614   public void processingInstruction(String target, String data)
615           throws org.xml.sax.SAXException
616   {
617     append(m_doc.createProcessingInstruction(target, data));
618   }
619 
620   /**
621    * Report an XML comment anywhere in the document.
622    *
623    * This callback will be used for comments inside or outside the
624    * document element, including comments in the external DTD
625    * subset (if read).
626    *
627    * @param ch An array holding the characters in the comment.
628    * @param start The starting position in the array.
629    * @param length The number of characters to use from the array.
630    */
comment(char ch[], int start, int length)631   public void comment(char ch[], int start, int length) throws org.xml.sax.SAXException
632   {
633     append(m_doc.createComment(new String(ch, start, length)));
634   }
635 
636   /** Flag indicating that we are processing a CData section          */
637   protected boolean m_inCData = false;
638 
639   /**
640    * Report the start of a CDATA section.
641    *
642    * @see #endCDATA
643    */
startCDATA()644   public void startCDATA() throws org.xml.sax.SAXException
645   {
646     m_inCData = true;
647     append(m_doc.createCDATASection(""));
648   }
649 
650   /**
651    * Report the end of a CDATA section.
652    *
653    * @see #startCDATA
654    */
endCDATA()655   public void endCDATA() throws org.xml.sax.SAXException
656   {
657     m_inCData = false;
658   }
659 
660   /**
661    * Receive notification of cdata.
662    *
663    * <p>The Parser will call this method to report each chunk of
664    * character data.  SAX parsers may return all contiguous character
665    * data in a single chunk, or they may split it into several
666    * chunks; however, all of the characters in any single event
667    * must come from the same external entity, so that the Locator
668    * provides useful information.</p>
669    *
670    * <p>The application must not attempt to read from the array
671    * outside of the specified range.</p>
672    *
673    * <p>Note that some parsers will report whitespace using the
674    * ignorableWhitespace() method rather than this one (validating
675    * parsers must do so).</p>
676    *
677    * @param ch The characters from the XML document.
678    * @param start The start position in the array.
679    * @param length The number of characters to read from the array.
680    * @see #ignorableWhitespace
681    * @see org.xml.sax.Locator
682    */
cdata(char ch[], int start, int length)683   public void cdata(char ch[], int start, int length) throws org.xml.sax.SAXException
684   {
685     if(isOutsideDocElem()
686        && org.apache.xml.utils.XMLCharacterRecognizer.isWhiteSpace(ch, start, length))
687       return;  // avoid DOM006 Hierarchy request error
688 
689     String s = new String(ch, start, length);
690 
691     CDATASection section  =(CDATASection) m_currentNode.getLastChild();
692     section.appendData(s);
693   }
694 
695   /**
696    * Report the start of DTD declarations, if any.
697    *
698    * Any declarations are assumed to be in the internal subset
699    * unless otherwise indicated.
700    *
701    * @param name The document type name.
702    * @param publicId The declared public identifier for the
703    *        external DTD subset, or null if none was declared.
704    * @param systemId The declared system identifier for the
705    *        external DTD subset, or null if none was declared.
706    * @see #endDTD
707    * @see #startEntity
708    */
startDTD(String name, String publicId, String systemId)709   public void startDTD(String name, String publicId, String systemId)
710           throws org.xml.sax.SAXException
711   {
712 
713     // Do nothing for now.
714   }
715 
716   /**
717    * Report the end of DTD declarations.
718    *
719    * @see #startDTD
720    */
endDTD()721   public void endDTD() throws org.xml.sax.SAXException
722   {
723 
724     // Do nothing for now.
725   }
726 
727   /**
728    * Begin the scope of a prefix-URI Namespace mapping.
729    *
730    * <p>The information from this event is not necessary for
731    * normal Namespace processing: the SAX XML reader will
732    * automatically replace prefixes for element and attribute
733    * names when the http://xml.org/sax/features/namespaces
734    * feature is true (the default).</p>
735    *
736    * <p>There are cases, however, when applications need to
737    * use prefixes in character data or in attribute values,
738    * where they cannot safely be expanded automatically; the
739    * start/endPrefixMapping event supplies the information
740    * to the application to expand prefixes in those contexts
741    * itself, if necessary.</p>
742    *
743    * <p>Note that start/endPrefixMapping events are not
744    * guaranteed to be properly nested relative to each-other:
745    * all startPrefixMapping events will occur before the
746    * corresponding startElement event, and all endPrefixMapping
747    * events will occur after the corresponding endElement event,
748    * but their order is not guaranteed.</p>
749    *
750    * @param prefix The Namespace prefix being declared.
751    * @param uri The Namespace URI the prefix is mapped to.
752    * @see #endPrefixMapping
753    * @see #startElement
754    */
startPrefixMapping(String prefix, String uri)755   public void startPrefixMapping(String prefix, String uri)
756           throws org.xml.sax.SAXException
757   {
758 	      if(null == prefix || prefix.equals(""))
759 	        prefix = "xmlns";
760 	      else prefix = "xmlns:"+prefix;
761 	      m_prefixMappings.addElement(prefix);
762 	      m_prefixMappings.addElement(uri);
763   }
764 
765   /**
766    * End the scope of a prefix-URI mapping.
767    *
768    * <p>See startPrefixMapping for details.  This event will
769    * always occur after the corresponding endElement event,
770    * but the order of endPrefixMapping events is not otherwise
771    * guaranteed.</p>
772    *
773    * @param prefix The prefix that was being mapping.
774    * @see #startPrefixMapping
775    * @see #endElement
776    */
endPrefixMapping(String prefix)777   public void endPrefixMapping(String prefix) throws org.xml.sax.SAXException{}
778 
779   /**
780    * Receive notification of a skipped entity.
781    *
782    * <p>The Parser will invoke this method once for each entity
783    * skipped.  Non-validating processors may skip entities if they
784    * have not seen the declarations (because, for example, the
785    * entity was declared in an external DTD subset).  All processors
786    * may skip external entities, depending on the values of the
787    * http://xml.org/sax/features/external-general-entities and the
788    * http://xml.org/sax/features/external-parameter-entities
789    * properties.</p>
790    *
791    * @param name The name of the skipped entity.  If it is a
792    *        parameter entity, the name will begin with '%'.
793    */
skippedEntity(String name)794   public void skippedEntity(String name) throws org.xml.sax.SAXException{}
795 }
796