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