1 /*

     2 * Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "cxml_internal.h"

    20 #include <xml/cxml/nw_dom_node.h>

    21 #include <xml/cxml/nw_dom_document.h>

    22 #include <xml/cxml/nw_dom_element.h>

    23 #include <xml/cxml/nw_tinytree.h>

    24 #include <xml/cxml/nw_encoder_wbxmlwriter.h>

    25 #include <xml/cxml/nw_xmlp_xmlp2wbxml.h>

    26 #include <xml/cxml/nw_tinydom_utils.h>

    27 

    28 /*#include "nw_parser.h"*/

    29 

    30 /************************

    31 * DOCUMENT - NODE Methods

    32 *************************/

    33 

    34 EXPORT_C void

    35 NW_DOM_DocumentNode_Delete(NW_DOM_DocumentNode_t* docNode){

    36   NW_WBXML_Parser_t *wbxmlParser;

    37   NW_TinyDom_Tree_t *tinyDomTree;

    38   NW_WBXML_Document_t *document;

    39   NW_TinyTree_t *tinyTree;

    40 

    41 if (docNode == NULL) {

    42     return;

    43   }

    44 

    45   tinyTree = NW_TinyTree_Node_findTree(docNode);

    46   

    47   if(tinyTree != NULL){

    48     document = NW_TinyDom_getDocHeader(tinyTree);

    49     tinyDomTree = NW_TinyDom_getTree(tinyTree);

    50     wbxmlParser = tinyDomTree->parser;

    51     if(wbxmlParser != NULL){

    52       NW_WBXML_Parser_delete(wbxmlParser);

    53     }

    54     if(tinyDomTree != NULL){

    55       NW_TinyDom_Tree_destruct(tinyDomTree);

    56     }

    57     if(document != NULL){

    58       NW_WBXML_Document_destruct(document);

    59     }

    60   }

    61 }

    62   /* ???? Does the writer need any cleanup ? */

    63 

    64 

    65 static void

    66 NW_TinyDom_Handle_Initialize(NW_TinyDom_Handle_t *h, 

    67                              NW_Uint32 default_public_id,

    68                              NW_Bool extTNotStringTable)

    69 {  

    70   NW_ASSERT(h != NULL);

    71 

    72   (void) NW_Mem_memset(h, 0, sizeof(*h));

    73 

    74   NW_WBXML_Parser_newInPlace (&(h->wbxmlParser));

    75   h->wbxmlParser.ext_t_not_table_index =(NW_Uint8)((extTNotStringTable == NW_FALSE)?

    76                                           CXML_FALSE : CXML_TRUE);

    77   NW_WBXML_Document_construct(&(h->document), default_public_id);

    78   NW_TinyDom_Tree_construct (&(h->tinyDOMTree), 

    79                              &(h->wbxmlParser), 

    80                              &(h->document), 

    81                              &(h->writer));

    82   NW_TinyDom_Parser_construct (&(h->tinyParser), &(h->tinyDOMTree));

    83 }

    84 

    85 

    86 /* ************************************************************************/

    87 

    88 /*

    89  * Create and populate a dom tree by parsing a buffer, returning the

    90  * document node.

    91  */

    92 

    93 EXPORT_C

    94 NW_DOM_DocumentNode_t * 

    95 NW_DOM_DocumentNode_BuildWBXMLTree(NW_TinyDom_Handle_t *h, 

    96                                    NW_Byte *buffer,

    97                                    NW_Int32 length,

    98                                    NW_Bool freeBuff,

    99                                    NW_Bool extTNotStringTable)

   100 {

   101   NW_Status_t status;

   102 

   103   NW_ASSERT(h != NULL);

   104 

   105   NW_TinyDom_Handle_Initialize(h, 0, extTNotStringTable);

   106 

   107   status = NW_TinyDom_Parser_buildTree (&(h->tinyParser), 

   108                                         (char *)buffer, 

   109                                         (NW_Uint32)length,

   110                                         freeBuff);

   111   if (status == NW_STAT_SUCCESS) {

   112     return  h->tinyDOMTree.root_node;

   113   }

   114   return NULL;

   115 }

   116 

   117 /*

   118  * This function is same at that of NW_DOM_DocumentNode_BuildWBXMLTree(..)

   119  * but returns the error code.

   120  */

   121 

   122 static

   123 NW_DOM_DocumentNode_t * 

   124 CXML_DOM_DocumentNode_BuildWBXMLTree(NW_TinyDom_Handle_t *h, 

   125                                    NW_Byte *buffer,

   126                                    NW_Int32 length,

   127                                    NW_Bool freeBuff,

   128                                    NW_Bool extTNotStringTable,

   129                                    NW_Status_t* errorStatus)

   130 {

   131   NW_Status_t status;

   132 

   133   NW_ASSERT(h != NULL);

   134 

   135   NW_TinyDom_Handle_Initialize(h, 0, extTNotStringTable);

   136 

   137   status = NW_TinyDom_Parser_buildTree (&(h->tinyParser), 

   138                                         (char *)buffer, 

   139                                         (NW_Uint32)length,

   140                                         freeBuff);

   141   if (status == NW_STAT_SUCCESS) 

   142   {

   143     *errorStatus = status;

   144     return  h->tinyDOMTree.root_node;

   145   }

   146   *errorStatus = status;

   147   return NULL;

   148 }

   149 

   150 

   151 /* Function to copy the string table extension values from the 

   152  * WBXML encoder to WBXML parser

   153  */

   154 

   155 static NW_Status_t

   156 NW_DOM_Write_WBXML_StrTbl(NW_TinyDom_Handle_t *p, void* WBXMLEncStrTbl)

   157 {

   158      NW_Status_t status = NW_STAT_SUCCESS;

   159      NW_Status_t s = NW_STAT_WBXML_ITERATE_DONE;

   160      NW_Uint32 stringTableByteCount = 0;

   161      NW_Encoder_StringTableIterator_t strTableIterator;

   162      NW_Uint8* pLiteralBuf;

   163      NW_String_t pLiteralStr;

   164      NW_Uint32 docTableIndex;

   165      NW_Encoder_StringTable_t* strTable = NULL;

   166      NW_WBXML_Document_t* doc = &(p->document);

   167          

   168      strTable = (NW_Encoder_StringTable_t*) WBXMLEncStrTbl;

   169 

   170      stringTableByteCount = NW_Encoder_StringTable_getTotalBytes(strTable);

   171      

   172      

   173      if(stringTableByteCount > 0)

   174      {

   175         /*The following function always return success so why bother to check? */

   176 

   177         NW_Encoder_StringTable_StringTableIterateInit(WBXMLEncStrTbl,&strTableIterator);

   178 

   179 

   180         s =  NW_Encoder_StringTable_StringTableIterateNext

   181                     (&strTableIterator,&stringTableByteCount,&pLiteralBuf);

   182 

   183         while(s == NW_STAT_WBXML_ITERATE_MORE)

   184         {

   185 

   186          pLiteralStr.length = stringTableByteCount;

   187          pLiteralStr.storage = pLiteralBuf;

   188 

   189          status =  NW_WBXML_Document_putTableString(doc,&pLiteralStr,&docTableIndex) ;

   190 

   191          if(status != NW_STAT_SUCCESS)

   192          {

   193           break;

   194          }

   195 

   196            s =  NW_Encoder_StringTable_StringTableIterateNext

   197                     (&strTableIterator,&stringTableByteCount,&pLiteralBuf) ;

   198 

   199         }/*end while */

   200 

   201      }/*end if(stringTableByteCount > 0)*/

   202 

   203      //Delete the tree

   204 

   205      NW_Encoder_StringTable_delete(WBXMLEncStrTbl);

   206      WBXMLEncStrTbl = NULL;

   207  return status;

   208 }/*end NW_DOM_Write_WBXML_StrTbl()*/

   209 

   210 static

   211 NW_DOM_DocumentNode_t*

   212 NW_DOM_DocumentNode_BuildXMLTree(NW_TinyDom_Handle_t *h, 

   213                                  NW_Byte *buffer,

   214                                  NW_Int32 length,

   215                                  NW_Uint32 publicID,

   216                                  NW_Bool extTNotStringTable)

   217 {

   218 

   219   NW_Buffer_t inBuff;

   220   NW_Buffer_t *outBuff = NULL;

   221   NW_Uint32 encoding;

   222   NW_Endianness_t endianness;

   223   NW_DOM_DocumentNode_t* docNode;

   224   NW_Status_t status;

   225   NW_Uint32 line;

   226   void* WBXMLEncStrTbl;

   227 

   228   inBuff.length = length;

   229   inBuff.data = buffer;

   230 

   231   status = NW_XML_ComputeEncoding(length, 

   232                                   buffer,

   233                                   &encoding, 

   234                                   &endianness);

   235   if(status != NW_STAT_SUCCESS){

   236     return NULL;

   237   }

   238 

   239 /*

   240  * If applications want to use HTML Parser they can call the exported

   241  * NW_HTMLP_HtmlToWbxml() and then call NW_DOM_DocumentNode_BuildWBXMLTree()

   242  */

   243   status = NW_XML_XmlToWbxml(&inBuff, encoding, &outBuff, &line, publicID,&WBXMLEncStrTbl); 

   244 

   245  

   246 

   247   if(status != NW_STAT_SUCCESS){

   248     if(outBuff != NULL){

   249       NW_Mem_Free(outBuff);

   250     }

   251 

   252     return NULL;

   253   }

   254   docNode = NW_DOM_DocumentNode_BuildWBXMLTree(h, 

   255                                               outBuff->data,

   256                                               outBuff->length,

   257                                               NW_TRUE,

   258                                               extTNotStringTable);

   259 

   260   /* Write extension string table related information to the WBXML encoder. */

   261   

   262   if( docNode && WBXMLEncStrTbl)

   263     {

   264      status = NW_DOM_Write_WBXML_StrTbl(h,WBXMLEncStrTbl);

   265      if(status != NW_STAT_SUCCESS)

   266      {

   267        if(outBuff != NULL)

   268        {

   269          NW_Mem_Free(outBuff);

   270        }

   271      }

   272     }/* end if(WBXMLEncStrTbl)*/

   273  

   274   NW_Mem_Free(outBuff);

   275   return docNode;

   276 }

   277 

   278 static

   279 NW_DOM_DocumentNode_t*

   280 CXML_DOM_DocumentNode_BuildXMLTree(NW_TinyDom_Handle_t *h, 

   281                                  NW_Byte *buffer,

   282                                  NW_Int32 length,

   283                                  NW_Uint32 publicID,

   284                                  NW_Bool extTNotStringTable,

   285                                  NW_Status_t* errorStatus)

   286 {

   287 

   288   NW_Buffer_t inBuff;

   289   NW_Buffer_t *outBuff = NULL;

   290   NW_Uint32 encoding;

   291   NW_Endianness_t endianness;

   292   NW_DOM_DocumentNode_t* docNode;

   293   NW_Status_t status;

   294   NW_Uint32 line;

   295   void* WBXMLEncStrTbl;

   296 

   297   inBuff.length = length;

   298   inBuff.data = buffer;

   299 

   300   status = NW_XML_ComputeEncoding(length, 

   301                                   buffer,

   302                                   &encoding, 

   303                                   &endianness);

   304   if(status != NW_STAT_SUCCESS)

   305   {

   306     *errorStatus = status;

   307     return NULL;

   308   }

   309 

   310 /*

   311  * If applications want to use HTML Parser they can call the exported

   312  * NW_HTMLP_HtmlToWbxml() and then call NW_DOM_DocumentNode_BuildWBXMLTree()

   313  */

   314   status = NW_XML_XmlToWbxml(&inBuff, encoding, &outBuff, &line, publicID,&WBXMLEncStrTbl); 

   315 

   316  

   317 

   318   if(status != NW_STAT_SUCCESS){

   319     if(outBuff != NULL){

   320       NW_Mem_Free(outBuff);

   321     }

   322     *errorStatus = status;

   323     return NULL;

   324   }

   325 

   326   docNode = CXML_DOM_DocumentNode_BuildWBXMLTree(h, 

   327                                               outBuff->data,

   328                                               outBuff->length,

   329                                               NW_TRUE,

   330                                               extTNotStringTable,

   331                                               errorStatus);

   332 

   333   /* Write extension string table related information to the WBXML encoder. */

   334   

   335   if( docNode && WBXMLEncStrTbl)

   336     {

   337      status = NW_DOM_Write_WBXML_StrTbl(h,WBXMLEncStrTbl);

   338      if(status != NW_STAT_SUCCESS)

   339      {

   340        if(outBuff != NULL)

   341        {

   342          NW_Mem_Free(outBuff);

   343        }

   344        *errorStatus = status;

   345      }

   346     }/* end if(WBXMLEncStrTbl)*/

   347  

   348   NW_Mem_Free(outBuff);

   349   return docNode;

   350 }/*CXML_DOM_DocumentNode_BuildXMLTree() */

   351 

   352 EXPORT_C NW_DOM_DocumentNode_t*

   353 NW_DOM_DocumentNode_BuildTree(NW_TinyDom_Handle_t *h, 

   354                                    NW_Byte *buffer,

   355                                    NW_Int32 length,

   356                                    NW_Bool encoded,

   357                                    NW_Uint32 publicID,																	 

   358                                    NW_Bool extTNotStringTable)

   359 {

   360   if(encoded == NW_TRUE){

   361     return  NW_DOM_DocumentNode_BuildWBXMLTree(h, 

   362                                                buffer,

   363                                                length,

   364                                                NW_FALSE,

   365                                                extTNotStringTable);

   366   }

   367 

   368   return NW_DOM_DocumentNode_BuildXMLTree(h,buffer, length, publicID, extTNotStringTable);

   369 }

   370 

   371 

   372 

   373 

   374 /*

   375  * Returns publicId of the document (WBXML Specific)

   376  * otherwise 0

   377  */

   378 

   379 EXPORT_C NW_Uint32 

   380 NW_DOM_DocumentNode_getPublicIdAsNumber(NW_DOM_DocumentNode_t *doc)

   381 {

   382   NW_WBXML_Document_t *header;

   383   NW_TinyTree_t *tiny_tree;

   384   

   385   NW_ASSERT(doc != NULL);

   386 

   387   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

   388     return 0;

   389   }

   390  

   391   tiny_tree = NW_TinyTree_Node_findTree(doc);

   392   header = NW_TinyDom_getDocHeader(tiny_tree);

   393   NW_ASSERT(header != NULL);

   394 

   395   return header->publicid;

   396 }

   397 

   398 /*

   399  * Gets the publicid as string

   400  * Returns

   401  *    NW_STAT_DOM_NODE_TYPE_ERR

   402  *    NW_STAT_SUCCESS

   403  * MODIFIED - docType

   404  */

   405 

   406 EXPORT_C NW_Status_t

   407 NW_DOM_DocumentNode_getPublicId(NW_DOM_DocumentNode_t *doc, 

   408                                 NW_String_t *docType)

   409 {

   410   NW_WBXML_Document_t *header;

   411   NW_TinyTree_t *tiny_tree;

   412 

   413   NW_ASSERT(doc != NULL);

   414   NW_ASSERT(docType != NULL);

   415 

   416   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE)

   417     return NW_STAT_DOM_NODE_TYPE_ERR;

   418 

   419   tiny_tree = NW_TinyTree_Node_findTree(doc);

   420   header = NW_TinyDom_getDocHeader(tiny_tree);

   421 

   422   NW_ASSERT(header != NULL);

   423   NW_String_shallowCopy(docType, header->doc_type);

   424 

   425   return NW_STAT_SUCCESS;

   426 }

   427 

   428 /*

   429  * Returns the version of the document, 

   430  * 0 in case of invalid operation (e.g. NULL doc)

   431  */

   432 

   433 EXPORT_C NW_Uint8 

   434 NW_DOM_DocumentNode_getVersion(NW_DOM_DocumentNode_t *doc)

   435 {

   436   NW_WBXML_Document_t *header;

   437   NW_TinyTree_t *tiny_tree;

   438 

   439   NW_ASSERT(doc != NULL); 

   440 

   441   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

   442     return 0;

   443   }

   444 

   445   tiny_tree = NW_TinyTree_Node_findTree(doc);

   446   header = NW_TinyDom_getDocHeader(tiny_tree);

   447   NW_ASSERT(header != NULL);

   448   

   449   return header->version;

   450   

   451 }

   452 

   453 /*

   454  * Returns the supported encoding of the document

   455  * or 0 for invalid document

   456  */

   457 

   458 EXPORT_C NW_Uint32 

   459 NW_DOM_DocumentNode_getCharacterEncoding(NW_DOM_DocumentNode_t *doc)

   460 {

   461   NW_WBXML_Document_t *header;

   462   NW_TinyTree_t *tiny_tree;

   463 

   464   NW_ASSERT(doc != NULL); 

   465 

   466   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE)

   467     return 0;

   468 

   469   tiny_tree = NW_TinyTree_Node_findTree(doc);

   470   header = NW_TinyDom_getDocHeader(tiny_tree);

   471   NW_ASSERT(header != NULL);

   472 

   473   return header->charset;

   474 }

   475 

   476 /*

   477  * Returns child node that is the root of this document

   478  */

   479 

   480 EXPORT_C NW_DOM_ElementNode_t * 

   481 NW_DOM_DocumentNode_getDocumentElement(NW_DOM_DocumentNode_t *doc)

   482 {

   483   NW_DOM_Node_t *docChild;

   484   NW_Uint16 type;

   485   

   486   NW_ASSERT(doc != NULL); 

   487 

   488   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

   489     return NULL;

   490   }

   491 

   492   /*

   493    * Get the first child of the document node

   494    * (can be a PI node)

   495    */

   496 

   497   docChild = NW_DOM_Node_getFirstChild(doc);

   498 

   499   type = NW_DOM_Node_getNodeType(docChild);    

   500   if (type == 0){

   501     return NULL;

   502   }

   503 

   504   while (type != NW_DOM_ELEMENT_NODE){

   505     docChild = NW_DOM_Node_getNextSibling(docChild);

   506     type = NW_DOM_Node_getNodeType(docChild);

   507   }

   508 

   509   return docChild;

   510 }

   511 

   512 /*

   513  * Gets the dictionary

   514  */

   515 

   516 EXPORT_C NW_WBXML_Dictionary_t *

   517 NW_DOM_DocumentNode_getDictionary(NW_DOM_DocumentNode_t *doc)

   518 {

   519   NW_Uint32 publicid = 0;

   520   NW_Uint32 encoding;

   521   NW_WBXML_Dictionary_t *dictionary = NULL;

   522   NW_Status_t status;

   523 

   524   NW_ASSERT(doc != NULL);

   525 

   526   encoding = NW_DOM_DocumentNode_getCharacterEncoding(doc);

   527   publicid = NW_DOM_DocumentNode_getPublicIdAsNumber(doc);

   528 

   529   if (publicid != 0){

   530     dictionary = NW_WBXML_Dictionary_getByPublicId(publicid);

   531   }

   532   else{

   533     NW_String_t docType;

   534 

   535     status = NW_DOM_DocumentNode_getPublicId(doc, &docType);

   536     if (status != NW_STAT_SUCCESS){

   537       return NULL;

   538     }

   539     dictionary = NW_WBXML_Dictionary_getByDocType(&docType, encoding);

   540   }

   541   return dictionary;

   542 }

   543 

   544 

   545 

   546 NW_Status_t

   547 NW_DOM_DocumentNode_getElementIteratorByTagName(NW_DOM_DocumentNode_t *doc, 

   548                                                 NW_String_t* name,

   549                                                 NW_DOM_NodeIterator_t *handle)

   550 {

   551   NW_WBXML_Dictionary_t *dict = NULL;

   552   NW_String_UCS2Buff_t *buff = NULL;

   553   NW_Uint32 encoding;

   554   NW_Int16 token;

   555 

   556   NW_ASSERT(doc != NULL);

   557   NW_ASSERT(name != NULL);

   558   NW_ASSERT(handle != NULL);

   559 

   560   encoding = NW_DOM_DocumentNode_getCharacterEncoding(doc);

   561   dict = NW_DOM_DocumentNode_getDictionary(doc);

   562   buff = NW_String_stringToUCS2Buff(name, encoding);

   563   if((buff == NULL) || (dict == NULL)){

   564     NW_Mem_Free(buff);

   565     return NW_STAT_FAILURE;

   566   }

   567   token = NW_WBXML_Dictionary_getTagToken(dict, buff, NW_TRUE);

   568   NW_Mem_Free(buff);

   569   if (token < 0) {

   570     return NW_STAT_FAILURE;

   571   }

   572   else { 

   573   return NW_DOM_DocumentNode_getElementIteratorByTagToken(doc, 

   574                                                           (NW_Uint16)token, 

   575                                                           handle);

   576 }

   577 }

   578 

   579 NW_Status_t

   580 NW_DOM_DocumentNode_getElementIteratorByTagToken(NW_DOM_DocumentNode_t *doc, 

   581                                                  NW_Uint16 token,

   582                                                  NW_DOM_NodeIterator_t *handle)

   583 {

   584   

   585   NW_DOM_ElementNode_t *elem;

   586 

   587   NW_ASSERT(doc != NULL);

   588   NW_ASSERT(handle != NULL);

   589 

   590   if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE)

   591     return NW_STAT_DOM_NODE_TYPE_ERR;

   592 

   593   elem = NW_DOM_DocumentNode_getDocumentElement(doc);

   594   NW_ASSERT(elem != NULL);

   595 

   596   return NW_DOM_NodeIterator_initialize(handle, elem, token); 

   597 }

   598 

   599 

   600 

   601 

   602 

   603 /*

   604  * Returns a pointer to the created Element Node

   605  */

   606 EXPORT_C NW_DOM_ElementNode_t *

   607 NW_DOM_DocumentNode_createElementNode(

   608   NW_DOM_DocumentNode_t *doc, NW_String_t *name)

   609 {

   610   NW_Uint32 encoding = NW_DOM_DocumentNode_getCharacterEncoding(doc);

   611   NW_String_UCS2Buff_t *ucs2Buff = NULL;

   612  NW_Uint8 *uint8Buf = NULL;

   613  NW_Int32 fqToken = 0;

   614   NW_WBXML_Dictionary_t *dictionary = NW_DOM_DocumentNode_getDictionary(doc);

   615   NW_TinyTree_t* tinyTree;

   616   NW_TinyDom_Tree_t *tree;

   617   

   618   if ((doc == NULL) || (name == NULL) || (dictionary == NULL))

   619   {

   620     return NULL;

   621   }

   622 

   623   ucs2Buff = NW_String_stringToUCS2Buff(name, encoding);

   624   if (ucs2Buff == NULL){

   625     return NULL;

   626   }

   627   uint8Buf = (NW_Uint8 *) CXML_Str_CvtToAscii((NW_Ucs2*) ucs2Buff);

   628   NW_Mem_Free(ucs2Buff);

   629   if(uint8Buf == NULL){

   630     return NULL;

   631   }

   632   tinyTree = NW_TinyTree_Node_findTree(doc);

   633   tree = NW_TinyDom_getTree(tinyTree);

   634 

   635   fqToken = (NW_Int32) NW_WBXML_Dictionary_getTagToken(dictionary, ucs2Buff, NW_TRUE);

   636   NW_Mem_Free(uint8Buf);

   637   if (fqToken == -1){

   638     return NW_TinyDom_createElementByName(tree, name);

   639   }

   640   

   641   return NW_TinyDom_createElementByToken(tree, (NW_Uint16)fqToken);  

   642 }

   643 

   644 /*

   645  * Returns a pointer to the created Element Node

   646  */

   647 EXPORT_C NW_DOM_ElementNode_t * 

   648 NW_DOM_DocumentNode_createElementNodeByToken(

   649   NW_DOM_DocumentNode_t *doc, NW_Uint16 token)

   650 {

   651   NW_TinyTree_t* tinyTree;

   652   NW_TinyDom_Tree_t *tree;

   653   NW_WBXML_Dictionary_t *dictionary;

   654   

   655   dictionary = NW_DOM_DocumentNode_getDictionary(doc);

   656   if ((doc == NULL) || (dictionary == NULL) || (token == 0))

   657   {

   658     return NULL;

   659   }

   660 

   661   tinyTree = NW_TinyTree_Node_findTree(doc);

   662   tree = NW_TinyDom_getTree(tinyTree);

   663 

   664   return NW_TinyDom_createElementByToken(tree, (NW_Uint16)token);  

   665 }

   666 

   667 

   668 /*

   669  * Returns a pointer to the created Text Node

   670  */

   671 EXPORT_C NW_DOM_TextNode_t * 

   672 NW_DOM_DocumentNode_createTextNodeWithTextItem(

   673   NW_DOM_DocumentNode_t *doc, NW_DOM_TextItem_t *data)

   674 {

   675   NW_TinyTree_t* tinyTree;

   676   NW_TinyDom_Tree_t *tree;

   677 

   678   if ((doc == NULL) || (data == NULL))

   679     return NULL;

   680 

   681   tinyTree = NW_TinyTree_Node_findTree(doc);

   682   tree = NW_TinyDom_getTree(tinyTree);

   683 

   684   return NW_TinyDom_createTextNode(tree, data);

   685 }

   686 

   687 /*

   688  * Returns a pointer to the created Text Node

   689  */

   690 EXPORT_C NW_DOM_TextNode_t * 

   691 NW_DOM_DocumentNode_createTextNode(

   692   NW_DOM_DocumentNode_t *doc, NW_String_t *data)

   693 {

   694   NW_TinyTree_t* tinyTree;

   695   NW_TinyDom_Tree_t *tree;

   696   NW_DOM_TextItem_t item;

   697 

   698   if (NW_DOM_TextItem_initFromString(&item, data) != NW_STAT_SUCCESS)

   699     return NULL;

   700 

   701   if ((doc == NULL) || (data == NULL))

   702     return NULL;

   703 

   704   tinyTree = NW_TinyTree_Node_findTree(doc);

   705   tree = NW_TinyDom_getTree(tinyTree);

   706 

   707   return NW_TinyDom_createTextNode(tree, &item);

   708 }

   709 

   710 /*

   711  * Returns a pointer to the created Comment Node

   712  */

   713 NW_DOM_CommentNode_t * 

   714 NW_DOM_DocumentNode_createCommentNode(

   715   NW_DOM_DocumentNode_t *doc, NW_String_t *data)

   716 {

   717   NW_DOM_TextNode_t *t = 

   718     NW_DOM_DocumentNode_createTextNode(doc, data);

   719   if (t == NULL)

   720     return NULL;

   721   NW_TinyTree_Node_setUserFlags(t, T_DOM_NODE_COMMENT);

   722   t->flags |= T_DOM_NODE_XML;

   723   return (NW_DOM_CommentNode_t *)t;

   724 }

   725 

   726 

   727 /*

   728  * Returns a pointer to the created CDataSection Node

   729  */

   730 NW_DOM_CDATASectionNode_t * 

   731 NW_DOM_DocumentNode_createCDATASectionNode(

   732   NW_DOM_DocumentNode_t *doc, NW_String_t *data)

   733 {

   734   NW_DOM_TextNode_t *t = 

   735     NW_DOM_DocumentNode_createTextNode(doc, data);

   736   if (t == NULL)

   737     return NULL;

   738   NW_TinyTree_Node_setUserFlags(t, T_DOM_NODE_CDATASECTION);

   739   t->flags |= T_DOM_NODE_XML;

   740   return (NW_DOM_CommentNode_t *)t;

   741 }

   742 

   743 

   744 /*

   745  * Returns a pointer to the created ProcessingInstructionNode Node

   746  */

   747 NW_DOM_ProcessingInstructionNode_t * 

   748 NW_DOM_DocumentNode_createProcessingInstructionNodeByAttrVal(NW_DOM_DocumentNode_t* pDoc,

   749                                                              NW_String_t* pTargetString,

   750                                                              NW_DOM_AttrVal_t* pData)

   751 {

   752   NW_TinyTree_Node_t* pPiNode;

   753   NW_TinyTree_Node_t* pAttrNode;

   754   NW_TinyTree_t* pTinyTree;

   755   NW_TinyDom_Tree_t* pTree;

   756   NW_WBXML_Dictionary_t* pDictionary;

   757   NW_Uint32 encoding;

   758   NW_Int32 fqToken;

   759 

   760   if ((pDoc == NULL) || (pTargetString == NULL) || (pData == NULL)) {

   761     return NULL;

   762   }

   763   pTinyTree = NW_TinyTree_Node_findTree(pDoc);

   764   pTree = NW_TinyDom_getTree(pTinyTree);

   765 

   766   pDictionary = NW_DOM_DocumentNode_getDictionary(pDoc);

   767   if (pDictionary == NULL) {

   768     return NULL;

   769   }

   770   encoding = NW_DOM_DocumentNode_getCharacterEncoding(pDoc);

   771   fqToken = NW_WBXML_Dictionary_getAttributeToken(pDictionary,

   772                                                   pTargetString,

   773                                                   encoding,

   774                                                   NW_TRUE /* name */);

   775   if (fqToken == -1)

   776   {

   777     pPiNode = NW_TinyTree_createNode(&(pTree->tree), 0);

   778     if (pPiNode == NULL) {

   779       return NULL;

   780     }

   781     NW_TinyTree_Node_setUserFlags(pPiNode, T_DOM_NODE_PI);

   782 

   783     pAttrNode = NW_TinyDom_createAttributeByName(pTree,

   784                                                  pTargetString,

   785                                                  pData);

   786     if (pAttrNode == NULL) {

   787       (void)NW_TinyTree_deleteNode(pPiNode);

   788       return NULL;

   789     }

   790     (void)NW_TinyTree_attachChild(pPiNode, pAttrNode);

   791     return pPiNode;

   792   }

   793   return NW_DOM_DocumentNode_createProcessingInstructionNodeByToken(pDoc,

   794                                                                     (NW_Uint16)fqToken,

   795                                                                     pData);

   796 }

   797 

   798 /*

   799  * Returns a pointer to the created ProcessingInstructionNode Node

   800  */

   801 

   802 NW_DOM_ProcessingInstructionNode_t * 

   803 NW_DOM_DocumentNode_createProcessingInstructionNodeByToken(

   804   NW_DOM_DocumentNode_t *pDoc, NW_Uint16 token, NW_DOM_AttrVal_t *pData)

   805 {

   806   NW_TinyTree_Node_t* pPiNode;

   807   NW_TinyTree_Node_t* pAttrNode;

   808   NW_TinyTree_t* pTinyTree;

   809   NW_TinyDom_Tree_t* pTree;

   810 

   811   if ((pDoc == NULL) || (token == 0) || (pData == NULL))

   812     return NULL;

   813 

   814   pTinyTree = NW_TinyTree_Node_findTree(pDoc);

   815   pTree = NW_TinyDom_getTree(pTinyTree);

   816   pPiNode = NW_TinyTree_createNode(&(pTree->tree), 0);

   817   if (pPiNode == NULL) {

   818     return NULL;

   819   }

   820   NW_TinyTree_Node_setUserFlags(pPiNode, T_DOM_NODE_PI);

   821 

   822   pAttrNode = NW_TinyDom_createAttributeByToken(pTree,

   823                                                 (NW_Uint8)token,

   824                                                 pData);

   825   if (pAttrNode == NULL) {

   826     (void)NW_TinyTree_deleteNode(pPiNode);

   827     return NULL;

   828   }

   829   (void)NW_TinyTree_attachChild(pPiNode, pAttrNode);

   830   return pPiNode;

   831 }

   832 

   833 /*

   834  * Returns a pointer to the created ProcessingInstructionNode Node

   835  */

   836 NW_DOM_ProcessingInstructionNode_t * 

   837 NW_DOM_DocumentNode_createProcessingInstructionNode(

   838   NW_DOM_DocumentNode_t *doc, NW_String_t *target, NW_String_t *data)

   839 {

   840   NW_DOM_AttrVal_t val;

   841 

   842   if ((doc == NULL) || (target == 0) || (data == NULL))

   843     return NULL;

   844 

   845   NW_DOM_AttrVal_initFromString(&val, data);

   846   return NW_DOM_DocumentNode_createProcessingInstructionNodeByAttrVal(doc, target, &val);  

   847 }

   848 

   849 /*

   850  * Returns a pointer to the created Document Node

   851  * - NOT SUPPRTED - ask Steve 

   852 NW_DOM_DocumentNode_t * 

   853 NW_DOM_DocumentNode_createDocument(

   854     NW_Uint8 version, NW_String_t *publicid, NW_Uint32 encoding)

   855 {

   856   NW_WBXML_Parser_t *WBXMLParser;

   857   NW_TinyDom_Parser_t *tinyParser; 

   858   NW_TinyDom_Tree_t *domTree;

   859   NW_WBXML_Writer_t *writer;

   860   NW_Status_t status;

   861 

   862   WBXMLParser = NW_Mem_Malloc(sizeof(NW_WBXML_Parser_t));

   863   tinyParser = NW_Mem_Malloc(sizeof(NW_TinyDom_Parser_t));

   864   domTree = NW_Mem_Malloc(sizeof(NW_TinyDom_Tree_t));

   865   writer = NW_Mem_Malloc(sizeof(NW_WBXML_Writer_t));

   866 

   867   NW_WBXML_Parser_reset(WBXMLParser);

   868   domTree->doc->version = version;

   869   domTree->doc->doc_type = publicid;

   870   domTree->doc->charset = encoding;

   871   NW_TinyDom_Tree_construct(domTree, WBXMLParser, domTree->doc, writer);

   872   NW_TinyDom_Parser_construct(tinyParser, domTree);

   873   status = NW_TinyDom_Tree_create(domTree, tinyParser, domTree->doc, 

   874     WBXMLParser, writer, 2);

   875   if (status != NW_STAT_SUCCESS)

   876     return NULL;

   877   return NW_TinyDom_writeDocHeader(domTree, version, publicid, encoding);

   878 }*/

   879 

   880 /*

   881  * Create an empty dom tree, returning the document node.

   882  */

   883 

   884 EXPORT_C NW_DOM_DocumentNode_t * 

   885 NW_DOM_DocumentNode_createDocumentWithNumberPublicId(NW_TinyDom_Handle_t *h,

   886                                                      NW_Uint8 version,

   887                                                      NW_Uint32 publicid, 

   888                                                      NW_Uint32 encoding,

   889                                                      NW_Bool extTNotStringTable,

   890                                                      NW_Bool enableStringTable)

   891 {

   892   NW_Status_t status = NW_STAT_SUCCESS;

   893   NW_TinyDom_Handle_Initialize(h, publicid, extTNotStringTable);

   894 

   895   h->document.charset = encoding;

   896   h->document.publicid = publicid;

   897   h->document.version = version;

   898 

   899   	 

   900   	 status = NW_TinyDom_Tree_create(&h->tinyDOMTree, &h->tinyParser, 

   901                                   &h->document, &h->wbxmlParser,

   902                                   &h->writer, 4, enableStringTable);

   903      

   904   

   905 

   906   if(status == NW_STAT_SUCCESS)

   907   {

   908   	return h->tinyDOMTree.root_node;

   909   }

   910   else

   911   {

   912   	

   913   	return NULL;

   914   }

   915 }

   916 

   917 

   918 /*

   919  * One of the API for Building the DOM tree.

   920  */

   921 

   922 EXPORT_C NW_DOM_DocumentNode_t* 

   923 CXML_DOM_DocumentNode_BuildTree(NW_TinyDom_Handle_t* h, 

   924                               NW_Byte* buffer,

   925                               NW_Int32 length,

   926                               NW_Bool encoded,

   927                               NW_Uint32 publicID,

   928                               NW_Bool extTNotStringTable,

   929                               NW_Status_t* errorStatus)

   930 {

   931  *errorStatus = NW_STAT_SUCCESS;

   932  if(encoded == NW_TRUE)

   933  {

   934     return  CXML_DOM_DocumentNode_BuildWBXMLTree(h, 

   935                                                  buffer,

   936                                                  length,

   937                                                  NW_FALSE,

   938                                                  extTNotStringTable,

   939                                                  errorStatus);

   940   }

   941 

   942   return CXML_DOM_DocumentNode_BuildXMLTree(h,

   943                                             buffer, 

   944                                             length, 

   945                                             publicID, 

   946                                             extTNotStringTable,

   947                                             errorStatus);

   948  

   949 

   950 }/*end CXML_DOM_DocumentNode_BuildTree()*/

   951