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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 "messagedefparser\contextprocessor.h"

#include "messagedefparser\initialstate.h"

#include "messagedefparser\definitiontokenizer.h"

#include "messagedefparser\integeridentifier.h"

#include "util.h"

namespace Parser

{

void CContextProcessor::ProcessState()

    {

    Tokens::TTokenType tokenType = CurrentTokenType();

    iResult = Parser::EUnexpectedToken;

    const CIdentifierBase* ident = NULL;

    switch (iInternalState)

        {

        case EStateExpectContextIdentifier:

            if (tokenType == Tokens::EIdentifier)

                {

                CreateTempContext();

                }

            break;

        case EStateExpectBaseOrFirstMember:

            iResult = Parser::ENoError; // default to ok - most cases here will succeed

            switch (tokenType)

                {

                case Tokens::EColon:

                    iInternalState = EStateExpectBaseIdentifier;

                    break;

                case Tokens::EIdentifier:

                case Tokens::EIntType:

                case Tokens::EPadType:

                case Tokens::EMessageIdType:

                    CreateTempMember();

                    break;

                default:

                    iResult = Parser::EUnexpectedToken;

                }

            break;

        case EStateExpectBaseIdentifier:

            iInternalState = EStateExpectMoreMembersOrEnd;

            if (tokenType == Tokens::EIdentifier)

                {

                ident = ParserSM().FindIdentifier(CurrentToken());

                if (!ident)

                    {

                    iResult = Parser::EUnknownIdentifier;

                    }

                else if (ident->Type() == Parser::EContextIdentifier)

                    {

                    iIdentifier->SetBaseContext(static_cast<const CContextIdentifier*>(ident));

                    iResult = Parser::ENoError;

                    }

                else

                    {

                    iResult = Parser::EInvalidType;

                    }

                }

            break;

        case EStateExpectMemberNameOrFormat:

            switch (tokenType)

                {

                case Tokens::EIdentifier:

                    if (iIdentifier->FindMember(CurrentToken()))

                        {

                        iResult = Parser::EDuplicateIdentifier;

                        delete iTempMember;

                        }

                    else

                        {

                        iTempMember->iMemberName = _strdup(CurrentToken());

                        iIdentifier->AddMember(iTempMember);

                        iResult = Parser::ENoError;

                        }

                    iInternalState = EStateExpectMoreMembersOrEnd;

                    iTempMember = NULL;

                    break;

                case Tokens::EDisplayDec:

                case Tokens::EDisplayHex:

                    iTempMember->iIdentifierOptions = new TIntegerIdentifierOptions(tokenType == Tokens::EDisplayHex);

                    iInternalState = EStateExpectMemberName;

                    iResult = Parser::ENoError;

                    break;

                }

            break;

        case EStateExpectMemberName:

            if (tokenType == Tokens::EIdentifier)

                {

                if (iIdentifier->FindMember(CurrentToken()))

                    {

                    iResult = Parser::EDuplicateIdentifier;

                    delete iTempMember;

                    }

                else

                    {

                    iTempMember->iMemberName = _strdup(CurrentToken());

                    iIdentifier->AddMember(iTempMember);

                    iResult = Parser::ENoError;

                    }

                iInternalState = EStateExpectMoreMembersOrEnd;

                iTempMember = NULL;

                }

            break;

        case EStateExpectMoreMembersOrEnd:

            iResult = Parser::ENoError;

            switch (tokenType)

                {

                case Tokens::EEnd:

                    if (iIdentifier->iMembers.size() > 0)

                        {

                        iInternalState = EStateExpectEndContext;

                        }

                    else

                        {

                        iResult = Parser::EUnexpectedToken;

                        }

                    break;

                case Tokens::EIdentifier:

                case Tokens::EIntType:

                case Tokens::EPadType:

                case Tokens::EMessageIdType:

                    CreateTempMember();

                    break;

                default:

                    iResult = Parser::EUnexpectedToken;

                }

            break;

        case EStateExpectEndContext:

            if (tokenType == Tokens::EContext)

                {

                if (ParserSM().FindContextBySize(iIdentifier->TotalSize()))

                    {

                    iResult = Parser::EDuplicateIdentifier;

                    }

                else

                    {

                    iResult = Parser::ENoError;

                    ParserSM().AddIdentifier(iIdentifier);

                    iIdentifier = NULL;

                    }

                }

            ParserSM().SetState(new CInitialState(ParserSM()));

            break;

        case EStateExpectPadSize:

            {

            iResult = Parser::ENoError;

            iInternalState = EStateExpectMoreMembersOrEnd;

            unsigned int v = 0;

            if (tokenType == Tokens::ENumberHex)

                {

                v = HexToVal(CurrentToken());

                }

            else if (tokenType == Tokens::ENumberDec)

                {

                v = atol(CurrentToken());

                }

            else

                {

                iResult = Parser::EUnexpectedToken;

                delete iTempMember;

                }

            if (iResult == Parser::ENoError)

                {

                if (v >= 1)

                    {

                    iTempMember->iArraySize = v;

                    iIdentifier->AddMember(iTempMember);

                    }

                else

                    {

                    iResult = Parser::EValueOutOfRange;

                    delete iTempMember;

                    }

                }

            iTempMember = NULL;

            }

            break;

        }

    if (iResult != Parser::ENoError)

        {

        ParserSM().SetError(iResult);

        }

    }

void CContextProcessor::CreateTempContext()

    {

    if (!ParserSM().FindIdentifier(CurrentToken()))

        {

        iIdentifier = new CContextIdentifier(CurrentToken());

        iInternalState = EStateExpectBaseOrFirstMember;

        iResult = Parser::ENoError;

        }

    else

        {

        iResult = Parser::EDuplicateIdentifier;

        }

    }

void CContextProcessor::CreateTempMember()

    {

    // Expect type of the member - can be a builtin (PAD, UINTx, INTx, TMESSAGEID)

    // or an identifier of a predefined struct/enum

    const CIdentifierBase* ident = ParserSM().FindIdentifier(CurrentToken());

    if (!ident) 

        {

        iResult = EUnknownIdentifier;

        }

    else if (ident->Type() == EEnumTypeIdentifier || ident->Type() == EStructIdentifier

        || ident->Type() == EIntegerTypeIdentifier || ident->Type() == Parser::EMessageIdTypeIdentifier)

        {

        iTempMember = new TMember();

        iTempMember->iMemberType = ident;

        if (ident->Type() == EIntegerTypeIdentifier)

            {

            iInternalState = EStateExpectMemberNameOrFormat;

            }

        else

            {

            iInternalState = EStateExpectMemberName;

            }

        }

    else if (ident->Type() == EPadTypeIdentifier)

        {

        iTempMember = new TMember();

        iTempMember->iMemberType = ident;

        iInternalState = EStateExpectPadSize;

        }

    else

        {

        iResult = Parser::EInvalidType;

        }

    }

} // namespace Parser