--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commsfwtools/commstools/utracedecoder/src/messagedefparser/aliasprocessor.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,139 @@
+// 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\aliasprocessor.h"
+#include "messagedefparser\initialstate.h"
+#include "messagedefparser\definitiontokenizer.h"
+#include "messagedefparser\signatureidentifier.h"
+#include "messagedefparser\messageidentifier.h"
+#include "messagedefparser\contextidentifier.h"
+#include "util.h"
+
+namespace Parser
+{
+#if 1
+
+void CAliasProcessor::ProcessState()
+    {
+    Tokens::TTokenType tokenType = CurrentTokenType();
+    iResult = Parser::EUnexpectedToken;
+
+    switch (iInternalState)
+        {
+        case EStateExpectAliasTargetType:
+            iResult = Parser::ENoError;
+            switch (tokenType)
+                {
+                case Tokens::EContext:
+                    iAliasTargetType = Parser::EContextIdentifier;
+                    break;
+
+                case Tokens::ESignature:
+                    iAliasTargetType = Parser::ESignatureIdentifier;
+                    break;
+
+                case Tokens::EMessage:
+                    iAliasTargetType = Parser::EMessageIdentifier;
+                    break;
+                
+                default:
+                    iResult = Parser::EUnexpectedToken;
+                    break;
+                }
+            iInternalState = EStateExpectAliasName;
+            break;
+
+        case EStateExpectAliasName:
+            if (tokenType == Tokens::EIdentifier)
+                {
+                if (!ParserSM().FindIdentifier(CurrentToken()))
+                    {
+                    iName = _strdup(CurrentToken());
+                    iInternalState = EStateExpectEquals;
+                    iResult = Parser::ENoError;
+                    }
+                else 
+                    {
+                    iResult = Parser::EDuplicateIdentifier;
+                    }
+                }
+            break;
+
+        case EStateExpectEquals:
+            if (tokenType == Tokens::EEquals)
+                {
+                iInternalState = EStateExpectAliasTarget;
+                iResult = Parser::ENoError;
+                }
+            break;
+
+        case EStateExpectAliasTarget:
+            if (tokenType == Tokens::EIdentifier)
+                {
+                const CIdentifierBase* realIdentifier;
+                realIdentifier = ParserSM().FindIdentifier(CurrentToken());
+                if (!realIdentifier || realIdentifier->Type() != iAliasTargetType)
+                    {
+                    iResult = Parser::EUnknownIdentifier;
+                    }
+                else
+                    {
+                    switch (iAliasTargetType)
+                        {
+                        case Parser::EContextIdentifier:
+                            iIdentifier = new CContextAliasIdentifier(
+                                iName, static_cast<const CContextIdentifier*>(realIdentifier));
+                            break;
+
+                        case Parser::ESignatureIdentifier:
+                            iIdentifier = new CSignatureAliasIdentifier(
+                                iName, static_cast<const CSignatureIdentifier*>(realIdentifier));
+                            break;
+
+                        case Parser::EMessageIdentifier:
+                            iIdentifier = new CMessageAliasIdentifier(
+                                iName, static_cast<const CMessageIdentifier*>(realIdentifier));
+                            break;
+                        }
+
+                    if (iIdentifier)
+                        {
+                        ParserSM().AddIdentifier(iIdentifier);
+                        iIdentifier = NULL;
+                        iResult = Parser::ENoError;
+                        ParserSM().SetState(new CInitialState(ParserSM()));
+                        }
+                    }
+                }
+            break;
+        }
+
+    if (iResult != Parser::ENoError)
+        {
+        ParserSM().SetError(iResult);
+        }
+    }
+
+
+CAliasProcessor::~CAliasProcessor()
+    {
+    delete iName;
+    }
+
+#endif
+
+
+} // namespace Parser
+