/*

* Copyright (c) 2000 - 2001 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 <string.h>

#include "cxml_internal.h"

#include "nw_encoder_wbxmlwriter.h"

#include "nw_xmlp_xmlparser.h"

#include "nw_xmlp_xmlp2wbxml.h"

#include "nw_encoder_stringtable.h"

#include "cxml_xmlp_entity.h"

typedef struct CXML_Encoding_String_s {

   NW_Int8* charSetStr;

   NW_Uint32   encodingVal;

}CXML_Encoding_String_t;

/* Number of encoding string supported */

#define CXML_Encoding_Str_Num 5

static

const CXML_Encoding_String_t CXML_EncodingStr_Array[] = 

{

 {(NW_Int8*) "utf-8", HTTP_utf_8 },

 {(NW_Int8*) "us-ascii", HTTP_us_ascii  },

 {(NW_Int8*) "iso-10646-ucs-2", HTTP_iso_10646_ucs_2 },

 {(NW_Int8*) "iso-8859-1", HTTP_iso_8859_1 },

 {(NW_Int8*) "utf-8", HTTP_utf_16}

};

typedef struct NW_XML_XmlpWbxmlEncoder_s

{

    NW_WBXML_Writer_t* pE;

    /*

    need access to last tag token to backpatch attribute and content flags

    */

    NW_Uint32 lastTagTokenIndex;

    NW_Uint32 publicID; /* needed to pass to start callback */

    NW_Uint32 encoding; /* needed to pass to start callback */

} NW_XML_XmlpWbxmlEncoder_t;

/* The following function finds the encoding in the XML declaration statement (if any). 

 * This function is called only when there is no BOM present and encoding is assumed 

 * ASCII/Latine-1.

 * e.g. <?xml version="1.0" encoding="iso-8859-1"?>, here XML Declaration has the encoding

 * of "iso-8859-1"

 */

static NW_Bool NW_XML_FindEncoding(NW_Uint32 length, const unsigned char* pBuf, NW_Uint32* encodingVal)

{

 NW_Bool s = NW_FALSE;

 NW_Uint8* sourceWalker     = NULL;

 NW_Uint8* encodingStart    = NULL;

 NW_Uint8* encodingValStart = NULL;

 NW_Uint8* endXMLDecl       = NULL;

 NW_Uint32  xmlDeclLen       = 0;

 NW_Uint32  encodingValLen   = 0;

 NW_Uint32 i = 0;

 /* Look for end of the XML Declration statement */

 endXMLDecl = (NW_Uint8*) strstr((char*) pBuf+2, "?>");

 if(endXMLDecl)

 {

  xmlDeclLen =  endXMLDecl -  pBuf;

     if(xmlDeclLen < length)

     {

      encodingStart = (NW_Uint8*) strstr(( (char*)(pBuf+2) ),"encoding");

      /*Move the pointer after the encoding */

       if(encodingStart)

       {

        sourceWalker = encodingStart + 8;

        /*Skip any space */

        while(CXML_Str_Isspace((NW_Ucs2)(*sourceWalker & 0xffff) ) ) 

        {

            sourceWalker++;

        }

        if(*sourceWalker == '=')

        {

            sourceWalker++;

            while(CXML_Str_Isspace((NW_Ucs2)(*sourceWalker & 0xffff) ) )

            {

                sourceWalker++;

            }

        }

        if( (*sourceWalker == '\'') || (*sourceWalker == '\"') )

        {

         sourceWalker++;

        }

		 encodingValStart = sourceWalker;

		/* End the Encoding value consume if one of following condition is reached:

		 * 1) Closing quote has encounted.

		 * 2) '>' closing tag has encountered

		 * 3) Space had encounted

		 * 4) '?' has encounded.

		 * There is possibilty of some arguments after encoding like following:

		 * <?xml version="1.0" encoding="iso-8859-1" standalone="no"?>

		 */

		while( (*sourceWalker != '\'') && (*sourceWalker != '\"') &&

			   (*sourceWalker != '>') && (*sourceWalker != '?') )

		{

		 encodingValLen++;

		 sourceWalker++;

		}

        for(i=0; i < CXML_Encoding_Str_Num; i++)

	    {

         if(!strncmp((char*) encodingValStart, (char*) CXML_EncodingStr_Array[i].charSetStr,encodingValLen))

         {

          *encodingVal = CXML_EncodingStr_Array[i].encodingVal;

          s = NW_TRUE;

          break;

         }

        }/*end for() */

       }/*end if(encodingStart)*/

     }/*end if(xmlDeclLen < length)*/

 }/*end if(endXMLDecl)*/

 return s;

}/*end NW_XML_FindEncoding()*/

NW_Status_t

EXPORT_C

NW_XML_ComputeEncoding(NW_Uint32 length, const unsigned char* pBuf,

                             NW_Uint32* pEncoding, NW_Endianness_t* pEndianness)

{

    NW_Uint32 c0, c1, c2, c3;

    if (length < 4)

    {

        return NW_STAT_FAILURE;

    }

    c0 = pBuf[0];

    c1 = pBuf[1];

    c2 = pBuf[2];

    c3 = pBuf[3];

    if (c0 == 0 && c1 == 0 && c2 == 0xfe && c3 == 0xff)

    {

        *pEncoding = 1001; /* ISO-10646-UCS-4 IANA MIBenum */

        *pEndianness = NW_BIG_ENDIAN;

    }

    else if (c0 == 0 && c1 == 0 && c2 == 0 && c3 == 0x3c)

    {

        *pEncoding = 1001; /* ISO-10646-UCS-4 IANA MIBenum */

        *pEndianness = NW_BIG_ENDIAN;

    }

    else if (c0 == 0xff && c1 == 0xfe && c2 == 0 && c3 == 0)

    {

        *pEncoding = 1001; /* ISO-10646-UCS-4 IANA MIBenum */

        *pEndianness = NW_LITTLE_ENDIAN;

    }

    else if (c0 == 0x3c && c1 == 0 && c2 == 0 && c3 == 0)

    {

        *pEncoding = 1001; /* ISO-10646-UCS-4 IANA MIBenum */

        *pEndianness = NW_LITTLE_ENDIAN;

    }

    else if (c0 == 0xfe && c1 == 0xff && !(c2 == 0 && c3 == 0))

    {

        /* call it UCS-2 instead of UTF-16 IANA MIBenum, favor over

           UTF-16BE 1013 */

        *pEncoding = 1000;

        *pEndianness = NW_BIG_ENDIAN;

    }

    else if (c0 == 0 && c1 == 0x3c && c2 == 0 && c3 == 0x3f)

    {

        /* could be UTF-16 but must read xml encoding decl to tell */

        *pEncoding = 1000; /* UCS-2 IANA MIBenum */

        *pEndianness = NW_BIG_ENDIAN;

    }

    else if (c0 == 0xff && c1 == 0xfe && !(c2 == 0 && c3 == 0))

    {

         /* call it UCS-2 instead of UTF-16 IANA MIBenum, favor over

            UTF-16LE 1014 */

        *pEncoding = 1000;

        *pEndianness = NW_LITTLE_ENDIAN;

    }

    else if (c0 == 0x3c && c1 == 0 && c2 == 0x3f && c3 == 0)

    {

        /* could be UTF-16 but must read xml encoding decl to tell */

        *pEncoding = 1000; /* UCS-2 IANA MIBenum */

        *pEndianness = NW_LITTLE_ENDIAN;

    }

    else if (c0 == 0x3c && c1 == 0x3f && c2 == 0x78 && c3 == 0x6d)

    {

        /* could be anything with anything with an ASCII subset,

        must read xml encoding decl to tell */

        if( !NW_XML_FindEncoding (length,pBuf, pEncoding) )

        {

        /*If encoding is not in the XML Declaration */

        *pEncoding = 106; /* UTF-8 IANA MIBenum, no endianness */

        }

        *pEndianness = NW_NATIVE_ENDIAN; 

    }

    else if (c0 == 0xef && c1 == 0xbb && c2 == 0xbf) /* c3 ignored */

    {

        *pEncoding = 106; /* UTF-8 IANA MIBenum, no endianness */

        *pEndianness = NW_NATIVE_ENDIAN; /* Ha! */

    }

    else

    {

        /* default to UTF-8 and let the parser barf if it isn't */

        *pEncoding = 106; /* UTF-8 IANA MIBenum, no endianness */

        *pEndianness = NW_NATIVE_ENDIAN; /* Ha! */

    }

    return NW_STAT_SUCCESS;

}

/* When encoding is UCS-2, the parser has changed the byte order to

native, however, the WBXML should be written in network (i.e., big

endian) order.  The way this is done is to change the byte order

in-place to network order, write the WBXML, and then put the byte

order back to native in-place. */

static

void

NW_XML_XmlpWbxmlEncoder_Ucs2NativeToNetworkByteOrder(NW_Uint32 byteCount,

                                                     NW_Uint8* pBuf)

{

  NW_Uint32 i;

  NW_Uint16 c_ucs2 = 1;

  if (((NW_Uint8*)&c_ucs2)[0] == 1) { /* test for little endian host */

    for (i = 0; i < byteCount; i += 2) {

      (void)NW_Mem_memcpy(&c_ucs2, pBuf + i, sizeof(NW_Uint16));

      pBuf[i] = (NW_Uint8)((c_ucs2 >> 8) & 0xff);

      pBuf[i+1] = (NW_Uint8)(c_ucs2 & 0xff);

    }

  }

}

static

void

NW_XML_XmlpWbxmlEncoder_Ucs2NetworkToNativeByteOrder(NW_Uint32 byteCount,

                                                     NW_Uint8* pBuf)

{

  NW_Uint32 i;

  NW_Uint16 c_ucs2 = 1;

  if (((NW_Uint8*)&c_ucs2)[0] == 1) { /* test for little endian host */

    for (i = 0; i < byteCount; i += 2) {

      /* this is a clever trick: pick up bytes in big endian order,

         force the result to memory via taking address of result which

         will put the 16-bits into native byte order, then copy the

         result over the original bytes */

      c_ucs2 = (NW_Uint16)((pBuf[i] << 8) | pBuf[i+1]);

      (void)NW_Mem_memcpy(pBuf + i, &c_ucs2, sizeof(NW_Uint16));

    }

  }

}

/* end of line normalization replaces DOS or Mac style end of line

with Unix style end of line.  If no normalization is needed, then on

return *ppTextOut == pTextIn (i.e., no malloc was done), otherwise you

need to call NW_Mem_Free(*ppTextOut) when you are done with the output

NOTE: only works for native byte order!

*/

static

NW_Status_t

NW_XML_XmlpWbxmlEncoder_EndOfLineNormalization(NW_Uint32 encoding,

                                               NW_Uint32* pCharCount,

                                               NW_Uint32* pByteCount,

                                               const NW_Uint8* pTextIn,

                                               NW_Uint8** ppTextOut)

{

  NW_Uint32 i;

  NW_Uint32 j;

  NW_Uint32 elideCharCount;

  NW_Uint32 elideByteCount;

  NW_Int32 byteCount;

  NW_Ucs2 cUCS2;

  NW_Uint8 crHit;

  NW_Uint8 needsNormalization = 0;

  /* the output is the input unless it must be normalized */

  *ppTextOut = (NW_Uint8*)pTextIn;

  /* scan to count #xD's that need translating */

  elideCharCount = 0;

  elideByteCount = 0;

  crHit = 0;

  for (i = 0; i < *pByteCount; i += (NW_Uint32)byteCount) {

    byteCount = NW_String_readChar((NW_Uint8*)&(pTextIn[i]), &cUCS2, encoding);

    if (byteCount < 0) {

      return NW_STAT_FAILURE;

    }

    /* catch DOS 0xd 0xa eol */

    if (crHit && (cUCS2 == 0xa)) {

      elideCharCount++;

      elideByteCount += (NW_Uint32)byteCount;

    }

    if (cUCS2 == 0xd) {

      needsNormalization = 1;

      crHit = 1;

    } else {

      crHit = 0;

    }

  }

  if (needsNormalization) {

    /* alloc a new string */

    *ppTextOut = (NW_Uint8*) NW_Mem_Malloc(*pByteCount - elideByteCount);

    if (*ppTextOut == NULL) {

      *ppTextOut = (NW_Uint8*)pTextIn;

      return NW_STAT_OUT_OF_MEMORY;

    }

    /* make a normalized copy of input */

    crHit = 0;

    j = 0;

    for (i = 0; i < *pByteCount; i += (NW_Uint32)byteCount) {

      byteCount = NW_String_readChar((NW_Uint8*)&(pTextIn[i]), &cUCS2, encoding);

      if (byteCount < 0) {

        NW_Mem_Free(*ppTextOut);

        *ppTextOut = (NW_Uint8*)pTextIn;

        return NW_STAT_FAILURE;

      }

      /* check that readChar isn't trying to read off end of buffer */

      NW_ASSERT((i + byteCount - 1) < *pByteCount);

      if (cUCS2 == 0xd) {

        crHit = 1;

        if (byteCount == 1) {

          (*ppTextOut)[j++] = 0xa;

        } else if (byteCount == 2) {

          /* this looks odd but takes into account either endianess */

          if (pTextIn[i] == 0xd) {

            (*ppTextOut)[j++] = (NW_Uint8)0xa;

            (*ppTextOut)[j++] = 0;

          } else {

            (*ppTextOut)[j++] = 0;

            (*ppTextOut)[j++] = (NW_Uint8)0xa;

          }

        } else {

          NW_ASSERT(byteCount <= 2); /* code bug, force debug stop here */

          NW_Mem_Free(*ppTextOut);

          *ppTextOut = (NW_Uint8*)pTextIn;

          return NW_STAT_FAILURE;

        }

      } else {

        if (!(crHit && (cUCS2 == 0xa))) {

          (void)NW_Mem_memcpy(&((*ppTextOut)[j]), &(pTextIn[i]), (NW_Uint32)byteCount);

          j += (NW_Uint32)byteCount;

        }

        crHit = 0;

      }

    }

    *pByteCount -= elideByteCount;

    *pCharCount -= elideCharCount;

  }

  return NW_STAT_SUCCESS;

}

static

NW_Status_t

NW_XML_XmlpWbxmlEncoder_New(NW_Uint32 publicID, NW_Uint32 encoding, void** ppV)

{

    NW_WBXML_Dictionary_t* pDictionary;

    NW_XML_XmlpWbxmlEncoder_t** ppTE = (NW_XML_XmlpWbxmlEncoder_t**)ppV;

    *ppTE = (NW_XML_XmlpWbxmlEncoder_t*) NW_Mem_Malloc(sizeof(NW_XML_XmlpWbxmlEncoder_t));

    if (!*ppTE) {

        return NW_STAT_OUT_OF_MEMORY;

    }

    (*ppTE)->lastTagTokenIndex = 0;

    (*ppTE)->publicID = publicID;

    (*ppTE)->encoding = encoding;

    (*ppTE)->pE = (NW_WBXML_Writer_t*) NW_Mem_Malloc(sizeof(NW_WBXML_Writer_t));

    if (!((*ppTE)->pE)) {

        return NW_STAT_OUT_OF_MEMORY;

    }

    /* Note that we only have access to one dictionary and we

    should really have two: one for tags and one for attributes. */

    pDictionary = NW_WBXML_Dictionary_getByPublicId((*ppTE)->publicID);

    if(  ( CXML_Additional_Feature_Supprted() & CXML_DTD_SUPPORT_ON) )

    {

     NW_Encoder_StringTable_t* strTable = NW_Encoder_StringTable_new();

     NW_WBXML_Writer_Initialize((*ppTE)->pE,

                             0, NULL, NULL, /* no mem needed for sizing */

                             pDictionary,

							 pDictionary,

                             NW_Encoder_StringTable_getStringTableOffset,

							 NW_Encoder_StringTable_addToStringTable,

                             strTable, 

							 NW_Encoder_StringTable_StringTableIterateInit,

							 NW_Encoder_StringTable_StringTableIterateNext,

                             1 /* do sizing only */);

    }

    else

    {

    NW_WBXML_Writer_Initialize((*ppTE)->pE,

                               0, NULL, NULL, /* no mem needed for sizing */

                               pDictionary, pDictionary,

                               NULL, NULL, NULL, NULL, NULL, /* string table stuff */

                               1 /* do sizing only */);

    }

    return NW_STAT_SUCCESS;

}

static

void

NW_XML_XmlpWbxmlEncoder_SetToWrite(NW_XML_XmlpWbxmlEncoder_t* pTE,

                                   NW_Uint32 byteLength, NW_Uint8* pBuf,

                                   NW_WBXML_Writer_GrowBuf_t growBufCallback)

{

    if( ( CXML_Additional_Feature_Supprted() & CXML_DTD_SUPPORT_ON) )

    {

        NW_Encoder_StringTable_t* strTable = NW_Encoder_StringTable_new();

        NW_WBXML_Writer_Initialize(pTE->pE,

                             byteLength, pBuf,

                             growBufCallback,

                             pTE->pE->pTagDictionary,

							 pTE->pE->pAttributeDictionary,

                             NW_Encoder_StringTable_getStringTableOffset,

							 NW_Encoder_StringTable_addToStringTable,

                             strTable, 

							 NW_Encoder_StringTable_StringTableIterateInit,

							 NW_Encoder_StringTable_StringTableIterateNext,

                             0 /* don't do sizing, write */);

    }

   else

    {

    NW_WBXML_Writer_Initialize(pTE->pE,

                               byteLength, pBuf,

                               growBufCallback,

                               pTE->pE->pTagDictionary,

                               pTE->pE->pAttributeDictionary,

                               NULL, NULL, NULL, NULL, NULL,  /* string table stuff */

                               0 /* don't do sizing, write */);

    }

}

void

NW_XML_XmlpWbxmlEncoder_Delete(void* pV)

{

    NW_XML_XmlpWbxmlEncoder_t* pTE = (NW_XML_XmlpWbxmlEncoder_t*)pV;

    NW_WBXML_Writer_t* pE = pTE->pE;

    NW_Mem_Free(pE); /* note that this doesn't free WBXML buf and string table. */

    NW_Mem_Free(pTE);

}

static

NW_Status_t

NW_XML_XmlpWbxmlEncoder_StartDocument_CB(NW_XML_Reader_t* pT, void* pV)

{

    NW_XML_XmlpWbxmlEncoder_t* pTE = (NW_XML_XmlpWbxmlEncoder_t*)pV;

    NW_WBXML_Writer_t* pE = pTE->pE;

    NW_REQUIRED_PARAM(pT);

    /* Note: We do not build a string table because it isn't clear if

    it is worthwhile. */

    return NW_WBXML_Writer_Header(pE, 3, pTE->publicID, pTE->encoding, 0);

}

static

NW_Status_t

NW_XML_XmlpWbxmlEncoder_Tag_Start_CB(NW_XML_Reader_t* pT,

                                     const NW_XML_Reader_Interval_t* pI_name,

                                     void* pV)

{

    NW_XML_XmlpWbxmlEncoder_t* pTE = (NW_XML_XmlpWbxmlEncoder_t*)pV;

    NW_WBXML_Writer_t* pE = pTE->pE;

    NW_Uint32 length;

    NW_Uint32 nameByteLength;

    NW_Uint8* pName;

    NW_Status_t s;

    if (!NW_XML_Reader_Interval_IsWellFormed(pI_name)) {

        return NW_STAT_FAILURE;

    }

    length = pI_name->stop - pI_name->start;

    nameByteLength = length;

    s = NW_XML_Reader_DataAddressFromBuffer(pT, pI_name->start,

                                         &nameByteLength,

                                         &pName);

    if (NW_STAT_IS_FAILURE(s)) {

        return s;

    }

    if (nameByteLength != length) {

        return NW_STAT_FAILURE;

    }

    length = pI_name->charStop - pI_name->charStart;

    s = NW_WBXML_Writer_TagString(pE, pTE->encoding, length, nameByteLength,

                            pName, &(pTE->lastTagTokenIndex));

    if (NW_STAT_IS_FAILURE(s)) {

        return s;

    }

    /* default to content but erase if see empty tag end */

    return NW_WBXML_Writer_TagSetContentFlag(pE, pTE->lastTagTokenIndex);

}

static

NW_Status_t

NW_XML_XmlpWbxmlEncoder_Attr_Start_CB(NW_XML_Reader_t* pT,

                                      const NW_XML_Reader_Interval_t* pI_name,