// 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\structprocessor.h"

#include "messagedefparser\integeridentifier.h"

#include "messagedefparser\initialstate.h"

#include "messagedefparser\definitiontokenizer.h"

#include "util.h"

namespace Parser

{

void CStructProcessor::ProcessState()

    {

    Tokens::TTokenType tokenType = CurrentTokenType();

    iResult = Parser::EUnexpectedToken;

    const CIdentifierBase* ident = NULL;

    switch (iInternalState)

        {

        case EStateExpectStructIdentifier:

            // name of new struct

            if (tokenType == Tokens::EIdentifier)

                {

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

                    {

                    iIdentifier = new CStructIdentifier(CurrentToken());

                    iInternalState = EStateExpectMoreMembersOrEnd;

                    iResult = Parser::ENoError;

                    }

                else

                    {

                    iResult = Parser::EDuplicateIdentifier;

                    }

                }

            break;

        case EStateExpectMoreMembersOrEnd:

            iResult = Parser::ENoError;

            switch (tokenType)

                {

                case Tokens::EPadType:

                case Tokens::EIntType:

                case Tokens::EIdentifier:

                case Tokens::EMessageIdType:

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

                    if (!ident)

                        {

                        iResult = Parser::EUnknownIdentifier;

                        }

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

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

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

                        {

                        iTempMember = new TMember();

                        iTempMember->iMemberType = ident;

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

                            {

                            iInternalState = EStateExpectMemberNameOrFormat;

                            }

                        else

                            {

                            iInternalState = EStateExpectMemberName;

                            }

                        }

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

                        {

                        iTempMember = new TMember();

                        iTempMember->iMemberType = ident;

                        iInternalState = EStateExpectPadSize;

                        break;

                        }

                    else 

                        {

                        iResult = Parser::EInvalidType;

                        }

                    break;

                case Tokens::EEnd:

                    iInternalState = EStateExpectEndStruct;

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

                        {

                        iResult = Parser::EUnexpectedToken;

                        }

                    break;

                default:

                    iResult = Parser::EUnexpectedToken;

                    break;

                }

            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 EStateExpectEndStruct:

            if (tokenType == Tokens::EStruct)

                {

                ParserSM().AddIdentifier(iIdentifier);

                iIdentifier = NULL;

                iResult = Parser::ENoError;

                }

            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);

        }

    }

} // namespace Parser