/*

* Copyright (c) 2000 - 2004 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: 

*

*/

/*

  HTML Parser

*/

#ifndef FEA_RME_NOHTMLPARSER

#include "nwx_defs.h"

#include "CHtmlpParser.h"

#include <nw_string_char.h>

#include "BrsrStatusCodes.h"

#include "nwx_string.h"

#include "nw_htmlp_to_wbxml.h"

#include "nw_htmlp_html_dict.h"

#include "nw_htmlp_wml_dict.h"

#include <nw_wbxml_dictionary.h>

#include <nw_encoder_stringtable.h>

/* "<?" len 2 */

#define NW_HTMLP_String_PiFormStartLength 2

static

const NW_Uint8 NW_HTMLP_String_PiFormStart[NW_HTMLP_String_PiFormStartLength] =

  {

  '<', '?'

  };

/* "?>" len 2 */

#define NW_HTMLP_String_PiFormStopLength 2

static

const NW_Uint8 NW_HTMLP_String_PiFormStop[NW_HTMLP_String_PiFormStopLength] =

  {

  '?', '>'

  };

/* "<!DOCTYPE" len 9 */

#define NW_HTMLP_String_DoctypeStartLength 9

static

const NW_Uint8 NW_HTMLP_String_DoctypeStart[NW_HTMLP_String_DoctypeStartLength] =

  {

  '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E'

  };

/* "<!--" len 4 comment start */

#define NW_HTMLP_String_CommentStartLength 4

static

const NW_Uint8 NW_HTMLP_String_CommentStart[NW_HTMLP_String_CommentStartLength] =

  {

  '<', '!', '-', '-'

  };

/* "-->" len 3 comment end */

#define NW_HTMLP_String_CommentStopLength 3

static

const NW_Uint8 NW_HTMLP_String_CommentStop[NW_HTMLP_String_CommentStopLength] =

  {

  '-', '-', '>'

  };

/* "<!--" len 3 comment start */

#define NW_HTMLP_String_ImodeCommentStartLength 3

static

const NW_Uint8 NW_HTMLP_String_ImodeCommentStart[NW_HTMLP_String_ImodeCommentStartLength] =

  {

  '<', '!', '-'

  };

/* "-->" len 3 comment end */

#define NW_HTMLP_String_ImodeCommentStopLength 2

static

const NW_Uint8 NW_HTMLP_String_ImodeCommentStop[NW_HTMLP_String_ImodeCommentStopLength] =

  {

  '-', '>'

  };

/* "-->" len 3 comment end */

#define NW_HTMLP_String_Comment2StopLength 4

static

const NW_Uint8 NW_HTMLP_String_Comment2Stop[NW_HTMLP_String_Comment2StopLength] =

  {

  '-', '-','!','>'

  };

/* "<!" len 2 comment start */

#define NW_HTMLP_String_LooseCommentStartLength 2

static

const NW_Uint8 NW_HTMLP_String_LooseCommentStart[NW_HTMLP_String_LooseCommentStartLength] =

  {

  '<', '!'

  };

/* "<![CDATA[" len 9 */

#define NW_HTMLP_String_CdataStartLength 9

static

const NW_Uint8 NW_HTMLP_String_CdataStart[NW_HTMLP_String_CdataStartLength] =

  {

  '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '['

  };

/* "]]>" len 3 */

#define NW_HTMLP_String_CdataStopLength 3

static

const NW_Uint8 NW_HTMLP_String_CdataStop[NW_HTMLP_String_CdataStopLength] =

  {

  ']', ']', '>'

  };

/* "/>" len 2 */

#define NW_HTMLP_String_MiniEndLength 2

static

const NW_Uint8 NW_HTMLP_String_MiniEnd[NW_HTMLP_String_MiniEndLength] =

  {

  '/', '>'

  };

/* ">" len 1 */

#define NW_HTMLP_String_TagEndLength 1

static

const NW_Uint8 NW_HTMLP_String_TagEnd[NW_HTMLP_String_TagEndLength] =

  {

  '>'

  };

/* "</script>" len 9 */

#define NW_HTMLP_String_EndScriptLength 9

static

const NW_Uint8 NW_HTMLP_String_EndScript[NW_HTMLP_String_EndScriptLength] =

  {

  '<', '/','s','c','r','i','p','t','>'

  };

// =" or =' len 2

#define NW_HTMLP_String_EqualQuoteLength 2

static

const NW_Uint8 NW_HTMLP_String_EqualDblQuote[NW_HTMLP_String_EqualQuoteLength] =

  {

  '=', '\"'

  };

static

const NW_Uint8 NW_HTMLP_String_EqualSngQuote[NW_HTMLP_String_EqualQuoteLength] =

  {

  '=', '\''

  };

// TODO: Throughout this class iCBs is checked against null.  It appears that iCBs is 

//       created in the constructor and not deallocated until the destructor.  If 

//       this is the case all of the iCBs null check should be removed.

//lint -esym(794, CHtmlpParser::iCBs) Conceivable use of null pointer

/* constructors and destructor of CHtmlpParser */

CHtmlpParser* CHtmlpParser::NewL(     

                                 NW_Uint32 inputByteCount, 

                                 NW_Uint8* pInputBuf, 

                                 NW_HTMLP_ElementTableIndex_t elementCount,

                                 NW_HTMLP_ElementDescriptionConst_t* pElementDictionary,

                                 NW_Uint32 encoding,

                                 NW_Bool consumeSpaces,

                                 void * parser,

                                 NW_Bool isScript)

  {

  CHtmlpParser * self = (CHtmlpParser *)parser;

  if (!self)

    {

    self = new (ELeave) CHtmlpParser(consumeSpaces);

    CleanupStack::PushL(self);

    self->ConstructL(inputByteCount, pInputBuf, elementCount, pElementDictionary, encoding, isScript);

    CleanupStack::Pop(); //instance

    return self;

    }

  else

    {

    User::LeaveIfError(

      NW_HTMLP_Lexer_InitFromBuffer(self->iLexer, inputByteCount, pInputBuf, elementCount, pElementDictionary));

    NW_HTMLP_Lexer_SetEncoding(self->iLexer, encoding);

    return self;

    }

  }

CHtmlpParser::CHtmlpParser( NW_Bool consumeSpaces)

  {

  iLastTextBuf = NULL;

  iLastValid = -1;

  iPreviousValidOutput = NULL;

  iConsumeSpaces = consumeSpaces;

  iRestarted = NW_FALSE;

  iWithinNoscript = NW_FALSE;

  }

void CHtmlpParser::ConstructL(NW_Uint32 inputByteCount, 

                              NW_Uint8* pInputBuf, 

                              NW_HTMLP_ElementTableIndex_t elementCount,

                              NW_HTMLP_ElementDescriptionConst_t* pElementDictionary,

                              NW_Uint32 encoding,

                              NW_Bool isScript)

  {

  iSPLElemHandling = (NW_HTMLP_SPL_Elem_Handling_t*)NW_Mem_Malloc(sizeof(NW_HTMLP_SPL_Elem_Handling_t));

  User::LeaveIfNull( iSPLElemHandling );

  NW_HTMLP_ElementParseState_New();

  User::LeaveIfNull( iElementParseState );

  iCBs = (NW_HTMLP_EventCallbacks_t*)NW_Mem_Malloc(sizeof(NW_HTMLP_EventCallbacks_t));

  User::LeaveIfNull( iCBs );

  NW_Mem_memset(iCBs, 0, sizeof(NW_HTMLP_EventCallbacks_t));

  iLexer = (NW_HTMLP_Lexer_t* )NW_Mem_Malloc(sizeof(NW_HTMLP_Lexer_t));

  /* Reregister the document text with the Reader in preparation for parsing. */

  User::LeaveIfError(

    NW_HTMLP_Lexer_InitFromBuffer(iLexer, inputByteCount, pInputBuf, elementCount, pElementDictionary));

  NW_HTMLP_Lexer_SetEncoding(iLexer, encoding);

  /* Null out all WBXML generation callback addresses. */

  NW_Mem_memset(iCBs, 0, sizeof(NW_HTMLP_EventCallbacks_t));

  iOrigEncoding = -1;

  iLeftBytes = NULL;

  iIsScript = isScript;

  }

CHtmlpParser::~CHtmlpParser()

  {

  NW_Mem_Free(iSPLElemHandling);

  if (iElementParseState)

    {

    NW_HTMLP_ElementParseState_Delete(&iElementParseState);

    }

  if (iLastValidStack)

    {

    NW_HTMLP_ElementParseState_Delete(&iLastValidStack);

    }

  if (iCBs->charsetContext)

    {

    NW_Mem_Free(iCBs->charsetContext);

    }

  NW_Mem_Free(iCBs);

  NW_Mem_Free ((void *)iLexer);

  NW_Buffer_Free(iLastTextBuf);

  NW_Buffer_Free(iPreviousValidOutput);

  NW_Buffer_Free(iVisitedHeadText);

  }

  /*

  on entry: lexer read position is at the first character of keyword

  on return: If matched keyword, then *pMatch == NW_TRUE, interval marks

  .........: keyword in doc and lexer read position is just after keyword.

  .........: NOTE: Keyword match just means the string of keyword chars

  .........: exists at the read position so it does not mean that the keyword

  .........: is delimited at the end---it might be followed by more name chars.

  .........: If did not match keyword, then *pMatch == NW_FALSE and lexer

  .........: read position is unchanged from on entry.

  eof handling: if encounters EOF while attempting operation then returns

  ............: *pMatch == NW_FALSE and KBrsrSuccess

  on error return: return value is not KBrsrSuccess, *pMatch == NW_FALSE

  ...............: and lexer read position is unspecified

*/

TBrowserStatusCode CHtmlpParser::NW_HTMLP_IfExistsConsumeKeywordCase(NW_HTMLP_Interval_t* pI,

                                                                     NW_Uint32 asciiCharCount,

                                                                     const NW_Uint8* pKeyword,

                                                                     NW_Bool CaseSensitive,

                                                                     NW_Bool* pMatch)

  {

  NW_HTMLP_Lexer_Position_t position;

  TBrowserStatusCode e;

  NW_Bool match;

  *pMatch = NW_FALSE;

  NW_HTMLP_Lexer_GetPosition(iLexer, &position);

  NW_HTMLP_Interval_Init(pI);

  e = NW_HTMLP_Lexer_AsciiStringCompareCase(iLexer, asciiCharCount, pKeyword, CaseSensitive, &match);

  if (e == KBrsrSuccess) {

    if (match == NW_TRUE) {

      NW_HTMLP_Interval_Start(pI, iLexer);

      e = NW_HTMLP_Lexer_AdvanceOffset(iLexer, asciiCharCount);

      if (BRSR_STAT_IS_FAILURE(e)) {

        NW_HTMLP_Interval_Init(pI);

        return e;

        }

      NW_HTMLP_Interval_Stop(pI, iLexer);

      *pMatch = NW_TRUE;

      } else {

      NW_HTMLP_Lexer_SetPosition(iLexer, &position);

        }

    }

  return e;

  }

TBrowserStatusCode CHtmlpParser::NW_HTMLP_IfExistsConsumeKeyword(NW_HTMLP_Interval_t* pI,

                                                                 NW_Uint32 asciiCharCount,

                                                                 const NW_Uint8* pKeyword,

                                                                 NW_Bool* pMatch)

  {

  return NW_HTMLP_IfExistsConsumeKeywordCase( pI,

    asciiCharCount,

    pKeyword,

    NW_TRUE,

    pMatch);

  }

  /*

  on entry: no assumptions

  on return: Lexer read position moved ahead until character at current

  .........: read position is not whitespace.  Return value is KBrsrSuccess.

  eof handling: if encounters EOF then stops at that point and returns

  ............: KBrsrSuccess

  on error return: return value is not KBrsrSuccess and lexer read position

  ...............: is unspecified

*/

TBrowserStatusCode CHtmlpParser::NW_HTMLP_SkipSpace()

  {

  TBrowserStatusCode e = KBrsrSuccess;

  NW_Bool match = NW_FALSE;

  while (!NW_HTMLP_Lexer_AtEnd(iLexer)) {

    e = NW_HTMLP_Lexer_IsSpace(iLexer, &match);

    if (BRSR_STAT_IS_FAILURE(e)) {

      return e;

      }

    if (match == NW_TRUE) {

      e = NW_HTMLP_Lexer_Advance(iLexer);

      if (BRSR_STAT_IS_FAILURE(e)) {

        return e;

        }

      } else {

      break;

        }

    }

  return e;

  }

  /*

  on entry: no assumptions

  on return: Lexer read position moved ahead until character at current

  .........: read position is not whitespace or a 'junk' character.

  .........: The junk characters were found on live websites.

  .........: Return value is KBrsrSuccess.

  eof handling: if encounters EOF then stops at that point and returns

  ............: KBrsrSuccess

  on error return: return value is not KBrsrSuccess and lexer read position

  ...............: is unspecified

*/

TBrowserStatusCode CHtmlpParser::NW_HTMLP_SkipJunk()

{

TBrowserStatusCode e = KBrsrSuccess;

NW_Bool match = NW_FALSE;

while (!NW_HTMLP_Lexer_AtEnd(iLexer)) 

    {

    e = NW_HTMLP_Lexer_IsSpace(iLexer, &match);

    if (BRSR_STAT_IS_FAILURE(e)) 

        {

        return e;

        }

    if (match == NW_FALSE) 

        {

        e = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, ';', &match);

        if (BRSR_STAT_IS_FAILURE(e)) {

            return e;

            }

        }

    if (match == NW_FALSE) 

        {

        e = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, '+', &match);

        if (BRSR_STAT_IS_FAILURE(e)) 

            {

            return e;

            }

        }

    if (match == NW_TRUE) 

        {

        e = NW_HTMLP_Lexer_Advance(iLexer);

        if (BRSR_STAT_IS_FAILURE(e)) 

            {

            return e;

            }

        } 

    else 

        {

        break;

        }

    }

return e;

}

  /*

  on entry: no assumptions

  on return: Lexer read position moved ahead until character at current

  .........: read position is not CR or LF.  Return value is KBrsrSuccess.

  eof handling: if encounters EOF then stops at that point and returns

  ............: KBrsrSuccess

  on error return: return value is not KBrsrSuccess and lexer read position

  ...............: is unspecified

*/

TBrowserStatusCode CHtmlpParser::NW_HTMLP_SkipCRLF()

  {

  TBrowserStatusCode e = KBrsrSuccess;

  NW_Bool match = NW_FALSE;

  while (!NW_HTMLP_Lexer_AtEnd(iLexer)) {

    e = NW_HTMLP_Lexer_IsCRLF(iLexer, &match);

    if (BRSR_STAT_IS_FAILURE(e)) {

      return e;

      }

    if (match == NW_TRUE) {

      e = NW_HTMLP_Lexer_Advance(iLexer);

      if (BRSR_STAT_IS_FAILURE(e)) {

        return e;

        }

      } else {

      break;

        }

    }

  return e;

  }

  /*

  A name (e.g., tag name) matches the pattern "[a-zA-Z][a-zA-Z0-9.-_:]*\s"

  Assumes starting read position is at the first character of name.

  On return: *pMatch = NW_TRUE if found name, NW_FALSE if no name parsed

  On return: If *pMatch == NW_TRUE, then *pI marks the name.

    TBD: loosen this up to allow the pattern [a-zA-Z][^/?]*\s

    don't allow ? due to ?> on PI forms

    don't allow / due to /> on empty element

*/

TBrowserStatusCode CHtmlpParser::NW_HTMLP_ParseName(NW_Bool* pMatch,

                                                    NW_HTMLP_Interval_t* pI)

  {

  NW_HTMLP_Lexer_Position_t position;

  TBrowserStatusCode sl = KBrsrSuccess;

  NW_Bool isLetter = NW_FALSE;

  TBrowserStatusCode sd = KBrsrSuccess;

  NW_Bool isDigit = NW_FALSE;

  TBrowserStatusCode sp = KBrsrSuccess;

  NW_Bool isPeriod = NW_FALSE;

  TBrowserStatusCode sh = KBrsrSuccess;

  NW_Bool isHyphen = NW_FALSE;

  TBrowserStatusCode su = KBrsrSuccess;

  NW_Bool isUnderscore = NW_FALSE;

  TBrowserStatusCode sc = KBrsrSuccess;

  NW_Bool isColon = NW_FALSE;

  TBrowserStatusCode s = KBrsrSuccess;

  *pMatch = NW_FALSE;

  NW_HTMLP_Lexer_GetPosition(iLexer, &position);

  NW_HTMLP_Interval_Init(pI);

  sl = NW_HTMLP_Lexer_IsAsciiLetter(iLexer, &isLetter);

  if (!BRSR_STAT_IS_FAILURE(sl)) {

    if (isLetter) {

      NW_HTMLP_Interval_Start(pI, iLexer);

      while ((!BRSR_STAT_IS_FAILURE(sl) && !BRSR_STAT_IS_FAILURE(su)

        && !BRSR_STAT_IS_FAILURE(sc) && !BRSR_STAT_IS_FAILURE(sd)

        && !BRSR_STAT_IS_FAILURE(sp) && !BRSR_STAT_IS_FAILURE(sh)

        && !BRSR_STAT_IS_FAILURE(s))

        && (isLetter || isDigit || isPeriod || isHyphen

        || isUnderscore || isColon)) {

        s = NW_HTMLP_Lexer_Advance(iLexer);

        sl = NW_HTMLP_Lexer_IsAsciiLetter(iLexer, &isLetter);

        sd = NW_HTMLP_Lexer_IsAsciiDigit(iLexer, &isDigit);

        sp = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, '.', &isPeriod);

        sh = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, '-', &isHyphen);

        su = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, '_', &isUnderscore);

        sc = NW_HTMLP_Lexer_AsciiCharCompare(iLexer, ':', &isColon);

        }

      NW_HTMLP_Interval_Stop(pI, iLexer);

      *pMatch = NW_TRUE;

      }

    }

  if (BRSR_STAT_IS_FAILURE(sl) || BRSR_STAT_IS_FAILURE(su)

    || BRSR_STAT_IS_FAILURE(sc) || BRSR_STAT_IS_FAILURE(sd)

    || BRSR_STAT_IS_FAILURE(sp) || BRSR_STAT_IS_FAILURE(sh)

    || BRSR_STAT_IS_FAILURE(s)) {

    return KBrsrFailure;

    }

  if (*pMatch == NW_FALSE) {

    s = NW_HTMLP_Lexer_SetPosition(iLexer, &position);

    if (BRSR_STAT_IS_FAILURE(s)) {

      return s;

      }

    }

  return KBrsrSuccess;

  }

  /*

  on entry: lexer read position is just after '<!--'

  on return: If skipped comment, then *pMatch == NW_TRUE  and

  .........: lexer read position is just after closing '>'.

  .........: If did not skip comment, then *pMatch == NW_FALSE and

  .........: lexer read position is unspecified.

  .........: In either case return value is KBrsrSuccess.

  eof handling: if encounters EOF while attempting operation then returns

  ............: *pMatch == NW_FALSE and KBrsrSuccess with lexer read

  ............: position at EOF

  on error return: return value is not KBrsrSuccess, *pMatch == NW_FALSE

  ...............: and lexer read position is unspecified

*/