1 /*

     2  * reserved comment block

     3  * DO NOT REMOVE OR ALTER!

     4  */

     5 /*

     6  * Copyright 2001-2004 The Apache Software Foundation.

     7  *

     8  * Licensed under the Apache License, Version 2.0 (the "License");

     9  * you may not use this file except in compliance with the License.

    10  * You may obtain a copy of the License at

    11  *

    12  *     http://www.apache.org/licenses/LICENSE-2.0

    13  *

    14  * Unless required by applicable law or agreed to in writing, software

    15  * distributed under the License is distributed on an "AS IS" BASIS,

    16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    17  * See the License for the specific language governing permissions and

    18  * limitations under the License.

    19  */

    20 /*

    21  * $Id: SerializerBase.java,v 1.5 2006/04/14 12:09:19 sunithareddy Exp $

    22  */

    23 package com.sun.org.apache.xml.internal.serializer;

    24 

    25 import java.io.IOException;

    26 import java.util.Vector;

    27 

    28 import javax.xml.transform.SourceLocator;

    29 import javax.xml.transform.Transformer;

    30 

    31 import com.sun.org.apache.xml.internal.serializer.utils.MsgKey;

    32 import com.sun.org.apache.xml.internal.serializer.utils.Utils;

    33 import org.xml.sax.Attributes;

    34 import org.xml.sax.ContentHandler;

    35 import org.xml.sax.Locator;

    36 import org.xml.sax.SAXException;

    37 import org.xml.sax.SAXParseException;

    38 import org.xml.sax.ext.Locator2;

    39 

    40 

    41 /**

    42  * This class acts as a base class for the XML "serializers"

    43  * and the stream serializers.

    44  * It contains a number of common fields and methods.

    45  *

    46  * @xsl.usage internal

    47  */

    48 public abstract class SerializerBase

    49     implements SerializationHandler, SerializerConstants

    50 {

    51 

    52 

    53     /**

    54      * To fire off the end element trace event

    55      * @param name Name of element

    56      */

    57     protected void fireEndElem(String name)

    58         throws org.xml.sax.SAXException

    59     {

    60         if (m_tracer != null)

    61         {

    62             flushMyWriter();

    63             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDELEMENT,name, (Attributes)null);

    64         }

    65     }

    66 

    67     /**

    68      * Report the characters trace event

    69      * @param chars  content of characters

    70      * @param start  starting index of characters to output

    71      * @param length  number of characters to output

    72      */

    73     protected void fireCharEvent(char[] chars, int start, int length)

    74         throws org.xml.sax.SAXException

    75     {

    76         if (m_tracer != null)

    77         {

    78             flushMyWriter();

    79             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CHARACTERS, chars, start,length);

    80         }

    81     }

    82 

    83     /**

    84      * true if we still need to call startDocumentInternal()

    85          */

    86     protected boolean m_needToCallStartDocument = true;

    87 

    88     /** True if a trailing "]]>" still needs to be written to be

    89      * written out. Used to merge adjacent CDATA sections

    90      */

    91     protected boolean m_cdataTagOpen = false;

    92 

    93     /**

    94      * All the attributes of the current element, collected from

    95      * startPrefixMapping() calls, or addAddtribute() calls, or

    96      * from the SAX attributes in a startElement() call.

    97      */

    98     protected AttributesImplSerializer m_attributes = new AttributesImplSerializer();

    99 

   100     /**

   101      * Tells if we're in an EntityRef event.

   102      */

   103     protected boolean m_inEntityRef = false;

   104 

   105     /** This flag is set while receiving events from the external DTD */

   106     protected boolean m_inExternalDTD = false;

   107 

   108     /**

   109      * The System ID for the doc type.

   110      */

   111     private String m_doctypeSystem;

   112 

   113     /**

   114      * The public ID for the doc type.

   115      */

   116     private String m_doctypePublic;

   117 

   118     /**

   119      * Flag to tell that we need to add the doctype decl, which we can't do

   120      * until the first element is encountered.

   121      */

   122     boolean m_needToOutputDocTypeDecl = true;

   123 

   124     /**

   125      * The character encoding.  Must match the encoding used for the

   126      * printWriter.

   127      */

   128     private String m_encoding = null;

   129 

   130     /**

   131      * Tells if we should write the XML declaration.

   132      */

   133     private boolean m_shouldNotWriteXMLHeader = false;

   134 

   135     /**

   136      * The standalone value for the doctype.

   137      */

   138     private String m_standalone;

   139 

   140     /**

   141      * True if standalone was specified.

   142      */

   143     protected boolean m_standaloneWasSpecified = false;

   144 

   145     /**

   146      * Flag to tell if indenting (pretty-printing) is on.

   147      */

   148     protected boolean m_doIndent = false;

   149     /**

   150      * Amount to indent.

   151      */

   152     protected int m_indentAmount = 0;

   153 

   154     /**

   155      * Tells the XML version, for writing out to the XML decl.

   156      */

   157     private String m_version = null;

   158 

   159     /**

   160      * The mediatype.  Not used right now.

   161      */

   162     private String m_mediatype;

   163 

   164     /**

   165      * The transformer that was around when this output handler was created (if

   166      * any).

   167      */

   168     private Transformer m_transformer;

   169 

   170     /**

   171      * Pairs of local names and corresponding URIs of CDATA sections. This list

   172      * comes from the cdata-section-elements attribute. Every second one is a

   173      * local name, and every other second one is the URI for the local name.

   174      */

   175     protected Vector m_cdataSectionElements = null;

   176 

   177     /**

   178      * Namespace support, that keeps track of currently defined

   179      * prefix/uri mappings. As processed elements come and go, so do

   180      * the associated mappings for that element.

   181      */

   182     protected NamespaceMappings m_prefixMap;

   183 

   184     /**

   185      * Handle for firing generate events.  This interface may be implemented

   186      * by the referenced transformer object.

   187      */

   188     protected SerializerTrace m_tracer;

   189 

   190     protected SourceLocator m_sourceLocator;

   191 

   192 

   193     /**

   194      * The writer to send output to. This field is only used in the ToStream

   195      * serializers, but exists here just so that the fireStartDoc() and

   196      * other fire... methods can flush this writer when tracing.

   197      */

   198     protected java.io.Writer m_writer = null;

   199 

   200     /**

   201      * A reference to "stack frame" corresponding to

   202      * the current element. Such a frame is pushed at a startElement()

   203      * and popped at an endElement(). This frame contains information about

   204      * the element, such as its namespace URI.

   205      */

   206     protected ElemContext m_elemContext = new ElemContext();

   207 

   208     /**

   209      * A utility buffer for converting Strings passed to

   210      * character() methods to character arrays.

   211      * Reusing this buffer means not creating a new character array

   212      * everytime and it runs faster.

   213      */

   214     protected char[] m_charsBuff = new char[60];

   215 

   216     /**

   217      * A utility buffer for converting Strings passed to

   218      * attribute methods to character arrays.

   219      * Reusing this buffer means not creating a new character array

   220      * everytime and it runs faster.

   221      */

   222     protected char[] m_attrBuff = new char[30];

   223 

   224     private Locator m_locator = null;

   225 

   226     protected boolean m_needToCallSetDocumentInfo = true;

   227 

   228     /**

   229      * Receive notification of a comment.

   230      *

   231      * @see ExtendedLexicalHandler#comment(String)

   232      */

   233     public void comment(String data) throws SAXException

   234     {

   235         final int length = data.length();

   236         if (length > m_charsBuff.length)

   237         {

   238             m_charsBuff = new char[length * 2 + 1];

   239         }

   240         data.getChars(0, length, m_charsBuff, 0);

   241         comment(m_charsBuff, 0, length);

   242     }

   243 

   244     /**

   245      * If at runtime, when the qname of the attribute is

   246      * known, another prefix is specified for the attribute, then we can

   247      * patch or hack the name with this method. For

   248      * a qname of the form "ns?:otherprefix:name", this function patches the

   249      * qname by simply ignoring "otherprefix".

   250      * TODO: This method is a HACK! We do not have access to the

   251      * XML file, it sometimes generates a NS prefix of the form "ns?" for

   252      * an attribute.

   253      */

   254     protected String patchName(String qname)

   255     {

   256 

   257 

   258         final int lastColon = qname.lastIndexOf(':');

   259 

   260         if (lastColon > 0) {

   261             final int firstColon = qname.indexOf(':');

   262             final String prefix = qname.substring(0, firstColon);

   263             final String localName = qname.substring(lastColon + 1);

   264 

   265         // If uri is "" then ignore prefix

   266             final String uri = m_prefixMap.lookupNamespace(prefix);

   267             if (uri != null && uri.length() == 0) {

   268                 return localName;

   269             }

   270             else if (firstColon != lastColon) {

   271                 return prefix + ':' + localName;

   272             }

   273         }

   274         return qname;

   275     }

   276 

   277     /**

   278      * Returns the local name of a qualified name. If the name has no prefix,

   279      * then it works as the identity (SAX2).

   280      * @param qname the qualified name

   281      * @return the name, but excluding any prefix and colon.

   282      */

   283     protected static String getLocalName(String qname)

   284     {

   285         final int col = qname.lastIndexOf(':');

   286         return (col > 0) ? qname.substring(col + 1) : qname;

   287     }

   288 

   289     /**

   290      * Receive an object for locating the origin of SAX document events.

   291      *

   292      * @param locator An object that can return the location of any SAX document

   293      * event.

   294      *

   295      * Receive an object for locating the origin of SAX document events.

   296      *

   297      * <p>SAX parsers are strongly encouraged (though not absolutely

   298      * required) to supply a locator: if it does so, it must supply

   299      * the locator to the application by invoking this method before

   300      * invoking any of the other methods in the DocumentHandler

   301      * interface.</p>

   302      *

   303      * <p>The locator allows the application to determine the end

   304      * position of any document-related event, even if the parser is

   305      * not reporting an error.  Typically, the application will

   306      * use this information for reporting its own errors (such as

   307      * character content that does not match an application's

   308      * business rules).  The information returned by the locator

   309      * is probably not sufficient for use with a search engine.</p>

   310      *

   311      * <p>Note that the locator will return correct information only

   312      * during the invocation of the events in this interface.  The

   313      * application should not attempt to use it at any other time.</p>

   314      */

   315     public void setDocumentLocator(Locator locator)

   316     {

   317         m_locator = locator;

   318     }

   319 

   320     /**

   321      * Adds the given attribute to the set of collected attributes , but only if

   322      * there is a currently open element.

   323      *

   324      * An element is currently open if a startElement() notification has

   325      * occured but the start of the element has not yet been written to the

   326      * output.  In the stream case this means that we have not yet been forced

   327      * to close the elements opening tag by another notification, such as a

   328      * character notification.

   329      *

   330      * @param uri the URI of the attribute

   331      * @param localName the local name of the attribute

   332      * @param rawName    the qualified name of the attribute

   333      * @param type the type of the attribute (probably CDATA)

   334      * @param value the value of the attribute

   335      * @param XSLAttribute true if this attribute is coming from an xsl:attriute element

   336      * @see ExtendedContentHandler#addAttribute(String, String, String, String, String)

   337      */

   338     public void addAttribute(

   339         String uri,

   340         String localName,

   341         String rawName,

   342         String type,

   343         String value,

   344         boolean XSLAttribute)

   345         throws SAXException

   346     {

   347         if (m_elemContext.m_startTagOpen)

   348         {

   349             addAttributeAlways(uri, localName, rawName, type, value, XSLAttribute);

   350         }

   351 

   352     }

   353 

   354     /**

   355      * Adds the given attribute to the set of attributes, even if there is

   356      * no currently open element. This is useful if a SAX startPrefixMapping()

   357      * should need to add an attribute before the element name is seen.

   358      *

   359      * @param uri the URI of the attribute

   360      * @param localName the local name of the attribute

   361      * @param rawName   the qualified name of the attribute

   362      * @param type the type of the attribute (probably CDATA)

   363      * @param value the value of the attribute

   364      * @param XSLAttribute true if this attribute is coming from an xsl:attribute element

   365      * @return true if the attribute was added,

   366      * false if an existing value was replaced.

   367      */

   368     public boolean addAttributeAlways(

   369         String uri,

   370         String localName,

   371         String rawName,

   372         String type,

   373         String value,

   374         boolean XSLAttribute)

   375     {

   376         boolean was_added;

   377 //            final int index =

   378 //                (localName == null || uri == null) ?

   379 //                m_attributes.getIndex(rawName):m_attributes.getIndex(uri, localName);

   380             int index;

   381 //            if (localName == null || uri == null){

   382 //                index = m_attributes.getIndex(rawName);

   383 //            }

   384 //            else {

   385 //                index = m_attributes.getIndex(uri, localName);

   386 //            }

   387 

   388             if (localName == null || uri == null || uri.length() == 0)

   389                 index = m_attributes.getIndex(rawName);

   390             else {

   391                 index = m_attributes.getIndex(uri,localName);

   392             }

   393             if (index >= 0)

   394             {

   395                 /* We've seen the attribute before.

   396                  * We may have a null uri or localName, but all

   397                  * we really want to re-set is the value anyway.

   398                  */

   399                 m_attributes.setValue(index,value);

   400                 was_added = false;

   401             }

   402             else

   403             {

   404                 // the attribute doesn't exist yet, create it

   405                 m_attributes.addAttribute(uri, localName, rawName, type, value);

   406                 was_added = true;

   407             }

   408             return was_added;

   409 

   410     }

   411 

   412 

   413     /**

   414      *  Adds  the given attribute to the set of collected attributes,

   415      * but only if there is a currently open element.

   416      *

   417      * @param name the attribute's qualified name

   418      * @param value the value of the attribute

   419      */

   420     public void addAttribute(String name, final String value)

   421     {

   422         if (m_elemContext.m_startTagOpen)

   423         {

   424             final String patchedName = patchName(name);

   425             final String localName = getLocalName(patchedName);

   426             final String uri = getNamespaceURI(patchedName, false);

   427 

   428             addAttributeAlways(uri,localName, patchedName, "CDATA", value, false);

   429          }

   430     }

   431 

   432     /**

   433      * Adds the given xsl:attribute to the set of collected attributes,

   434      * but only if there is a currently open element.

   435      *

   436      * @param name the attribute's qualified name (prefix:localName)

   437      * @param value the value of the attribute

   438      * @param uri the URI that the prefix of the name points to

   439      */

   440     public void addXSLAttribute(String name, final String value, final String uri)

   441     {

   442         if (m_elemContext.m_startTagOpen)

   443         {

   444             final String patchedName = patchName(name);

   445             final String localName = getLocalName(patchedName);

   446 

   447             addAttributeAlways(uri,localName, patchedName, "CDATA", value, true);

   448          }

   449     }

   450 

   451     /**

   452      * Add the given attributes to the currently collected ones. These

   453      * attributes are always added, regardless of whether on not an element

   454      * is currently open.

   455      * @param atts List of attributes to add to this list

   456      */

   457     public void addAttributes(Attributes atts) throws SAXException

   458     {

   459 

   460         int nAtts = atts.getLength();

   461         for (int i = 0; i < nAtts; i++)

   462         {

   463             String uri = atts.getURI(i);

   464 

   465             if (null == uri)

   466                 uri = "";

   467 

   468             addAttributeAlways(

   469                 uri,

   470                 atts.getLocalName(i),

   471                 atts.getQName(i),

   472                 atts.getType(i),

   473                 atts.getValue(i),

   474                 false);

   475 

   476         }

   477     }

   478 

   479     /**

   480      * Return a {@link ContentHandler} interface into this serializer.

   481      * If the serializer does not support the {@link ContentHandler}

   482      * interface, it should return null.

   483      *

   484      * @return A {@link ContentHandler} interface into this serializer,

   485      *  or null if the serializer is not SAX 2 capable

   486      * @throws IOException An I/O exception occured

   487      */

   488     public ContentHandler asContentHandler() throws IOException

   489     {

   490         return this;

   491     }

   492 

   493     /**

   494      * Report the end of an entity.

   495      *

   496      * @param name The name of the entity that is ending.

   497      * @throws org.xml.sax.SAXException The application may raise an exception.

   498      * @see #startEntity

   499      */

   500     public void endEntity(String name) throws org.xml.sax.SAXException

   501     {

   502         if (name.equals("[dtd]"))

   503             m_inExternalDTD = false;

   504         m_inEntityRef = false;

   505 

   506         if (m_tracer != null)

   507             this.fireEndEntity(name);

   508     }

   509 

   510     /**

   511      * Flush and close the underlying java.io.Writer. This method applies to

   512      * ToStream serializers, not ToSAXHandler serializers.

   513      * @see ToStream

   514      */

   515     public void close()

   516     {

   517         // do nothing (base behavior)

   518     }

   519 

   520     /**

   521      * Initialize global variables

   522      */

   523     protected void initCDATA()

   524     {

   525         // CDATA stack

   526         //        _cdataStack = new Stack();

   527         //        _cdataStack.push(new Integer(-1)); // push dummy value

   528     }

   529 

   530     /**

   531      * Returns the character encoding to be used in the output document.

   532      * @return the character encoding to be used in the output document.

   533      */

   534     public String getEncoding()

   535     {

   536         return m_encoding;

   537     }

   538 

   539    /**

   540      * Sets the character encoding coming from the xsl:output encoding stylesheet attribute.

   541      * @param m_encoding the character encoding

   542      */

   543     public void setEncoding(String m_encoding)

   544     {

   545         this.m_encoding = m_encoding;

   546     }

   547 

   548     /**

   549      * Sets the value coming from the xsl:output omit-xml-declaration stylesheet attribute

   550      * @param b true if the XML declaration is to be omitted from the output

   551      * document.

   552      */

   553     public void setOmitXMLDeclaration(boolean b)

   554     {

   555         this.m_shouldNotWriteXMLHeader = b;

   556     }

   557 

   558 

   559     /**

   560      * @return true if the XML declaration is to be omitted from the output

   561      * document.

   562      */

   563     public boolean getOmitXMLDeclaration()

   564     {

   565         return m_shouldNotWriteXMLHeader;

   566     }

   567 

   568     /**

   569      * Returns the previously set value of the value to be used as the public

   570      * identifier in the document type declaration (DTD).

   571      *

   572      *@return the public identifier to be used in the DOCTYPE declaration in the

   573      * output document.

   574      */

   575     public String getDoctypePublic()

   576     {

   577         return m_doctypePublic;

   578     }

   579 

   580     /** Set the value coming from the xsl:output doctype-public stylesheet attribute.

   581       * @param doctypePublic the public identifier to be used in the DOCTYPE

   582       * declaration in the output document.

   583       */

   584     public void setDoctypePublic(String doctypePublic)

   585     {

   586         this.m_doctypePublic = doctypePublic;

   587     }

   588 

   589 

   590     /**

   591      * Returns the previously set value of the value to be used

   592      * as the system identifier in the document type declaration (DTD).

   593          * @return the system identifier to be used in the DOCTYPE declaration in

   594          * the output document.

   595      *

   596      */

   597     public String getDoctypeSystem()

   598     {

   599         return m_doctypeSystem;

   600     }

   601 

   602     /** Set the value coming from the xsl:output doctype-system stylesheet attribute.

   603       * @param doctypeSystem the system identifier to be used in the DOCTYPE

   604       * declaration in the output document.

   605       */

   606     public void setDoctypeSystem(String doctypeSystem)

   607     {

   608         this.m_doctypeSystem = doctypeSystem;

   609     }

   610 

   611     /** Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties

   612      * @param doctypeSystem the system identifier to be used in the DOCTYPE

   613      * declaration in the output document.

   614      * @param doctypePublic the public identifier to be used in the DOCTYPE

   615      * declaration in the output document.

   616      */

   617     public void setDoctype(String doctypeSystem, String doctypePublic)

   618     {

   619         this.m_doctypeSystem = doctypeSystem;

   620         this.m_doctypePublic = doctypePublic;

   621     }

   622 

   623     /**

   624      * Sets the value coming from the xsl:output standalone stylesheet attribute.

   625      * @param standalone a value of "yes" indicates that the

   626      * <code>standalone</code> delaration is to be included in the output

   627      * document. This method remembers if the value was explicitly set using

   628      * this method, verses if the value is the default value.

   629      */

   630     public void setStandalone(String standalone)

   631     {

   632         if (standalone != null)

   633         {

   634             m_standaloneWasSpecified = true;

   635             setStandaloneInternal(standalone);

   636         }

   637     }

   638     /**

   639      * Sets the XSL standalone attribute, but does not remember if this is a

   640      * default or explicite setting.

   641      * @param standalone "yes" | "no"

   642      */

   643     protected void setStandaloneInternal(String standalone)

   644     {

   645         if ("yes".equals(standalone))

   646             m_standalone = "yes";

   647         else

   648             m_standalone = "no";

   649 

   650     }

   651 

   652     /**

   653      * Gets the XSL standalone attribute

   654      * @return a value of "yes" if the <code>standalone</code> delaration is to

   655      * be included in the output document.

   656      *  @see XSLOutputAttributes#getStandalone()

   657      */

   658     public String getStandalone()

   659     {

   660         return m_standalone;

   661     }

   662 

   663     /**

   664      * @return true if the output document should be indented to visually

   665      * indicate its structure.

   666      */

   667     public boolean getIndent()

   668     {

   669         return m_doIndent;

   670     }

   671     /**

   672      * Gets the mediatype the media-type or MIME type associated with the output

   673      * document.

   674      * @return the mediatype the media-type or MIME type associated with the

   675      * output document.

   676      */

   677     public String getMediaType()

   678     {

   679         return m_mediatype;

   680     }

   681 

   682     /**

   683      * Gets the version of the output format.

   684      * @return the version of the output format.

   685      */

   686     public String getVersion()

   687     {

   688         return m_version;

   689     }

   690 

   691     /**

   692      * Sets the value coming from the xsl:output version attribute.

   693      * @param version the version of the output format.

   694      * @see SerializationHandler#setVersion(String)

   695      */

   696     public void setVersion(String version)

   697     {

   698         m_version = version;

   699     }

   700 

   701     /**

   702      * Sets the value coming from the xsl:output media-type stylesheet attribute.

   703      * @param mediaType the non-null media-type or MIME type associated with the

   704      * output document.

   705      * @see javax.xml.transform.OutputKeys#MEDIA_TYPE

   706      * @see SerializationHandler#setMediaType(String)

   707      */

   708     public void setMediaType(String mediaType)

   709     {

   710         m_mediatype = mediaType;

   711     }

   712 

   713     /**

   714      * @return the number of spaces to indent for each indentation level.

   715      */

   716     public int getIndentAmount()

   717     {

   718         return m_indentAmount;

   719     }

   720 

   721     /**

   722      * Sets the indentation amount.

   723      * @param m_indentAmount The m_indentAmount to set

   724      */

   725     public void setIndentAmount(int m_indentAmount)

   726     {

   727         this.m_indentAmount = m_indentAmount;

   728     }

   729 

   730     /**

   731      * Sets the value coming from the xsl:output indent stylesheet

   732      * attribute.

   733      * @param doIndent true if the output document should be indented to

   734      * visually indicate its structure.

   735      * @see XSLOutputAttributes#setIndent(boolean)

   736      */

   737     public void setIndent(boolean doIndent)

   738     {

   739         m_doIndent = doIndent;

   740     }

   741 

   742     /**

   743      * This method is used when a prefix/uri namespace mapping

   744      * is indicated after the element was started with a

   745      * startElement() and before and endElement().

   746      * startPrefixMapping(prefix,uri) would be used before the

   747      * startElement() call.

   748      * @param uri the URI of the namespace

   749      * @param prefix the prefix associated with the given URI.

   750      *

   751      * @see ExtendedContentHandler#namespaceAfterStartElement(String, String)

   752      */

   753     public void namespaceAfterStartElement(String uri, String prefix)

   754         throws SAXException

   755     {

   756         // default behavior is to do nothing

   757     }

   758 

   759     /**

   760      * Return a {@link DOMSerializer} interface into this serializer. If the

   761      * serializer does not support the {@link DOMSerializer} interface, it should

   762      * return null.

   763      *

   764      * @return A {@link DOMSerializer} interface into this serializer,  or null

   765      * if the serializer is not DOM capable

   766      * @throws IOException An I/O exception occured

   767      * @see Serializer#asDOMSerializer()

   768      */

   769     public DOMSerializer asDOMSerializer() throws IOException

   770     {

   771         return this;

   772     }

   773 

   774     /**

   775      * Push a boolean state based on if the name of the current element

   776      * is found in the list of qnames.  A state is only pushed if

   777      * there were some cdata-section-names were specified.

   778      * <p>

   779      * Hidden parameters are the vector of qualified elements specified in

   780      * cdata-section-names attribute, and the m_cdataSectionStates stack

   781      * onto which whether the current element is in the list is pushed (true or

   782      * false). Other hidden parameters are the current elements namespaceURI,

   783      * localName and qName

   784      */

   785     protected boolean isCdataSection()

   786     {

   787 

   788         boolean b = false;

   789 

   790         if (null != m_cdataSectionElements)

   791         {

   792             if (m_elemContext.m_elementLocalName == null)

   793                 m_elemContext.m_elementLocalName =

   794                     getLocalName(m_elemContext.m_elementName);

   795             if (m_elemContext.m_elementURI == null)

   796             {

   797                 String prefix = getPrefixPart(m_elemContext.m_elementName);

   798                 if (prefix != null)

   799                     m_elemContext.m_elementURI =

   800                         m_prefixMap.lookupNamespace(prefix);

   801 

   802             }

   803 

   804             if ((null != m_elemContext.m_elementURI)

   805                 && m_elemContext.m_elementURI.length() == 0)

   806                 m_elemContext.m_elementURI = null;

   807 

   808             int nElems = m_cdataSectionElements.size();

   809 

   810             // loop through 2 at a time, as these are pairs of URI and localName

   811             for (int i = 0; i < nElems; i += 2)

   812             {

   813                 String uri = (String) m_cdataSectionElements.elementAt(i);

   814                 String loc = (String) m_cdataSectionElements.elementAt(i + 1);

   815                 if (loc.equals(m_elemContext.m_elementLocalName)

   816                     && subPartMatch(m_elemContext.m_elementURI, uri))

   817                 {

   818                     b = true;

   819 

   820                     break;

   821                 }

   822             }

   823         }

   824         return b;

   825     }

   826 

   827     /**

   828      * Tell if two strings are equal, without worry if the first string is null.

   829      *

   830      * @param p String reference, which may be null.

   831      * @param t String reference, which may be null.

   832      *

   833      * @return true if strings are equal.

   834      */

   835     private static final boolean subPartMatch(String p, String t)

   836     {

   837         return (p == t) || ((null != p) && (p.equals(t)));

   838     }

   839 

   840     /**

   841      * Returns the local name of a qualified name.

   842      * If the name has no prefix,

   843      * then it works as the identity (SAX2).

   844      *

   845      * @param qname a qualified name

   846      * @return returns the prefix of the qualified name,

   847      * or null if there is no prefix.

   848      */

   849     protected static final String getPrefixPart(String qname)

   850     {

   851         final int col = qname.indexOf(':');

   852         return (col > 0) ? qname.substring(0, col) : null;

   853         //return (col > 0) ? qname.substring(0,col) : "";

   854     }

   855 

   856     /**

   857      * Some users of the serializer may need the current namespace mappings

   858      * @return the current namespace mappings (prefix/uri)

   859      * @see ExtendedContentHandler#getNamespaceMappings()

   860      */

   861     public NamespaceMappings getNamespaceMappings()

   862     {

   863         return m_prefixMap;

   864     }

   865 

   866     /**

   867      * Returns the prefix currently pointing to the given URI (if any).

   868      * @param namespaceURI the uri of the namespace in question

   869      * @return a prefix pointing to the given URI (if any).

   870      * @see ExtendedContentHandler#getPrefix(String)

   871      */

   872     public String getPrefix(String namespaceURI)

   873     {

   874         String prefix = m_prefixMap.lookupPrefix(namespaceURI);

   875         return prefix;

   876     }

   877 

   878     /**

   879      * Returns the URI of an element or attribute. Note that default namespaces

   880      * do not apply directly to attributes.

   881      * @param qname a qualified name

   882      * @param isElement true if the qualified name is the name of

   883      * an element.

   884      * @return returns the namespace URI associated with the qualified name.

   885      */

   886     public String getNamespaceURI(String qname, boolean isElement)

   887     {

   888         String uri = EMPTYSTRING;

   889         int col = qname.lastIndexOf(':');

   890         final String prefix = (col > 0) ? qname.substring(0, col) : EMPTYSTRING;

   891 

   892         if (!EMPTYSTRING.equals(prefix) || isElement)

   893         {

   894             if (m_prefixMap != null)

   895             {

   896                 uri = m_prefixMap.lookupNamespace(prefix);

   897                 if (uri == null && !prefix.equals(XMLNS_PREFIX))

   898                 {

   899                     throw new RuntimeException(

   900                         Utils.messages.createMessage(

   901                             MsgKey.ER_NAMESPACE_PREFIX,

   902                             new Object[] { qname.substring(0, col) }  ));

   903                 }

   904             }

   905         }

   906         return uri;

   907     }

   908 

   909     /**

   910      * Returns the URI of prefix (if any)

   911      *

   912          * @param prefix the prefix whose URI is searched for

   913      * @return the namespace URI currently associated with the

   914      * prefix, null if the prefix is undefined.

   915      */

   916     public String getNamespaceURIFromPrefix(String prefix)

   917     {

   918         String uri = null;

   919         if (m_prefixMap != null)

   920             uri = m_prefixMap.lookupNamespace(prefix);

   921         return uri;

   922     }

   923 

   924     /**

   925      * Entity reference event.

   926      *

   927      * @param name Name of entity

   928      *

   929      * @throws org.xml.sax.SAXException

   930      */

   931     public void entityReference(String name) throws org.xml.sax.SAXException

   932     {

   933 

   934         flushPending();

   935 

   936         startEntity(name);

   937         endEntity(name);

   938 

   939         if (m_tracer != null)

   940                     fireEntityReference(name);

   941     }

   942 

   943     /**

   944      * Sets the transformer associated with this serializer

   945      * @param t the transformer associated with this serializer.

   946      * @see SerializationHandler#setTransformer(Transformer)

   947      */

   948     public void setTransformer(Transformer t)

   949     {

   950         m_transformer = t;

   951 

   952         // If this transformer object implements the SerializerTrace interface

   953         // then assign m_tracer to the transformer object so it can be used

   954         // to fire trace events.

   955         if ((m_transformer instanceof SerializerTrace) &&

   956             (((SerializerTrace) m_transformer).hasTraceListeners())) {

   957            m_tracer = (SerializerTrace) m_transformer;

   958         } else {

   959            m_tracer = null;

   960         }

   961     }

   962     /**

   963      * Gets the transformer associated with this serializer

   964      * @return returns the transformer associated with this serializer.

   965      * @see SerializationHandler#getTransformer()

   966      */

   967     public Transformer getTransformer()

   968     {

   969         return m_transformer;

   970     }

   971 

   972     /**

   973      * This method gets the nodes value as a String and uses that String as if

   974      * it were an input character notification.

   975      * @param node the Node to serialize

   976      * @throws org.xml.sax.SAXException

   977      */

   978     public void characters(org.w3c.dom.Node node)

   979         throws org.xml.sax.SAXException

   980     {

   981         flushPending();

   982         String data = node.getNodeValue();

   983         if (data != null)

   984         {

   985             final int length = data.length();

   986             if (length > m_charsBuff.length)

   987             {

   988                 m_charsBuff = new char[length * 2 + 1];

   989             }

   990             data.getChars(0, length, m_charsBuff, 0);

   991             characters(m_charsBuff, 0, length);

   992         }

   993     }

   994 

   995 

   996     /**

   997      * @see org.xml.sax.ErrorHandler#error(SAXParseException)

   998      */

   999     public void error(SAXParseException exc) throws SAXException {

  1000     }

  1001 

  1002     /**

  1003      * @see org.xml.sax.ErrorHandler#fatalError(SAXParseException)

  1004      */

  1005     public void fatalError(SAXParseException exc) throws SAXException {

  1006 

  1007       m_elemContext.m_startTagOpen = false;

  1008 

  1009     }

  1010 

  1011     /**

  1012      * @see org.xml.sax.ErrorHandler#warning(SAXParseException)

  1013      */

  1014     public void warning(SAXParseException exc) throws SAXException

  1015     {

  1016     }

  1017 

  1018     /**

  1019      * To fire off start entity trace event

  1020      * @param name Name of entity

  1021      */

  1022     protected void fireStartEntity(String name)

  1023         throws org.xml.sax.SAXException

  1024     {

  1025         if (m_tracer != null)

  1026         {

  1027             flushMyWriter();

  1028             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENTITYREF, name);

  1029         }

  1030     }

  1031 

  1032     /**

  1033      * Report the characters event

  1034      * @param chars  content of characters

  1035      * @param start  starting index of characters to output

  1036      * @param length  number of characters to output

  1037      */

  1038 //    protected void fireCharEvent(char[] chars, int start, int length)

  1039 //        throws org.xml.sax.SAXException

  1040 //    {

  1041 //        if (m_tracer != null)

  1042 //            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CHARACTERS, chars, start,length);

  1043 //    }

  1044 //

  1045 

  1046     /**

  1047      * This method is only used internally when flushing the writer from the

  1048      * various fire...() trace events.  Due to the writer being wrapped with

  1049      * SerializerTraceWriter it may cause the flush of these trace events:

  1050      * EVENTTYPE_OUTPUT_PSEUDO_CHARACTERS

  1051      * EVENTTYPE_OUTPUT_CHARACTERS

  1052      * which trace the output written to the output stream.

  1053      *

  1054      */

  1055     private void flushMyWriter()

  1056     {

  1057         if (m_writer != null)

  1058         {

  1059             try

  1060             {

  1061                 m_writer.flush();

  1062             }

  1063             catch(IOException ioe)

  1064             {

  1065 

  1066             }

  1067         }

  1068     }

  1069     /**

  1070      * Report the CDATA trace event

  1071      * @param chars  content of CDATA

  1072      * @param start  starting index of characters to output

  1073      * @param length  number of characters to output

  1074      */

  1075     protected void fireCDATAEvent(char[] chars, int start, int length)

  1076         throws org.xml.sax.SAXException

  1077     {

  1078                 if (m_tracer != null)

  1079         {

  1080             flushMyWriter();

  1081                         m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CDATA, chars, start,length);

  1082         }

  1083     }

  1084 

  1085     /**

  1086      * Report the comment trace event

  1087      * @param chars  content of comment

  1088      * @param start  starting index of comment to output

  1089      * @param length  number of characters to output

  1090      */

  1091     protected void fireCommentEvent(char[] chars, int start, int length)

  1092         throws org.xml.sax.SAXException

  1093     {

  1094                 if (m_tracer != null)

  1095         {

  1096             flushMyWriter();

  1097                         m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_COMMENT, new String(chars, start, length));

  1098         }

  1099     }

  1100 

  1101 

  1102     /**

  1103      * To fire off end entity trace event

  1104      * @param name Name of entity

  1105      */

  1106     public void fireEndEntity(String name)

  1107         throws org.xml.sax.SAXException

  1108     {

  1109         if (m_tracer != null)

  1110             flushMyWriter();

  1111         // we do not need to handle this.

  1112     }

  1113 

  1114     /**

  1115      * To fire off start document trace  event

  1116      */

  1117      protected void fireStartDoc()

  1118         throws org.xml.sax.SAXException

  1119     {

  1120         if (m_tracer != null)

  1121         {

  1122             flushMyWriter();

  1123             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_STARTDOCUMENT);

  1124         }

  1125     }

  1126 

  1127 

  1128     /**

  1129      * To fire off end document trace event

  1130      */

  1131     protected void fireEndDoc()

  1132         throws org.xml.sax.SAXException

  1133     {

  1134         if (m_tracer != null)