/*

* Copyright (c) 2003 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:  Lexer for CSS

*

*/

// INCLUDE FILES

#include <e32def.h>  // First to avoid NULL redefine warning (no #ifndef NULL).

#include "nwx_defs.h"

#include "CSSReader.h"

#include "nw_text_ucs2.h"

#include "nwx_assert.h"

#include "nwx_http_defs.h"

#include "nwx_string.h"

#include "BrsrStatusCodes.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

#define ASCII_NULL                0x00

#define ASCII_EXCLAMATION_MARK    '!'

#define ASCII_QUOTATION_MARK      '"'

#define ASCII_HASH                '#'

/*#define ASCII_PERCENT             '%'*/

#define ASCII_APOSTROPHE          '\''

#define ASCII_LEFT_PARENTHESIS    '('

#define ASCII_RIGHT_PARENTHESIS   ')'

#define ASCII_ASTERISK            '*'

#define ASCII_EQUALS              '='

#define ASCII_COMMA               ','

#define ASCII_HYPHEN              '-'

#define ASCII_UNDERSCORE          '_'

#define ASCII_DOT                 '.'

#define ASCII_SLASH               '/'

#define ASCII_BACKSLASH           '\\'

#define ASCII_COLON               ':'

#define ASCII_SEMI_COLON          ';'

#define ASCII_LESS_THAN           '<'

/*#define ASCII_GREATER_THAN        '>'*/

#define ASCII_AT                  '@'

#define ASCII_LEFT_BRACE          '{'

#define ASCII_VERTICAL_LINE       '|'

#define ASCII_RIGHT_BRACE         '}'

#define ASCII_LEFT_BRACKET        '['

#define ASCII_RIGHT_BRACKET       ']'

#define ASCII_LOWER_R             'r'

#define ASCII_LOWER_U             'u'

static const TText16 importRule[] = {'i','m','p','o','r','t','\0'};

static const TText16 mediaRule[] = {'m','e','d','i','a','\0'};

static const TText16 charsetRule[] = {'@','c','h','a','r','s','e','t','\0'};

static const TText16 activeClass[] = {'a','c','t','i','v','e','\0'};

static const TText16 focusClass[] = {'f','o','c','u','s','\0'};

static const TText16 linkClass[] = {'l','i','n','k','\0'};

static const TText16 visitedClass[] = {'v','i','s','i','t','e','d','\0'};

static const TText16 cachedClass[] = {'c','a','c','h','e','d','\0'};

static const TText16 important[] = {'i','m','p','o','r','t','a','n','t','\0'};

static const TText16 all[] = {'a','l','l','\0'};

/*static const TText16 screen[] = {'s','c','r','e','e','n','\0'};*/

static const TText16 handheld[] = {'h','a','n','d','h','e','l','d','\0'};

static const TText16 cdo[] = { '<', '!', '-', '-','\0' };

static const TText16 cdc[] = { '-', '-','>','\0' };

static const TText16 em[] = { 'e','m','\0' };

static const TText16 ex[] = { 'e','x','\0' };

static const TText16 px[] = { 'p','x','\0' };

static const TText16 in[] = { 'i','n','\0' };

static const TText16 cm[] = { 'c','m','\0' };

static const TText16 mm[] = { 'm','m','\0' };

static const TText16 pt[] = { 'p','t','\0' };

static const TText16 pc[] = { 'p','c','\0' };

static const TText16 percent[] = {'%','\0'};

static const TText16 rgb[] = {'r','g','b','(','\0'};

/* following strings need to be changed */

static const TText16 latin1[] = {'i','s','o','-','8','8','5','9','-','1','\0'};

static const TText16 ucs2[]= {'i','s','o','-','1','0','6','4','6','-','u','c','s','-','2','\0'};

static const TText16 utf8[]= {'u','t','f','-','8','\0'};

static const TText16 usAscii[]= {'u','s','-','a','s','c','i','i','\0'};

// MODULE DATA STRUCTURES

struct TCSSKeyword

{

  const TText16* name;

  TUint16 tokenType;

};

// Array of charsets

static const TCSSKeyword TCSSReaderCharsets[] =

{

  {latin1, HTTP_iso_8859_1},

  {ucs2, HTTP_iso_10646_ucs_2},

  {utf8, HTTP_utf_8},

  {usAscii, HTTP_us_ascii}

};

// Array of at-rules

static const TCSSKeyword TCSSReaderAtRuleKeywords[] =

{

  {importRule, IMPORT_RULE},

  {mediaRule, MEDIA_RULE},

  {charsetRule, CHARSET_RULE},

};

// Array of pseudo-class keywords

static const TCSSKeyword TCSSPseudoClassKeywords[] =

{

  {activeClass, ACTIVE_PSEUDO_CLASS},

  {linkClass, LINK_PSEUDO_CLASS},

  {visitedClass, VISITED_PSEUDO_CLASS},

  {focusClass, FOCUS_PSEUDO_CLASS},

  {cachedClass, CACHED_PSEUDO_CLASS}

};

// Array of units

static const TCSSKeyword TCSSUnitKeywords[] =

{

  {em, EMS},

  {ex, EXS},

  {px, PXS},

  {in, INS},

  {cm, CMS},

  {mm, MMS},

  {pt, PTS},

  {pc, PCS},

  {percent, PERCENTAGE}

};

// FORWARD DECLARATIONS

// LOCAL FUNCTION PROTOTYPES

/* -------------------------------------------------------------------------*/

static void NW_CSS_Reader_Ucs2_ntoh(NW_Byte* pBuf, TUint32 byteCount)

{

  TUint32 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(TUint16));

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

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

    }

  }

}

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// TCSSReader::ReadCharL

// Reads a character as a unicode character

// -----------------------------------------------------------------------------

//

TInt32 TCSSReader::ReadChar(TText16* c)

{

  TInt32 byteCnt;

  *c = 0;

  if (iPosition == iLength)

  {

    return -1;

  }

  if ((byteCnt = NW_String_readChar(iBuffer+iPosition, c, iEncoding)) == -1)

  {

    *c = 0;

    return -1;

  }

  if (!Advance(byteCnt))

  {

    *c = 0;

    return -1;

  }

  return byteCnt;

}

/* ------------------------------------------------------------------------- */

TBool TCSSReader::Equals(const TText16* aStr, TBool aCaseInsensitive)

{

  TUint32 position;

  TUint32 len;

  position = iPosition;

  len = NW_Str_Strlen(aStr);

  for (TUint32 index=0; index < len; index++)

  {

    TText16 strCh;

    TText16 c;

    if (ReadChar(&c) == -1)

    {

      SetPosition(position);

      return EFalse;

    }

    if (aCaseInsensitive)

    {

      strCh = NW_Str_ToLower(*aStr);

	    c = NW_Str_ToLower(c);

    }

    else

    {

      strCh = *aStr;

    }

    if (c != strCh)

    {

      SetPosition(position);

      return EFalse;

    }

    aStr++;

  }

  return ETrue;

}

/* ------------------------------------------------------------------------- */

TBool TCSSReader::ReadString(TCSSReaderUnit *aStr)

{

  TText16 c;

  TText16 strStartChar;

  TText16 previousChar;

  TInt32 byteCnt;

  TInt32 escLen;

  byteCnt = ReadChar(&c);

  if ((c != ASCII_QUOTATION_MARK) && (c != ASCII_APOSTROPHE))

  {

    return EFalse;

  }

  strStartChar = previousChar = c;

  aStr->Init(iBuffer + iPosition, 0, 0);

  while ((byteCnt = ReadChar(&c)) != -1)

  {

    /* check for escape character */

    if (c == strStartChar)

    {

      if (previousChar != ASCII_BACKSLASH)

      {

        return ETrue;

      }

    }

    else if (c == ASCII_BACKSLASH)

    {

      escLen = ReadEscape(&c);

      if (escLen == -1)

      {

        return EFalse;

      }

      byteCnt += escLen;

      previousChar = ' ';

    }

    else

    {

      previousChar = c;

    }

    aStr->iLength += byteCnt;

    aStr->iNumChars ++;

  }

  return EFalse;

}

/* ------------------------------------------------------------------------- */

TBool TCSSReader::ReadURI(TCSSReaderUnit *aStr)

{

  static const TText16 url[] = { 'u','r','l','(','\0' };

  TInt32 byteCnt;

  TText16 c;

  TUint32 position;

  NW_ASSERT(aStr);

  if (!Equals((TText16*)url, EFalse))

  {

    return EFalse;

  }

  SkipWhiteSpaces();

  position = iPosition;

  if (ReadString(aStr))

  {

    SkipWhiteSpaces();

    ReadChar(&c);

    if (c == ASCII_RIGHT_PARENTHESIS)

    {

      return ETrue;

    }

   return EFalse;

  }

  SetPosition(position);

  aStr->Init(iBuffer+iPosition, 0,0);

  /* read url */

  while ((byteCnt = ReadChar(&c)) != -1)

  {

    if (c == ASCII_RIGHT_PARENTHESIS)

    {

      return ETrue;

    }

    aStr->iLength += byteCnt;

    aStr->iNumChars++;

  }

  return EFalse;

}

/* -------------------------------------------------------------------------*/

TBool TCSSReader::ReadBlock(TText16 aClosingChar)

{

  TInt32 byteCnt;

  TText16 c;

  TCSSReaderUnit unit;

  TBool status = ETrue;

  status = ETrue;

  while ((byteCnt = ReadChar(&c)) != -1)

  {

    if (c == aClosingChar)

    {

      return ETrue;

    }

    switch(c)

    {

      case ASCII_LEFT_BRACE:

        status = ReadBlock(ASCII_RIGHT_BRACE);

        break;

      case ASCII_LEFT_PARENTHESIS:

        status = ReadBlock(ASCII_RIGHT_PARENTHESIS);

        break;

      case ASCII_LEFT_BRACKET:

        status = ReadBlock(ASCII_RIGHT_BRACKET);

        break;

      case ASCII_APOSTROPHE:

      case ASCII_QUOTATION_MARK:

        SetPosition(iPosition - byteCnt);

        status = ReadString(&unit);

        break;

      default:

        break;

    }

    if (!status)

    {

      return EFalse;

    }

  }

  return EFalse;

}

/* ------------------------------------------------------------------------- *

   final methods

 * ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

TBool TCSSReader::IsValidMedia(TCSSReaderUnit *aStr)

{

  TCSSReader r(aStr->iStorage, aStr->iLength, iEncoding);

  return (r.Equals((TText16 *)all, EFalse) || r.Equals((TText16 *)handheld, EFalse));

}

/* ------------------------------------------------------------------------- */

TInt8 TCSSReader::ReadNextToken(TCSSReaderUnit* aToken)

{

  TText16 c;

  TInt32 byteCnt;

  TCSSReaderUnit str;

  TUint32 thisPosition;

  NW_ASSERT(aToken);

  if (iPosition == iLength)

  {

    return -1;

  }

  thisPosition = iPosition;

  aToken->Init(iBuffer+iPosition, 0,0);

  if ((byteCnt = ReadChar(&c)) == -1)

  {

    return -1;

  }

  if (c == ASCII_BACKSLASH)

  {

    byteCnt = ReadEscape(&c);

  }

  aToken->iLength = byteCnt;

  aToken->iNumChars++;

  if (NW_Str_Isspace(c))

  {

    return SPACE;

  }

  if (NW_Str_Isdigit(c))

  {

    SetPosition(iPosition - byteCnt);

    return DIGIT;

  }

  switch(c)

  {

  case ASCII_NULL:

    return BUFFER_END;

  case ASCII_LEFT_BRACE:

    return LEFT_BRACE;

  case ASCII_RIGHT_BRACE:

    return RIGHT_BRACE;

  case ASCII_LEFT_BRACKET:

    return LEFT_BRACKET;

  case ASCII_RIGHT_BRACKET:

    return RIGHT_BRACKET;

  case ASCII_DOT:

    return DOT;

  case ASCII_COMMA:

    return COMMA;

  case ASCII_SEMI_COLON:

    return SEMI_COLON;

  case ASCII_ASTERISK:

    return ASTERISK;

  case ASCII_EQUALS:

    return EQUALS;

  case ASCII_VERTICAL_LINE:

    return VERTICAL_LINE;

  case ASCII_RIGHT_PARENTHESIS:

    return RIGHT_PARENTHESIS;

  case ASCII_HASH:

    return HASH;

  case ASCII_SLASH:

      return 0;

  case ASCII_LESS_THAN:

    SetPosition(thisPosition);

    if (Equals((TText16 *)cdo, EFalse))

    {

      aToken->iLength += NW_Str_Strlen((TText16 *)cdo) -1 ;

      return CDO;

    }

    return -1;

  case ASCII_HYPHEN:

    SetPosition(thisPosition);

    if (Equals((TText16 *)cdc, EFalse))

    {

      return CDC;

    }

    SetPosition(thisPosition);

    return HYPHEN;

  case ASCII_APOSTROPHE:

  case ASCII_QUOTATION_MARK:

    SetPosition(thisPosition);

    if (ReadString(aToken))

    {

      return STRING;

    }

    return -1;

  case ASCII_AT:

    {

      TUint32 index = 0;

      while (index < sizeof(TCSSReaderAtRuleKeywords)/sizeof(TCSSKeyword))

      {

        if (Equals(TCSSReaderAtRuleKeywords[index].name, EFalse))

        {

          TUint32 length = NW_Str_Strlen(TCSSReaderAtRuleKeywords[index].name);

          if (iEncoding == HTTP_iso_10646_ucs_2)

          {

             // Ucs2 chars are 2 bytes.

             aToken->iLength += (2 * length);

          }

          else

          {

             aToken->iLength += length;

          }

          return (TInt8)TCSSReaderAtRuleKeywords[index].tokenType;

        }

        index++;

      }

      if (ReadIdentifier(&str))

      {

        aToken->iLength += str.iNumChars;

        return ATKEYWORD;

      }

      return -1;

    }