1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 1999 The Apache Software Foundation.  All rights 

  6.  * reserved.

  7.  *

  8.  * Redistribution and use in source and binary forms, with or without

  9.  * modification, are permitted provided that the following conditions

  10.  * are met:

  11.  *

  12.  * 1. Redistributions of source code must retain the above copyright

  13.  *    notice, this list of conditions and the following disclaimer. 

  14.  *

  15.  * 2. Redistributions in binary form must reproduce the above copyright

  16.  *    notice, this list of conditions and the following disclaimer in

  17.  *    the documentation and/or other materials provided with the

  18.  *    distribution.

  19.  *

  20.  * 3. The end-user documentation included with the redistribution,

  21.  *    if any, must include the following acknowledgment:  

  22.  *       "This product includes software developed by the

  23.  *        Apache Software Foundation (http://www.apache.org/)."

  24.  *    Alternately, this acknowledgment may appear in the software itself,

  25.  *    if and wherever such third-party acknowledgments normally appear.

  26.  *

  27.  * 4. The names "Xalan" and "Apache Software Foundation" must

  28.  *    not be used to endorse or promote products derived from this

  29.  *    software without prior written permission. For written 

  30.  *    permission, please contact apache@apache.org.

  31.  *

  32.  * 5. Products derived from this software may not be called "Apache",

  33.  *    nor may "Apache" appear in their name, without prior written

  34.  *    permission of the Apache Software Foundation.

  35.  *

  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  47.  * SUCH DAMAGE.

  48.  * ====================================================================

  49.  *

  50.  * This software consists of voluntary contributions made by many

  51.  * individuals on behalf of the Apache Software Foundation and was

  52.  * originally based on software copyright (c) 1999, Lotus

  53.  * Development Corporation., http://www.lotus.com.  For more

  54.  * information on the Apache Software Foundation, please see

  55.  * <http://www.apache.org/>.

  56.  */

  57. package org.apache.xalan.serialize;

  58. 

  59. import java.util.Stack;

  60. 

  61. import java.io.Writer;

  62. import java.io.IOException;

  63. 

  64. import java.util.Hashtable;

  65. import java.util.Vector;

  66. import java.util.Properties;

  67. import java.util.BitSet;

  68. 

  69. import org.xml.sax.*;

  70. 

  71. import org.apache.xml.utils.BoolStack;

  72. import org.apache.xml.utils.Trie;

  73. import org.apache.xml.utils.FastStringBuffer;

  74. import org.apache.xalan.res.XSLMessages;

  75. import org.apache.xpath.res.XPATHErrorResources;

  76. import org.apache.xml.utils.StringToIntTable;

  77. import org.apache.xalan.templates.OutputProperties;

  78. 

  79. import javax.xml.transform.OutputKeys;

  80. import javax.xml.transform.Result;

  81. 

  82. /**

  83.  * <meta name="usage" content="general"/>

  84.  * SerializerToHTML formats SAX-style events into XML.

  85.  */

  86. public class SerializerToHTML extends SerializerToXML

  87. {

  88. 

  89.   /** State stack to keep track of if the current element has output 

  90.    *  escaping disabled. */

  91.   protected BoolStack m_isRawStack = new BoolStack();

  92. 

  93.   /** True if the current element is a block element.  (seems like 

  94.    *  this needs to be a stack. -sb). */

  95.   private boolean m_inBlockElem = false;

  96. 

  97.   /**

  98.    * Map that tells which XML characters should have special treatment, and it

  99.    *  provides character to entity name lookup.

  100.    */

  101.   protected static CharInfo m_htmlcharInfo =

  102.     new CharInfo(CharInfo.HTML_ENTITIES_RESOURCE);

  103. 

  104.   /** A digital search trie for fast, case insensitive lookup of ElemDesc objects. */

  105.   static Trie m_elementFlags = new Trie();

  106. 

  107.   static

  108.   {

  109. 

  110.     // HTML 4.0 loose DTD

  111.     m_elementFlags.put("BASEFONT", new ElemDesc(0 | ElemDesc.EMPTY));

  112.     m_elementFlags.put("FRAME",

  113.                        new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));

  114.     m_elementFlags.put("FRAMESET", new ElemDesc(0 | ElemDesc.BLOCK));

  115.     m_elementFlags.put("NOFRAMES", new ElemDesc(0 | ElemDesc.BLOCK));

  116.     m_elementFlags.put("ISINDEX",

  117.                        new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));

  118.     m_elementFlags.put("APPLET",

  119.                        new ElemDesc(0 | ElemDesc.WHITESPACESENSITIVE));

  120.     m_elementFlags.put("CENTER", new ElemDesc(0 | ElemDesc.BLOCK));

  121.     m_elementFlags.put("DIR", new ElemDesc(0 | ElemDesc.BLOCK));

  122.     m_elementFlags.put("MENU", new ElemDesc(0 | ElemDesc.BLOCK));

  123. 

  124.     // HTML 4.0 strict DTD

  125.     m_elementFlags.put("TT", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  126.     m_elementFlags.put("I", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  127.     m_elementFlags.put("B", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  128.     m_elementFlags.put("BIG", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  129.     m_elementFlags.put("SMALL", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  130.     m_elementFlags.put("EM", new ElemDesc(0 | ElemDesc.PHRASE));

  131.     m_elementFlags.put("STRONG", new ElemDesc(0 | ElemDesc.PHRASE));

  132.     m_elementFlags.put("DFN", new ElemDesc(0 | ElemDesc.PHRASE));

  133.     m_elementFlags.put("CODE", new ElemDesc(0 | ElemDesc.PHRASE));

  134.     m_elementFlags.put("SAMP", new ElemDesc(0 | ElemDesc.PHRASE));

  135.     m_elementFlags.put("KBD", new ElemDesc(0 | ElemDesc.PHRASE));

  136.     m_elementFlags.put("VAR", new ElemDesc(0 | ElemDesc.PHRASE));

  137.     m_elementFlags.put("CITE", new ElemDesc(0 | ElemDesc.PHRASE));

  138.     m_elementFlags.put("ABBR", new ElemDesc(0 | ElemDesc.PHRASE));

  139.     m_elementFlags.put("ACRONYM", new ElemDesc(0 | ElemDesc.PHRASE));

  140.     m_elementFlags.put("SUP",

  141.                        new ElemDesc(0 | ElemDesc.SPECIAL

  142.                                     | ElemDesc.ASPECIAL));

  143.     m_elementFlags.put("SUB",

  144.                        new ElemDesc(0 | ElemDesc.SPECIAL

  145.                                     | ElemDesc.ASPECIAL));

  146.     m_elementFlags.put("SPAN",

  147.                        new ElemDesc(0 | ElemDesc.SPECIAL

  148.                                     | ElemDesc.ASPECIAL));

  149.     m_elementFlags.put("BDO",

  150.                        new ElemDesc(0 | ElemDesc.SPECIAL

  151.                                     | ElemDesc.ASPECIAL));

  152.     m_elementFlags.put("BR",

  153.                        new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL

  154.                                     | ElemDesc.EMPTY | ElemDesc.BLOCK));

  155.     m_elementFlags.put("BODY", new ElemDesc(0 | ElemDesc.BLOCK));

  156.     m_elementFlags.put("ADDRESS",

  157.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  158.                                     | ElemDesc.BLOCKFORMFIELDSET));

  159.     m_elementFlags.put("DIV",

  160.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  161.                                     | ElemDesc.BLOCKFORMFIELDSET));

  162.     m_elementFlags.put("A", new ElemDesc(0 | ElemDesc.SPECIAL));

  163.     m_elementFlags.put("MAP",

  164.                        new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL

  165.                                     | ElemDesc.BLOCK));

  166.     m_elementFlags.put("AREA",

  167.                        new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));

  168.     m_elementFlags.put("LINK",

  169.                        new ElemDesc(0 | ElemDesc.HEADMISC | ElemDesc.EMPTY

  170.                                     | ElemDesc.BLOCK));

  171.     m_elementFlags.put("IMG",

  172.                        new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL

  173.                                     | ElemDesc.EMPTY

  174.                                     | ElemDesc.WHITESPACESENSITIVE));

  175.     m_elementFlags.put("OBJECT",

  176.                        new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL

  177.                                     | ElemDesc.HEADMISC

  178.                                     | ElemDesc.WHITESPACESENSITIVE));

  179.     m_elementFlags.put("PARAM", new ElemDesc(0 | ElemDesc.EMPTY));

  180.     m_elementFlags.put("HR",

  181.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  182.                                     | ElemDesc.BLOCKFORMFIELDSET

  183.                                     | ElemDesc.EMPTY));

  184.     m_elementFlags.put("P",

  185.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  186.                                     | ElemDesc.BLOCKFORMFIELDSET));

  187.     m_elementFlags.put("H1",

  188.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  189.     m_elementFlags.put("H2",

  190.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  191.     m_elementFlags.put("H3",

  192.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  193.     m_elementFlags.put("H4",

  194.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  195.     m_elementFlags.put("H5",

  196.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  197.     m_elementFlags.put("H6",

  198.                        new ElemDesc(0 | ElemDesc.HEAD | ElemDesc.BLOCK));

  199.     m_elementFlags.put("PRE",

  200.                        new ElemDesc(0 | ElemDesc.PREFORMATTED

  201.                                     | ElemDesc.BLOCK));

  202.     m_elementFlags.put("Q",

  203.                        new ElemDesc(0 | ElemDesc.SPECIAL

  204.                                     | ElemDesc.ASPECIAL));

  205.     m_elementFlags.put("BLOCKQUOTE",

  206.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  207.                                     | ElemDesc.BLOCKFORMFIELDSET));

  208.     m_elementFlags.put("INS", new ElemDesc(0));

  209.     m_elementFlags.put("DEL", new ElemDesc(0));

  210.     m_elementFlags.put("DL",

  211.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  212.                                     | ElemDesc.BLOCKFORMFIELDSET));

  213.     m_elementFlags.put("DT", new ElemDesc(0 | ElemDesc.BLOCK));

  214.     m_elementFlags.put("DD", new ElemDesc(0 | ElemDesc.BLOCK));

  215.     m_elementFlags.put("OL",

  216.                        new ElemDesc(0 | ElemDesc.LIST | ElemDesc.BLOCK));

  217.     m_elementFlags.put("UL",

  218.                        new ElemDesc(0 | ElemDesc.LIST | ElemDesc.BLOCK));

  219.     m_elementFlags.put("LI", new ElemDesc(0 | ElemDesc.BLOCK));

  220.     m_elementFlags.put("FORM", new ElemDesc(0 | ElemDesc.BLOCK));

  221.     m_elementFlags.put("LABEL", new ElemDesc(0 | ElemDesc.FORMCTRL));

  222.     m_elementFlags.put("INPUT",

  223.                        new ElemDesc(0 | ElemDesc.FORMCTRL

  224.                                     | ElemDesc.INLINELABEL | ElemDesc.EMPTY));

  225.     m_elementFlags.put("SELECT",

  226.                        new ElemDesc(0 | ElemDesc.FORMCTRL

  227.                                     | ElemDesc.INLINELABEL));

  228.     m_elementFlags.put("OPTGROUP", new ElemDesc(0));

  229.     m_elementFlags.put("OPTION", new ElemDesc(0));

  230.     m_elementFlags.put("TEXTAREA",

  231.                        new ElemDesc(0 | ElemDesc.FORMCTRL

  232.                                     | ElemDesc.INLINELABEL));

  233.     m_elementFlags.put("FIELDSET",

  234.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM));

  235.     m_elementFlags.put("LEGEND", new ElemDesc(0));

  236.     m_elementFlags.put("BUTTON",

  237.                        new ElemDesc(0 | ElemDesc.FORMCTRL

  238.                                     | ElemDesc.INLINELABEL));

  239.     m_elementFlags.put("TABLE",

  240.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  241.                                     | ElemDesc.BLOCKFORMFIELDSET));

  242.     m_elementFlags.put("CAPTION", new ElemDesc(0 | ElemDesc.BLOCK));

  243.     m_elementFlags.put("THEAD", new ElemDesc(0 | ElemDesc.BLOCK));

  244.     m_elementFlags.put("TFOOT", new ElemDesc(0 | ElemDesc.BLOCK));

  245.     m_elementFlags.put("TBODY", new ElemDesc(0 | ElemDesc.BLOCK));

  246.     m_elementFlags.put("COLGROUP", new ElemDesc(0 | ElemDesc.BLOCK));

  247.     m_elementFlags.put("COL",

  248.                        new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));

  249.     m_elementFlags.put("TR", new ElemDesc(0 | ElemDesc.BLOCK));

  250.     m_elementFlags.put("TH", new ElemDesc(0));

  251.     m_elementFlags.put("TD", new ElemDesc(0));

  252.     m_elementFlags.put("HEAD",

  253.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.HEADELEM));

  254.     m_elementFlags.put("TITLE", new ElemDesc(0 | ElemDesc.BLOCK));

  255.     m_elementFlags.put("BASE",

  256.                        new ElemDesc(0 | ElemDesc.EMPTY | ElemDesc.BLOCK));

  257.     m_elementFlags.put("META",

  258.                        new ElemDesc(0 | ElemDesc.HEADMISC | ElemDesc.EMPTY

  259.                                     | ElemDesc.BLOCK));

  260.     m_elementFlags.put("STYLE",

  261.                        new ElemDesc(0 | ElemDesc.HEADMISC | ElemDesc.RAW

  262.                                     | ElemDesc.BLOCK));

  263.     m_elementFlags.put("SCRIPT",

  264.                        new ElemDesc(0 | ElemDesc.SPECIAL | ElemDesc.ASPECIAL

  265.                                     | ElemDesc.HEADMISC | ElemDesc.RAW));

  266.     m_elementFlags.put("NOSCRIPT",

  267.                        new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  268.                                     | ElemDesc.BLOCKFORMFIELDSET));

  269.     m_elementFlags.put("HTML", new ElemDesc(0 | ElemDesc.BLOCK));

  270. 

  271.     // From "John Ky" <hand@syd.speednet.com.au

  272.     // Transitional Document Type Definition ()

  273.     // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/sgml/loosedtd.html#basefont

  274.     m_elementFlags.put("FONT", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  275. 

  276.     // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/present/graphics.html#edef-STRIKE

  277.     m_elementFlags.put("S", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  278.     m_elementFlags.put("STRIKE", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  279. 

  280.     // file:///C:/Documents%20and%20Settings/sboag.BOAG600E/My%20Documents/html/present/graphics.html#edef-U

  281.     m_elementFlags.put("U", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  282. 

  283.     // From "John Ky" <hand@syd.speednet.com.au

  284.     m_elementFlags.put("NOBR", new ElemDesc(0 | ElemDesc.FONTSTYLE));

  285.     

  286.      // HTML 4.0, section 16.5

  287.      m_elementFlags.put("IFRAME",

  288.                                         new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  289.                                                                      | ElemDesc.BLOCKFORMFIELDSET));

  290.      // NS4 extensions

  291.      m_elementFlags.put("LAYER",

  292.                                         new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  293.                                                                      | ElemDesc.BLOCKFORMFIELDSET));

  294.      m_elementFlags.put("ILAYER",

  295.                                         new ElemDesc(0 | ElemDesc.BLOCK | ElemDesc.BLOCKFORM

  296.                                                                      | ElemDesc.BLOCKFORMFIELDSET));

  297.   

  298.     ElemDesc elemDesc;

  299. 

  300.     elemDesc = (ElemDesc) m_elementFlags.get("AREA");

  301. 

  302.     elemDesc.setAttr("HREF", ElemDesc.ATTRURL);

  303.     elemDesc.setAttr("NOHREF", ElemDesc.ATTREMPTY);

  304. 

  305.     elemDesc = (ElemDesc) m_elementFlags.get("BASE");

  306. 

  307.     elemDesc.setAttr("HREF", ElemDesc.ATTRURL);

  308. 

  309.     elemDesc = (ElemDesc) m_elementFlags.get("BLOCKQUOTE");

  310. 

  311.     elemDesc.setAttr("CITE", ElemDesc.ATTRURL);

  312. 

  313.     elemDesc = (ElemDesc) m_elementFlags.get("Q");

  314. 

  315.     elemDesc.setAttr("CITE", ElemDesc.ATTRURL);

  316. 

  317.     elemDesc = (ElemDesc) m_elementFlags.get("INS");

  318. 

  319.     elemDesc.setAttr("CITE", ElemDesc.ATTRURL);

  320. 

  321.     elemDesc = (ElemDesc) m_elementFlags.get("DEL");

  322. 

  323.     elemDesc.setAttr("CITE", ElemDesc.ATTRURL);

  324. 

  325.     elemDesc = (ElemDesc) m_elementFlags.get("A");

  326. 

  327.     elemDesc.setAttr("HREF", ElemDesc.ATTRURL);

  328.     elemDesc.setAttr("NAME", ElemDesc.ATTRURL);

  329.     

  330.     elemDesc = (ElemDesc) m_elementFlags.get("LINK");

  331.     elemDesc.setAttr("HREF", ElemDesc.ATTRURL);

  332. 

  333.     elemDesc = (ElemDesc) m_elementFlags.get("INPUT");

  334. 

  335.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  336.     elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);

  337.     elemDesc.setAttr("CHECKED", ElemDesc.ATTREMPTY);

  338.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  339.     elemDesc.setAttr("ISMAP", ElemDesc.ATTREMPTY);

  340.     elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);

  341. 

  342.     elemDesc = (ElemDesc) m_elementFlags.get("SELECT");

  343. 

  344.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  345.     elemDesc.setAttr("MULTIPLE", ElemDesc.ATTREMPTY);

  346. 

  347.     elemDesc = (ElemDesc) m_elementFlags.get("OPTGROUP");

  348. 

  349.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  350. 

  351.     elemDesc = (ElemDesc) m_elementFlags.get("OPTION");

  352. 

  353.     elemDesc.setAttr("SELECTED", ElemDesc.ATTREMPTY);

  354.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  355. 

  356.     elemDesc = (ElemDesc) m_elementFlags.get("TEXTAREA");

  357. 

  358.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  359.     elemDesc.setAttr("READONLY", ElemDesc.ATTREMPTY);

  360. 

  361.     elemDesc = (ElemDesc) m_elementFlags.get("BUTTON");

  362. 

  363.     elemDesc.setAttr("DISABLED", ElemDesc.ATTREMPTY);

  364. 

  365.     elemDesc = (ElemDesc) m_elementFlags.get("SCRIPT");

  366. 

  367.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  368.     elemDesc.setAttr("FOR", ElemDesc.ATTRURL);

  369.     elemDesc.setAttr("DEFER", ElemDesc.ATTREMPTY);

  370. 

  371.     elemDesc = (ElemDesc) m_elementFlags.get("IMG");

  372. 

  373.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  374.     elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);

  375.     elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);

  376.     elemDesc.setAttr("ISMAP", ElemDesc.ATTREMPTY);

  377. 

  378.     elemDesc = (ElemDesc) m_elementFlags.get("OBJECT");

  379. 

  380.     elemDesc.setAttr("CLASSID", ElemDesc.ATTRURL);

  381.     elemDesc.setAttr("CODEBASE", ElemDesc.ATTRURL);

  382.     elemDesc.setAttr("DATA", ElemDesc.ATTRURL);

  383.     elemDesc.setAttr("ARCHIVE", ElemDesc.ATTRURL);

  384.     elemDesc.setAttr("USEMAP", ElemDesc.ATTRURL);

  385.     elemDesc.setAttr("DECLARE", ElemDesc.ATTREMPTY);

  386. 

  387.     elemDesc = (ElemDesc) m_elementFlags.get("FORM");

  388. 

  389.     elemDesc.setAttr("ACTION", ElemDesc.ATTRURL);

  390. 

  391.     elemDesc = (ElemDesc) m_elementFlags.get("HEAD");

  392. 

  393.     elemDesc.setAttr("PROFILE", ElemDesc.ATTRURL);

  394. 

  395.     // Attribution to: "Voytenko, Dimitry" <DVoytenko@SECTORBASE.COM>

  396.     elemDesc = (ElemDesc) m_elementFlags.get("FRAME");

  397. 

  398.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  399.     elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);

  400.  

  401.     // HTML 4.0, section 16.5

  402.     elemDesc = (ElemDesc) m_elementFlags.get("IFRAME");

  403.  

  404.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  405.     elemDesc.setAttr("LONGDESC", ElemDesc.ATTRURL);

  406.  

  407.     // NS4 extensions

  408.     elemDesc = (ElemDesc) m_elementFlags.get("LAYER");

  409.  

  410.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  411.  

  412.     elemDesc = (ElemDesc) m_elementFlags.get("ILAYER");

  413.  

  414.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  415.  

  416.     elemDesc = (ElemDesc) m_elementFlags.get("DIV");

  417. 

  418.     elemDesc.setAttr("SRC", ElemDesc.ATTRURL);

  419.   }

  420. 

  421.   /**

  422.    * Dummy element for elements not found.

  423.    */

  424.   static private ElemDesc m_dummy = new ElemDesc(0 | ElemDesc.BLOCK);

  425. 

  426.   /** True if URLs should be specially escaped with the %xx form. */

  427.   private boolean m_specialEscapeURLs = true;

  428. 

  429.   /** True if the META tag should be omitted. */

  430.   private boolean m_omitMetaTag = false;

  431. 

  432.   /**

  433.    * Tells if the formatter should use special URL escaping.

  434.    *

  435.    * @param bool True if URLs should be specially escaped with the %xx form.

  436.    */

  437.   public void setSpecialEscapeURLs(boolean bool)

  438.   {

  439.     m_specialEscapeURLs = bool;

  440.   }

  441. 

  442.   /**

  443.    * Tells if the formatter should omit the META tag.

  444.    *

  445.    * @param bool True if the META tag should be omitted.

  446.    */

  447.   public void setOmitMetaTag(boolean bool)

  448.   {

  449.     m_omitMetaTag = bool;

  450.   }

  451. 

  452.   /**

  453.    * Specifies an output format for this serializer. It the

  454.    * serializer has already been associated with an output format,

  455.    * it will switch to the new format. This method should not be

  456.    * called while the serializer is in the process of serializing

  457.    * a document.

  458.    *

  459.    * @param format The output format to use

  460.    */

  461.   public void setOutputFormat(Properties format)

  462.   {

  463. 

  464.     m_specialEscapeURLs =

  465.       OutputProperties.getBooleanProperty(OutputProperties.S_USE_URL_ESCAPING,

  466.                                           format);

  467. 

  468.     m_omitMetaTag =

  469.       OutputProperties.getBooleanProperty(OutputProperties.S_OMIT_META_TAG,

  470.                                           format);

  471.                             

  472.     super.setOutputFormat(format);

  473.   }

  474. 

  475.   /**

  476.    * Tells if the formatter should use special URL escaping.

  477.    *

  478.    * @return True if URLs should be specially escaped with the %xx form.

  479.    */

  480.   public boolean getSpecialEscapeURLs()

  481.   {

  482.     return m_specialEscapeURLs;

  483.   }

  484. 

  485.   /**

  486.    * Tells if the formatter should omit the META tag.

  487.    *

  488.    * @return True if the META tag should be omitted.

  489.    */

  490.   public boolean getOmitMetaTag()

  491.   {

  492.     return m_omitMetaTag;

  493.   }

  494. 

  495.   /**

  496.    * Get a description of the given element.

  497.    *

  498.    * @param name non-null name of element, case insensitive.

  499.    *

  500.    * @return non-null reference to ElemDesc, which may be m_dummy if no 

  501.    *         element description matches the given name.

  502.    */

  503.   ElemDesc getElemDesc(String name)

  504.   {

  505. 

  506.     if (null != name)

  507.     {

  508.       Object obj = m_elementFlags.get(name);

  509. 

  510.       if (null != obj)

  511.         return (ElemDesc) obj;

  512.     }

  513. 

  514.     return m_dummy;

  515.   }

  516. 

  517.   /**

  518.    * Default constructor.

  519.    */

  520.   public SerializerToHTML()

  521.   {

  522. 

  523.     super();

  524.     m_charInfo = m_htmlcharInfo;

  525.   }

  526. 

  527.   /** The name of the current element. */

  528.   private String m_currentElementName = null;

  529. 

  530.   /**

  531.    * Receive notification of the beginning of a document.

  532.    *

  533.    * @throws org.xml.sax.SAXException Any SAX exception, possibly

  534.    *            wrapping another exception.

  535.    *

  536.    * @throws org.xml.sax.SAXException

  537.    */

  538.   public void startDocument() throws org.xml.sax.SAXException

  539.   {

  540. 

  541.     m_needToOutputDocTypeDecl = true;

  542.     m_startNewLine = false;

  543.     m_shouldNotWriteXMLHeader = true;

  544. 

  545.     if (true == m_needToOutputDocTypeDecl)

  546.     {

  547.       if ((null != m_doctypeSystem) || (null != m_doctypePublic))

  548.       {

  549.         accum("<!DOCTYPE HTML");

  550. 

  551.         if (null != m_doctypePublic)

  552.         {

  553.           accum(" PUBLIC \"");

  554.           accum(m_doctypePublic);

  555.           accum("\"");

  556.         }

  557. 

  558.         if (null != m_doctypeSystem)

  559.         {

  560.           if (null == m_doctypePublic)

  561.             accum(" SYSTEM \"");

  562.           else

  563.             accum(" \"");

  564. 

  565.           accum(m_doctypeSystem);

  566.           accum("\"");

  567.         }

  568. 

  569.         accum(">");

  570.         outputLineSep();

  571.       }

  572.     }

  573. 

  574.     m_needToOutputDocTypeDecl = false;

  575.   }

  576. 

  577.   /**

  578.    *  Receive notification of the beginning of an element.

  579.    *

  580.    *

  581.    *  @param namespaceURI

  582.    *  @param localName

  583.    *  @param name The element type name.

  584.    *  @param atts The attributes attached to the element, if any.

  585.    *  @throws org.xml.sax.SAXException Any SAX exception, possibly

  586.    *             wrapping another exception.

  587.    *  @see #endElement

  588.    *  @see org.xml.sax.AttributeList

  589.    */

  590.   public void startElement(

  591.           String namespaceURI, String localName, String name, Attributes atts)

  592.             throws org.xml.sax.SAXException

  593.   {

  594.     // System.out.println("SerializerToHTML#startElement("+namespaceURI+", "+localName+", "+name+", ...);");

  595. 

  596.     if (null != namespaceURI && namespaceURI.length() > 0)

  597.     {

  598.       super.startElement(namespaceURI, localName, name, atts);

  599. 

  600.       return;

  601.     }

  602. 

  603.     boolean savedDoIndent = m_doIndent;

  604.     boolean noLineBreak;

  605. 

  606.     writeParentTagEnd();

  607.     pushState(

  608.       namespaceURI, localName,

  609.       m_cdataSectionNames, m_cdataSectionStates);

  610. 

  611.     // pushState(namespaceURI, localName, m_format.getNonEscapingElements(),

  612.     //          m_disableOutputEscapingStates);

  613.     ElemDesc elemDesc = getElemDesc(name);

  614. 

  615.     // ElemDesc parentElemDesc = getElemDesc(m_currentElementName);

  616.     boolean isBlockElement = elemDesc.is(ElemDesc.BLOCK);

  617.     boolean isHeadElement = elemDesc.is(ElemDesc.HEADELEM);

  618. 

  619.     // boolean isWhiteSpaceSensitive = elemDesc.is(ElemDesc.WHITESPACESENSITIVE);

  620.     if (m_ispreserve)

  621.       m_ispreserve = false;

  622.     else if (m_doIndent && (null != m_currentElementName)

  623.              && (!m_inBlockElem || isBlockElement)

  624. 

  625.     /* && !isWhiteSpaceSensitive */

  626.     )

  627.     {

  628.       m_startNewLine = true;

  629. 

  630.       indent(m_currentIndent);

  631.     }

  632. 

  633.     m_inBlockElem = !isBlockElement;

  634. 

  635.     m_isRawStack.push(elemDesc.is(ElemDesc.RAW));

  636. 

  637.     m_currentElementName = name;

  638. 

  639.     // m_parents.push(m_currentElementName);

  640.     this.accum('<');

  641.     this.accum(name);

  642. 

  643.     int nAttrs = atts.getLength();

  644. 

  645.     for (int i = 0; i < nAttrs; i++)

  646.     {

  647.       processAttribute(atts.getQName(i), elemDesc, atts.getValue(i));

  648.     }

  649. 

  650.     // Flag the current element as not yet having any children.

  651.     openElementForChildren();

  652. 

  653.     m_currentIndent += this.m_indentAmount;

  654.     m_isprevtext = false;

  655.     m_doIndent = savedDoIndent;

  656. 

  657.     if (isHeadElement)

  658.     {

  659.       writeParentTagEnd();

  660. 

  661.       if (!m_omitMetaTag)

  662.       {

  663.         if (m_doIndent)

  664.           indent(m_currentIndent);

  665. 

  666.         accum(

  667.           "<META http-equiv=\"Content-Type\" content=\"text/html; charset=");

  668. 

  669.         // String encoding = Encodings.getMimeEncoding(m_encoding).toLowerCase();

  670.         String encoding = Encodings.getMimeEncoding(m_encoding);

  671. 

  672.         accum(encoding);

  673.         accum('"');

  674.         accum('>');

  675.       }

  676.     }

  677.   }

  678. 

  679.   /**

  680.    *  Receive notification of the end of an element.

  681.    *

  682.    *

  683.    *  @param namespaceURI

  684.    *  @param localName

  685.    *  @param name The element type name

  686.    *  @throws org.xml.sax.SAXException Any SAX exception, possibly

  687.    *             wrapping another exception.

  688.    */

  689.   public void endElement(String namespaceURI, String localName, String name)

  690.           throws org.xml.sax.SAXException

  691.   {

  692.     // System.out.println("SerializerToHTML#endElement("+namespaceURI+", "+localName+", "+name+");");

  693.     if (null != namespaceURI && namespaceURI.length() > 0)

  694.     {

  695.       super.endElement(namespaceURI, localName, name);

  696. 

  697.       return;

  698.     }

  699. 

  700.     m_currentIndent -= this.m_indentAmount;

  701. 

  702.     boolean hasChildNodes = childNodesWereAdded();

  703. 

  704.     // System.out.println(m_currentElementName);

  705.     // m_parents.pop();

  706.     m_isRawStack.pop();

  707. 

  708.     ElemDesc elemDesc = getElemDesc(name);

  709. 

  710.     // ElemDesc parentElemDesc = getElemDesc(m_currentElementName);

  711.     boolean isBlockElement = elemDesc.is(ElemDesc.BLOCK);

  712.     boolean shouldIndent = false;

  713. 

  714.     if (m_ispreserve)

  715.     {

  716.       m_ispreserve = false;

  717.     }

  718.     else if (m_doIndent && (!m_inBlockElem || isBlockElement))

  719.     {

  720.       m_startNewLine = true;

  721.       shouldIndent = true;

  722. 

  723.       // indent(m_currentIndent);

  724.     }

  725. 

  726.     m_inBlockElem = !isBlockElement;

  727. 

  728.     if (hasChildNodes)

  729.     {

  730.       if (shouldIndent)

  731.         indent(m_currentIndent);

  732. 

  733.       this.accum("</");

  734.       this.accum(name);

  735.       this.accum('>');

  736. 

  737.       m_currentElementName = name;

  738.     }

  739.     else

  740.     {

  741.       if (!elemDesc.is(ElemDesc.EMPTY))

  742.       {

  743.         this.accum('>');

  744. 

  745.         // As per Dave/Paul recommendation 12/06/2000

  746.         // if (shouldIndent)

  747.         //  indent(m_currentIndent);

  748. 

  749.         this.accum('<');

  750.         this.accum('/');

  751.         this.accum(name);

  752.         this.accum('>');

  753.       }

  754.       else

  755.       {

  756.         this.accum('>');

  757.       }

  758.     }

  759. 

  760.     if (elemDesc.is(ElemDesc.WHITESPACESENSITIVE))

  761.       m_ispreserve = true;

  762. 

  763.     if (hasChildNodes)

  764.     {

  765.       if (!m_preserves.isEmpty())

  766.         m_preserves.pop();

  767.     }

  768. 

  769.     m_isprevtext = false;

  770. 

  771.     // m_disableOutputEscapingStates.pop();

  772.     m_cdataSectionStates.pop();

  773.   }

  774. 

  775.   /**

  776.    * Process an attribute.

  777.    * @param   name   The name of the attribute.

  778.    * @param elemDesc non-null reference to the owning element description.

  779.    * @param   value   The value of the attribute.

  780.    *

  781.    * @throws org.xml.sax.SAXException

  782.    */

  783.   protected void processAttribute(

  784.           String name, ElemDesc elemDesc, String value)

  785.             throws org.xml.sax.SAXException

  786.   {

  787. 

  788.     this.accum(' ');

  789. 

  790.     if (((value.length() == 0) || value.equalsIgnoreCase(name))

  791.             && elemDesc.isAttrFlagSet(name, ElemDesc.ATTREMPTY))

  792.     {

  793.       this.accum(name);

  794.     }

  795.     else

  796.     {

  797.       this.accum(name);

  798.       this.accum('=');

  799. 

  800.       this.accum('\"');

  801.       if (elemDesc.isAttrFlagSet(name, ElemDesc.ATTRURL))

  802.         writeAttrURI(value, m_specialEscapeURLs);

  803.       else

  804.         writeAttrString(value, this.m_encoding);

  805.       this.accum('\"');

  806. 

  807.     }

  808.   }

  809.   

  810.   /**

  811.    * Tell if a character is an ASCII digit.

  812.    */

  813.    private boolean isASCIIDigit(char c)

  814.    {

  815.       return (c >= '0' && c <= '9');

  816.    }

  817.    

  818.  /**

  819.   * Make an integer into an HH hex value.

  820.   * Does no checking on the size of the input, since this 

  821.   * is only meant to be used locally by writeAttrURI.

  822.   * 

  823.   * @param i must be a value less than 255.

  824.   * 

  825.   * @return should be a two character string.

  826.   */

  827.   private String makeHHString(int i)

  828.   {

  829.     String s = Integer.toHexString(i).toUpperCase();

  830.     if(s.length() == 1)

  831.     {

  832.       s = "0"+s;

  833.     }

  834.     return s;

  835.   }

  836.     

  837.   /**

  838.   * Dmitri Ilyin: Makes sure if the String is HH encoded sign.

  839.   * @param str must be 2 characters long

  840.   *

  841.   * @return true or false

  842.   */

  843.   private boolean isHHSign(String str) 

  844.   {

  845.     boolean sign = true;  

  846.     try {

  847.       char r = (char)Integer.parseInt(str,16);

  848.     } catch (NumberFormatException e) {

  849.       sign = false;  

  850.     }

  851.     return sign;

  852.   }

  853.   

  854.   /**

  855.    * Write the specified <var>string</var> after substituting non ASCII characters,

  856.    * with <CODE>%HH</CODE>, where HH is the hex of the byte value.

  857.    *

  858.    * @param   string      String to convert to XML format.

  859.    * @param doURLEscaping True if we should try to encode as 

  860.    *                      per http://www.ietf.org/rfc/rfc2396.txt.

  861.    *

  862.    * @throws org.xml.sax.SAXException if a bad surrogate pair is detected.

  863.    */

  864.   public void writeAttrURI(String string, boolean doURLEscaping)

  865.           throws org.xml.sax.SAXException

  866.   {

  867.     // http://www.ietf.org/rfc/rfc2396.txt says:

  868.     // A URI is always in an "escaped" form, since escaping or unescaping a

  869.     // completed URI might change its semantics.  Normally, the only time

  870.     // escape encodings can safely be made is when the URI is being created

  871.     // from its component parts; each component may have its own set of

  872.     // characters that are reserved, so only the mechanism responsible for

  873.     // generating or interpreting that component can determine whether or

  874.     // not escaping a character will change its semantics. Likewise, a URI

  875.     // must be separated into its components before the escaped characters

  876.     // within those components can be safely decoded.

  877.     //

  878.     // ...So we do our best to do limited escaping of the URL, without 

  879.     // causing damage.  If the URL is already properly escaped, in theory, this 

  880.     // function should not change the string value.

  881. 

  882.     char[] stringArray = string.toCharArray();

  883.     int len = stringArray.length;

  884.         

  885.     for (int i = 0; i < len; i++)

  886.     {

  887.       char ch = stringArray[i];

  888. 

  889.       if ((ch < 32) || (ch > 126))

  890.       {

  891.         if (doURLEscaping)

  892.         {

  893.           // Encode UTF16 to UTF8.

  894.           // Reference is Unicode, A Primer, by Tony Graham.

  895.           // Page 92.

  896.           

  897.           // Note that Kay doesn't escape 0x20...

  898.           //  if(ch == 0x20) // Not sure about this... -sb

  899.           //  {

  900.           //    accum(ch);

  901.           //  }

  902.           //  else 

  903.           if(ch <= 0x7F)

  904.           {

  905.             accum('%');

  906.             accum(makeHHString(ch));          

  907.           }

  908.           else if(ch <= 0x7FF)

  909.           {

  910.             // Clear low 6 bits before rotate, put high 4 bits in low byte, 

  911.             // and set two high bits.

  912.             int high = (ch >> 6) | 0xC0;  

  913.             int low = (ch & 0x3F) | 0x80; // First 6 bits, + high bit

  914.             accum('%');

  915.             accum(makeHHString(high));

  916.             accum('%');

  917.             accum(makeHHString(low));

  918.           }

  919.           else if( isUTF16Surrogate(ch) ) // high surrogate

  920.           {

  921.             // I'm sure this can be done in 3 instructions, but I choose 

  922.             // to try and do it exactly like it is done in the book, at least 

  923.             // until we are sure this is totally clean.  I don't think performance 

  924.             // is a big issue with this particular function, though I could be 

  925.             // wrong.  Also, the stuff below clearly does more masking than 

  926.             // it needs to do.

  927.             

  928.             // Clear high 6 bits.

  929.             int highSurrogate = ((int) ch) & 0x03FF;

  930.             

  931.             // Middle 4 bits (wwww) + 1

  932.             // "Note that the value of wwww from the high surrogate bit pattern

  933.             // is incremented to make the uuuuu bit pattern in the scalar value 

  934.             // so the surrogate pair don't address the BMP."

  935.             int wwww = ((highSurrogate & 0x03C0) >> 6);

  936.             int uuuuu = wwww+1;  

  937.             

  938.             // next 4 bits

  939.             int zzzz = (highSurrogate & 0x003C) >> 2;

  940.             

  941.             // low 2 bits

  942.             int yyyyyy = ((highSurrogate & 0x0003) << 4) & 0x30;

  943.             

  944.             // Get low surrogate character.

  945.             ch = stringArray[++i];

  946.             

  947.             // Clear high 6 bits.

  948.             int lowSurrogate = ((int) ch) & 0x03FF;

  949.             

  950.             // put the middle 4 bits into the bottom of yyyyyy (byte 3)

  951.             yyyyyy = yyyyyy | ((lowSurrogate & 0x03C0) >> 6);

  952.             

  953.             // bottom 6 bits.

  954.             int xxxxxx = (lowSurrogate & 0x003F);

  955.             

  956.             int byte1 = 0xF0 | (uuuuu >> 2); // top 3 bits of uuuuu

  957.             int byte2 = 0x80 | (((uuuuu & 0x03) << 4) & 0x30) | zzzz;

  958.             int byte3 = 0x80 | yyyyyy;

  959.             int byte4 = 0x80 | xxxxxx;

  960.             

  961.             accum('%');

  962.             accum(makeHHString(byte1));

  963.             accum('%');

  964.             accum(makeHHString(byte2));

  965.             accum('%');

  966.             accum(makeHHString(byte3));

  967.             accum('%');

  968.             accum(makeHHString(byte4));

  969.           }

  970.           else 

  971.           {

  972.             int high = (ch >> 12) | 0xE0; // top 4 bits

  973.             int middle = ((ch & 0x0FC0) >> 6) | 0x80; // middle 6 bits

  974.             int low = (ch & 0x3F) | 0x80; // First 6 bits, + high bit

  975.             accum('%');

  976.             accum(makeHHString(high));

  977.             accum('%');

  978.             accum(makeHHString(middle));

  979.             accum('%');

  980.             accum(makeHHString(low));

  981.           }

  982. 

  983.         }

  984.         else if (canConvert(ch))

  985.         {

  986.           accum(ch);

  987.         }

  988.         else

  989.         {

  990.           accum("&#");

  991.           accum(Integer.toString(ch));

  992.           accum(';');

  993.         }

  994.       }

  995.       else if('%' == ch)

  996.       {

  997.         // If the character is a '%' number number, try to avoid double-escaping.

  998.         // There is a question if this is legal behavior.

  999.           

  1000. // Dmitri Ilyin: to check if '%' number number is invalid. It must be checked if %xx is a sign, that would be encoded

  1001. // The encoded signes are in Hex form. So %xx my be in form %3C that is "<" sign. I will try to change here a little.

  1002.           

  1003. //        if( ((i+2) < len) && isASCIIDigit(stringArray[i+1]) && isASCIIDigit(stringArray[i+2]) )

  1004.         

  1005. // We are no longer escaping '%'

  1006.        /* if ( ((i+2) < len) && isHHSign(new String(stringArray,i+1,2)) )

  1007.         {

  1008.           accum(ch);

  1009.         }

  1010.         else

  1011.         {

  1012.           if (doURLEscaping)

  1013.           {

  1014.            accum('%');

  1015.            accum(makeHHString(ch));

  1016.           }

  1017.           else*/

  1018.             accum(ch);

  1019.        // }   

  1020.                

  1021.       } 

  1022.       // Since http://www.ietf.org/rfc/rfc2396.txt refers to the URI grammar as

  1023.       // not allowing quotes in the URI proper syntax, nor in the fragment 

  1024.       // identifier, we believe that it's OK to double escape quotes.

  1025.       else if (ch == '"')

  1026.       {

  1027.         // Mike Kay encodes this as ", so he may know something I don't?

  1028.         if (doURLEscaping)

  1029.           accum("%22");

  1030.         else

  1031.           accum("""); // we have to escape this, I guess.

  1032.       }

  1033.       else

  1034.       {

  1035.         accum(ch);

  1036.       }

  1037.     }

  1038.               

  1039.   }

  1040. 

  1041.   /**

  1042.    * Writes the specified <var>string</var> after substituting <VAR>specials</VAR>,

  1043.    * and UTF-16 surrogates for character references <CODE>&#xnn</CODE>.

  1044.    *

  1045.    * @param   string      String to convert to XML format.

  1046.    * @param   encoding    CURRENTLY NOT IMPLEMENTED.

  1047.    *

  1048.    * @throws org.xml.sax.SAXException

  1049.    */

  1050.   public void writeAttrString(String string, String encoding)

  1051.           throws org.xml.sax.SAXException

  1052.   {

  1053. 

  1054.     final char chars[] = string.toCharArray();

  1055.     final int strLen = chars.length;

  1056. 

  1057.     for (int i = 0; i < strLen; i++)

  1058.     {

  1059.       char ch = chars[i];

  1060. 

  1061.       // System.out.println("SPECIALSSIZE: "+SPECIALSSIZE);

  1062.       // System.out.println("ch: "+(int)ch);

  1063.       // System.out.println("m_maxCharacter: "+(int)m_maxCharacter);

  1064.       // System.out.println("m_attrCharsMap[ch]: "+(int)m_attrCharsMap[ch]);

  1065.       if (canConvert(ch) && (!m_charInfo.isSpecial(ch)))

  1066.       {

  1067.         accum(ch);

  1068.       }

  1069.       else if ('<' == ch || '>' == ch)

  1070.       {

  1071.         accum(ch);  // no escaping in this case, as specified in 15.2

  1072.       }

  1073.       else if (('&' == ch) && ((i + 1) < strLen) && ('{' == chars[i + 1]))

  1074.       {

  1075.         accum(ch);  // no escaping in this case, as specified in 15.2

  1076.       }

  1077.       else

  1078.       {

  1079.         int pos = accumDefaultEntity(ch, i, chars, strLen, false);

  1080. 

  1081.         if (i != pos)

  1082.         {

  1083.           i = pos - 1;

  1084.         }

  1085.         else

  1086.         {

  1087.           if (isUTF16Surrogate(ch))

  1088.           {

  1089.             try

  1090.             {

  1091.               i = writeUTF16Surrogate(ch, chars, i, strLen);

  1092.             }

  1093.             catch(IOException ioe)

  1094.             {

  1095.               throw new SAXException(ioe);

  1096.             }

  1097.           }

  1098. 

  1099.           // The next is kind of a hack to keep from escaping in the case 

  1100.           // of Shift_JIS and the like.

  1101. 

  1102.           /*

  1103.           else if ((ch < m_maxCharacter) && (m_maxCharacter == 0xFFFF)

  1104.           && (ch != 160))

  1105.           {

  1106.           accum(ch);  // no escaping in this case

  1107.           }

  1108.           else

  1109.           */

  1110.           String entityName = m_charInfo.getEntityNameForChar(ch);

  1111. 

  1112.           if (null != entityName)

  1113.           {

  1114.             accum('&');

  1115.             accum(entityName);

  1116.             accum(';');

  1117.           }

  1118.           else if (canConvert(ch))

  1119.           {

  1120.             accum(ch);  // no escaping in this case

  1121.           }

  1122.           else

  1123.           {

  1124.             accum("&#");

  1125.             accum(Integer.toString(ch));

  1126.             accum(';');

  1127.           }

  1128.         }

  1129.       }

  1130.     }

  1131.   }

  1132. 

  1133.   /**

  1134.    * Copy an entity into the accumulation buffer.

  1135.    *

  1136.    * @param s The name of the entity.

  1137.    * @param pos unused.

  1138.    *

  1139.    * @return The pos argument.

  1140.    *

  1141.    * @throws org.xml.sax.SAXException

  1142.    */

  1143.   private int copyEntityIntoBuf(String s, int pos)

  1144.           throws org.xml.sax.SAXException

  1145.   {

  1146. 

  1147.     int l = s.length();

  1148. 

  1149.     accum('&');

  1150. 

  1151.     for (int i = 0; i < l; i++)

  1152.     {

  1153.       accum(s.charAt(i));

  1154.     }

  1155. 

  1156.     accum(';');

  1157. 

  1158.     return pos;

  1159.   }

  1160. 

  1161.   /**

  1162.    * Receive notification of character data.

  1163.    *

  1164.    * <p>The Parser will call this method to report each chunk of

  1165.    * character data.  SAX parsers may return all contiguous character

  1166.    * data in a single chunk, or they may split it into several

  1167.    * chunks; however, all of the characters in any single event

  1168.    * must come from the same external entity, so that the Locator

  1169.    * provides useful information.</p>

  1170.    *

  1171.    * <p>The application must not attempt to read from the array

  1172.    * outside of the specified range.</p>

  1173.    *

  1174.    * <p>Note that some parsers will report whitespace using the

  1175.    * ignorableWhitespace() method rather than this one (validating

  1176.    * parsers must do so).</p>

  1177.    *

  1178.    * @param chars The characters from the XML document.

  1179.    * @param start The start position in the array.

  1180.    * @param length The number of characters to read from the array.

  1181.    * @throws org.xml.sax.SAXException Any SAX exception, possibly

  1182.    *            wrapping another exception.

  1183.    * @see #ignorableWhitespace

  1184.    * @see org.xml.sax.Locator

  1185.    *

  1186.    * @throws org.xml.sax.SAXException

  1187.    */

  1188.   public void characters(char chars[], int start, int length)

  1189.           throws org.xml.sax.SAXException

  1190.   {

  1191. 

  1192.     if (m_isRawStack.peekOrFalse())

  1193.     {

  1194.       try

  1195.       {

  1196.         writeParentTagEnd();

  1197. 

  1198.         m_ispreserve = true;

  1199. 

  1200.         if (shouldIndent())

  1201.           indent(m_currentIndent);

  1202. 

  1203.         // this.accum("<![CDATA[");

  1204.         // this.accum(chars, start, length);

  1205.         writeNormalizedChars(chars, start, length, false);

  1206. 

  1207.         // this.accum("]]>");

  1208.         return;

  1209.       }

  1210.       catch (IOException ioe)

  1211.       {

  1212.         throw new org.xml.sax.SAXException(

  1213.           XSLMessages.createXPATHMessage(

  1214.           XPATHErrorResources.ER_OIERROR, null), ioe);  //"IO error", ioe);

  1215.       }

  1216.     }

  1217.     else

  1218.     {

  1219.       super.characters(chars, start, length);

  1220.     }

  1221.   }

  1222. 

  1223.   /**

  1224.    *  Receive notification of cdata.

  1225.    *

  1226.    *  <p>The Parser will call this method to report each chunk of

  1227.    *  character data.  SAX parsers may return all contiguous character

  1228.    *  data in a single chunk, or they may split it into several

  1229.    *  chunks; however, all of the characters in any single event

  1230.    *  must come from the same external entity, so that the Locator

  1231.    *  provides useful information.</p>

  1232.    *

  1233.    *  <p>The application must not attempt to read from the array

  1234.    *  outside of the specified range.</p>

  1235.    *

  1236.    *  <p>Note that some parsers will report whitespace using the

  1237.    *  ignorableWhitespace() method rather than this one (validating

  1238.    *  parsers must do so).</p>

  1239.    *

  1240.    *  @param ch The characters from the XML document.

  1241.    *  @param start The start position in the array.

  1242.    *  @param length The number of characters to read from the array.

  1243.    *  @throws org.xml.sax.SAXException Any SAX exception, possibly

  1244.    *             wrapping another exception.

  1245.    *  @see #ignorableWhitespace

  1246.    *  @see org.xml.sax.Locator

  1247.    *

  1248.    * @throws org.xml.sax.SAXException

  1249.    */

  1250.   public void cdata(char ch[], int start, int length)

  1251.           throws org.xml.sax.SAXException

  1252.   {

  1253. 

  1254.     if ((null != m_currentElementName)

  1255.             && (m_currentElementName.equalsIgnoreCase("SCRIPT")

  1256.                 || m_currentElementName.equalsIgnoreCase("STYLE")))

  1257.     {

  1258.       try

  1259.       {

  1260.         writeParentTagEnd();

  1261. 

  1262.         m_ispreserve = true;

  1263. 

  1264.         if (shouldIndent())

  1265.           indent(m_currentIndent);

  1266. 

  1267.         // this.accum(ch, start, length);

  1268.         writeNormalizedChars(ch, start, length, true);

  1269.       }

  1270.       catch (IOException ioe)

  1271.       {

  1272.         throw new org.xml.sax.SAXException(

  1273.           XSLMessages.createXPATHMessage(

  1274.           XPATHErrorResources.ER_OIERROR, null), ioe);  //"IO error", ioe);

  1275.       }

  1276.     }

  1277. 

  1278.     /*

  1279.     else if(m_stripCData) // should normally always be false

  1280.     {

  1281.       try

  1282.       {

  1283.         writeParentTagEnd();

  1284.         m_ispreserve = true;

  1285.         if (shouldIndent())

  1286.           indent(m_currentIndent);

  1287.         // this.accum("<![CDATA[");

  1288.         this.accum(ch, start, length);

  1289.         // this.accum("]]>");

  1290.       }

  1291.       catch(IOException ioe)

  1292.       {

  1293.         throw new org.xml.sax.SAXException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_OIERROR, null),ioe); //"IO error", ioe);

  1294.       }

  1295.     }

  1296.     */

  1297.     else

  1298.     {

  1299.       super.cdata(ch, start, length);

  1300.     }

  1301.   }

  1302. 

  1303.   /**

  1304.    *  Receive notification of a processing instruction.

  1305.    *

  1306.    *  @param target The processing instruction target.

  1307.    *  @param data The processing instruction data, or null if

  1308.    *         none was supplied.

  1309.    *  @throws org.xml.sax.SAXException Any SAX exception, possibly

  1310.    *             wrapping another exception.

  1311.    *

  1312.    * @throws org.xml.sax.SAXException

  1313.    */

  1314.   public void processingInstruction(String target, String data)

  1315.           throws org.xml.sax.SAXException

  1316.   {

  1317. 

  1318.     // Use a fairly nasty hack to tell if the next node is supposed to be 

  1319.     // unescaped text.

  1320.     if (target.equals(Result.PI_DISABLE_OUTPUT_ESCAPING))

  1321.     {

  1322.       startNonEscaping();

  1323.     }

  1324.     else if (target.equals(Result.PI_ENABLE_OUTPUT_ESCAPING))

  1325.     {

  1326.       endNonEscaping();

  1327.     }

  1328.     else

  1329.     {

  1330.       writeParentTagEnd();

  1331. 

  1332.       if (shouldIndent())

  1333.         indent(m_currentIndent);

  1334. 

  1335.       this.accum("<?" + target);

  1336. 

  1337.       if (data.length() > 0 &&!Character.isSpaceChar(data.charAt(0)))

  1338.         this.accum(" ");

  1339. 

  1340.       this.accum(data + ">");  // different from XML

  1341.       

  1342.       // Always output a newline char if not inside of an 

  1343.       // element. The whitespace is not significant in that

  1344.       // case.

  1345.       if (m_elemStack.isEmpty())

  1346.          outputLineSep();

  1347. 

  1348.       m_startNewLine = true;

  1349.     }

  1350.   }

  1351. 

  1352.   /**

  1353.    * Receive notivication of a entityReference.

  1354.    *

  1355.    * @param name non-null reference to entity name string.

  1356.    *

  1357.    * @throws org.xml.sax.SAXException

  1358.    */

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

  1360.   {

  1361. 

  1362.     this.accum("&");

  1363.     this.accum(name);

  1364.     this.accum(";");

  1365.   }

  1366. }

  1367.