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_tinytree.h>

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

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

    23 

    24 /*

    25  * Returns

    26  *  NW_STAT_DOM_NODE_TYPE_ERR - not a text node

    27  *  NW_STAT_SUCCESS

    28  *

    29  */

    30 

    31 EXPORT_C NW_Status_t

    32 NW_DOM_TextNode_getTextItemIterator(NW_DOM_TextNode_t *node,

    33                                     NW_DOM_TextItemIterator_t *iterator)

    34 {

    35   NW_TinyTree_t *tiny_tree;

    36 

    37   NW_ASSERT(node != NULL);

    38   NW_ASSERT(iterator != NULL);

    39 

    40   if ((NW_DOM_Node_getNodeType(node) != NW_DOM_TEXT_NODE)

    41       && (NW_DOM_Node_getNodeType(node) != NW_DOM_COMMENT_NODE)

    42       && (NW_DOM_Node_getNodeType(node) != NW_DOM_CDATA_SECTION_NODE)) {

    43     return NW_STAT_DOM_NODE_TYPE_ERR;

    44   }

    45 

    46   tiny_tree = NW_TinyTree_Node_findTree(node);

    47   NW_TinyDom_TextHandle_init(iterator,

    48                              NW_TinyDom_getParser(tiny_tree),

    49                              NW_TinyTree_Node_getSourceOffset(node));

    50 

    51   return NW_STAT_SUCCESS;

    52 }

    53 

    54 /*

    55  * Returns

    56  *  NW_STAT_DOM_NODE_TYPE_ERR - not a text node

    57  *  NW_STAT_OUT_OF_MEMORY - unable to allocate memory for string storage

    58  *  NW_STAT_DOM_NO_STRING_RETURNED - If string storage is not assigned

    59  *  NW_STAT_SUCCESS

    60  *

    61  * MODIFIED valueString - the value of the node

    62  */

    63 

    64 EXPORT_C NW_Status_t

    65 NW_DOM_TextNode_getData(NW_DOM_TextNode_t *node,

    66                         NW_String_t *valueString)

    67 {

    68   NW_Status_t status;

    69   NW_DOM_TextItemIterator_t iterator;

    70   NW_String_t str;

    71   NW_DOM_TextItem_t item;

    72   NW_DOM_DocumentNode_t *docNode;

    73   NW_Uint32 encoding;

    74 

    75   NW_ASSERT(node != NULL);

    76   NW_ASSERT(valueString != NULL);

    77 

    78   docNode = NW_DOM_Node_getOwnerDocument(node);

    79   encoding = NW_DOM_DocumentNode_getCharacterEncoding(docNode);

    80 

    81   if (NW_DOM_Node_getNodeType(node) != NW_DOM_TEXT_NODE){

    82     return NW_STAT_DOM_NODE_TYPE_ERR;

    83   }

    84 

    85   /* Initializes the handle with values*/

    86 

    87   status = NW_DOM_TextNode_getTextItemIterator(node, &iterator);

    88   if (status != NW_STAT_SUCCESS){

    89     return status;

    90   }

    91 

    92   valueString->length = 0;

    93   valueString->storage = NULL;

    94   NW_String_setUserOwnsStorage(valueString);

    95 

    96   while (NW_DOM_TextItemIterator_getNextTextItem(&iterator, &item)

    97          == NW_STAT_WBXML_ITERATE_MORE){

    98 

    99     status = NW_DOM_TextItem_toString(&item, &str, encoding);

   100 

   101     if (status != NW_STAT_SUCCESS){

   102       return status;

   103     }

   104 

   105     if ((valueString->length == 0) || (valueString->storage == NULL)){

   106       status = NW_String_deepCopy(valueString, &str);

   107     }

   108     else{

   109       status = NW_String_concatenate(valueString, &str, encoding);

   110     }

   111 

   112     if (status != NW_STAT_SUCCESS){

   113       NW_String_deleteStorage(&str);

   114       if (status == NW_STAT_OUT_OF_MEMORY)

   115       {

   116         return NW_STAT_OUT_OF_MEMORY;

   117       }

   118       else

   119       {

   120         return NW_STAT_DOM_NO_STRING_RETURNED;

   121       }

   122     }

   123   }

   124 

   125   NW_String_deleteStorage(&str);

   126   return NW_STAT_SUCCESS;

   127 }

   128 

   129 

   130 /*

   131  * This method creates a new TextNode and replaces the previous one

   132  * Returns NW_STAT_BAD_INPUT_PARAM

   133  *         NW_STAT_SUCCESS

   134  */

   135 

   136 EXPORT_C NW_Status_t

   137 NW_DOM_TextNode_setDataFromTextItem(NW_DOM_TextNode_t** node,

   138                                     NW_DOM_TextItem_t *val)

   139 {

   140   NW_DOM_Node_t *parent = NW_DOM_Node_getParentNode(*node);

   141   NW_DOM_DocumentNode_t *doc = NW_DOM_Node_getOwnerDocument(*node);

   142   NW_DOM_TextNode_t *newNode = NULL;

   143   NW_Status_t status;

   144 

   145   if ((node == NULL) || (val == NULL) || (parent == NULL) || (doc == NULL))

   146     return NW_STAT_BAD_INPUT_PARAM;

   147 

   148   newNode = NW_DOM_DocumentNode_createTextNodeWithTextItem(doc, val);

   149   if (newNode == NULL)

   150     return NW_STAT_BAD_INPUT_PARAM;

   151 

   152   status = NW_DOM_Node_replaceChild(parent, newNode, *node);

   153   if (status != NW_STAT_SUCCESS)

   154     return status;

   155   *node = newNode;

   156   return NW_STAT_SUCCESS;

   157 }

   158 

   159 

   160 EXPORT_C NW_Status_t

   161 NW_DOM_TextNode_addDataFromTextItem(NW_DOM_TextNode_t* node,

   162                                     NW_DOM_TextItem_t *val)

   163 {

   164   NW_TinyTree_t* tinyTree;

   165   NW_TinyDom_Tree_t* domTree;

   166   NW_DOM_DocumentNode_t *docNode;

   167   NW_Uint32 encoding;

   168 

   169   if ((node == NULL) || (val == NULL))

   170     return NW_STAT_BAD_INPUT_PARAM;

   171 

   172   tinyTree = NW_TinyTree_Node_findTree(node);

   173   docNode = NW_DOM_Node_getOwnerDocument(node);

   174   if ((tinyTree == NULL) || (docNode == NULL)) {

   175     return NW_STAT_FAILURE;

   176   }

   177   domTree = NW_TinyDom_getTree(tinyTree);

   178   if (domTree == NULL) {

   179     return NW_STAT_FAILURE;

   180   }

   181   encoding = NW_DOM_DocumentNode_getCharacterEncoding(docNode);

   182 

   183   return NW_TinyDom_addDataFromTextItem(tinyTree, domTree, node,

   184                                         val, encoding);

   185 }

   186 

   187 /*

   188  * This method creates a new TextNode and replaces the previous one

   189  * Returns

   190  * Returns NW_STAT_BAD_INPUT_PARAM

   191  *         NW_STAT_SUCCESS

   192  */

   193 

   194 EXPORT_C NW_Status_t

   195 NW_DOM_TextNode_setData(NW_DOM_TextNode_t** node, NW_String_t *val)

   196 {

   197   NW_DOM_Node_t *parent = NW_DOM_Node_getParentNode(*node);

   198   NW_DOM_DocumentNode_t *doc = NW_DOM_Node_getOwnerDocument(*node);

   199   NW_DOM_TextNode_t *newNode = NULL;

   200   NW_Status_t status;

   201 

   202   if ((node == NULL) || (val == NULL) || (parent == NULL) || (doc == NULL))

   203     return NW_STAT_BAD_INPUT_PARAM;

   204 

   205   newNode = NW_DOM_DocumentNode_createTextNode(doc, val);

   206 

   207   if (newNode == NULL){

   208     /* TBD is this correct?  maybe it is out-of-memory? */

   209     return NW_STAT_BAD_INPUT_PARAM;

   210   }

   211   /* TBD replaceChild is buggy because it may return the child as the status! */

   212   status = NW_DOM_Node_replaceChild(parent, newNode, *node);

   213 

   214   if (status != NW_STAT_SUCCESS){

   215     return status;

   216   }

   217   /* TBD isn't there a memory leak when the old child is not deleted? */

   218 

   219   *node = newNode;

   220   return NW_STAT_SUCCESS;

   221 }

   222 

   223 

   224 /**

   225  * TextItem methods

   226  **/

   227 

   228 

   229 NW_DOM_TextItem_t *

   230 NW_DOM_TextItem_new(void)

   231 {

   232   return (NW_DOM_TextItem_t *) NW_Mem_Malloc(sizeof (NW_DOM_TextItem_t));

   233 }

   234 

   235 /*

   236  * Initializes a Text Item of type NW_DOM_TEXT_ITEM_STRING

   237  * Returns NW_STAT_SUCCESS

   238  */

   239 

   240 EXPORT_C NW_Status_t

   241 NW_DOM_TextItem_initFromString (NW_DOM_TextItem_t *item,

   242                                 NW_String_t * string)

   243 {

   244   NW_ASSERT(item != NULL);

   245   NW_ASSERT(string != NULL);

   246 

   247   item->type = NW_WBXML_ATTR_COMPONENT_STRING;

   248   item->component.string = *string;

   249   return NW_STAT_SUCCESS;

   250 }

   251 

   252 /**

   253  * Initializes a Text Item of type NW_DOM_TEXT_ITEM_ENTITY

   254  * Returns NW_STAT_SUCCESS

   255  */

   256 

   257 EXPORT_C NW_Status_t

   258 NW_DOM_TextItem_initFromEntity (NW_DOM_TextItem_t *item, NW_Uint32 entity)

   259 {

   260 

   261   NW_ASSERT(item != NULL);

   262 

   263   item->type = NW_WBXML_ATTR_COMPONENT_ENTITY;

   264   item->component.entity = entity;

   265   return NW_STAT_SUCCESS;

   266 }

   267 

   268 

   269 /*

   270  Initializes a Text Item of type NW_DOM_TEXT_ITEM_EXTENSION

   271  Returns NW_STAT_SUCCESS or NW_STAT_FAILURE if args are not valid.

   272 

   273  Makes a shallow copy of str.

   274  */

   275 EXPORT_C NW_Status_t

   276 NW_DOM_TextItem_initFromExtension (NW_DOM_TextItem_t *item,

   277                                    NW_Uint16 token,

   278                                    NW_String_t *str)

   279 {

   280   /* Text items and AttrVals are nearly the same thing. */

   281   return NW_DOM_AttrVal_initFromExtension(item, token, str);

   282 }

   283 

   284 /*

   285  Initializes a Text Item of type NW_DOM_TEXT_ITEM_EXTENSION for the

   286  particular case of EXT_T_[0,1,2] where the associated integer value

   287  is not a reference into the string table.

   288 

   289  Returns NW_STAT_SUCCESS or NW_STAT_FAILURE if args are not valid.

   290 */

   291 EXPORT_C NW_Status_t

   292 NW_DOM_TextItem_initFromExtensionInt (NW_DOM_TextItem_t *item,

   293                                       NW_Uint16 token,

   294                                       NW_Uint32 x)

   295 {

   296   /* Text items and AttrVals are nearly the same thing. */

   297   return NW_DOM_AttrVal_initFromExtensionInt(item, token, x);

   298 }

   299 

   300 

   301 /*

   302  * Initializes a Text Item of type NW_DOM_TEXT_ITEM_OPAQUE

   303  * Returns NW_STAT_SUCCESS

   304  */

   305 

   306 EXPORT_C NW_Status_t

   307 NW_DOM_TextItem_initFromOpaque (NW_DOM_TextItem_t *item,

   308                                 NW_Uint32 length,

   309                                 NW_Byte* data)

   310 {

   311   NW_ASSERT(item != NULL);

   312   NW_ASSERT(data != NULL);

   313 

   314   item->type = NW_WBXML_ATTR_COMPONENT_OPAQUE;

   315   item->component.opaque.length = length;

   316   item->component.opaque.data = data;

   317 

   318   return NW_STAT_SUCCESS;

   319 }

   320 

   321 

   322 NW_Status_t

   323 NW_DOM_TextItem_delete(NW_DOM_TextItem_t *textItem)

   324 {

   325   NW_ASSERT(textItem != NULL);

   326 

   327   NW_Mem_Free(textItem);

   328 

   329   return NW_STAT_SUCCESS;

   330 }

   331 

   332 /*

   333  * Returns the type of Text Item

   334  */

   335 

   336 EXPORT_C NW_DOM_TextItemType_t

   337 NW_DOM_TextItem_getType(NW_DOM_TextItem_t *item)

   338 {

   339 

   340   NW_ASSERT(item != NULL);

   341 

   342   switch(item->type)

   343   {

   344     case NW_WBXML_ATTR_COMPONENT_EXT:

   345       return NW_DOM_TEXT_ITEM_EXTENSION;

   346     case NW_WBXML_ATTR_COMPONENT_STRING:

   347       return NW_DOM_TEXT_ITEM_STRING;

   348     case NW_WBXML_ATTR_COMPONENT_ENTITY:

   349       return NW_DOM_TEXT_ITEM_ENTITY;

   350     case NW_WBXML_ATTR_COMPONENT_OPAQUE:

   351       return NW_DOM_TEXT_ITEM_OPAQUE;

   352     default:

   353       return 0;

   354   }

   355 }

   356 

   357 /*

   358  * Sets the type of Text Item

   359  */

   360 

   361 /* TBD This is a very dangerous function and should be made internal

   362    use only (i.e., static)! */

   363 NW_Status_t

   364 NW_DOM_TextItem_setType(NW_DOM_TextItem_t *item,

   365                         NW_DOM_TextItemType_t type)

   366 {

   367   NW_ASSERT(item != NULL);

   368 

   369   switch(type)

   370   {

   371     case NW_DOM_TEXT_ITEM_EXTENSION:

   372       item->type = NW_WBXML_ATTR_COMPONENT_EXT;

   373       break;

   374     case NW_DOM_TEXT_ITEM_STRING:

   375       item->type = NW_WBXML_ATTR_COMPONENT_STRING;

   376       break;

   377     case NW_DOM_TEXT_ITEM_OPAQUE:

   378       item->type = NW_WBXML_ATTR_COMPONENT_OPAQUE;

   379       break;

   380     case NW_DOM_TEXT_ITEM_ENTITY:

   381       item->type = NW_WBXML_ATTR_COMPONENT_ENTITY;

   382       break;

   383     default:

   384       return NW_STAT_BAD_INPUT_PARAM;

   385   }

   386   return NW_STAT_SUCCESS;

   387 }

   388 

   389 /*

   390  * Returns

   391  *  NW_STAT_WBXML_ERROR_CHARSET_UNSUPPORTED - if encoding is not supported

   392  *  NW_STAT_DOM_NO_STRING_RETURNED

   393  *  NW_STAT_SUCCESS

   394  *

   395  * MODIFIED - string - the String representation of item

   396  */

   397 

   398 EXPORT_C NW_Status_t

   399 NW_DOM_TextItem_toString(NW_DOM_TextItem_t *item,

   400                          NW_String_t *string,

   401                          NW_Uint32 encoding)

   402 {

   403   NW_Status_t status;

   404 

   405   NW_ASSERT(item != NULL);

   406   NW_ASSERT(string != NULL);

   407 

   408   NW_String_initialize(string, NULL, 0);

   409 

   410   if ((NW_String_charsetValid(encoding)) != NW_STAT_SUCCESS){

   411     return NW_STAT_WBXML_ERROR_CHARSET_UNSUPPORTED;

   412   }

   413 

   414   switch (NW_DOM_TextItem_getType(item))

   415   {

   416     case NW_DOM_TEXT_ITEM_STRING:

   417       {

   418         NW_Byte *storage = item->component.string.storage;

   419         status = NW_String_initialize(string, storage, encoding);

   420         if(status == NW_STAT_SUCCESS){

   421           return NW_STAT_SUCCESS;

   422         }

   423         else{

   424           return NW_STAT_DOM_NO_STRING_RETURNED;

   425         }

   426       }

   427     case NW_DOM_TEXT_ITEM_ENTITY:

   428       status = NW_String_entityToString(item->component.entity,

   429                                         string, encoding);

   430         if(status == NW_STAT_SUCCESS){

   431           return NW_STAT_SUCCESS;

   432         }

   433         else{

   434           return NW_STAT_DOM_NO_STRING_RETURNED;

   435         }

   436 

   437     case NW_DOM_TEXT_ITEM_OPAQUE:

   438       return NW_STAT_DOM_NO_STRING_RETURNED;

   439     case NW_DOM_TEXT_ITEM_EXTENSION:

   440       {

   441         NW_Uint8 t; /* 8-bit token */

   442 

   443         t = (NW_Uint8)(item->component.ext.token);

   444         if ((t == NW_WBXML_EXT_0)

   445             || (t == NW_WBXML_EXT_1)

   446             || (t == NW_WBXML_EXT_2)) {

   447           return NW_STAT_DOM_NO_STRING_RETURNED;

   448         }

   449         if ((item->component.ext.type

   450              == NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER)

   451             && ((t == NW_WBXML_EXT_T_0)

   452                 || (t == NW_WBXML_EXT_T_1)

   453                 || (t == NW_WBXML_EXT_T_2))) {

   454           return NW_STAT_DOM_NO_STRING_RETURNED;

   455         }

   456         if (item->component.ext.value.string.storage == NULL) {

   457           return NW_STAT_DOM_NO_STRING_RETURNED;

   458         }

   459         /* struct assignment, shallow copy */

   460         *string = item->component.ext.value.string;

   461         return NW_STAT_SUCCESS;

   462       }

   463     default:

   464       return NW_STAT_DOM_NO_STRING_RETURNED;

   465   }

   466 }

   467 

   468 

   469 EXPORT_C NW_Uint32

   470 NW_DOM_TextItem_getEntity(NW_DOM_TextItem_t *item)

   471 {

   472   NW_ASSERT(item != NULL);

   473 

   474   if (NW_DOM_TextItem_getType(item) != NW_DOM_TEXT_ITEM_ENTITY){

   475     return 0;

   476   }

   477 

   478   return item->component.entity;

   479 }

   480 

   481 /*

   482  * If TextItem is of type NW_DOM_TEXT_ITEM_STRING returns NW_STAT_SUCCESS

   483  * and modifies string.

   484  */

   485 

   486 EXPORT_C NW_Status_t

   487 NW_DOM_TextItem_getString(NW_DOM_TextItem_t *item,

   488                           NW_String_t *string)

   489 {

   490   NW_ASSERT(item != NULL);

   491   NW_ASSERT(string != NULL);

   492 

   493   if (NW_DOM_TextItem_getType(item) != NW_DOM_TEXT_ITEM_STRING){

   494     return NW_STAT_BAD_INPUT_PARAM;

   495   }

   496 

   497   return NW_String_copy(string, &item->component.string);

   498 }

   499 

   500 EXPORT_C NW_Status_t

   501 NW_DOM_TextItem_getExtensionToken(NW_DOM_TextItem_t* pItem,

   502                                   NW_Uint16* pX)

   503 {

   504   /* Text items and AttrVals are nearly the same thing. */

   505   return NW_DOM_AttrVal_getExtensionToken(pItem, pX);

   506 }

   507 

   508 /* If TextItem is of type NW_DOM_TEXT_ITEM_EXTENSION and extension

   509  isn't EXT_T_[0,1,2] in non string table reference form, returns token

   510  otherwise returns 0 and returns str->length = 0, str->storage = NULL.

   511 

   512  All returned strings are shallow copies and the only proper way to

   513  free these is to call NW_String_delete(pStr). */

   514 EXPORT_C NW_Uint16

   515 NW_DOM_TextItem_getExtension(NW_DOM_TextItem_t *item,

   516                              NW_String_t *str)

   517 {

   518   NW_Uint16 fqToken;

   519   NW_Uint8 t; /* 8-bit token */

   520 

   521   NW_ASSERT(item != NULL);

   522   NW_ASSERT(str != NULL);

   523 

   524   NW_String_initialize(str, NULL, 0);

   525 

   526   if (NW_DOM_TextItem_getType(item) != NW_DOM_TEXT_ITEM_EXTENSION) {

   527     return 0;

   528   }

   529 

   530   /* TBD If it could be gauranteed that the extension was constructed

   531      correctly then it would be enough to just unconditionally

   532      shallowCopy. */

   533 

   534   fqToken = (NW_Uint16)(item->component.ext.token);

   535   t = (NW_Uint8)fqToken;

   536 

   537   if (((t == NW_WBXML_EXT_T_0)

   538        || (t == NW_WBXML_EXT_T_1)

   539        || (t == NW_WBXML_EXT_T_2))

   540       && (item->component.ext.type

   541          == NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER)) {

   542     /* This function is not for this case: use "getExtensionInt" form. */

   543     return 0;

   544   }

   545 

   546   if ((t != NW_WBXML_EXT_0) && (t != NW_WBXML_EXT_1) && (t != NW_WBXML_EXT_2)) {

   547     /* By fiat we do nothing with the single byte extension tokens.  A

   548      more correct version might be to callback to the client to

   549      request a mapping to a client determined string.

   550 

   551      In the normal case where EXT_T refers to the string table, both

   552      the EXT_T and EXT_I forms are represented by an explicit pointer

   553      to the string value since for the EXT_T form we don't have a

   554      pointer to the string table anyway. */

   555     NW_String_shallowCopy(str, &item->component.ext.value.string);

   556   }

   557   return fqToken;

   558 }

   559 

   560 EXPORT_C NW_Status_t

   561 NW_DOM_TextItem_getExtensionInt(NW_DOM_TextItem_t* item,

   562                                 NW_Uint32* x)

   563 {

   564   NW_Uint16 fqToken;

   565   NW_Uint8 t; /* 8-bit token */

   566 

   567   NW_ASSERT(item != NULL);

   568   NW_ASSERT(x != NULL);

   569 

   570   if ((NW_DOM_TextItem_getType(item) != NW_DOM_TEXT_ITEM_EXTENSION)

   571       || ((item->component.ext.type

   572            != NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER)))

   573   {

   574     return NW_STAT_FAILURE;

   575   }

   576 

   577   fqToken = (NW_Uint16)(item->component.ext.token);

   578   t = (NW_Uint8)fqToken;

   579   if ((t == NW_WBXML_EXT_T_0)

   580       || (t == NW_WBXML_EXT_T_1)

   581       || (t == NW_WBXML_EXT_T_2)) {

   582     *x = item->component.ext.value.x;

   583     return NW_STAT_SUCCESS;

   584   }

   585   return NW_STAT_FAILURE;

   586 }

   587 

   588 EXPORT_C NW_Byte *

   589 NW_DOM_TextItem_getOpaque(NW_DOM_TextItem_t *item,

   590                           NW_Uint32 *opaqueLen)

   591 {

   592   NW_ASSERT(item != NULL);

   593 

   594   if (NW_DOM_TextItem_getType(item) != NW_DOM_TEXT_ITEM_OPAQUE){

   595     return NULL;

   596   }

   597 

   598   *opaqueLen = item->component.opaque.length;

   599   return item->component.opaque.data;

   600 }

   601 

   602 

   603 /*

   604  * TEXT NODE HANDLE

   605  */

   606 

   607 NW_DOM_TextItemIterator_t *

   608 NW_DOM_TextItemIterator_new(void)

   609 {

   610   return (NW_DOM_TextItemIterator_t *)

   611     NW_Mem_Malloc(sizeof (NW_DOM_TextItemIterator_t));

   612 }

   613 

   614 

   615 NW_Status_t

   616 NW_DOM_TextItemIterator_delete(NW_DOM_TextItemIterator_t *handle)

   617 {

   618   NW_ASSERT(handle != NULL);

   619 

   620   NW_Mem_Free (handle);

   621 

   622   return NW_STAT_SUCCESS;

   623 }

   624 

   625 /*

   626  * Returns NW_STAT_WBXML_ITERATE_MORE

   627  *         NW_STAT_WBXML_ITERATE_DONE

   628  *

   629  * MODIFIED textItem

   630  */

   631 

   632 EXPORT_C NW_Status_t

   633 NW_DOM_TextItemIterator_getNextTextItem(NW_DOM_TextItemIterator_t *handle,

   634                                         NW_DOM_TextItem_t *textItem)

   635 {

   636   NW_TinyTree_Offset_t offset;

   637 

   638   NW_ASSERT(handle != NULL);

   639   NW_ASSERT(textItem != NULL);

   640 

   641   offset = NW_TinyDom_TextHandle_iterate(handle, textItem);

   642   if (offset == 0){

   643     return NW_STAT_WBXML_ITERATE_DONE;

   644   }

   645   return NW_STAT_WBXML_ITERATE_MORE;

   646 }