/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "cxml_internal.h"

#include <xml/cxml/nw_tinydom.h>

#include <xml/cxml/nw_wbxml_parse.h>

#include <xml/cxml/nw_wbxml_reader.h>

#include <xml/cxml/nw_wbxml_event.h>

#include "nw_wbxml_parsei.h"

/*Parser flags */

/* Top four bits are pass state */

#define T_PARSE_PASS_MASK      0xF0000000

#define T_PARSE_PASS_1         0x00000000

#define T_PARSE_PASS_2         0x10000000

#define T_PARSE_PASS_3         0x20000000

/* Next 8 bits are for parser states */

#define T_PARSE_S_MASK         0x07F00000

#define T_PARSE_S_TAG_START    0x00000000

#define T_PARSE_S_ATTR_START   0x00100000

#define T_PARSE_S_ATTR_VALS    0x00200000

#define T_PARSE_S_CONTENT      0x00300000

#define T_PARSE_F_EXT          0x08000000 /* Extension substate flag */

  /* Remaining 20 bits are flags */

#define T_PARSE_FLAG_TEXT      0x00000001

#define T_PARSE_FLAG_ATTR      0x00000002

/*

* Implements the tiny dom parser. This includes the methods to build a

* tiny dom tree, and the underlying support routines to access the

* "virtual elements" of the tree. The only thing that currently gets

* in the way of a clean parser interface are several references to the

* underlying parser state here. The underlying parser needs to be

* fixed so it is never necessary to pass this. Several TODOs in this

* file indicate places where references to parser state should be

* removed.  

*/

static

NW_Uint32

GET_PASS(NW_TinyDom_Parser_t* parser){

  return parser->state & T_PARSE_PASS_MASK;

}

static

void 

SET_PASS(NW_TinyDom_Parser_t* parser, NW_Uint32 pass){

  parser->state &= ~T_PARSE_PASS_MASK;

  parser->state |= pass;

}

static

NW_Uint32

GET_STATE(NW_TinyDom_Parser_t* parser){

  return parser->state & T_PARSE_S_MASK;

}

static

void 

SET_STATE(NW_TinyDom_Parser_t* parser, NW_Uint32 state){

  parser->state &= ~T_PARSE_S_MASK;

  parser->state |= state;

}

/* Callbacks to handle parsing passes: 

*

* Tiny dom uses multiple passes to implement the tree lazily. The

* first two build the tree. Later, lazy deserialization invokes

* further passes over parts of the source.

* 

* Pass 1 counts nodes and allocates space, pass 2 builds the

* tree. However, there is much common behavior for both passes, since

* accurate counting of nodes requires running the parser state

* machine. Common behavior is implemented in common callbacks, while

* pass-specific behavior is mostly implemented in pass-specific

* callbacks.

*

* The tree built by passes 1 & 2 contains a node for every tag. If a tag

* has attributes, the tree contains a node for the first attribute,

* attached as the first child of the node. For text content, the tree

* contains a node for the first text element in each sequence of text

* elements. The goal of the tree design is to make it easy to find

* elements for deserialization while using the minimum amount of

* storage.

* 

* The deserialization API invokes parser methods that know how to

* parse one of the node types stored in the tree (tags, attributes,

* text). The API sets the parser offset using the node offset,

* identifies the node type using the node type flags, and then calls

* the appropriate parser method to parse a section of the source.

* 

* When called for deserialization the parser generates events as usual:

* these are handled by the pass 3 handlers which build the appropriate

* data structures for the API to return.

* 

* This may seem like a rather byzantine mechanism for

* deserialization, but the goal is to use exactly the same parsing

* code for all operations on the source. This makes it easy to change

* or replace parsing code.  Also, all of the parsing logic is kept in

* the parser module: the dom module (this one) has no knowledge of

* parsing. This makes it easy to attach the dom module to different

* parsers (one for wbxml, one for xml).  

*

* A note on buffer usage: tiny trees use segmented expandable buffers

* (ebuffers) so that the tree can be read and written in minimum memory.

* When building a tree from an existing buffer (passes 1 & 2), the whole

* buffer is contained in the ebuffer segment 0. This means that the 

* offsets we store in the tree nodes (which are indexes into the ebuffer)

* are the same as the parser offsets in the buffer. However, for 

* deserialization (pass 3), we may be reading a tree that was constructed

* or modified via the dom api. This may have multiple segments and a given

* node offset may refer to an address in any segment. Therefore, when setting

* the parser offset from a node source offset, we first need to translate

* the node source offset into a segment + offset form, and use this to set

* the parser.   

*/

static 

NW_Status_t 

Pass_1_StartDocument_CB (NW_WBXML_Parser_t *parser, 

                         NW_WBXML_Document_t *doc, 

                         void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  NW_REQUIRED_PARAM(doc);

  SET_STATE(tiny_parser, T_PARSE_S_CONTENT);

  tiny_parser->state &= ~T_PARSE_FLAG_TEXT; /* prepare for text */

  tiny_parser->node_count = 1;

  return NW_STAT_SUCCESS;

}

static 

NW_Status_t 

Pass_2_StartDocument_CB (NW_WBXML_Parser_t *parser, 

                         NW_WBXML_Document_t *doc, 

                         void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  NW_REQUIRED_PARAM(doc);

  tiny_parser->dom_tree->root_node = NW_TinyTree_setRoot(&(tiny_parser->dom_tree->tree), 0);

  if (tiny_parser->dom_tree->root_node != NULL){

    tiny_parser->current_node = tiny_parser->dom_tree->root_node;

    NW_TinyTree_Node_setUserFlags(tiny_parser->current_node, T_DOM_NODE_DOC);

    SET_STATE(tiny_parser, T_PARSE_S_CONTENT);

    tiny_parser->state &= ~T_PARSE_FLAG_TEXT; /* prepare for text */

    return NW_STAT_SUCCESS;

  }

  else{

    return NW_STAT_OUT_OF_MEMORY;

  }  

}

/* Private utility function to do NW_Byte reordering of ucs2 strings */

/* TODO:  move this to our string library */

static 

void

NW_String_Ucs2_ntoh(NW_String_t *string){

  NW_Uint32 i;

  NW_Ucs2 character;

  for(i = 0; i < string->length; i+=2){

    character = (NW_Ucs2)((string->storage[i] << 8) | string->storage[i+1]);

    (void) NW_Mem_memcpy (&string->storage[i], &character, sizeof (character));

  }

}

/* 

 * This callback sets the parser pass and takes care of any NW_Byte reordering 

 * that needs to be done on the string table. For some encodings (such as ucs2)

 * this allows applications to reference strings from the original storage.

 */

/* TODO:  TODO: Add a flag to document to check if this has already been done 

  (in case the same buffer is parsed over again from the beginning.)

 */

static 

NW_Status_t 

Pass_1_EndDocument_CB (NW_WBXML_Parser_t *parser, 

                       void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  //NW_String_t string;

  //NW_WBXML_Document_t *doc = tiny_parser->dom_tree->doc;

  NW_REQUIRED_PARAM(parser);

  // WLIU: all byte order conversions are moved to pass 2.

  //if(doc->charset == HTTP_iso_10646_ucs_2){

    /* TODO:  redefine string table as an NW_String_t ?? */

    //string.storage = doc->strtbl.data;

    //string.length = doc->strtbl.length;

    //NW_String_Ucs2_ntoh(&string);

  //}

  SET_PASS(tiny_parser, T_PARSE_PASS_2);

  return NW_STAT_SUCCESS;  

}

static 

NW_Status_t 

Pass_2_EndDocument_CB (NW_WBXML_Parser_t *parser, 

                       void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  SET_PASS(tiny_parser, T_PARSE_PASS_3);

  return NW_STAT_SUCCESS;  

}

static 

NW_Status_t 

Pass_1_Tag_Start_CB (NW_WBXML_Parser_t *parser, 

                     void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  tiny_parser->node_count++;

  return NW_STAT_SUCCESS;

}

static 

NW_Status_t 

Pass_2_Tag_Start_CB (NW_WBXML_Parser_t *parser, 

                     void *context)

{

  NW_Status_t status = NW_STAT_SUCCESS;

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  //Atleast there should be root node, before any tag

  if(tiny_parser->current_node != NULL)

  {

   tiny_parser->current_node = 

     NW_TinyTree_createChild(&(tiny_parser->dom_tree->tree), 

                            tiny_parser->current_node, 

                            (NW_TinyTree_Offset_t)parser->offset);

   if (tiny_parser->current_node != NULL)

   {

     NW_TinyTree_Node_setUserFlags(tiny_parser->current_node, T_DOM_NODE_TAG);

     status = NW_STAT_SUCCESS;

   }

   else

   {

    status =  NW_STAT_FAILURE;

   }  

  }//endif(tiny_parser->current_node != NULL)

  else

  {

   status =  NW_STAT_FAILURE;

  }

  return status;

}//end Pass_2_Tag_Start_CB(..)

static 

NW_Status_t 

Tag_Start_CB (NW_WBXML_Parser_t *parser, 

              void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_Status_t s = NW_STAT_FAILURE;

  switch(GET_PASS(tiny_parser)){

  case T_PARSE_PASS_1:

    s = Pass_1_Tag_Start_CB(parser, context);

    break;

  case T_PARSE_PASS_2:

    s = Pass_2_Tag_Start_CB(parser, context);

    break;

  default:

    NW_ASSERT(NW_FALSE);

  }

  SET_STATE(tiny_parser, T_PARSE_S_TAG_START);

  tiny_parser->state &= ~T_PARSE_FLAG_TEXT; /* No longer accumulating text */

  tiny_parser->state &= ~T_PARSE_FLAG_ATTR; /* Turn off attribute flag */

  return s;

}

static

NW_Status_t

Pass_2_Pi_CB (NW_WBXML_Parser_t *parser, 

              void *context)

{

  /* This is exactly like pass 2 tag start except for the node user flag. */

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_Status_t s = Tag_Start_CB(parser, context);

  if (s == NW_STAT_SUCCESS) {

    NW_TinyTree_Node_setUserFlags(tiny_parser->current_node, T_DOM_NODE_PI);

  }

  return s;

}

static 

NW_Status_t 

Tag_End_CB (NW_WBXML_Parser_t *parser, 

            void *context)

{

  NW_Status_t status = NW_STAT_SUCCESS;

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_Int32 lastvalid;

  NW_REQUIRED_PARAM(parser);

  lastvalid = NW_TinyDom_getLastValid(tiny_parser->dom_tree);

  if(GET_PASS(tiny_parser)== T_PARSE_PASS_2)

  {

    /* for the dom tree appending, we won't handle close tag which is beyond last valid mark */

    if (lastvalid == -1 || (NW_Int32)parser->offset <= lastvalid)

	{

      if(tiny_parser->current_node != NULL)

	  {

      tiny_parser->current_node = NW_TinyTree_findParent(tiny_parser->current_node);

	  }

	  else

	  {

	   status = NW_STAT_FAILURE;

	  }

	}

  }

  if(status == NW_STAT_SUCCESS)

  {

   SET_STATE(tiny_parser, T_PARSE_S_CONTENT);

   tiny_parser->state &= ~T_PARSE_FLAG_TEXT; /* No longer accumulating text */

  }

  return status;

}//end Tag_End_CB (..)

/* 

* The first attribute is added as (first) child of the current node.

* This makes it easy to find attributes for later deserialization

*/

static 

NW_Status_t 

Attr_Start_CB (NW_WBXML_Parser_t *parser, 

               void *context)

{

  NW_Status_t status = NW_STAT_SUCCESS;

  NW_TinyTree_Node_t* attr_node;

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  switch(GET_STATE(tiny_parser)){

  case T_PARSE_S_TAG_START:

  case T_PARSE_S_ATTR_START:

  case T_PARSE_S_ATTR_VALS:

    if((tiny_parser->state & T_PARSE_FLAG_ATTR) != T_PARSE_FLAG_ATTR){

      tiny_parser->state |= T_PARSE_FLAG_ATTR;

      switch (GET_PASS(tiny_parser)){

      case T_PARSE_PASS_1:

        tiny_parser->node_count++;

        break;

      case T_PARSE_PASS_2:

        attr_node = NW_TinyTree_createChild(&(tiny_parser->dom_tree->tree), 

                                            tiny_parser->current_node, 

                                            (NW_TinyTree_Offset_t)parser->offset);

        if (attr_node != NULL){

          NW_TinyTree_Node_setUserFlags(attr_node, T_DOM_NODE_ATTR);

        }

        else{

          status = NW_STAT_OUT_OF_MEMORY;

        }                    

        break;

      default:

        NW_ASSERT(NW_FALSE);

        status = NW_STAT_FAILURE;

      }

    }

    SET_STATE(tiny_parser, T_PARSE_S_ATTR_START);

    break;

  default:

    status = NW_STAT_FAILURE;

  }

  return status;  

}

static 

NW_Status_t 

Attr_Val_CB (NW_WBXML_Parser_t *parser, 

             void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  switch(GET_STATE(tiny_parser)){

  case T_PARSE_S_ATTR_START:

  case T_PARSE_S_ATTR_VALS:

    SET_STATE(tiny_parser,T_PARSE_S_ATTR_VALS);

    return NW_STAT_SUCCESS;

  default:

    return NW_STAT_FAILURE;

  }

}

static 

NW_Status_t 

Content_CB (NW_WBXML_Parser_t *parser, 

            void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  SET_STATE(tiny_parser, T_PARSE_S_CONTENT);

  /* We need to save the current offset to use if we need a text node. Ugh! */

  tiny_parser->content_offset = (NW_TinyTree_Offset_t)parser->offset; 

  return NW_STAT_SUCCESS;

}

/* Count code page switches */

static

NW_Status_t 

Pass_1_CodePage_CB (NW_WBXML_Parser_t *parser, 

                    void *context)

{

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  tiny_parser->cp_count++;

  return NW_STAT_SUCCESS;

}

/* 

* The first text element in a series of text elements is added as

* a child to the current element. This may be followed by several more

* text elements in the source buffer.  

*/

static 

NW_Status_t

Text_CB (NW_WBXML_Parser_t *parser, 

         NW_Uint32 val, 

         void *context)

{

  NW_Status_t status = NW_STAT_SUCCESS;

  NW_TinyTree_Node_t* text_node;

  NW_TinyDom_Parser_t *tiny_parser = (NW_TinyDom_Parser_t*)context;

  NW_REQUIRED_PARAM(parser);

  NW_REQUIRED_PARAM(val);

  /*We're getting content but aren't yet accumulating text */

  if((GET_STATE(tiny_parser)==T_PARSE_S_CONTENT)

     &&((tiny_parser->state & T_PARSE_FLAG_TEXT) != T_PARSE_FLAG_TEXT)){

    switch(GET_PASS(tiny_parser)){

    case T_PARSE_PASS_1:

      tiny_parser->node_count++;

      break;

    case T_PARSE_PASS_2:

      /* Attach text as child to current node. */

      if(tiny_parser->current_node != NULL)

      {

       text_node = NW_TinyTree_createChild(&(tiny_parser->dom_tree->tree), 

                                          tiny_parser->current_node, 

                                          tiny_parser->content_offset);

       if (text_node != NULL){

         NW_TinyTree_Node_setUserFlags(text_node, T_DOM_NODE_TEXT);

       }

       else{

         status = NW_STAT_FAILURE;

       }      

      }

      else

      {

       status = NW_STAT_FAILURE;

      }  

      break;

    default:

      NW_ASSERT(NW_FALSE);

      status = NW_STAT_FAILURE;

    }

    tiny_parser->state |= T_PARSE_FLAG_TEXT;

  }

  return status;

}

static 

NW_Status_t 

Pass_1_InlineString_CB (NW_WBXML_Parser_t *parser,