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      * Determine if the output is a standalone.
 147      */
 148     protected boolean m_isStandalone = false;
 149 
 150     /**
 151      * Flag to tell if indenting (pretty-printing) is on.
 152      */
 153     protected boolean m_doIndent = false;
 154     /**
 155      * Amount to indent.
 156      */
 157     protected int m_indentAmount = 0;
 158 
 159     /**
 160      * Tells the XML version, for writing out to the XML decl.
 161      */
 162     private String m_version = null;
 163 
 164     /**
 165      * The mediatype.  Not used right now.
 166      */
 167     private String m_mediatype;
 168 
 169     /**
 170      * The transformer that was around when this output handler was created (if
 171      * any).
 172      */
 173     private Transformer m_transformer;
 174 
 175     /**
 176      * Pairs of local names and corresponding URIs of CDATA sections. This list
 177      * comes from the cdata-section-elements attribute. Every second one is a
 178      * local name, and every other second one is the URI for the local name.
 179      */
 180     protected Vector m_cdataSectionElements = null;
 181 
 182     /**
 183      * Namespace support, that keeps track of currently defined
 184      * prefix/uri mappings. As processed elements come and go, so do
 185      * the associated mappings for that element.
 186      */
 187     protected NamespaceMappings m_prefixMap;
 188 
 189     /**
 190      * Handle for firing generate events.  This interface may be implemented
 191      * by the referenced transformer object.
 192      */
 193     protected SerializerTrace m_tracer;
 194 
 195     protected SourceLocator m_sourceLocator;
 196 
 197 
 198     /**
 199      * The writer to send output to. This field is only used in the ToStream
 200      * serializers, but exists here just so that the fireStartDoc() and
 201      * other fire... methods can flush this writer when tracing.
 202      */
 203     protected java.io.Writer m_writer = null;
 204 
 205     /**
 206      * A reference to "stack frame" corresponding to
 207      * the current element. Such a frame is pushed at a startElement()
 208      * and popped at an endElement(). This frame contains information about
 209      * the element, such as its namespace URI.
 210      */
 211     protected ElemContext m_elemContext = new ElemContext();
 212 
 213     /**
 214      * A utility buffer for converting Strings passed to
 215      * character() methods to character arrays.
 216      * Reusing this buffer means not creating a new character array
 217      * everytime and it runs faster.
 218      */
 219     protected char[] m_charsBuff = new char[60];
 220 
 221     /**
 222      * A utility buffer for converting Strings passed to
 223      * attribute methods to character arrays.
 224      * Reusing this buffer means not creating a new character array
 225      * everytime and it runs faster.
 226      */
 227     protected char[] m_attrBuff = new char[30];
 228 
 229     private Locator m_locator = null;
 230 
 231     protected boolean m_needToCallSetDocumentInfo = true;
 232 
 233     /**
 234      * Receive notification of a comment.
 235      *
 236      * @see ExtendedLexicalHandler#comment(String)
 237      */
 238     public void comment(String data) throws SAXException
 239     {
 240         final int length = data.length();
 241         if (length > m_charsBuff.length)
 242         {
 243             m_charsBuff = new char[length * 2 + 1];
 244         }
 245         data.getChars(0, length, m_charsBuff, 0);
 246         comment(m_charsBuff, 0, length);
 247     }
 248 
 249     /**
 250      * If at runtime, when the qname of the attribute is
 251      * known, another prefix is specified for the attribute, then we can
 252      * patch or hack the name with this method. For
 253      * a qname of the form "ns?:otherprefix:name", this function patches the
 254      * qname by simply ignoring "otherprefix".
 255      * TODO: This method is a HACK! We do not have access to the
 256      * XML file, it sometimes generates a NS prefix of the form "ns?" for
 257      * an attribute.
 258      */
 259     protected String patchName(String qname)
 260     {
 261 
 262 
 263         final int lastColon = qname.lastIndexOf(':');
 264 
 265         if (lastColon > 0) {
 266             final int firstColon = qname.indexOf(':');
 267             final String prefix = qname.substring(0, firstColon);
 268             final String localName = qname.substring(lastColon + 1);
 269 
 270         // If uri is "" then ignore prefix
 271             final String uri = m_prefixMap.lookupNamespace(prefix);
 272             if (uri != null && uri.length() == 0) {
 273                 return localName;
 274             }
 275             else if (firstColon != lastColon) {
 276                 return prefix + ':' + localName;
 277             }
 278         }
 279         return qname;
 280     }
 281 
 282     /**
 283      * Returns the local name of a qualified name. If the name has no prefix,
 284      * then it works as the identity (SAX2).
 285      * @param qname the qualified name
 286      * @return the name, but excluding any prefix and colon.
 287      */
 288     protected static String getLocalName(String qname)
 289     {
 290         final int col = qname.lastIndexOf(':');
 291         return (col > 0) ? qname.substring(col + 1) : qname;
 292     }
 293 
 294     /**
 295      * Receive an object for locating the origin of SAX document events.
 296      *
 297      * @param locator An object that can return the location of any SAX document
 298      * event.
 299      *
 300      * Receive an object for locating the origin of SAX document events.
 301      *
 302      * <p>SAX parsers are strongly encouraged (though not absolutely
 303      * required) to supply a locator: if it does so, it must supply
 304      * the locator to the application by invoking this method before
 305      * invoking any of the other methods in the DocumentHandler
 306      * interface.</p>
 307      *
 308      * <p>The locator allows the application to determine the end
 309      * position of any document-related event, even if the parser is
 310      * not reporting an error.  Typically, the application will
 311      * use this information for reporting its own errors (such as
 312      * character content that does not match an application's
 313      * business rules).  The information returned by the locator
 314      * is probably not sufficient for use with a search engine.</p>
 315      *
 316      * <p>Note that the locator will return correct information only
 317      * during the invocation of the events in this interface.  The
 318      * application should not attempt to use it at any other time.</p>
 319      */
 320     public void setDocumentLocator(Locator locator)
 321     {
 322         m_locator = locator;
 323     }
 324 
 325     /**
 326      * Adds the given attribute to the set of collected attributes , but only if
 327      * there is a currently open element.
 328      *
 329      * An element is currently open if a startElement() notification has
 330      * occured but the start of the element has not yet been written to the
 331      * output.  In the stream case this means that we have not yet been forced
 332      * to close the elements opening tag by another notification, such as a
 333      * character notification.
 334      *
 335      * @param uri the URI of the attribute
 336      * @param localName the local name of the attribute
 337      * @param rawName    the qualified name of the attribute
 338      * @param type the type of the attribute (probably CDATA)
 339      * @param value the value of the attribute
 340      * @param XSLAttribute true if this attribute is coming from an xsl:attriute element
 341      * @see ExtendedContentHandler#addAttribute(String, String, String, String, String)
 342      */
 343     public void addAttribute(
 344         String uri,
 345         String localName,
 346         String rawName,
 347         String type,
 348         String value,
 349         boolean XSLAttribute)
 350         throws SAXException
 351     {
 352         if (m_elemContext.m_startTagOpen)
 353         {
 354             addAttributeAlways(uri, localName, rawName, type, value, XSLAttribute);
 355         }
 356 
 357     }
 358 
 359     /**
 360      * Adds the given attribute to the set of attributes, even if there is
 361      * no currently open element. This is useful if a SAX startPrefixMapping()
 362      * should need to add an attribute before the element name is seen.
 363      *
 364      * @param uri the URI of the attribute
 365      * @param localName the local name of the attribute
 366      * @param rawName   the qualified name of the attribute
 367      * @param type the type of the attribute (probably CDATA)
 368      * @param value the value of the attribute
 369      * @param XSLAttribute true if this attribute is coming from an xsl:attribute element
 370      * @return true if the attribute was added,
 371      * false if an existing value was replaced.
 372      */
 373     public boolean addAttributeAlways(
 374         String uri,
 375         String localName,
 376         String rawName,
 377         String type,
 378         String value,
 379         boolean XSLAttribute)
 380     {
 381         boolean was_added;
 382 //            final int index =
 383 //                (localName == null || uri == null) ?
 384 //                m_attributes.getIndex(rawName):m_attributes.getIndex(uri, localName);
 385             int index;
 386 //            if (localName == null || uri == null){
 387 //                index = m_attributes.getIndex(rawName);
 388 //            }
 389 //            else {
 390 //                index = m_attributes.getIndex(uri, localName);
 391 //            }
 392 
 393             if (localName == null || uri == null || uri.length() == 0)
 394                 index = m_attributes.getIndex(rawName);
 395             else {
 396                 index = m_attributes.getIndex(uri,localName);
 397             }
 398             if (index >= 0)
 399             {
 400                 /* We've seen the attribute before.
 401                  * We may have a null uri or localName, but all
 402                  * we really want to re-set is the value anyway.
 403                  */
 404                 m_attributes.setValue(index,value);
 405                 was_added = false;
 406             }
 407             else
 408             {
 409                 // the attribute doesn't exist yet, create it
 410                 m_attributes.addAttribute(uri, localName, rawName, type, value);
 411                 was_added = true;
 412             }
 413             return was_added;
 414 
 415     }
 416 
 417 
 418     /**
 419      *  Adds  the given attribute to the set of collected attributes,
 420      * but only if there is a currently open element.
 421      *
 422      * @param name the attribute's qualified name
 423      * @param value the value of the attribute
 424      */
 425     public void addAttribute(String name, final String value)
 426     {
 427         if (m_elemContext.m_startTagOpen)
 428         {
 429             final String patchedName = patchName(name);
 430             final String localName = getLocalName(patchedName);
 431             final String uri = getNamespaceURI(patchedName, false);
 432 
 433             addAttributeAlways(uri,localName, patchedName, "CDATA", value, false);
 434          }
 435     }
 436 
 437     /**
 438      * Adds the given xsl:attribute to the set of collected attributes,
 439      * but only if there is a currently open element.
 440      *
 441      * @param name the attribute's qualified name (prefix:localName)
 442      * @param value the value of the attribute
 443      * @param uri the URI that the prefix of the name points to
 444      */
 445     public void addXSLAttribute(String name, final String value, final String uri)
 446     {
 447         if (m_elemContext.m_startTagOpen)
 448         {
 449             final String patchedName = patchName(name);
 450             final String localName = getLocalName(patchedName);
 451 
 452             addAttributeAlways(uri,localName, patchedName, "CDATA", value, true);
 453          }
 454     }
 455 
 456     /**
 457      * Add the given attributes to the currently collected ones. These
 458      * attributes are always added, regardless of whether on not an element
 459      * is currently open.
 460      * @param atts List of attributes to add to this list
 461      */
 462     public void addAttributes(Attributes atts) throws SAXException
 463     {
 464 
 465         int nAtts = atts.getLength();
 466         for (int i = 0; i < nAtts; i++)
 467         {
 468             String uri = atts.getURI(i);
 469 
 470             if (null == uri)
 471                 uri = "";
 472 
 473             addAttributeAlways(
 474                 uri,
 475                 atts.getLocalName(i),
 476                 atts.getQName(i),
 477                 atts.getType(i),
 478                 atts.getValue(i),
 479                 false);
 480 
 481         }
 482     }
 483 
 484     /**
 485      * Return a {@link ContentHandler} interface into this serializer.
 486      * If the serializer does not support the {@link ContentHandler}
 487      * interface, it should return null.
 488      *
 489      * @return A {@link ContentHandler} interface into this serializer,
 490      *  or null if the serializer is not SAX 2 capable
 491      * @throws IOException An I/O exception occured
 492      */
 493     public ContentHandler asContentHandler() throws IOException
 494     {
 495         return this;
 496     }
 497 
 498     /**
 499      * Report the end of an entity.
 500      *
 501      * @param name The name of the entity that is ending.
 502      * @throws org.xml.sax.SAXException The application may raise an exception.
 503      * @see #startEntity
 504      */
 505     public void endEntity(String name) throws org.xml.sax.SAXException
 506     {
 507         if (name.equals("[dtd]"))
 508             m_inExternalDTD = false;
 509         m_inEntityRef = false;
 510 
 511         if (m_tracer != null)
 512             this.fireEndEntity(name);
 513     }
 514 
 515     /**
 516      * Flush and close the underlying java.io.Writer. This method applies to
 517      * ToStream serializers, not ToSAXHandler serializers.
 518      * @see ToStream
 519      */
 520     public void close()
 521     {
 522         // do nothing (base behavior)
 523     }
 524 
 525     /**
 526      * Initialize global variables
 527      */
 528     protected void initCDATA()
 529     {
 530         // CDATA stack
 531         //        _cdataStack = new Stack();
 532         //        _cdataStack.push(new Integer(-1)); // push dummy value
 533     }
 534 
 535     /**
 536      * Returns the character encoding to be used in the output document.
 537      * @return the character encoding to be used in the output document.
 538      */
 539     public String getEncoding()
 540     {
 541         return m_encoding;
 542     }
 543 
 544    /**
 545      * Sets the character encoding coming from the xsl:output encoding stylesheet attribute.
 546      * @param m_encoding the character encoding
 547      */
 548     public void setEncoding(String m_encoding)
 549     {
 550         this.m_encoding = m_encoding;
 551     }
 552 
 553     /**
 554      * Sets the value coming from the xsl:output omit-xml-declaration stylesheet attribute
 555      * @param b true if the XML declaration is to be omitted from the output
 556      * document.
 557      */
 558     public void setOmitXMLDeclaration(boolean b)
 559     {
 560         this.m_shouldNotWriteXMLHeader = b;

 561     }
 562 
 563 
 564     /**
 565      * @return true if the XML declaration is to be omitted from the output
 566      * document.
 567      */
 568     public boolean getOmitXMLDeclaration()
 569     {
 570         return m_shouldNotWriteXMLHeader;
 571     }
 572 
 573     /**
 574      * Returns the previously set value of the value to be used as the public
 575      * identifier in the document type declaration (DTD).
 576      *
 577      *@return the public identifier to be used in the DOCTYPE declaration in the
 578      * output document.
 579      */
 580     public String getDoctypePublic()
 581     {
 582         return m_doctypePublic;
 583     }
 584 
 585     /** Set the value coming from the xsl:output doctype-public stylesheet attribute.
 586       * @param doctypePublic the public identifier to be used in the DOCTYPE
 587       * declaration in the output document.
 588       */
 589     public void setDoctypePublic(String doctypePublic)
 590     {
 591         this.m_doctypePublic = doctypePublic;
 592     }
 593 
 594 
 595     /**
 596      * Returns the previously set value of the value to be used
 597      * as the system identifier in the document type declaration (DTD).
 598          * @return the system identifier to be used in the DOCTYPE declaration in
 599          * the output document.
 600      *
 601      */
 602     public String getDoctypeSystem()
 603     {
 604         return m_doctypeSystem;
 605     }
 606 
 607     /** Set the value coming from the xsl:output doctype-system stylesheet attribute.
 608       * @param doctypeSystem the system identifier to be used in the DOCTYPE
 609       * declaration in the output document.
 610       */
 611     public void setDoctypeSystem(String doctypeSystem)
 612     {
 613         this.m_doctypeSystem = doctypeSystem;
 614     }
 615 
 616     /** Set the value coming from the xsl:output doctype-public and doctype-system stylesheet properties
 617      * @param doctypeSystem the system identifier to be used in the DOCTYPE
 618      * declaration in the output document.
 619      * @param doctypePublic the public identifier to be used in the DOCTYPE
 620      * declaration in the output document.
 621      */
 622     public void setDoctype(String doctypeSystem, String doctypePublic)
 623     {
 624         this.m_doctypeSystem = doctypeSystem;
 625         this.m_doctypePublic = doctypePublic;
 626     }
 627 
 628     /**
 629      * Sets the value coming from the xsl:output standalone stylesheet attribute.
 630      * @param standalone a value of "yes" indicates that the
 631      * <code>standalone</code> delaration is to be included in the output
 632      * document. This method remembers if the value was explicitly set using
 633      * this method, verses if the value is the default value.
 634      */
 635     public void setStandalone(String standalone)
 636     {
 637         if (standalone != null)
 638         {
 639             m_standaloneWasSpecified = true;
 640             setStandaloneInternal(standalone);
 641         }
 642     }

 643     /**
 644      * Sets the XSL standalone attribute, but does not remember if this is a
 645      * default or explicite setting.
 646      * @param standalone "yes" | "no"
 647      */
 648     protected void setStandaloneInternal(String standalone)
 649     {
 650         if ("yes".equals(standalone))
 651             m_standalone = "yes";
 652         else
 653             m_standalone = "no";
 654 
 655     }
 656 
 657     /**
 658      * Gets the XSL standalone attribute
 659      * @return a value of "yes" if the <code>standalone</code> delaration is to
 660      * be included in the output document.
 661      *  @see XSLOutputAttributes#getStandalone()
 662      */
 663     public String getStandalone()
 664     {
 665         return m_standalone;
 666     }
 667 
 668     /**
 669      * @return true if the output document should be indented to visually
 670      * indicate its structure.
 671      */
 672     public boolean getIndent()
 673     {
 674         return m_doIndent;
 675     }
 676     /**
 677      * Gets the mediatype the media-type or MIME type associated with the output
 678      * document.
 679      * @return the mediatype the media-type or MIME type associated with the
 680      * output document.
 681      */
 682     public String getMediaType()
 683     {
 684         return m_mediatype;
 685     }
 686 
 687     /**
 688      * Gets the version of the output format.
 689      * @return the version of the output format.
 690      */
 691     public String getVersion()
 692     {
 693         return m_version;
 694     }
 695 
 696     /**
 697      * Sets the value coming from the xsl:output version attribute.
 698      * @param version the version of the output format.
 699      * @see SerializationHandler#setVersion(String)
 700      */
 701     public void setVersion(String version)
 702     {
 703         m_version = version;
 704     }
 705 
 706     /**
 707      * Sets the value coming from the xsl:output media-type stylesheet attribute.
 708      * @param mediaType the non-null media-type or MIME type associated with the
 709      * output document.
 710      * @see javax.xml.transform.OutputKeys#MEDIA_TYPE
 711      * @see SerializationHandler#setMediaType(String)
 712      */
 713     public void setMediaType(String mediaType)
 714     {
 715         m_mediatype = mediaType;
 716     }
 717 
 718     /**
 719      * @return the number of spaces to indent for each indentation level.
 720      */
 721     public int getIndentAmount()
 722     {
 723         return m_indentAmount;
 724     }
 725 
 726     /**
 727      * Sets the indentation amount.
 728      * @param m_indentAmount The m_indentAmount to set
 729      */
 730     public void setIndentAmount(int m_indentAmount)
 731     {
 732         this.m_indentAmount = m_indentAmount;
 733     }
 734 
 735     /**
 736      * Sets the value coming from the xsl:output indent stylesheet
 737      * attribute.
 738      * @param doIndent true if the output document should be indented to
 739      * visually indicate its structure.
 740      * @see XSLOutputAttributes#setIndent(boolean)
 741      */
 742     public void setIndent(boolean doIndent)
 743     {
 744         m_doIndent = doIndent;

 745     }
 746 
 747     /**
 748      * Sets the isStandalone property
 749      * @param isStandalone true if the ORACLE_IS_STANDALONE is set to yes
 750      * @see OutputPropertiesFactory ORACLE_IS_STANDALONE
 751      */
 752     public void setIsStandalone(boolean isStandalone)
 753     {
 754        m_isStandalone = isStandalone;
 755     }
 756 
 757     /**
 758      * This method is used when a prefix/uri namespace mapping
 759      * is indicated after the element was started with a
 760      * startElement() and before and endElement().
 761      * startPrefixMapping(prefix,uri) would be used before the
 762      * startElement() call.
 763      * @param uri the URI of the namespace
 764      * @param prefix the prefix associated with the given URI.
 765      *
 766      * @see ExtendedContentHandler#namespaceAfterStartElement(String, String)
 767      */
 768     public void namespaceAfterStartElement(String uri, String prefix)
 769         throws SAXException
 770     {
 771         // default behavior is to do nothing
 772     }
 773 
 774     /**
 775      * Return a {@link DOMSerializer} interface into this serializer. If the
 776      * serializer does not support the {@link DOMSerializer} interface, it should
 777      * return null.
 778      *
 779      * @return A {@link DOMSerializer} interface into this serializer,  or null
 780      * if the serializer is not DOM capable
 781      * @throws IOException An I/O exception occured
 782      * @see Serializer#asDOMSerializer()
 783      */
 784     public DOMSerializer asDOMSerializer() throws IOException
 785     {
 786         return this;
 787     }
 788 
 789     /**
 790      * Push a boolean state based on if the name of the current element
 791      * is found in the list of qnames.  A state is only pushed if
 792      * there were some cdata-section-names were specified.
 793      * <p>
 794      * Hidden parameters are the vector of qualified elements specified in
 795      * cdata-section-names attribute, and the m_cdataSectionStates stack
 796      * onto which whether the current element is in the list is pushed (true or
 797      * false). Other hidden parameters are the current elements namespaceURI,
 798      * localName and qName
 799      */
 800     protected boolean isCdataSection()
 801     {
 802 
 803         boolean b = false;
 804 
 805         if (null != m_cdataSectionElements)
 806         {
 807             if (m_elemContext.m_elementLocalName == null)
 808                 m_elemContext.m_elementLocalName =
 809                     getLocalName(m_elemContext.m_elementName);
 810             if (m_elemContext.m_elementURI == null)
 811             {
 812                 String prefix = getPrefixPart(m_elemContext.m_elementName);
 813                 if (prefix != null)
 814                     m_elemContext.m_elementURI =
 815                         m_prefixMap.lookupNamespace(prefix);
 816 
 817             }
 818 
 819             if ((null != m_elemContext.m_elementURI)
 820                 && m_elemContext.m_elementURI.length() == 0)
 821                 m_elemContext.m_elementURI = null;
 822 
 823             int nElems = m_cdataSectionElements.size();
 824 
 825             // loop through 2 at a time, as these are pairs of URI and localName
 826             for (int i = 0; i < nElems; i += 2)
 827             {
 828                 String uri = (String) m_cdataSectionElements.elementAt(i);
 829                 String loc = (String) m_cdataSectionElements.elementAt(i + 1);
 830                 if (loc.equals(m_elemContext.m_elementLocalName)
 831                     && subPartMatch(m_elemContext.m_elementURI, uri))
 832                 {
 833                     b = true;
 834 
 835                     break;
 836                 }
 837             }
 838         }
 839         return b;
 840     }
 841 
 842     /**
 843      * Tell if two strings are equal, without worry if the first string is null.
 844      *
 845      * @param p String reference, which may be null.
 846      * @param t String reference, which may be null.
 847      *
 848      * @return true if strings are equal.
 849      */
 850     private static final boolean subPartMatch(String p, String t)
 851     {
 852         return (p == t) || ((null != p) && (p.equals(t)));
 853     }
 854 
 855     /**
 856      * Returns the local name of a qualified name.
 857      * If the name has no prefix,
 858      * then it works as the identity (SAX2).
 859      *
 860      * @param qname a qualified name
 861      * @return returns the prefix of the qualified name,
 862      * or null if there is no prefix.
 863      */
 864     protected static final String getPrefixPart(String qname)
 865     {
 866         final int col = qname.indexOf(':');
 867         return (col > 0) ? qname.substring(0, col) : null;
 868         //return (col > 0) ? qname.substring(0,col) : "";
 869     }
 870 
 871     /**
 872      * Some users of the serializer may need the current namespace mappings
 873      * @return the current namespace mappings (prefix/uri)
 874      * @see ExtendedContentHandler#getNamespaceMappings()
 875      */
 876     public NamespaceMappings getNamespaceMappings()
 877     {
 878         return m_prefixMap;
 879     }
 880 
 881     /**
 882      * Returns the prefix currently pointing to the given URI (if any).
 883      * @param namespaceURI the uri of the namespace in question
 884      * @return a prefix pointing to the given URI (if any).
 885      * @see ExtendedContentHandler#getPrefix(String)
 886      */
 887     public String getPrefix(String namespaceURI)
 888     {
 889         String prefix = m_prefixMap.lookupPrefix(namespaceURI);
 890         return prefix;
 891     }
 892 
 893     /**
 894      * Returns the URI of an element or attribute. Note that default namespaces
 895      * do not apply directly to attributes.
 896      * @param qname a qualified name
 897      * @param isElement true if the qualified name is the name of
 898      * an element.
 899      * @return returns the namespace URI associated with the qualified name.
 900      */
 901     public String getNamespaceURI(String qname, boolean isElement)
 902     {
 903         String uri = EMPTYSTRING;
 904         int col = qname.lastIndexOf(':');
 905         final String prefix = (col > 0) ? qname.substring(0, col) : EMPTYSTRING;
 906 
 907         if (!EMPTYSTRING.equals(prefix) || isElement)
 908         {
 909             if (m_prefixMap != null)
 910             {
 911                 uri = m_prefixMap.lookupNamespace(prefix);
 912                 if (uri == null && !prefix.equals(XMLNS_PREFIX))
 913                 {
 914                     throw new RuntimeException(
 915                         Utils.messages.createMessage(
 916                             MsgKey.ER_NAMESPACE_PREFIX,
 917                             new Object[] { qname.substring(0, col) }  ));
 918                 }
 919             }
 920         }
 921         return uri;
 922     }
 923 
 924     /**
 925      * Returns the URI of prefix (if any)
 926      *
 927          * @param prefix the prefix whose URI is searched for
 928      * @return the namespace URI currently associated with the
 929      * prefix, null if the prefix is undefined.
 930      */
 931     public String getNamespaceURIFromPrefix(String prefix)
 932     {
 933         String uri = null;
 934         if (m_prefixMap != null)
 935             uri = m_prefixMap.lookupNamespace(prefix);
 936         return uri;
 937     }
 938 
 939     /**
 940      * Entity reference event.
 941      *
 942      * @param name Name of entity
 943      *
 944      * @throws org.xml.sax.SAXException
 945      */
 946     public void entityReference(String name) throws org.xml.sax.SAXException
 947     {
 948 
 949         flushPending();
 950 
 951         startEntity(name);
 952         endEntity(name);
 953 
 954         if (m_tracer != null)
 955                     fireEntityReference(name);
 956     }
 957 
 958     /**
 959      * Sets the transformer associated with this serializer
 960      * @param t the transformer associated with this serializer.
 961      * @see SerializationHandler#setTransformer(Transformer)
 962      */
 963     public void setTransformer(Transformer t)
 964     {
 965         m_transformer = t;
 966 
 967         // If this transformer object implements the SerializerTrace interface
 968         // then assign m_tracer to the transformer object so it can be used
 969         // to fire trace events.
 970         if ((m_transformer instanceof SerializerTrace) &&
 971             (((SerializerTrace) m_transformer).hasTraceListeners())) {
 972            m_tracer = (SerializerTrace) m_transformer;
 973         } else {
 974            m_tracer = null;
 975         }
 976     }
 977     /**
 978      * Gets the transformer associated with this serializer
 979      * @return returns the transformer associated with this serializer.
 980      * @see SerializationHandler#getTransformer()
 981      */
 982     public Transformer getTransformer()
 983     {
 984         return m_transformer;
 985     }
 986 
 987     /**
 988      * This method gets the nodes value as a String and uses that String as if
 989      * it were an input character notification.
 990      * @param node the Node to serialize
 991      * @throws org.xml.sax.SAXException
 992      */
 993     public void characters(org.w3c.dom.Node node)
 994         throws org.xml.sax.SAXException
 995     {
 996         flushPending();
 997         String data = node.getNodeValue();
 998         if (data != null)
 999         {
1000             final int length = data.length();
1001             if (length > m_charsBuff.length)
1002             {
1003                 m_charsBuff = new char[length * 2 + 1];
1004             }
1005             data.getChars(0, length, m_charsBuff, 0);
1006             characters(m_charsBuff, 0, length);
1007         }
1008     }
1009 
1010 
1011     /**
1012      * @see org.xml.sax.ErrorHandler#error(SAXParseException)
1013      */
1014     public void error(SAXParseException exc) throws SAXException {
1015     }
1016 
1017     /**
1018      * @see org.xml.sax.ErrorHandler#fatalError(SAXParseException)
1019      */
1020     public void fatalError(SAXParseException exc) throws SAXException {
1021 
1022       m_elemContext.m_startTagOpen = false;
1023 
1024     }
1025 
1026     /**
1027      * @see org.xml.sax.ErrorHandler#warning(SAXParseException)
1028      */
1029     public void warning(SAXParseException exc) throws SAXException
1030     {
1031     }
1032 
1033     /**
1034      * To fire off start entity trace event
1035      * @param name Name of entity
1036      */
1037     protected void fireStartEntity(String name)
1038         throws org.xml.sax.SAXException
1039     {
1040         if (m_tracer != null)
1041         {
1042             flushMyWriter();
1043             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENTITYREF, name);
1044         }
1045     }
1046 
1047     /**
1048      * Report the characters event
1049      * @param chars  content of characters
1050      * @param start  starting index of characters to output
1051      * @param length  number of characters to output
1052      */
1053 //    protected void fireCharEvent(char[] chars, int start, int length)
1054 //        throws org.xml.sax.SAXException
1055 //    {
1056 //        if (m_tracer != null)
1057 //            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CHARACTERS, chars, start,length);
1058 //    }
1059 //
1060 
1061     /**
1062      * This method is only used internally when flushing the writer from the
1063      * various fire...() trace events.  Due to the writer being wrapped with
1064      * SerializerTraceWriter it may cause the flush of these trace events:
1065      * EVENTTYPE_OUTPUT_PSEUDO_CHARACTERS
1066      * EVENTTYPE_OUTPUT_CHARACTERS
1067      * which trace the output written to the output stream.
1068      *
1069      */
1070     private void flushMyWriter()
1071     {
1072         if (m_writer != null)
1073         {
1074             try
1075             {
1076                 m_writer.flush();
1077             }
1078             catch(IOException ioe)
1079             {
1080 
1081             }
1082         }
1083     }
1084     /**
1085      * Report the CDATA trace event
1086      * @param chars  content of CDATA
1087      * @param start  starting index of characters to output
1088      * @param length  number of characters to output
1089      */
1090     protected void fireCDATAEvent(char[] chars, int start, int length)
1091         throws org.xml.sax.SAXException
1092     {
1093                 if (m_tracer != null)
1094         {
1095             flushMyWriter();
1096                         m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_CDATA, chars, start,length);
1097         }
1098     }
1099 
1100     /**
1101      * Report the comment trace event
1102      * @param chars  content of comment
1103      * @param start  starting index of comment to output
1104      * @param length  number of characters to output
1105      */
1106     protected void fireCommentEvent(char[] chars, int start, int length)
1107         throws org.xml.sax.SAXException
1108     {
1109                 if (m_tracer != null)
1110         {
1111             flushMyWriter();
1112                         m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_COMMENT, new String(chars, start, length));
1113         }
1114     }
1115 
1116 
1117     /**
1118      * To fire off end entity trace event
1119      * @param name Name of entity
1120      */
1121     public void fireEndEntity(String name)
1122         throws org.xml.sax.SAXException
1123     {
1124         if (m_tracer != null)
1125             flushMyWriter();
1126         // we do not need to handle this.
1127     }
1128 
1129     /**
1130      * To fire off start document trace  event
1131      */
1132      protected void fireStartDoc()
1133         throws org.xml.sax.SAXException
1134     {
1135         if (m_tracer != null)
1136         {
1137             flushMyWriter();
1138             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_STARTDOCUMENT);
1139         }
1140     }
1141 
1142 
1143     /**
1144      * To fire off end document trace event
1145      */
1146     protected void fireEndDoc()
1147         throws org.xml.sax.SAXException
1148     {
1149         if (m_tracer != null)
1150         {
1151             flushMyWriter();
1152             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDDOCUMENT);
1153         }
1154     }
1155 
1156     /**
1157      * Report the start element trace event. This trace method needs to be
1158      * called just before the attributes are cleared.
1159      *
1160      * @param elemName the qualified name of the element
1161      *
1162      */
1163     protected void fireStartElem(String elemName)
1164         throws org.xml.sax.SAXException
1165     {
1166         if (m_tracer != null)
1167         {
1168             flushMyWriter();
1169             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_STARTELEMENT,
1170                 elemName, m_attributes);
1171         }
1172     }
1173 
1174 
1175     /**
1176      * To fire off the end element event
1177      * @param name Name of element
1178      */
1179 //    protected void fireEndElem(String name)
1180 //        throws org.xml.sax.SAXException
1181 //    {
1182 //        if (m_tracer != null)
1183 //            m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENDELEMENT,name, (Attributes)null);
1184 //    }
1185 
1186 
1187     /**
1188      * To fire off the PI trace event
1189      * @param name Name of PI
1190      */
1191     protected void fireEscapingEvent(String name, String data)
1192         throws org.xml.sax.SAXException
1193     {
1194 
1195         if (m_tracer != null)
1196         {
1197             flushMyWriter();
1198             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_PI,name, data);
1199         }
1200     }
1201 
1202 
1203     /**
1204      * To fire off the entity reference trace event
1205      * @param name Name of entity reference
1206      */
1207     protected void fireEntityReference(String name)
1208         throws org.xml.sax.SAXException
1209     {
1210         if (m_tracer != null)
1211         {
1212             flushMyWriter();
1213             m_tracer.fireGenerateEvent(SerializerTrace.EVENTTYPE_ENTITYREF,name, (Attributes)null);
1214         }
1215     }
1216 
1217     /**
1218      * Receive notification of the beginning of a document.
1219      * This method is never a self generated call,
1220      * but only called externally.
1221      *
1222      * <p>The SAX parser will invoke this method only once, before any
1223      * other methods in this interface or in DTDHandler (except for
1224      * setDocumentLocator).</p>
1225      *
1226      * @throws org.xml.sax.SAXException Any SAX exception, possibly
1227      *            wrapping another exception.
1228      *
1229      * @throws org.xml.sax.SAXException
1230      */
1231     public void startDocument() throws org.xml.sax.SAXException
1232     {
1233 
1234         // if we do get called with startDocument(), handle it right away
1235         startDocumentInternal();
1236         m_needToCallStartDocument = false;
1237         return;
1238     }
1239 
1240     /**
1241      * This method handles what needs to be done at a startDocument() call,
1242      * whether from an external caller, or internally called in the
1243      * serializer.  For historical reasons the serializer is flexible to
1244      * startDocument() not always being called.
1245      * Even if no external call is
1246      * made into startDocument() this method will always be called as a self
1247      * generated internal startDocument, it handles what needs to be done at a
1248      * startDocument() call.
1249      *
1250      * This method exists just to make sure that startDocument() is only ever
1251      * called from an external caller, which in principle is just a matter of
1252      * style.
1253      *
1254      * @throws SAXException
1255      */
1256     protected void startDocumentInternal() throws org.xml.sax.SAXException
1257     {
1258         if (m_tracer != null)
1259             this.fireStartDoc();
1260 
1261     }
1262 
1263     /* This method extracts version and encoding information from SAX events.
1264      */
1265     protected void setDocumentInfo() {
1266         if (m_locator == null)
1267                 return;
1268         try{
1269             String strVersion = ((Locator2)m_locator).getXMLVersion();
1270             if (strVersion != null)
1271                 setVersion(strVersion);
1272             /*String strEncoding = ((Locator2)m_locator).getEncoding();
1273             if (strEncoding != null)
1274                 setEncoding(strEncoding); */
1275 
1276         }catch(ClassCastException e){}
1277     }
1278 
1279     /**
1280      * This method is used to set the source locator, which might be used to
1281      * generated an error message.
1282      * @param locator the source locator
1283      *
1284      * @see ExtendedContentHandler#setSourceLocator(javax.xml.transform.SourceLocator)
1285      */
1286     public void setSourceLocator(SourceLocator locator)
1287     {
1288         m_sourceLocator = locator;
1289     }
1290 
1291 
1292     /**
1293      * Used only by TransformerSnapshotImpl to restore the serialization
1294      * to a previous state.
1295      *
1296      * @param mappings NamespaceMappings
1297      */
1298     public void setNamespaceMappings(NamespaceMappings mappings) {
1299         m_prefixMap = mappings;
1300     }
1301 
1302     public boolean reset()
1303     {
1304         resetSerializerBase();
1305         return true;
1306     }
1307 
1308     /**
1309      * Reset all of the fields owned by SerializerBase
1310      *
1311      */
1312     private void resetSerializerBase()
1313     {
1314         this.m_attributes.clear();
1315         this.m_cdataSectionElements = null;
1316         this.m_elemContext = new ElemContext();
1317         this.m_doctypePublic = null;
1318         this.m_doctypeSystem = null;
1319         this.m_doIndent = false;
1320         this.m_encoding = null;
1321         this.m_indentAmount = 0;
1322         this.m_inEntityRef = false;
1323         this.m_inExternalDTD = false;
1324         this.m_mediatype = null;
1325         this.m_needToCallStartDocument = true;
1326         this.m_needToOutputDocTypeDecl = false;
1327         if (this.m_prefixMap != null)
1328             this.m_prefixMap.reset();
1329         this.m_shouldNotWriteXMLHeader = false;
1330         this.m_sourceLocator = null;
1331         this.m_standalone = null;
1332         this.m_standaloneWasSpecified = false;
1333         this.m_tracer = null;
1334         this.m_transformer = null;
1335         this.m_version = null;
1336         // don't set writer to null, so that it might be re-used
1337         //this.m_writer = null;
1338     }
1339 
1340     /**
1341      * Returns true if the serializer is used for temporary output rather than
1342      * final output.
1343      *
1344      * This concept is made clear in the XSLT 2.0 draft.
1345      */
1346     final boolean inTemporaryOutputState()
1347     {
1348         /* This is a hack. We should really be letting the serializer know
1349          * that it is in temporary output state with an explicit call, but
1350          * from a pragmatic point of view (for now anyways) having no output
1351          * encoding at all, not even the default UTF-8 indicates that the serializer
1352          * is being used for temporary RTF.
1353          */
1354         return (getEncoding() == null);
1355 
1356     }
1357 
1358     /**
1359      * This method adds an attribute the the current element,
1360      * but should not be used for an xsl:attribute child.
1361      * @see ExtendedContentHandler#addAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
1362      */
1363     public void addAttribute(String uri, String localName, String rawName, String type, String value) throws SAXException
1364     {
1365         if (m_elemContext.m_startTagOpen)
1366         {
1367             addAttributeAlways(uri, localName, rawName, type, value, false);
1368         }
1369     }
1370 
1371     /**
1372      * @see org.xml.sax.DTDHandler#notationDecl(java.lang.String, java.lang.String, java.lang.String)
1373      */
1374     public void notationDecl(String arg0, String arg1, String arg2)
1375         throws SAXException {
1376         // This method just provides a definition to satisfy the interface
1377         // A particular sub-class of SerializerBase provides the implementation (if desired)
1378     }
1379 
1380     /**
1381      * @see org.xml.sax.DTDHandler#unparsedEntityDecl(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
1382      */
1383     public void unparsedEntityDecl(
1384         String arg0,
1385         String arg1,
1386         String arg2,
1387         String arg3)
1388         throws SAXException {
1389         // This method just provides a definition to satisfy the interface
1390         // A particular sub-class of SerializerBase provides the implementation (if desired)
1391     }
1392 
1393     /**
1394      * If set to false the serializer does not expand DTD entities,
1395      * but leaves them as is, the default value is true.
1396      */
1397     public void setDTDEntityExpansion(boolean expand) {
1398         // This method just provides a definition to satisfy the interface
1399         // A particular sub-class of SerializerBase provides the implementation (if desired)
1400     }
1401 









































































































































































































































































































































1402 }
--- EOF ---