/*

* 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:  Parser for CSS

*

*/

// INCLUDE FILES

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

#include "CSSParser.h"

#include "nw_string_string.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

// MODULE DATA STRUCTURES

// FORWARD DECLARATIONS

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

TBool TCSSParser::ParseElementName(TCSSReaderUnit* aNameSpace, TCSSReaderUnit* aElementName)

{

  TInt8 tokenType;

  TCSSReaderUnit token;

  switch(tokenType = iReader.ReadNextToken(&token))

  {

    case ALPHA:

      if (!iReader.ReadIdentifier(aElementName))

      {

        return EFalse;

      }

      tokenType = iReader.ReadNextToken(&token);

      break;

    case ASTERISK:

      tokenType = iReader.ReadNextToken(&token);

      break;

    case VERTICAL_LINE:

      break;

    default:

      SetPosition(token.iStorage);

      return ETrue;

  }

  if ((tokenType != VERTICAL_LINE) && (tokenType != -1))

  {

    SetPosition(token.iStorage);

    return ETrue;

  }

  /* There is a VERTICAL_LINE token - implies nameSpace present */

  aNameSpace->Init(aElementName->iStorage, aElementName->iLength, aElementName->iNumChars);

  aElementName->Init(NULL, 0, 0);

  switch(iReader.ReadNextToken(&token))

  {

    case ALPHA:

      return iReader.ReadIdentifier(aElementName);

    case ASTERISK:

      return ETrue;

    default:

      SetPosition(token.iStorage);

      return ETrue;

  }

}

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

TBrowserStatusCode TCSSParser::SelectorListIterate(TCSSReaderUnit* aTargetElement,

                                             TUint32 *aSpecificity)

{

  TBrowserStatusCode status;

  TCSSReaderUnit token;

  TCSSSimpleSelector simpleSelector;

  TUint8 numSimpleSelectors;

  *aSpecificity = 0;

  numSimpleSelectors = 0;

  while ((status = SimpleSelectorListIterate(&simpleSelector)) == KBrsrIterateMore)

  {

    *aSpecificity += simpleSelector.specificity;

    numSimpleSelectors++;

  }

  /* Error in parsing selector means that ignore this rule */

  if ((status != KBrsrIterateDone) || (numSimpleSelectors == 0)){ 

    return KBrsrFailure;

  }

  /* status is KBrsrIterateDone */

  aTargetElement->iStorage = simpleSelector.elementName.iStorage;

  aTargetElement->iLength = simpleSelector.elementName.iLength;

  aTargetElement->iNumChars = simpleSelector.elementName.iNumChars;

  switch(iReader.ReadNextToken(&token))

  {

    case COMMA:

      return KBrsrIterateMore;

    case LEFT_BRACE:

      return KBrsrIterateDone;

    default:

      return KBrsrFailure;

  }

}

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

TBrowserStatusCode TCSSParser::ParseRule()

{

  TBrowserStatusCode status;

  TCSSReaderUnit targetElement;

  TUint32 specificity = 0;

  /* parse selector */

  do

  {

    TText8* bufferPtr;

    iReader.SkipWhiteSpaces();

    bufferPtr = iReader.GetBufferPointer();

    status = SelectorListIterate(&targetElement, &specificity);  

    if (iEventListener != NULL)

    {

      TRAPD(ret, iEventListener->SelectorL(bufferPtr, &targetElement, specificity));

      if (ret == KErrNoMemory)

      {

        return KBrsrOutOfMemory;

      }

   }

  }while (status == KBrsrIterateMore);

  /* parse declaration list */

  do

  {

    TCSSReaderUnit property;

    TCSSPropertyVal propertyVal;

    TBool important;

    TUint8 numVals;

    status = DeclarationListIterate(&property, &propertyVal, &numVals, 1, &important);   

  }while (status == KBrsrIterateMore);

  if (status != KBrsrIterateDone)

  {

    TText8 *position;

    return iReader.GoToToken(RIGHT_BRACE, &position);

  }

  return KBrsrSuccess;

}

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

/* parse comma separated list of media */

TBool TCSSParser::HasValidMedia()

{

  TCSSReaderUnit medium;

  TInt8 tokenType;

  TCSSReaderUnit unit;

  TBool applies;

  applies = EFalse;

  do

  {

    iReader.SkipWhiteSpaces();

    /* Read medium */

    if (!iReader.ReadIdentifier(&medium))

    {

      return EFalse;

    }

    if (!applies)

    {/* Is handleheld mentioned ? */

      applies = iReader.IsValidMedia(&medium);

    }

    iReader.SkipWhiteSpaces();

    tokenType = iReader.ReadNextToken(&unit);

    if ((tokenType == SEMI_COLON) || (tokenType == LEFT_BRACE))

    {

      SetPosition(unit.iStorage);

      return applies;

    }

  }while (tokenType == COMMA);

  return EFalse;

}

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

TBrowserStatusCode TCSSParser::ParseImportRule()

{

  TCSSReaderUnit uri;

  TCSSReaderUnit unit;

  TBool applies;

  TInt8 tokenType;

  /* Skip any spaces */

  iReader.SkipWhiteSpaces();

  tokenType = iReader.ReadNextToken(&uri);

  if (tokenType == URI)

  {

    if (!iReader.ReadURI(&uri))

    {

      return KBrsrFailure;

    }

  }

  if ((tokenType != URI) && (tokenType != STRING))

  {

    return KBrsrFailure;

  }

  iReader.SkipWhiteSpaces();

  switch(iReader.ReadNextToken(&unit))

  {

    case SEMI_COLON:

      break;

    case ALPHA:

      applies = HasValidMedia();

      if (iReader.ReadNextToken(&unit) != SEMI_COLON)

      {

        return KBrsrFailure;

      }

      if (!applies)

      {

        return KBrsrSuccess;

      }

      break;

    default:

    /* return advance to semi-colon */

      return KBrsrFailure;

  }

  if (iEventListener)

  {

    return iEventListener->Import(&uri);

  }

  return KBrsrSuccess;

}

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

TBrowserStatusCode TCSSParser::ParseMediaRule()

{

  TCSSReaderUnit unit;

  if (!HasValidMedia()){

    return KBrsrFailure;

  }

  if (iReader.ReadNextToken(&unit) != LEFT_BRACE)

  {

    return KBrsrFailure;

  }

  while(iReader.ReadNextToken(&unit) != RIGHT_BRACE)

  {

    SetPosition(unit.iStorage);

    if (ParseRule() != KBrsrSuccess)

    {

      return KBrsrFailure;

    }

    iReader.SkipWhiteSpaces();

  }

  return KBrsrSuccess;

}

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

/* parse the header which can be comments, whitespaces, or import rules 

 * [S|CDO|CDC]* [import [S|CDO|CDC]* ]*

 */

TBrowserStatusCode TCSSParser::ParseStyleRules()

{

  TBrowserStatusCode status;

  TCSSReaderUnit token;

  TUint32 readerPosition;

  TText8 *position;

  TBool atRuleParsed = EFalse;

  status = KBrsrSuccess;

  iReader.SkipWhiteSpaces();

  while(status == KBrsrSuccess)

  {

    switch(iReader.ReadNextToken(&token))

    {

      case -1:

      case BUFFER_END:

        return KBrsrBufferEnd;

      case CDO:

        /* Skip SGML comments */

        break;

      case CDC:

        /* Skip SGML comments */

        break;

      case ATKEYWORD:

      case CHARSET_RULE:

        readerPosition = iReader.GetPosition();

        atRuleParsed = iReader.IgnoreAtRule(readerPosition);

        if (!atRuleParsed)

        {

          status = KBrsrFailure;

        }

        break;

      case IMPORT_RULE:

        readerPosition = iReader.GetPosition();

        if (ParseImportRule() != KBrsrSuccess)

        {

            atRuleParsed = iReader.IgnoreAtRule(readerPosition);

            if (!atRuleParsed)

            {

                status = KBrsrFailure;

            }

        }   

       break;

      case MEDIA_RULE:

        readerPosition = iReader.GetPosition();

        if (ParseMediaRule() != KBrsrSuccess)

        {

          atRuleParsed = iReader.IgnoreAtRule(readerPosition);

          if (!atRuleParsed)

          {

            status = KBrsrFailure;

          }

        }

        break;

      default:

        SetPosition(token.iStorage);

        if (ParseRule() != KBrsrSuccess)

        {

          status = iReader.GoToToken( RIGHT_BRACE, &position);          

        }

        break;

    }

    iReader.SkipWhiteSpaces();

  }

  return status;

}

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

TBrowserStatusCode TCSSParser::ParseHeader()

{

  TBrowserStatusCode status;

  TText8 *position;

  TCSSReaderUnit token;

  TUint32 thisPosition;

    // read the next token for @charset rule 

  TInt tok = iReader.ReadNextToken(&token) ;

  thisPosition = iReader.GetPosition();

  if(tok == -1 )

  {

    // various failures in read token return -1 

    return KBrsrFailure;

  }

  if (tok == CHARSET_RULE)

  {

    if (iReader.GoToToken(SEMI_COLON, &position) != KBrsrSuccess)

    {

        return KBrsrFailure;

    }

  }

  //If it is comment in the begginning then continue to read. Do not set

  //position again. Otherwise in the embedded style sheet, <style> element

  //is skipped.

  if(tok != CDO)

  {

   iReader.SetPosition(thisPosition - token.iLength);

  }

  /* parse the header which can be comments, whitespaces, or import rules 

   * [S|CDO|CDC]* [import [S|CDO|CDC]* ]*

   */

  status = KBrsrSuccess;

  while (status == KBrsrSuccess)

  {

    switch(iReader.ReadNextToken(&token))

    {

      case -1:

      case BUFFER_END:

        return KBrsrBufferEnd;

      case SPACE:

        break;

      case CDO:

        /* Skip SGML comments */

        break;

      case CDC:

        /* Skip SGML comments */

        break;

      case IMPORT_RULE:

        if (ParseImportRule() != KBrsrSuccess){

          status = iReader.GoToToken(SEMI_COLON, &position); 

        }

        break;

      default:

        SetPosition(token.iStorage);

        return KBrsrSuccess;

    }

  }

  return status;

}

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

TBrowserStatusCode TCSSParser::ParserPropertyVal(TCSSPropertyVal* aPropertyVal)

{

  TCSSReaderUnit token;

  TUint32 thisPosition;

  NW_ASSERT(aPropertyVal);

  aPropertyVal->next = NULL;

  iReader.SkipWhiteSpaces();

  aPropertyVal->val.Init(NULL, 0, 0);

  thisPosition = iReader.GetPosition();

  switch (aPropertyVal->type = iReader.ReadNextToken(&aPropertyVal->val))

  {

    case URI:

      if (!iReader.ReadURI(&aPropertyVal->val))

      {

        if (!iReader.ReadIdentifier(&aPropertyVal->val))

        {

          return KBrsrFailure;

        }

        aPropertyVal->type = IDENTIFIER;

      }

      break;

    case STRING:

      break;

    case HASH:

      if (!iReader.ReadName(&aPropertyVal->val))

      {

        return KBrsrFailure;

      }

      aPropertyVal->type = HASH;

      break;

    case ALPHA:

      if (!iReader.ReadIdentifier(&aPropertyVal->val))

      {

        return KBrsrFailure;

      }

      aPropertyVal->type = IDENTIFIER;

      break;

    case HYPHEN:

      {

        thisPosition = iReader.GetPosition();

        aPropertyVal->type = iReader.ReadNumberToken(&aPropertyVal->val);

        if (aPropertyVal->type == -1)

        {

          iReader.SetPosition(thisPosition);

          if (!iReader.ReadIdentifier(&aPropertyVal->val))

          {

            return KBrsrFailure;

          }

          aPropertyVal->type = IDENTIFIER;

        }

        break;

      }

    case RGB:

      {

        TCSSPropertyVal rVal;

        TCSSPropertyVal gVal;

        TCSSPropertyVal bVal;

        aPropertyVal->val.iStorage = GetPosition();

        if (ParserRGB(&rVal, &gVal, &bVal) != KBrsrSuccess)

        {

          return KBrsrFailure;

        }

      }

      break;

    case DOT:

      iReader.SetPosition(thisPosition);

      //Fall through to the default and read the number now

      /*lint -fallthrough */

    default:

      aPropertyVal->type = iReader.ReadNumberToken(&aPropertyVal->val);

      if (aPropertyVal->type == -1)

      {

        return KBrsrFailure;

      }

      break;

  }

  iReader.SkipWhiteSpaces();

  thisPosition = iReader.GetPosition();

  switch(iReader.ReadNextToken(&token))

  {

    case IMPORTANT:

    case RIGHT_BRACE:

    case SEMI_COLON:

    case BUFFER_END:

      SetPosition(token.iStorage); 

      return KBrsrSuccess;

    case URI:

      iReader.SetPosition(thisPosition);

      aPropertyVal->next = iReader.GetBufferPointer();

      return KBrsrSuccess;

    default:

      SetPosition(token.iStorage); 

      aPropertyVal->next = iReader.GetBufferPointer();

      return KBrsrSuccess;

  }

}