--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commsfwtools/commstools/utracedecoder/src/messagedefparser/contextprocessor.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,265 @@
+// 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
+