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

#include "messagedefparser\initialstate.h"

#include "messagedefparser\definitiontokenizer.h"

#include "messagedefparser\integeridentifier.h"

#include "util.h"

namespace Parser

{

void CSignatureProcessor::ProcessState()

    {

    Tokens::TTokenType tokenType = CurrentTokenType();

    Parser::TResult result = Parser::EUnexpectedToken;

    const CIdentifierBase* ident = NULL;

    switch (iInternalState)

        {

        case EStateExpectSignatureIdentifier:

            if (tokenType == Tokens::EIdentifier)

                {

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

                    {

                    iIdentifier = new CSignatureIdentifier(CurrentToken());

                    iInternalState = EStateExpectTypeIdOrBaseColon;

                    result = Parser::ENoError;

                    }

                else

                    {

                    result = Parser::EDuplicateIdentifier;

                    }

                }

            break;

        case EStateExpectTypeIdOrBaseColon:

            if (tokenType == Tokens::ETypeId)

                {

                result = Parser::ENoError;

                iInternalState = EStateExpectTypeIdEquals;

                }

            else if (tokenType == Tokens::EColon)

                {

                result = Parser::ENoError;

                iInternalState = EStateExpectSignatureBase;

                }

            break;

        case EStateExpectTypeIdEquals:

            if (tokenType == Tokens::EEquals)

                {

                result = Parser::ENoError;

                iInternalState = EStateExpectSignatureUidValue;

                }

            break;

        case EStateExpectSignatureUidValue:

            result = ResolveNumericToken(tokenType, CurrentToken(), 32, iIdentifier->TypeId().iUid);

            if (result == Parser::ENoError)

                {

                iInternalState = EStateExpectSignatureIdColon;

                }

            break;

        case EStateExpectSignatureIdColon:

            if (tokenType == Tokens::EColon)

                {

                result = Parser::ENoError;

                iInternalState = EStateExpectSignatureIdValue;

                }

            break;

        case EStateExpectSignatureIdValue:

            result = ResolveNumericToken(tokenType, CurrentToken(), 32, iIdentifier->TypeId().iType);

            if (result == Parser::ENoError)

                {

                iInternalState = EStateExpectMoreMembersOrEnd;

                }

            break;

        case EStateExpectMoreMembersOrEnd:

            result = Parser::ENoError;

            switch (tokenType)

                {

                case Tokens::EEnd:

                    iInternalState = EStateExpectEndSignature;

                    break;

                case Tokens::EIdentifier:

                case Tokens::EIntType:

                case Tokens::EPadType:

                case Tokens::EMessageIdType:

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

                    if (!ident) 

                        {

                        result = EUnknownIdentifier;

                        }

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

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

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

                        {

                        result = Parser::EInvalidType;

                        }

                    break;

                default:

                    result = Parser::EUnexpectedToken;

                }

            break;

        case EStateExpectMemberNameOrFormat:

            switch (tokenType)

                {

                case Tokens::EIdentifier:

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

                        {

                        result = Parser::EDuplicateIdentifier;

                        delete iTempMember;

                        }

                    else

                        {

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

                        iIdentifier->AddMember(iTempMember);

                        result = Parser::ENoError;

                        }

                    iTempMember = NULL;

                    iInternalState = EStateExpectMoreMembersOrEnd;

                    break;

                case Tokens::EDisplayDec:

                case Tokens::EDisplayHex:

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

                    iInternalState = EStateExpectMemberName;

                    result = Parser::ENoError;

                    break;

                }

            break;

        case EStateExpectMemberName:

            if (tokenType == Tokens::EIdentifier)

                {

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

                    {

                    result = Parser::EDuplicateIdentifier;

                    delete iTempMember;

                    }

                else

                    {

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

                    iIdentifier->AddMember(iTempMember);

                    result = Parser::ENoError;

                    }

                iTempMember = NULL;

                iInternalState = EStateExpectMoreMembersOrEnd;

                }

            break;

        case EStateExpectEndSignature:

            if (tokenType == Tokens::ESignature)

                {

                result = Parser::ENoError;

                ParserSM().AddIdentifier(iIdentifier);

                iIdentifier = NULL;

                }

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

            break;

        case EStateExpectSignatureBase:

            iInternalState = EStateExpectTypeId;

            if (tokenType == Tokens::EIdentifier)

                {

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

                if (!ident)

                    {

                    result = Parser::EUnknownIdentifier;

                    }

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

                    {

                    iIdentifier->SetBaseSignature(static_cast<const CSignatureIdentifier*>(ident));

                    result = Parser::ENoError;

                    }

                else

                    {

                    result = Parser::EInvalidType;

                    }

                }

            break;

        case EStateExpectTypeId:

            if (tokenType == Tokens::ETypeId)

                {

                result = Parser::ENoError;

                iInternalState = EStateExpectTypeIdEquals;

                }

            break;

        case EStateExpectPadSize:

            {

            result = Parser::ENoError;

            iInternalState = 6;

            unsigned int v = 0;

            if (tokenType == Tokens::ENumberHex)

                {

                v = HexToVal(CurrentToken());

                }

            else if (tokenType == Tokens::ENumberDec)

                {

                v = atol(CurrentToken());

                }

            else

                {

                result = Parser::EUnexpectedToken;

                delete iTempMember;

                }

            if (result == Parser::ENoError)

                {

                if (v >= 1)

                    {

                    iTempMember->iArraySize = v;

                    iIdentifier->AddMember(iTempMember);

                    }

                else

                    {

                    result = Parser::EValueOutOfRange;

                    delete iTempMember;

                    }

                }

            iTempMember = NULL;

            }

            break;

        }

    if (result != Parser::ENoError)

        {

        ParserSM().SetError(result);

        }

    }

} // namespace Parser