开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
DOMWriterImpl.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：60k
源码类别：

词法分析

开发平台：

Visual C++

DOMWriterImpl.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their featName, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: DOMWriterImpl.cpp,v 1.39 2003/05/18 14:02:03 knoaman Exp $
  59.  * $Log: DOMWriterImpl.cpp,v $
  60.  * Revision 1.39  2003/05/18 14:02:03  knoaman
  61.  * Memory manager implementation: pass per instance manager.
  62.  *
  63.  * Revision 1.38  2003/05/16 21:36:55  knoaman
  64.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  65.  *
  66.  * Revision 1.37  2003/05/15 18:25:54  knoaman
  67.  * Partial implementation of the configurable memory manager.
  68.  *
  69.  * Revision 1.36  2003/05/14 16:20:13  gareth
  70.  * Fix to problem with multiple default namespace attributes being serialized. Patch by Alberto Massari.
  71.  *
  72.  * Revision 1.35  2003/05/12 16:08:11  gareth
  73.  * fix to #18832. Corrected serilization with regards to namespace nodes. Patch by Alby Massari.
  74.  *
  75.  * Revision 1.34  2003/05/06 13:48:35  neilg
  76.  * fix GCC compilation problem and incorrect #include
  77.  *
  78.  * Revision 1.33  2003/05/05 21:23:21  neilg
  79.  * use of the new DOMNodeSPtr typedef and its friends to enable reference counting in
  80.  * the DOMWriter implementation for applications that require it.
  81.  *
  82.  * Revision 1.32  2003/04/02 03:14:42  peiyongz
  83.  * Bug#18594: DOMWriter does not recognize Document Fragment
  84.  *
  85.  * Revision 1.31  2003/03/16 05:42:04  peiyongz
  86.  * Bug#17983 Formatter does not escape control characters
  87.  *
  88.  * Revision 1.30  2003/02/25 16:07:37  tng
  89.  * [Bug 13493] Use const on static data in DOMWriterImpl.cpp.
  90.  *
  91.  * Revision 1.29  2003/01/28 18:31:47  peiyongz
  92.  * Bug#13694: Allow Xerces to write the BOM to XML files
  93.  *
  94.  * Revision 1.28  2003/01/24 20:21:46  tng
  95.  * DOMWriter: Call XMLFormatTarget::flush when done.
  96.  *
  97.  * Revision 1.27  2003/01/20 16:50:13  tng
  98.  * DOMWriter fix:
  99.  * 1. wrong wrong nested cdata message
  100.  * 2. pretty format the cdata section
  101.  * 3. do not increment error count if warning was issued
  102.  *
  103.  * Revision 1.26  2003/01/09 19:53:45  tng
  104.  * [Bug 15372] DOMBuilder::parseFromURI ignores result of handleErrors.
  105.  *
  106.  * Revision 1.25  2002/12/10 21:01:32  tng
  107.  * NLS: DOMWriter should use message loader to load message instead of using hardcoded static stirng
  108.  *
  109.  * Revision 1.24  2002/12/10 18:59:14  tng
  110.  * pretty format print: consistent newline
  111.  *
  112.  * Revision 1.23  2002/12/10 13:34:07  tng
  113.  * Pretty-format print: also indent PI/comment that appear inside the root element.
  114.  *
  115.  * Revision 1.22  2002/12/09 11:46:08  gareth
  116.  * More pretty pretty print feature. Patch by Kevin King. Closes bug #13840.
  117.  *
  118.  * Revision 1.21  2002/12/02 23:08:09  peiyongz
  119.  * fix to bug#14528: output n+1 cdatasection
  120.  *
  121.  * Revision 1.20  2002/11/13 21:51:22  peiyongz
  122.  * fix to Bug#14528
  123.  *
  124.  * Revision 1.19  2002/11/04 15:07:35  tng
  125.  * C++ Namespace Support.
  126.  *
  127.  * Revision 1.18  2002/10/03 18:13:38  peiyongz
  128.  * Bug#12560 Use const in DOMWriter - patch from Duncan Stodart
  129.  *                                                              (Duncan_Stodart@insession.com )
  130.  *
  131.  * Revision 1.17  2002/09/24 20:19:14  tng
  132.  * Performance: use XMLString::equals instead of XMLString::compareString
  133.  * and check for null string directly isntead of calling XMLString::stringLen
  134.  *
  135.  * Revision 1.16  2002/09/09 15:42:14  peiyongz
  136.  * Patch to Bug#12369: invalid output from DOMWriter using MemBufFormatTarget
  137.  *
  138.  * Revision 1.15  2002/08/07 18:10:19  peiyongz
  139.  * Fix to Bug#11534: Wrong CDATA Terminator in DOMWriterImpl
  140.  *
  141.  * Revision 1.14  2002/07/22 23:24:01  tng
  142.  * DOM L3: writeToString should use the fFormatter to do the transcoding
  143.  *
  144.  * Revision 1.13  2002/07/16 15:19:42  peiyongz
  145.  * check lenght of getEncoding()/getActualEncoding()
  146.  *
  147.  * Revision 1.12  2002/06/25 16:17:16  tng
  148.  * DOM L3: add release()
  149.  *
  150.  * Revision 1.11  2002/06/21 19:33:12  peiyongz
  151.  * support for feature split_cdata_section and entities revised.
  152.  *
  153.  * Revision 1.10  2002/06/18 15:35:25  peiyongz
  154.  * Bug#9950: Compilation error on MSVC5, patch from PeterV@ti.com.od.ua (Peter A. Volchek)
  155.  *
  156.  * Revision 1.9  2002/06/17 19:45:58  peiyongz
  157.  * optimization on fFeatures and featureId introduced
  158.  *
  159.  * Revision 1.8  2002/06/11 19:45:45  peiyongz
  160.  * Notify application of the XMLFormatter creation failure
  161.  *
  162.  * Revision 1.7  2002/06/10 16:02:21  peiyongz
  163.  * format-pretty-print partially supported
  164.  * resolve encoding from DOMDocument Interface
  165.  *
  166.  * Revision 1.6  2002/06/06 20:58:37  tng
  167.  * [Bug 9639] enum_mem in DOMError clashes with constant.
  168.  *
  169.  * Revision 1.5  2002/06/05 16:03:03  peiyongz
  170.  * delete[] used.
  171.  *
  172.  * Revision 1.4  2002/06/03 22:35:54  peiyongz
  173.  * constants changed
  174.  *
  175.  * Revision 1.3  2002/05/31 21:01:06  peiyongz
  176.  * move printing of XMLDecl into the processNode().
  177.  *
  178.  * Revision 1.2  2002/05/29 21:31:50  knoaman
  179.  * DOM L3 LS: DOMInputSource, DOMEntityResolver, DOMImplementationLS and DOMBuilder
  180.  *
  181.  * Revision 1.1  2002/05/28 22:39:39  peiyongz
  182.  * DOM3 Save Interface: DOMWriter/DOMWriterFilter
  183.  *
  184.  */
  186. #include "DOMWriterImpl.hpp"
  187. #include "DOMErrorImpl.hpp"
  188. #include "DOMLocatorImpl.hpp"
  189. #include "DOMImplementationImpl.hpp"
  191. #include <xercesc/framework/MemBufFormatTarget.hpp>
  193. #include <xercesc/util/TransService.hpp>
  194. #include <xercesc/util/TranscodingException.hpp>
  195. #include <xercesc/util/Janitor.hpp>
  196. #include <xercesc/util/XMLString.hpp>
  197. #include <xercesc/util/XMLUniDefs.hpp>
  198. #include <xercesc/util/XMLMsgLoader.hpp>
  199. #include <xercesc/dom/StDOMNode.hpp>
  202. XERCES_CPP_NAMESPACE_BEGIN
  205. // ---------------------------------------------------------------------------
  206. //  Local const data
  207. //
  208. // ---------------------------------------------------------------------------
  210. static const int INVALID_FEATURE_ID               = -1;
  211. static const int CANONICAL_FORM_ID                = 0x0;
  212. static const int DISCARD_DEFAULT_CONTENT_ID       = 0x1;
  213. static const int ENTITIES_ID                      = 0x2;
  214. static const int FORMAT_PRETTY_PRINT_ID           = 0x3;
  215. static const int NORMALIZE_CHARACTERS_ID          = 0x4;
  216. static const int SPLIT_CDATA_SECTIONS_ID          = 0x5;
  217. static const int VALIDATION_ID                    = 0x6;
  218. static const int WHITESPACE_IN_ELEMENT_CONTENT_ID = 0x7;
  219. static const int BYTE_ORDER_MARK_ID               = 0x8;
  221. //    feature                      true                       false
  222. // ================================================================================
  223. //canonical-form                 [optional] Not Supported     [required] (default)
  224. //discard-default-content        [required] (default)         [required]
  225. //entity                         [required] (default)         [optional]
  226. //format-pretty-print            [optional] Partially Supported [required] (default)
  227. //normalize-characters           [optional] Not Supported     [required] (default)
  228. //split-cdata-sections           [required] (default)         [required]
  229. //validation                     [optional] Not Supported     [required] (default)
  230. //whitespace-in-element-content  [requierd] (default)         [optional] Not Supported
  231. //
  233. //
  234. // Each feature has 2 entries in this array,
  235. // the first for "true",
  236. // the second for "false".
  237. //
  238. static const bool  featuresSupported[] = {
  239.     false, true,  // canonical-form
  240.     true,  true,  // discard-default-content
  241.     true,  true,  // entity
  242.     true,  true,  // format-pretty-print
  243.     false, true,  // normalize-characters
  244.     true,  true,  // split-cdata-sections
  245.     false, true,  // validation
  246.     true,  false, // whitespace-in-element-content
  247.     true,  true   // byte-order-mark
  248. };
  250. // default end-of-line sequence
  251. static const XMLCh  gEOLSeq[] =
  252. {
  253.     chLF, chNull
  254. };
  256. //UTF-8
  257. static const XMLCh  gUTF8[] =
  258. {
  259.     chLatin_U, chLatin_T, chLatin_F, chDash, chDigit_8, chNull
  260. };
  262. //</
  263. static const XMLCh  gEndElement[] =
  264. {
  265.     chOpenAngle, chForwardSlash, chNull
  266. };
  268. //?>
  269. static const XMLCh  gEndPI[] =
  270. {
  271.     chQuestion, chCloseAngle, chNull
  272. };
  274. //<?
  275. static const XMLCh  gStartPI[] =
  276. {
  277.     chOpenAngle, chQuestion, chNull
  278. };
  280. //<?xml version="
  281. static const XMLCh  gXMLDecl_VersionInfo[] =
  282. {
  283.     chOpenAngle, chQuestion, chLatin_x,     chLatin_m,  chLatin_l,  chSpace,
  284.     chLatin_v,   chLatin_e,  chLatin_r,     chLatin_s,  chLatin_i,  chLatin_o,
  285.     chLatin_n,   chEqual,    chDoubleQuote, chNull
  286. };
  288. static const XMLCh gXMLDecl_ver10[] =
  289. {
  290.     chDigit_1, chPeriod, chDigit_0, chNull
  291. };
  293. //encoding="
  294. static const XMLCh  gXMLDecl_EncodingDecl[] =
  295. {
  296.     chLatin_e,  chLatin_n,  chLatin_c,  chLatin_o,      chLatin_d, chLatin_i,
  297.     chLatin_n,  chLatin_g,  chEqual,    chDoubleQuote,  chNull
  298. };
  300. //" standalone="
  301. static const XMLCh  gXMLDecl_SDDecl[] =
  302. {
  303.     chLatin_s, chLatin_t, chLatin_a,   chLatin_n,    chLatin_d,   chLatin_a,
  304.     chLatin_l, chLatin_o, chLatin_n,   chLatin_e,    chEqual,     chDoubleQuote,
  305.     chNull
  306. };
  308. //"
  309. static const XMLCh  gXMLDecl_separator[] =
  310. {
  311.     chDoubleQuote, chSpace, chNull
  312. };
  314. //?>
  315. static const XMLCh  gXMLDecl_endtag[] =
  316. {
  317.     chQuestion, chCloseAngle,  chNull
  318. };
  320. //<![CDATA[
  321. static const XMLCh  gStartCDATA[] =
  322. {
  323.     chOpenAngle, chBang,    chOpenSquare, chLatin_C, chLatin_D,
  324.     chLatin_A,   chLatin_T, chLatin_A,    chOpenSquare, chNull
  325. };
  327. //]]>
  328. static const XMLCh  gEndCDATA[] =
  329. {
  330. //    chCloseSquare, chCloseAngle, chCloseAngle, chNull  // test only: ]>>
  331.       chCloseSquare, chCloseSquare, chCloseAngle, chNull
  332. };
  334. static const int offset = XMLString::stringLen(gEndCDATA);
  336. //<!--
  337. static const XMLCh  gStartComment[] =
  338. {
  339.     chOpenAngle, chBang, chDash, chDash, chNull
  340. };
  342. //-->
  343. static const XMLCh  gEndComment[] =
  344. {
  345.     chDash, chDash, chCloseAngle, chNull
  346. };
  348. //<!DOCTYPE
  349. static const XMLCh  gStartDoctype[] =
  350. {
  351.     chOpenAngle, chBang,    chLatin_D, chLatin_O, chLatin_C, chLatin_T,
  352.     chLatin_Y,   chLatin_P, chLatin_E, chSpace,   chNull
  353. };
  355. //PUBLIC "
  356. static const XMLCh  gPublic[] =
  357. {
  358.     chLatin_P, chLatin_U, chLatin_B,     chLatin_L, chLatin_I,
  359.     chLatin_C, chSpace,   chDoubleQuote, chNull
  360. };
  362. //SYSTEM "
  363. static const XMLCh  gSystem[] =
  364. {
  365.     chLatin_S, chLatin_Y, chLatin_S,     chLatin_T, chLatin_E,
  366.     chLatin_M, chSpace,   chDoubleQuote, chNull
  367. };
  369. //<!ENTITY
  370. static const XMLCh  gStartEntity[] =
  371. {
  372.     chOpenAngle, chBang,    chLatin_E, chLatin_N, chLatin_T, chLatin_I,
  373.     chLatin_T,   chLatin_Y, chSpace,   chNull
  374. };
  376. //NDATA "
  377. static const XMLCh  gNotation[] =
  378. {
  379.     chLatin_N, chLatin_D,     chLatin_A, chLatin_T, chLatin_A,
  380.     chSpace,   chDoubleQuote, chNull
  381. };
  383. //Feature
  384. static const XMLCh  gFeature[] =
  385. {
  386.     chLatin_F, chLatin_e, chLatin_a, chLatin_t, chLatin_u, chLatin_r,
  387.     chLatin_e, chSpace,   chNull
  388. };
  390. // Can not be set to
  391. static const XMLCh  gCantSet[] =
  392. {
  393.     chSpace,   chLatin_C, chLatin_a, chLatin_n, chSpace, chLatin_n, chLatin_o,
  394.     chLatin_t, chSpace,   chLatin_b, chLatin_e, chSpace, chLatin_s,
  395.     chLatin_e, chLatin_t, chSpace,   chLatin_t, chLatin_o, chSpace, chNull
  396. };
  398. static const XMLCh  gTrue[] =
  399. {
  400.     chSingleQuote, chLatin_t, chLatin_r, chLatin_u, chLatin_e,
  401.     chSingleQuote, chLF,      chNull
  402. };
  404. static const XMLCh  gFalse[] =
  405. {
  406.     chSingleQuote, chLatin_f, chLatin_a, chLatin_l, chLatin_s,
  407.     chLatin_e,     chSingleQuote, chLF, chNull
  408. };
  410. static const XMLByte  BOM_utf16be[] = {(XMLByte)0xFE, (XMLByte)0xFF, (XMLByte) 0};
  411. static const XMLByte  BOM_utf16le[] = {(XMLByte)0xFF, (XMLByte)0xFE, (XMLByte) 0};
  412. static const XMLByte  BOM_ucs4be[]  = {(XMLByte)0x00, (XMLByte)0x00, (XMLByte)0xFE, (XMLByte)0xFF, (XMLByte) 0};
  413. static const XMLByte  BOM_ucs4le[]  = {(XMLByte)0xFF, (XMLByte)0xFE, (XMLByte)0x00, (XMLByte)0x00, (XMLByte) 0};
  415. static const XMLCh s_xmlnsURI[] = // "http://www.w3.org/2000/xmlns/"
  416.     {  chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
  417.        chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod,
  418.        chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
  419.        chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash,
  420.        chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chForwardSlash, chNull};
  421. static const XMLCh s_xmlns[] = {chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
  422. static const XMLCh s_xmlURI[] =    // "http://www.w3.org/XML/1998/namespace"
  423.     { chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
  424.       chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod,
  425.       chLatin_o, chLatin_r, chLatin_g, chForwardSlash, chLatin_X, chLatin_M, chLatin_L, chForwardSlash,
  426.       chDigit_1, chDigit_9, chDigit_9, chDigit_8, chForwardSlash,
  427.       chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chLatin_p, chLatin_a, chLatin_c, chLatin_e,
  428.       chNull};
  430. //
  431. // Notification of the error though error handler
  432. //
  433. // The application may instruct the engine to abort serialization
  434. // by returning "false".
  435. //
  436. // REVISIT: update the locator ctor once the line#, col#, uri and offset
  437. // are available from DOM3 core
  438. //
  439. // REVISIT: use throwing exception to abort serialization is an interesting
  440. // thing here, since the serializer is a recusive function, we
  441. // can't use return, obviously. However we may have multiple try/catch
  442. // along its way going back to writeNode(). So far we don't come up with a
  443. // "short-cut" to go "directly" back.
  444. //
  445. #define  TRY_CATCH_THROW(action, forceToRethrow)                     
  446. fFormatter->setUnRepFlags(XMLFormatter::UnRep_Fail);                 
  447. try                                                                  
  448. {                                                                    
  449.     action;                                                          
  450. }                                                                    
  451. catch(TranscodingException const &e)                                 
  452. {                                                                    
  453.     if ( !reportError(nodeToWrite                                    
  454.                     , DOMError::DOM_SEVERITY_FATAL_ERROR             
  455.                     , e.getMessage())                       ||       
  456.           forceToRethrow)                                            
  457.         throw e;                                                       
  458. }
  460. DOMWriterImpl::~DOMWriterImpl()
  461. {
  462.     fMemoryManager->deallocate(fEncoding);//delete [] fEncoding;
  463.     fMemoryManager->deallocate(fNewLine);//delete [] fNewLine;
  464.     delete fNamespaceStack;
  465.     // we don't own/adopt error handler and filter
  466. }
  468. DOMWriterImpl::DOMWriterImpl(MemoryManager* const manager)
  469. :fFeatures(0)
  470. ,fEncoding(0)
  471. ,fNewLine(0)
  472. ,fErrorHandler(0)
  473. ,fFilter(0)
  474. ,fDocumentVersion(XMLUni::fgVersion1_0)
  475. ,fEncodingUsed(0)
  476. ,fNewLineUsed(0)
  477. ,fFormatter(0)
  478. ,fErrorCount(0)
  479. ,fCurrentLine(0)
  480. ,fNamespaceStack(0)
  481. ,fMemoryManager(manager)
  482. {
  483.     fNamespaceStack=new (fMemoryManager) RefVectorOf< RefHashTableOf<XMLCh> >(0,true, fMemoryManager);
  485.     //
  486.     // set features to default setting
  487.     //
  488.     setFeature(CANONICAL_FORM_ID,                false);
  489.     setFeature(DISCARD_DEFAULT_CONTENT_ID,       true );
  490.     setFeature(ENTITIES_ID,                      true );
  491.     setFeature(FORMAT_PRETTY_PRINT_ID,           false);
  492.     setFeature(NORMALIZE_CHARACTERS_ID,          false);
  493.     setFeature(SPLIT_CDATA_SECTIONS_ID,          true );
  494.     setFeature(VALIDATION_ID,                    false);
  495.     setFeature(WHITESPACE_IN_ELEMENT_CONTENT_ID, true );
  496.     setFeature(BYTE_ORDER_MARK_ID,               false);
  497. }
  499. bool DOMWriterImpl::canSetFeature(const XMLCh* const featName
  500.                                   , bool               state) const
  501. {
  502.     int featureId = INVALID_FEATURE_ID;
  503.     return checkFeature(featName, false, featureId) ? canSetFeature(featureId, state) : false;
  504. }
  506. void DOMWriterImpl::setFeature(const XMLCh* const featName
  507.                              , bool               state)
  508. {
  509.     int featureId = INVALID_FEATURE_ID;
  510.     checkFeature(featName, true, featureId);
  512.     if (!canSetFeature(featureId, state))
  513.     {
  514.         XMLCh  tmpbuf[256];
  515.         XMLString::copyString(tmpbuf, gFeature);
  516.         XMLString::catString(tmpbuf, featName);
  517.         XMLString::catString(tmpbuf, gCantSet);
  518.         XMLString::catString(tmpbuf, state? gTrue : gFalse);
  519.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, tmpbuf);
  520.     }
  521.     else
  522.         setFeature(featureId, state);
  524.     //
  525.     // canonical-form and format-pretty-print can not be both set to true
  526.     // meaning set canonical-form true will automatically set
  527.     // format-pretty-print to false and vise versa.
  528.     //
  529.     if ((featureId == CANONICAL_FORM_ID) && state)
  530.         setFeature(FORMAT_PRETTY_PRINT_ID, false);
  532.     if ((featureId == FORMAT_PRETTY_PRINT_ID) && state)
  533.         setFeature(CANONICAL_FORM_ID, false);
  535.     return;
  536. }
  538. bool DOMWriterImpl::getFeature(const XMLCh* const featName) const
  539. {
  540.     int featureId = INVALID_FEATURE_ID;
  541.     checkFeature(featName, true, featureId);
  542.     return getFeature(featureId);
  543. }
  545. // we don't check the validity of the encoding set
  546. void DOMWriterImpl::setEncoding(const XMLCh* const encoding)
  547. {
  548.     fMemoryManager->deallocate(fEncoding);//delete [] fEncoding;
  549.     fEncoding = XMLString::replicate(encoding, fMemoryManager);
  550. }
  552. const XMLCh* DOMWriterImpl::getEncoding() const
  553. {
  554.     return fEncoding;
  555. }
  557. void DOMWriterImpl::setNewLine(const XMLCh* const newLine)
  558. {
  559.     fMemoryManager->deallocate(fNewLine);//delete [] fNewLine;
  560.     fNewLine = XMLString::replicate(newLine, fMemoryManager);
  561. }
  563. const XMLCh* DOMWriterImpl::getNewLine() const
  564. {
  565.     return fNewLine;
  566. }
  568. void DOMWriterImpl::setErrorHandler(DOMErrorHandler *errorHandler)
  569. {
  570.     fErrorHandler = errorHandler;
  571. }
  573. DOMErrorHandler* DOMWriterImpl::getErrorHandler() const
  574. {
  575.     return fErrorHandler;
  576. }
  578. void DOMWriterImpl::setFilter(DOMWriterFilter *filter)
  579. {
  580.     fFilter = filter;
  581. }
  583. DOMWriterFilter* DOMWriterImpl::getFilter() const
  584. {
  585.     return fFilter;
  586. }
  588. //
  589. //
  590. //
  591. bool DOMWriterImpl::writeNode(XMLFormatTarget* const destination
  592.                             , const DOMNode         &nodeToWrite)
  593. {
  594.     //init session vars
  595.     initSession(&nodeToWrite);
  597.     try
  598.     {
  599.         fFormatter = new (fMemoryManager) XMLFormatter(fEncodingUsed
  600.                                      ,fDocumentVersion
  601.                                      ,destination
  602.                                      ,XMLFormatter::NoEscapes
  603.                                      ,XMLFormatter::UnRep_CharRef);
  604.     }
  605.     catch (const TranscodingException& e)
  606.     {
  607.         reportError(&nodeToWrite, DOMError::DOM_SEVERITY_FATAL_ERROR, e.getMessage());
  608.         return false;
  609.     }
  611.     try
  612.     {
  613.         Janitor<XMLFormatter> janName(fFormatter);
  614.         processNode(&nodeToWrite);
  615.         destination->flush();
  616.     }
  618.     //
  619.     // The serialize engine (processNode) throws an exception to abort
  620.     // serialization if
  621.     //
  622.     //   . A fatal error occurs which renters the output ill-formed, or
  623.     //   . Instructed by the application's error handler
  624.     //
  625.     catch (const TranscodingException&)
  626.     {
  627.         destination->flush();
  628.         return false;
  629.     }
  631.     catch (const XMLDOMMsg::Codes)
  632.     {
  633.         destination->flush();
  634.         return false;
  635.     }
  637.     //
  638.     // DOMSystemException
  639.     // This exception will be raised in response to any sort of IO or system
  640.     // error that occurs while writing to the destination. It may wrap an
  641.     // underlying system exception.
  642.     //
  643.     //catch (RuntimeException const &)
  644.     catch (...)
  645.     {
  646.         // REVISIT generate a DOMSystemException wrapping the underlying
  647.         //         exception.
  648.         destination->flush();
  649.         throw;
  650.     }
  652.     //
  653.     // true if node was successfully serialized and
  654.     // false in case a failure occured and the
  655.     // failure wasn't canceled by the error handler.
  656.     //
  657.     return ((fErrorCount == 0)? true : false);
  658. }
  660. //
  661. // We don't throw DOMSTRING_SIZE_ERR since we are no longer
  662. // using DOMString.
  663. //
  664. XMLCh* DOMWriterImpl::writeToString(const DOMNode &nodeToWrite)
  665. {
  666.     MemBufFormatTarget  destination(1023, fMemoryManager);
  667.     bool retVal;
  669.     // XMLCh is unicode, assume fEncoding as UTF-16
  670.     XMLCh* tempEncoding = fEncoding;
  671.     fEncoding = (XMLCh*) XMLUni::fgUTF16EncodingString;
  673.     try
  674.     {
  675.         retVal = writeNode(&destination, nodeToWrite);
  676.     }
  677.     catch (...)
  678.     {
  679.         //
  680.         // there is a possibility that memeory allocation
  681.         // exception thrown in XMLBuffer class
  682.         //
  683.         fEncoding = tempEncoding;
  684.         return 0;
  685.     }
  687.     fEncoding = tempEncoding;
  688.     return (retVal ? XMLString::replicate((XMLCh*) destination.getRawBuffer()) : 0);
  689. }
  691. void DOMWriterImpl::initSession(const DOMNode* const nodeToWrite)
  692. {
  694. /**
  695.  * The encoding to use when writing is determined as follows:
  696.  *     If the encoding attribute has been set, that value will be used.
  697.  *     If the encoding attribute is null or empty,
  698.  *            but the item to be written, or
  699.  *            the owner document specified encoding (ie. the "actualEncoding"
  700.  *            from the document) that value will be used.
  701.  *     If neither of the above provides an encoding name, a default encoding of
  702.  *            "UTF-8" will be used.
  703.  */
  704.     fEncodingUsed = gUTF8;
  706.     if (fEncoding && *fEncoding)
  707.     {
  708.         fEncodingUsed = fEncoding;
  709.     }
  710.     else
  711.     {
  712.         const DOMDocument *docu = (nodeToWrite->getNodeType() == DOMNode::DOCUMENT_NODE)?
  713.                             (const DOMDocument*)nodeToWrite : nodeToWrite->getOwnerDocument();
  714.         if (docu)
  715.         {
  716.             const XMLCh* tmpEncoding = docu->getEncoding();
  718.             if ( tmpEncoding && *tmpEncoding)
  719.             {
  720.                 fEncodingUsed = tmpEncoding;
  721.             }
  722.             else
  723.             {
  724.                 tmpEncoding = docu->getActualEncoding();
  726.                 if ( tmpEncoding && *tmpEncoding)
  727.                 {
  728.                     fEncodingUsed = tmpEncoding;
  729.                 }
  730.             }
  731.         }
  732.     }
  734.     /**
  735.      *  The end-of-line sequence of characters to be used in the XML being
  736.      *  written out. The only permitted values are these:
  737.      *     . null
  738.      *
  739.      *  Use a default end-of-line sequence. DOM implementations should choose
  740.      * the default to match the usual convention for text files in the
  741.      * environment being used. Implementations must choose a default
  742.      * sequence that matches one of those allowed by  2.11 "End-of-Line
  743.      * Handling".
  744.      *
  745.      *    CR    The carriage-return character (#xD)
  746.      *    CR-LF The carriage-return and line-feed characters (#xD #xA)
  747.      *    LF    The line-feed character (#xA)
  748.      *
  749.      *  The default value for this attribute is null
  750.      */
  751.     fNewLineUsed = (fNewLine && *fNewLine)? fNewLine : gEOLSeq;
  753.     /**
  754.      *  get Document Version
  755.      */
  756.     const DOMDocument *docu = (nodeToWrite->getNodeType() == DOMNode::DOCUMENT_NODE)?
  757.                               (const DOMDocument*)nodeToWrite : nodeToWrite->getOwnerDocument();
  758.     if (docu)
  759.     {
  760.         fDocumentVersion = docu->getVersion();
  761.     }
  763.     fErrorCount = 0;
  764. }
  766. //
  767. // Characters not representable in output encoding,
  768. //
  769. // 1. CHARACTER DATA (outside of markup)                --- no error
  770. //    ordinary character  -> numeric character reference
  771. //    '<' and '&'         -> &lt; and &amp;
  772. //
  773. // 2. Within MARKUP, but outside of attributes
  774. //    reported as an error                                 --- ERROR
  775. //    markup:
  776. //           start tag                                  done
  777. //           end tag                                    done
  778. //           empty element tag                          done
  779. //           entity references                          done
  780. //           character references    // REVISIT
  781. //           comments                                   done
  782. //           CDATA section delimiters                   done, done
  783. //           document type declarartions                done
  784. //           processing instructions (PI)               done
  785. //
  786. // 3. With in ATTRIBUTE
  787. //    -> numeric character reference
  788. //    no quotes                        -> in quotes
  789. //    with quotes, no apostrophe       -> in apostrophe
  790. //    with quotes and apostrophe       -> in quotes and &quot;
  791. //
  792. // 4. CDATA sections
  793. //    "split_cdata_section"  true                      --- char ref
  794. //                           false                     ---      ERROR
  795. //
  796. // ---------------------------------------------------------------------------
  797. //  Stream out a DOM node, and, recursively, all of its children. This
  798. //  function is the heart of writing a DOM tree out as XML source. Give it
  799. //  a document node and it will do the whole thing.
  800. // ---------------------------------------------------------------------------
  802. void DOMWriterImpl::processNode(const DOMNode* const nodeToWrite, int level)
  803. {
  805.     // Get the name and value out for convenience
  806.     const XMLCh*    nodeName = nodeToWrite->getNodeName();
  807.     const XMLCh*    nodeValue = nodeToWrite->getNodeValue();
  808.     unsigned long   lent = XMLString::stringLen(nodeValue);
  810.     switch (nodeToWrite->getNodeType())
  811.     {
  812.     case DOMNode::TEXT_NODE:
  813.         {
  814.             if (checkFilter(nodeToWrite) != DOMNodeFilter::FILTER_ACCEPT)
  815.                 break;
  817.             //skip ws if pretty print
  818.             if (getFeature(FORMAT_PRETTY_PRINT_ID))
  819.             {
  820.                 if(XMLString::isAllWhiteSpace(nodeValue))
  821.                     break;
  822.             }
  824.             setURCharRef();      // character data
  825.             fFormatter->formatBuf(nodeValue, lent, XMLFormatter::CharEscapes);
  826.             break;
  827.         }
  829.     case DOMNode::PROCESSING_INSTRUCTION_NODE:
  830.         {
  831.             if (checkFilter(nodeToWrite) != DOMNodeFilter::FILTER_ACCEPT)
  832.                 break;
  834.             if(level == 1)
  835.                 printNewLine();
  837.             printNewLine();
  838.             printIndent(level);
  840.             TRY_CATCH_THROW
  841.             (
  842.                 *fFormatter << XMLFormatter::NoEscapes << gStartPI << nodeName;
  843.                 if (lent > 0)
  844.                 {
  845.                     *fFormatter << chSpace << nodeValue;
  846.                 }
  847.                 *fFormatter << gEndPI;
  848.                 ,true
  849.             )
  850.             break;
  851.         }
  853.     case DOMNode::DOCUMENT_NODE: // Not to be shown to Filter
  854.         {
  856.             // output BOM if needed
  857.             processBOM();          
  858.             
  859.             setURCharRef();
  860.             const DOMDocument *docu = (const DOMDocument*)nodeToWrite;
  861.         
  862.             //[23] XMLDecl      ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
  863.             //[24] VersionInfo  ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
  864.             //[80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName
  865.             //[32] SDDecl       ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
  866.             //
  867.             // We always print out the xmldecl no matter whether it is
  868.             // present in the original XML instance document or not.
  869.             //
  870.             const XMLCh* versionNo = (docu->getVersion()) ? docu->getVersion() : gXMLDecl_ver10;
  871.             *fFormatter << gXMLDecl_VersionInfo << versionNo << gXMLDecl_separator;
  873.             // use the encoding resolved in initSession()
  874.             *fFormatter << gXMLDecl_EncodingDecl << fEncodingUsed << gXMLDecl_separator;
  876.             const XMLCh* st = (docu->getStandalone())? XMLUni::fgYesString : XMLUni::fgNoString;
  877.             *fFormatter << gXMLDecl_SDDecl << st << gXMLDecl_separator;
  879.             *fFormatter << gXMLDecl_endtag;
  881.             DOMNodeSPtr child = nodeToWrite->getFirstChild();
  882.             while( child != 0)
  883.             {
  884.                 processNode(child, level);
  885.                 child = child->getNextSibling();
  886.             }
  887.             printNewLine();
  888.             break;
  889.         }
  891.     case DOMNode::DOCUMENT_FRAGMENT_NODE:
  892.         {
  893.            
  894.             setURCharRef();
  896.             DOMNode *child = nodeToWrite->getFirstChild();
  897.             while( child != 0)
  898.             {
  899.                 processNode(child, level);
  900.                 child = child->getNextSibling();
  901.             }
  902.             printNewLine();
  903.             break;
  904.         }
  906.     case DOMNode::ELEMENT_NODE:
  907.         {
  908.             DOMNodeFilter::FilterAction filterAction = checkFilter(nodeToWrite);
  910.             if ( filterAction == DOMNodeFilter::FILTER_REJECT)
  911.                 break;
  913.             if(level == 1)
  914.                 printNewLine();
  916.             printNewLine();
  917.             printIndent(level);
  919.             //track the line number the current node begins on
  920.             int nodeLine = fCurrentLine;
  922.             // add an entry in the namespace stack
  923.             RefHashTableOf<XMLCh>* namespaceMap=new (fMemoryManager) RefHashTableOf<XMLCh>(12, false, fMemoryManager);
  924.             fNamespaceStack->addElement(namespaceMap);
  926.             if ( filterAction == DOMNodeFilter::FILTER_ACCEPT)
  927.             {
  928.                 //           this element    attributes   child elements
  929.                 // accept        yes             yes           yes
  930.                 // skip          no              no            yes
  931.                 //
  932.                 TRY_CATCH_THROW
  933.                 (
  934.                 // The name has to be representable without any escapes
  935.                     *fFormatter  << XMLFormatter::NoEscapes
  936.                                  << chOpenAngle << nodeName;
  937.                     ,true
  938.                 )
  940.                 // Output any attributes on this element
  941.                 setURCharRef();
  942.                 DOMNamedNodeMap *attributes = nodeToWrite->getAttributes();
  943.                 int attrCount = attributes->getLength();
  945.                 // check if the namespace for the current node is already defined
  946.                 const XMLCh* prefix = nodeToWrite->getPrefix();
  947.                 const XMLCh* uri = nodeToWrite->getNamespaceURI();
  948.                 if(uri && uri[0])
  949.                 {
  950.                     if(prefix==0 || prefix[0]==0)
  951.                         prefix=XMLUni::fgZeroLenString;
  952.                     bool bPrefixDeclared=false;
  953.                     for(int i=fNamespaceStack->size()-1;i>=0;i--)
  954.                     {
  955.                         RefHashTableOf<XMLCh>* curNamespaceMap=fNamespaceStack->elementAt(i);
  956.                         const XMLCh* thisUri=curNamespaceMap->get((void*)prefix);
  957.                         if(thisUri && XMLString::equals(thisUri,nodeToWrite->getNamespaceURI()))
  958.                         {
  959.                             bPrefixDeclared=true;
  960.                             break;
  961.                         }
  962.                     }
  963.                     if(!bPrefixDeclared)
  964.                     {
  965.                         namespaceMap->put((void*)prefix,(XMLCh*)nodeToWrite->getNamespaceURI());
  966.                         *fFormatter  << XMLFormatter::NoEscapes
  967.                                      << chSpace << s_xmlns;
  968.                         if(!XMLString::equals(prefix,XMLUni::fgZeroLenString))
  969.                             *fFormatter  << chColon << prefix;
  970.                         *fFormatter  << chEqual << chDoubleQuote
  971.                                      << XMLFormatter::AttrEscapes
  972.                                      << nodeToWrite->getNamespaceURI()
  973.                                      << XMLFormatter::NoEscapes
  974.                                      << chDoubleQuote;
  975.                     }
  976.                 }
  978.                 bool discard = getFeature(DISCARD_DEFAULT_CONTENT_ID);
  979.                 for (int i = 0; i < attrCount; i++)
  980.                 {
  981.                     DOMAttrSPtr  attribute = (DOMAttr*)attributes->item(i);
  983.                     // Not to be shown to Filter
  985.                     //
  986.                     //"discard-default-content"
  987.                     //    true
  988.                     //    [required] (default)
  989.                     //    Use whatever information available to the implementation
  990.                     //  (i.e. XML schema, DTD, the specified flag on Attr nodes,
  991.                     //  and so on) to decide what attributes and content should be
  992.                     //  discarded or not.
  993.                     //  Note that the specified flag on Attr nodes in itself is
  994.                     //  not always reliable, it is only reliable when it is set
  995.                     //  to false since the only case where it can be set to false
  996.                     //  is if the attribute was created by the implementation.
  997.                     //  The default content won't be removed if an implementation
  998.                     //  does not have any information available.
  999.                     //    false
  1000.                     //    [required]
  1001.                     //    Keep all attributes and all content.
  1002.                     //
  1003.                     if (discard && !((DOMAttr*)attribute )->getSpecified())
  1004.                         continue;
  1005.                     //
  1006.                     //  Again the name has to be completely representable. But the
  1007.                     //  attribute can have refs and requires the attribute style
  1008.                     //  escaping.
  1009.                     //
  1011.                     // if this attribute is a namespace declaration, add it to the namespace map for the current level
  1012.                     const XMLCh* ns = attribute->getNamespaceURI();
  1013.                     if (ns != 0 )
  1014.                     {
  1015.                         if(XMLString::equals(ns, s_xmlnsURI)) 
  1016.                         {
  1017.                 const XMLCh* nsPrefix = attribute->getLocalName();
  1018.                             if(XMLString::equals(attribute->getNodeName(),s_xmlns))
  1019. nsPrefix = XMLUni::fgZeroLenString;
  1020. if(namespaceMap->containsKey((void*)nsPrefix))
  1021. continue;
  1022.                             namespaceMap->put((void*)attribute->getLocalName(),(XMLCh*)attribute->getNodeValue());
  1023.                         }
  1024.                         else if(!XMLString::equals(ns, s_xmlURI)) 
  1025.                         {
  1026.                             // check if the namespace for the current node is already defined
  1027.                             const XMLCh* prefix = attribute->getPrefix();
  1028.                             if(prefix && prefix[0])
  1029.                             {
  1030.                                 bool bPrefixDeclared=false;
  1031.                                 for(int i=fNamespaceStack->size()-1;i>=0;i--)
  1032.                                 {
  1033.                                     RefHashTableOf<XMLCh>* curNamespaceMap=fNamespaceStack->elementAt(i);
  1034.                                     const XMLCh* thisUri=curNamespaceMap->get((void*)prefix);
  1035.                                     if(thisUri && XMLString::equals(thisUri,attribute->getNamespaceURI()))
  1036.                                     {
  1037.                                         bPrefixDeclared=true;
  1038.                                         break;
  1039.                                     }
  1040.                                 }
  1041.                                 if(!bPrefixDeclared)
  1042.                                 {
  1043.                                     namespaceMap->put((void*)prefix,(XMLCh*)attribute->getNamespaceURI());
  1044.                                     *fFormatter  << XMLFormatter::NoEscapes
  1045.                                                  << chSpace << s_xmlns << chColon << prefix
  1046.                                                  << chEqual << chDoubleQuote
  1047.                                                  << XMLFormatter::AttrEscapes
  1048.                                                  << attribute->getNamespaceURI()
  1049.                                                  << XMLFormatter::NoEscapes
  1050.                                                  << chDoubleQuote;
  1051.                                 }
  1052.                             }
  1053.                         }
  1054.                     }
  1055.                     *fFormatter  << XMLFormatter::NoEscapes
  1056.                                  << chSpace << attribute->getNodeName()
  1057.                                  << chEqual << chDoubleQuote
  1058.                                  << XMLFormatter::AttrEscapes
  1059.                                  << attribute->getNodeValue()
  1060.                                  << XMLFormatter::NoEscapes
  1061.                                  << chDoubleQuote;
  1062.                 } // end of for
  1063.             } // end of FILTER_ACCEPT
  1065.             level++;
  1067.             // FILTER_SKIP may start from here
  1069.             //
  1070.             //  Test for the presence of children, which includes both
  1071.             //  text content and nested elements.
  1072.             //
  1073.             DOMNodeSPtr child = nodeToWrite->getFirstChild();
  1074.             if (child != 0)
  1075.             {
  1076.                 // There are children. Close start-tag, and output children.
  1077.                 // No escapes are legal here
  1078.                 if (filterAction == DOMNodeFilter::FILTER_ACCEPT)
  1079.                     *fFormatter << XMLFormatter::NoEscapes << chCloseAngle;
  1081.                 while( child != 0)
  1082.                 {
  1083.                     processNode(child, level);
  1084.                     child = child->getNextSibling();
  1085.                 }
  1087.                 level--;
  1089.                 if (filterAction == DOMNodeFilter::FILTER_ACCEPT)
  1090.                 {
  1091.                     //if we are not on the same line as when we started
  1092.                     //this node then print a new line and indent
  1093.                     if(nodeLine != fCurrentLine)
  1094.                     {
  1095.                         printNewLine();
  1097.                         if(nodeLine != fCurrentLine && level == 0)
  1098.                             printNewLine();
  1100.                         printIndent(level);
  1101.                     }
  1102.                     TRY_CATCH_THROW
  1103.                     (
  1104.                          *fFormatter << XMLFormatter::NoEscapes << gEndElement
  1105.                                      << nodeName << chCloseAngle;
  1106.                         ,true
  1107.                     )
  1109.                 }
  1110.             }
  1111.             else
  1112.             {
  1113.                 level--;
  1115.                 //
  1116.                 //  There were no children. Output the short form close of
  1117.                 //  the element start tag, making it an empty-element tag.
  1118.                 //
  1119.                 if (filterAction == DOMNodeFilter::FILTER_ACCEPT)
  1120.                 {
  1121.                     TRY_CATCH_THROW
  1122.                     (
  1123.                         *fFormatter << XMLFormatter::NoEscapes << chForwardSlash << chCloseAngle;
  1124.                        , true
  1125.                     )
  1126.                 }
  1127.             }
  1129.             // remove the namespace map at this level
  1130.             fNamespaceStack->removeLastElement();
  1132.             break;
  1133.         }
  1135.     case DOMNode::ENTITY_REFERENCE_NODE:
  1136.         {
  1137.             //"entities"
  1138.             //true
  1139.             //[required] (default)
  1140.             //Keep EntityReference and Entity nodes in the document.
  1142.             //false
  1143.             //[optional]
  1144.             //Remove all EntityReference and Entity nodes from the document,
  1145.             //       putting the entity expansions directly in their place.
  1146.             //       Text nodes are into "normal" form.
  1147.             //Only EntityReference nodes to non-defined entities are kept in the document.
  1149.             if (checkFilter(nodeToWrite) != DOMNodeFilter::FILTER_ACCEPT)
  1150.                 break;
  1152.             if (getFeature(ENTITIES_ID))
  1153.             {
  1154.                 TRY_CATCH_THROW
  1155.                 (
  1156.                     *fFormatter << XMLFormatter::NoEscapes << chAmpersand
  1157.                                 << nodeName << chSemiColon;
  1158.                     , true
  1159.                 )
  1160.             }
  1161.             else
  1162.             {
  1163.                 // check if the referenced entity is defined or not
  1164.                 if (nodeToWrite->getOwnerDocument()->getDoctype()->getEntities()->getNamedItem(nodeName))
  1165.                 {
  1166.                     DOMNodeSPtr child;
  1167.                     for (child = nodeToWrite->getFirstChild();
  1168.                     child != 0;
  1169.                     child = child->getNextSibling())
  1170.                     {
  1171.                         processNode(child, level);
  1172.                     }
  1173.                 }
  1174.                 else
  1175.                 {
  1176.                     TRY_CATCH_THROW
  1177.                    (
  1178.                         *fFormatter<<XMLFormatter::NoEscapes<<chAmpersand<<nodeName<<chSemiColon;
  1179.                         , true
  1180.                     )
  1181.                 }
  1182.             }
  1183.             break;
  1184.         }
  1186.         //
  1187.         //  feature:split_cdata_sections     occurence of ]]>   unrep-char
  1188.         //  ===============================================================
  1189.         //          true                        split            split
  1190.         //          false                       fails            fails
  1191.         //
  1192.     case DOMNode::CDATA_SECTION_NODE:
  1193.         {
  1194.             if (checkFilter(nodeToWrite) != DOMNodeFilter::FILTER_ACCEPT)
  1195.                 break;
  1197.             if(level == 1)
  1198.                 printNewLine();
  1200.             printNewLine();
  1201.             printIndent(level);
  1203.             if (getFeature(SPLIT_CDATA_SECTIONS_ID))
  1204.             {
  1205.                 // it is fairly complicated and we process this
  1206.                 // in a separate function.
  1207.                 procCdataSection(nodeValue, nodeToWrite, level);
  1208.             }
  1209.             else
  1210.             {
  1211.                 // search for "]]>", the node value is not supposed to have this
  1212.                 if (XMLString::patternMatch((XMLCh* const) nodeValue, gEndCDATA) != -1)
  1213.                 {
  1214.                     reportError(nodeToWrite, DOMError::DOM_SEVERITY_FATAL_ERROR, XMLDOMMsg::Writer_NestedCDATA);
  1215.                 }
  1217.                 TRY_CATCH_THROW
  1218.                 (
  1219.                     // transcoder throws exception for unrep chars
  1220.                     *fFormatter << XMLFormatter::NoEscapes << gStartCDATA << nodeValue << gEndCDATA;
  1221.                    , true
  1222.                 )
  1223.             }
  1225.             break;
  1226.         }
  1228.     case DOMNode::COMMENT_NODE:
  1229.         {
  1230.             if (checkFilter(nodeToWrite) != DOMNodeFilter::FILTER_ACCEPT)
  1231.                 break;
  1233.             if(level == 1)
  1234.                 printNewLine();
  1236.             printNewLine();
  1237.             printIndent(level);
  1239.             TRY_CATCH_THROW
  1240.             (
  1241.                 *fFormatter << XMLFormatter::NoEscapes << gStartComment
  1242.                 << nodeValue << gEndComment;
  1243.                 , true
  1244.             )
  1245.             break;
  1246.         }
  1248.     case DOMNode::DOCUMENT_TYPE_NODE:  // Not to be shown to Filter
  1249.         {
  1250.             const DOMDocumentType *doctype = (const DOMDocumentType *)nodeToWrite;;
  1252.             fFormatter->setEscapeFlags(XMLFormatter::NoEscapes);
  1254.             printNewLine();
  1255.             printIndent(level);
  1257.             TRY_CATCH_THROW
  1258.             (
  1259.                 *fFormatter << gStartDoctype << nodeName;
  1261.                 const XMLCh  *id = doctype->getPublicId();
  1262.                 if (id && *id)
  1263.                 {
  1264.                     *fFormatter << chSpace << gPublic << id << chDoubleQuote;
  1266.                     id = doctype->getSystemId();
  1267.                     if (id && *id)
  1268.                     {
  1269.                         *fFormatter << chSpace << chDoubleQuote << id << chDoubleQuote;
  1270.                     }
  1271.                     else
  1272.                     {
  1273.                         //
  1274.                         // 4.2.2 External Entities
  1275.                         // [Definition: If the entity is not internal,
  1276.                         //           it is an external entity, declared as follows:]
  1277.                         // External Entity Declaration
  1278.                         // [75] ExternalID ::= 'SYSTEM' S SystemLiteral
  1279.                         //                   | 'PUBLIC' S PubidLiteral S SystemLiteral
  1280.                         //
  1281.                         reportError(nodeToWrite, DOMError::DOM_SEVERITY_FATAL_ERROR, XMLDOMMsg::Writer_NotRecognizedType);
  1282.                         // systemLiteral not found
  1283.                     }
  1284.                 }
  1285.                 else
  1286.                 {
  1287.                     id = doctype->getSystemId();
  1288.                     if (id && *id)
  1289.                     {
  1290.                         *fFormatter << chSpace << gSystem << id << chDoubleQuote;
  1291.                     }
  1292.                 }
  1294.                 id = doctype->getInternalSubset();
  1295.                 if (id && *id)
  1296.                 {
  1297.                     *fFormatter << chSpace << chOpenSquare << id << chCloseSquare;
  1298.                 }
  1300.                 *fFormatter << chCloseAngle;
  1301.                 , true
  1303.             ) // end of TRY_CATCH_THROW
  1305.             break;
  1306.         }
  1308.     case DOMNode::ENTITY_NODE:  // Not to be shown to Filter
  1309.         {
  1310.             //
  1311.             // REVISIT: how does the feature "entities" impact
  1312.             // entity node?
  1313.             //
  1314.             printNewLine();
  1315.             printIndent(level);
  1317.             fFormatter->setEscapeFlags(XMLFormatter::NoEscapes);
  1318.             *fFormatter << gStartEntity    << nodeName;
  1320.             const XMLCh * id = ((const DOMEntity*)nodeToWrite)->getPublicId();
  1321.             if (id)
  1322.                 *fFormatter << gPublic << id << chDoubleQuote;
  1324.             id = ((const DOMEntity*)nodeToWrite)->getSystemId();
  1325.             if (id)
  1326.                 *fFormatter << gSystem << id << chDoubleQuote;
  1328.             id = ((const DOMEntity*)nodeToWrite)->getNotationName();
  1329.             if (id)
  1330.                 *fFormatter << gNotation << id << chDoubleQuote;
  1332.             *fFormatter << chCloseAngle;
  1334.             break;
  1335.         }
  1337.     default:
  1338.         /***
  1339.             This is an implementation specific behaviour, we abort serialization
  1340.             once unrecognized node type encountered.
  1341.          ***/
  1342.         {
  1343.             reportError(nodeToWrite, DOMError::DOM_SEVERITY_FATAL_ERROR, XMLDOMMsg::Writer_NotRecognizedType);
  1344.             // UnreognizedNodeType;
  1345.         }
  1347.         break;
  1348.     }
  1350. }
  1352. //
  1353. //
  1354. DOMNodeFilter::FilterAction DOMWriterImpl::checkFilter(const DOMNode* const node) const
  1355. {
  1356.     if (!fFilter ||
  1357.         ((fFilter->getWhatToShow() & (1 << (node->getNodeType() - 1))) == 0))
  1358.         return DOMNodeFilter::FILTER_ACCEPT;
  1360.     //
  1361.     // if and only if there is a filter, and it is interested
  1362.     // in the node type, then we pass the node to the filter
  1363.     // for examination
  1364.     //
  1365.     return (DOMNodeFilter::FilterAction) fFilter->acceptNode(node);
  1366. }
  1369. bool DOMWriterImpl::checkFeature(const XMLCh* const featName
  1370.                                , bool               toThrow
  1371.                                , int&               featureId) const
  1372. {
  1373.     // check for null and/or empty feature name
  1374.     if (!featName || !*featName)
  1375.     {
  1376.         if (toThrow)
  1377.             throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  1379.         return false;
  1380.     }
  1382.     featureId = INVALID_FEATURE_ID;
  1384.     if (XMLString::equals(featName, XMLUni::fgDOMWRTCanonicalForm))
  1385.         featureId = CANONICAL_FORM_ID;
  1386.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTDiscardDefaultContent))
  1387.         featureId = DISCARD_DEFAULT_CONTENT_ID;
  1388.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTEntities))
  1389.         featureId = ENTITIES_ID;
  1390.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTFormatPrettyPrint))
  1391.         featureId = FORMAT_PRETTY_PRINT_ID;
  1392.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTNormalizeCharacters))
  1393.         featureId = NORMALIZE_CHARACTERS_ID;
  1394.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTSplitCdataSections))
  1395.         featureId = SPLIT_CDATA_SECTIONS_ID;
  1396.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTValidation))
  1397.         featureId = VALIDATION_ID;
  1398.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTWhitespaceInElementContent))
  1399.         featureId = WHITESPACE_IN_ELEMENT_CONTENT_ID;
  1400.     else if (XMLString::equals(featName, XMLUni::fgDOMWRTBOM))
  1401.         featureId = BYTE_ORDER_MARK_ID;
  1403.     //feature name not resolvable
  1404.     if (featureId == INVALID_FEATURE_ID)
  1405.     {
  1406.         if (toThrow)
  1407.             throw DOMException(DOMException::NOT_FOUND_ERR, featName);
  1409.         return false;
  1410.     }
  1412.     return true;
  1413. }
  1415. bool DOMWriterImpl::reportError(const DOMNode* const    errorNode
  1416.                               , DOMError::ErrorSeverity errorType
  1417.                               , const XMLCh*   const    errorMsg)
  1418. {
  1419.     bool toContinueProcess = true;   // default value for no error handler
  1421.     if (fErrorHandler)
  1422.     {
  1423.         DOMLocatorImpl  locator(0, 0, (DOMNode* const) errorNode, 0, 0);
  1424.         DOMErrorImpl    domError(errorType , errorMsg, &locator);
  1425.         toContinueProcess = fErrorHandler->handleError(domError);
  1426.     }
  1428.     if (errorType != DOMError::DOM_SEVERITY_WARNING)
  1429.         fErrorCount++;
  1431.     return toContinueProcess;
  1432. }
  1434. bool DOMWriterImpl::reportError(const DOMNode* const    errorNode
  1435.                               , DOMError::ErrorSeverity errorType
  1436.                               , XMLDOMMsg::Codes        toEmit)
  1437. {
  1438.     const unsigned int msgSize = 1023;
  1439.     XMLCh errText[msgSize + 1];
  1441.     DOMImplementationImpl::getMsgLoader4DOM()->loadMsg(toEmit, errText, msgSize);
  1443.     bool toContinueProcess = true;   // default value for no error handler
  1445.     if (fErrorHandler)
  1446.     {
  1447.         DOMLocatorImpl  locator(0, 0, (DOMNode* const) errorNode, 0, 0);
  1448.         DOMErrorImpl    domError(errorType , errText, &locator);
  1449.         toContinueProcess = fErrorHandler->handleError(domError);
  1450.     }
  1452.     if (errorType != DOMError::DOM_SEVERITY_WARNING)
  1453.         fErrorCount++;
  1455.     if (errorType == DOMError::DOM_SEVERITY_FATAL_ERROR || !toContinueProcess)
  1456.         throw toEmit;
  1458.     return toContinueProcess;
  1459. }
  1461. //
  1462. //
  1463. //
  1464. void DOMWriterImpl::procCdataSection(const XMLCh*   const nodeValue
  1465.                                    , const DOMNode* const nodeToWrite
  1466.                                    , int level)
  1467. {
  1468.     /***
  1469.      * Append a ']]>' at the end
  1470.      */
  1471.     int len = XMLString::stringLen(nodeValue);
  1472.     XMLCh* repNodeValue = (XMLCh*) fMemoryManager->allocate
  1473.     (
  1474.         (len + offset + 1) * sizeof(XMLCh)
  1475.     );//new XMLCh [len + offset + 1];
  1476.     XMLString::copyString(repNodeValue, nodeValue);
  1477.     XMLString::catString(repNodeValue, gEndCDATA);
  1478.     ArrayJanitor<XMLCh>  jName(repNodeValue, fMemoryManager);
  1480.     XMLCh* curPtr  = (XMLCh*) repNodeValue;
  1481.     XMLCh* nextPtr = 0;
  1482.     int    endTagPos = -1;
  1484.     bool   endTagFound = true;
  1486.     while (endTagFound)
  1487.     {
  1488.         endTagPos = XMLString::patternMatch(curPtr, gEndCDATA);
  1489.         if (endTagPos != -1)
  1490.         {
  1491.             nextPtr = curPtr + endTagPos + offset;  // skip the ']]>'
  1492.             *(curPtr + endTagPos) = chNull;         //nullify the first ']'
  1493.             if (endTagPos != len)
  1494.                 reportError(nodeToWrite, DOMError::DOM_SEVERITY_WARNING, XMLDOMMsg::Writer_NestedCDATA);
  1495.             len = len - endTagPos - offset;
  1496.         }
  1497.         else
  1498.         {
  1499.             endTagFound = false;
  1500.         }
  1502.         /***
  1503.             to check ]]>]]>
  1504.         ***/
  1505.         if (endTagPos == 0)
  1506.         {
  1507.             printNewLine();
  1508.             printIndent(level);
  1509.             TRY_CATCH_THROW
  1510.             (
  1511.                 *fFormatter << XMLFormatter::NoEscapes << gStartCDATA << gEndCDATA;
  1512.                 , true
  1513.             )
  1514.         }
  1515.         else
  1516.         {
  1517.             procUnrepCharInCdataSection(curPtr, nodeToWrite, level);
  1518.         }
  1520.         if (endTagFound)
  1521.         {
  1522.             *(nextPtr - offset) = chCloseSquare;   //restore the first ']'
  1523.             curPtr = nextPtr;
  1524.         }
  1525.     }
  1527.     return;
  1528. }
  1530. //
  1531. //
  1532. //
  1533. void DOMWriterImpl::procUnrepCharInCdataSection(const XMLCh*   const nodeValue
  1534.                                               , const DOMNode* const nodeToWrite
  1535.                                               , int level)
  1536. {
  1537.     //
  1538.     //  We have to check each character and see if it could be represented.
  1539.     //  As long as it can, we just keep up with where we started and how
  1540.     //  many chars we've checked. When we hit an unrepresentable one, we
  1541.     //  stop, transcode everything we've collected, then start handling
  1542.     //  the unrepresentables via char refs. We repeat this until we get all
  1543.     //  the chars done.
  1544.     //
  1545.     const XMLCh*    srcPtr = nodeValue;
  1546.     const XMLCh*    endPtr = nodeValue +  XMLString::stringLen(nodeValue);;
  1548.     // Set up the common part of the buffer that we build char refs into
  1549.     XMLCh tmpBuf[32];
  1550.     tmpBuf[0] = chAmpersand;
  1551.     tmpBuf[1] = chPound;
  1552.     tmpBuf[2] = chLatin_x;
  1554.     while (srcPtr < endPtr)
  1555.     {
  1556.         const XMLCh* tmpPtr = srcPtr;
  1557.         while (tmpPtr < endPtr)
  1558.         {
  1559.             if (fFormatter->getTranscoder()->canTranscodeTo(*tmpPtr))
  1560.                 tmpPtr++;
  1561.             else
  1562.                 break;
  1563.         }
  1565.         if (tmpPtr > srcPtr)
  1566.         {
  1567.             printNewLine();
  1568.             printIndent(level);
  1569.             TRY_CATCH_THROW
  1570.            (
  1571.                 *fFormatter << XMLFormatter::NoEscapes << gStartCDATA;
  1572.                 , true
  1573.             )
  1575.             // We got at least some chars that can be done normally
  1576.             fFormatter->formatBuf
  1577.             (
  1578.                 srcPtr
  1579.                 , tmpPtr - srcPtr
  1580.                 , XMLFormatter::NoEscapes
  1581.                 , XMLFormatter::UnRep_Fail
  1582.             );
  1584.             TRY_CATCH_THROW
  1585.             (
  1586.                 *fFormatter << XMLFormatter::NoEscapes << gEndCDATA;
  1587.                 , true
  1588.             )
  1590.             // Update the source pointer to our new spot
  1591.             srcPtr = tmpPtr;
  1592.         }
  1593.         else
  1594.         {
  1595.             //
  1596.             //  We hit something unrepresentable. So continue forward doing
  1597.             //  char refs until we hit something representable again or the
  1598.             //  end of input.
  1599.             //
  1601.             // one warning for consective unrep chars
  1602.             reportError(nodeToWrite, DOMError::DOM_SEVERITY_WARNING, XMLDOMMsg::Writer_NotRepresentChar);
  1604.             while (srcPtr < endPtr)
  1605.             {
  1606.                 // Build a char ref for the current char
  1607.                 XMLString::binToText(*srcPtr, &tmpBuf[3], 8, 16);
  1608.                 const unsigned int bufLen = XMLString::stringLen(tmpBuf);
  1609.                 tmpBuf[bufLen] = chSemiColon;
  1610.                 tmpBuf[bufLen+1] = chNull;
  1612.                 // And now call recursively back to our caller to format this
  1613.                 fFormatter->formatBuf
  1614.                 (
  1615.                     tmpBuf
  1616.                     , bufLen + 1
  1617.                     , XMLFormatter::NoEscapes
  1618.                     , XMLFormatter::UnRep_Fail
  1619.                 );
  1621.                 // Move up the source pointer and break out if needed
  1622.                 srcPtr++;
  1623.                 if (fFormatter->getTranscoder()->canTranscodeTo(*srcPtr))
  1624.                     break;
  1625.             }
  1626.         }
  1627.     }
  1628. }
  1630. void DOMWriterImpl::processNode(const DOMNode* const nodeToWrite)
  1631. {
  1632.     processNode(nodeToWrite, 0);
  1633. }
  1635. bool DOMWriterImpl::canSetFeature(const int featureId
  1636.                                        , bool      val) const
  1637. {
  1638.     return featuresSupported[2*featureId + (val? 0: 1)];
  1639. }
  1641. void DOMWriterImpl::printNewLine()
  1642. {
  1643.     if (getFeature(FORMAT_PRETTY_PRINT_ID))
  1644.     {
  1645.         fCurrentLine++;
  1646.         *fFormatter << fNewLineUsed;
  1647.     }
  1648. }
  1650. void DOMWriterImpl::printIndent(int level) const
  1651. {
  1652.     if (getFeature(FORMAT_PRETTY_PRINT_ID))
  1653.     {
  1654.         for(int i = 0; i < level; i++)
  1655.             *fFormatter << chSpace << chSpace;
  1656.     }
  1657. }
  1659. void DOMWriterImpl::release()
  1660. {
  1661.     DOMWriterImpl* writer = (DOMWriterImpl*) this;
  1662.     delete writer;
  1663. }
  1665. void DOMWriterImpl::processBOM()
  1666. {
  1667.     // if the feature is not set, don't output bom
  1668.     if (!getFeature(BYTE_ORDER_MARK_ID))
  1669.         return;
  1671.     if ((XMLString::compareIString(fEncoding, XMLUni::fgUTF16LEncodingString)  == 0) ||
  1672.         (XMLString::compareIString(fEncoding, XMLUni::fgUTF16LEncodingString2) == 0)  )
  1673.     {
  1674.         fFormatter->writeBOM(BOM_utf16le, 2);
  1675.     }
  1676.     else if ((XMLString::compareIString(fEncoding, XMLUni::fgUTF16BEncodingString)  == 0) ||
  1677.              (XMLString::compareIString(fEncoding, XMLUni::fgUTF16BEncodingString2) == 0)  )
  1678.     {
  1679.         fFormatter->writeBOM(BOM_utf16be, 2);
  1680.     }
  1681.     else if ((XMLString::compareIString(fEncoding, XMLUni::fgUTF16EncodingString)  == 0) ||
  1682.              (XMLString::compareIString(fEncoding, XMLUni::fgUTF16EncodingString2) == 0) ||
  1683.              (XMLString::compareIString(fEncoding, XMLUni::fgUTF16EncodingString3) == 0) ||
  1684.              (XMLString::compareIString(fEncoding, XMLUni::fgUTF16EncodingString4) == 0) ||
  1685.              (XMLString::compareIString(fEncoding, XMLUni::fgUTF16EncodingString5) == 0)  ) 
  1686.     {
  1687. #if defined(ENDIANMODE_LITTLE)
  1688.             fFormatter->writeBOM(BOM_utf16le, 2);
  1689. #elif defined(ENDIANMODE_BIG)
  1690.             fFormatter->writeBOM(BOM_utf16be, 2);
  1691. #endif
  1692.     }
  1693.     else if ((XMLString::compareIString(fEncoding, XMLUni::fgUCS4LEncodingString)  == 0) ||
  1694.              (XMLString::compareIString(fEncoding, XMLUni::fgUCS4LEncodingString2) == 0)  )
  1695.     {
  1696.         fFormatter->writeBOM(BOM_ucs4le, 4);
  1697.     }
  1698.     else if ((XMLString::compareIString(fEncoding, XMLUni::fgUCS4BEncodingString)  == 0) ||
  1699.              (XMLString::compareIString(fEncoding, XMLUni::fgUCS4BEncodingString2) == 0)  )
  1700.     {
  1701.         fFormatter->writeBOM(BOM_ucs4be, 4);
  1702.     }
  1703.     else if ((XMLString::compareIString(fEncoding, XMLUni::fgUCS4EncodingString)  == 0) ||
  1704.              (XMLString::compareIString(fEncoding, XMLUni::fgUCS4EncodingString2) == 0) ||
  1705.              (XMLString::compareIString(fEncoding, XMLUni::fgUCS4EncodingString3) == 0)  )
  1706.     {
  1707. #if defined(ENDIANMODE_LITTLE)
  1708.         fFormatter->writeBOM(BOM_ucs4le, 4);
  1709. #elif defined(ENDIANMODE_BIG)
  1710.         fFormatter->writeBOM(BOM_ucs4be, 4);
  1711. #endif
  1712.     }
  1714.     return;
  1716. }
  1718. XERCES_CPP_NAMESPACE_END