// 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\messageprocessor.h"
#include "messagedefparser\initialstate.h"
#include "messagedefparser\definitiontokenizer.h"
#include "messagedefparser\signatureidentifier.h"
#include "util.h"

namespace Parser
{

void CMessageProcessor::ProcessState()
    {
    Tokens::TTokenType tokenType = CurrentTokenType();
    Parser::TResult result = Parser::EUnexpectedToken;
    const CIdentifierBase* ident = NULL;

    switch (iInternalState)
        {
        case EStateExpectMessageIdentifier:
            if (tokenType == Tokens::EIdentifier)
                {
                if (!ParserSM().FindIdentifier(CurrentToken()))
                    {
                    iIdentifier = new CMessageIdentifier(CurrentToken());
                    iInternalState = EStateExpectSignature;
                    result = Parser::ENoError;
                    }
                else
                    {
                    result = Parser::EDuplicateIdentifier;
                    }
                }
            break;

        case EStateExpectSignature:
            if (tokenType == Tokens::ESignature)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectSignatureEquals;
                }
            break;

        case EStateExpectSignatureEquals:
            if (tokenType == Tokens::EEquals)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectSignatureIdentifier;
                }
            break;

        case EStateExpectSignatureIdentifier:
            iInternalState = EStateExpectMessageId;
            if (tokenType == Tokens::EIdentifier)
                {
                ident = ParserSM().FindIdentifier(CurrentToken());
                if (!ident)
                    {
                    result = Parser::EUnknownIdentifier;
                    }
                else if (ident->Type() == Parser::ESignatureIdentifier)
                    {
                    iIdentifier->iSignature = static_cast<const CSignatureIdentifier*>(ident);
                    result = Parser::ENoError;
                    }
                else
                    {
                    result = Parser::EInvalidType;
                    }
                }
            break;

        case EStateExpectMessageId:
            if (tokenType == Tokens::EMessageId)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectMessageIdEquals;
                }
            break;

        case EStateExpectMessageIdEquals:
            if (tokenType == Tokens::EEquals)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectMessageRealmValue;
                }
            break;

        case EStateExpectMessageRealmValue:
            result = ResolveNumericToken(tokenType, CurrentToken(), 32, iIdentifier->iMessageId.iRealmId);
            if (result == Parser::ENoError)
                {
                iInternalState = EStateExpectMessageColon;
                }
            break;

        case EStateExpectMessageColon:
            if (tokenType == Tokens::EColon)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectMessageIdValue;
                }
            break;

        case EStateExpectMessageIdValue:
            result = ResolveNumericToken(tokenType, CurrentToken(), 16, iIdentifier->iMessageId.iMessageId);
            if (result == Parser::ENoError)
                {
                iInternalState = EStateExpectEnd;
                }
            break;

        case EStateExpectEnd:
            if (tokenType == Tokens::EEnd)
                {
                result = Parser::ENoError;
                iInternalState = EStateExpectEndMessage;
                }
            break;

        case EStateExpectEndMessage:
            if (tokenType == Tokens::EMessage)
                {
                result = Parser::ENoError;
                ParserSM().AddIdentifier(iIdentifier);
                iIdentifier = NULL;
                }
            ParserSM().SetState(new CInitialState(ParserSM()));
            break;
        }

    if (result != Parser::ENoError)
        {
        ParserSM().SetError(result);
        }
    }

} // namespace Parser