--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commsfwtools/commstools/utracedecoder/src/messagedefparser/enumprocessor.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,176 @@
+// 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 <cassert>
+#include "messagedefparser\enumprocessor.h"
+#include "messagedefparser\initialstate.h"
+#include "messagedefparser\definitiontokenizer.h"
+#include "util.h"
+
+namespace Parser
+{
+
+void CEnumProcessor::ProcessState()
+    {
+    Tokens::TTokenType tokenType = CurrentTokenType();
+    Parser::TResult result = Parser::EUnexpectedToken;
+    const CIntegerTypeIdentifier* intType;
+
+    switch (iInternalState)
+        {
+        case EStateExpectEnumIdentifierOrFormat:
+            switch (tokenType)
+                {
+                case Tokens::EIdentifier:
+                    if (!ParserSM().FindIdentifier(CurrentToken()))
+                        {
+                        iIdentifier = new CEnumTypeIdentifier(CurrentToken());
+                        iInternalState = EStateExpectColon;
+                        result = Parser::ENoError;
+                        }
+                    else
+                        {
+                        result = Parser::EDuplicateIdentifier;
+                        }
+                    break;
+
+                case Tokens::EDisplayDec:
+                case Tokens::EDisplayHex:
+                    iFormatOptions.iFormatAsHex = (tokenType == Tokens::EDisplayHex);
+                    iInternalState = EStateExpectEnumIdentifier;
+                    result = Parser::ENoError;
+                    break;
+                }
+
+        case EStateExpectEnumIdentifier:
+            if (tokenType == Tokens::EIdentifier)
+                {
+                if (!ParserSM().FindIdentifier(CurrentToken()))
+                    {
+                    iIdentifier = new CEnumTypeIdentifier(CurrentToken());
+                    iInternalState = EStateExpectColon;
+                    result = Parser::ENoError;
+                    }
+                else
+                    {
+                    result = Parser::EDuplicateIdentifier;
+                    }
+                }
+            break;
+
+        case EStateExpectColon:
+            if (tokenType == Tokens::EColon)
+                {
+                iInternalState = EStateExpectBaseIntType;
+                result = Parser::ENoError;
+                }
+            break;
+
+        case EStateExpectBaseIntType:
+            result = Parser::ENoError;
+            iInternalState = EStateExpectEnumValueIdentifierOrEnd;
+            if (tokenType == Tokens::EIntType)
+                {
+                intType = static_cast<const CIntegerTypeIdentifier*>(ParserSM().FindIdentifier(CurrentToken()));
+                assert(intType && intType->Type() == Parser::EIntegerTypeIdentifier);
+                iIdentifier->SetSize(intType->Size());
+                iIdentifier->SetSigned(intType->Signed());
+                }
+            else
+                {
+                result = Parser::EInvalidType;
+                }
+            break;
+        
+        case EStateExpectEnumValueIdentifierOrEnd:
+            if (tokenType == Tokens::EIdentifier)
+                {
+                if (!ParserSM().FindIdentifier(CurrentToken()))
+                    {
+                    iTempEnumValue = new CEnumValueIdentifier(CurrentToken());
+                    result = Parser::ENoError;
+                    iInternalState = EStateExpectEquals;
+                    }
+                else
+                    {
+                    result = Parser::EDuplicateIdentifier;
+                    }
+                }
+            else if (tokenType == Tokens::EEnd && iIdentifier->iEnumValues.size() > 0)
+                {
+                iInternalState = EStateExpectEndEnum;
+                result = Parser::ENoError;
+                }
+            break;
+
+        case EStateExpectEquals:
+            if (tokenType == Tokens::EEquals)
+                {
+                result = Parser::ENoError;
+                iInternalState = EStateExpectEnumValue;
+                }
+            break;
+
+        case EStateExpectEnumValue:
+            iInternalState = EStateExpectEnumValueIdentifierOrEnd;
+            if (tokenType == Tokens::ENumberDec || tokenType == Tokens::ENumberHex)
+                {
+                if (tokenType == Tokens::ENumberDec)
+                    {
+                    iTempEnumValue->iValue = atol(CurrentToken());
+                    }
+                else 
+                    {
+                    iTempEnumValue->iValue = HexToVal(CurrentToken());
+                    }
+
+                if (iIdentifier->ValueInRange(iTempEnumValue->iValue))
+                    {
+                    ParserSM().AddIdentifier(iTempEnumValue);
+                    iIdentifier->AddValue(iTempEnumValue);
+                    iTempEnumValue = NULL;
+                    result = Parser::ENoError;
+                    }
+                else
+                    {
+                    result = Parser::EValueOutOfRange;
+                    }
+                }
+            break;
+
+        case EStateExpectEndEnum:
+            if (tokenType == Tokens::EEnum)
+                {
+                result = Parser::ENoError;
+                iIdentifier->iFormatOptions = iFormatOptions;
+                ParserSM().AddIdentifier(iIdentifier);
+                iIdentifier = NULL;
+                ParserSM().SetState(new CInitialState(ParserSM()));
+                }
+            else
+                {
+                ParserSM().SetState(new CInitialState(ParserSM()));
+                }
+            break;
+        }
+
+    if (result != Parser::ENoError)
+        {
+        ParserSM().SetError(result);
+        }
+    }
+
+} // namespace Parser
+