// parser.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ioutils.h>

#include <fshell/ltkutils.h>

#include "parser.h"

#include "fshell.h"

#include "lexer.h"

#include "command_factory.h"

//

// Globals.

//

_LIT(KChildError, "?");

_LIT(KPipe, "|");

_LIT(KDoublePipe, "||");

_LIT(KRedirectStdinFromFile, "<");

_LIT(KRedirectStdoutToFile1, ">");

_LIT(KRedirectStdoutToFile2, "1>");

_LIT(KRedirectStdoutToFileAppend1, ">>");

_LIT(KRedirectStdoutToFileAppend2, "1>>");

_LIT(KRedirectStdoutToStderr, "1>&2");

_LIT(KRedirectStderrToFile, "2>");

_LIT(KRedirectStderrToFileAppend, "2>>");

_LIT(KRedirectStderrToStdout, "2>&1");

_LIT(KAmpersand, "&");

_LIT(KDoubleAmpersand, "&&");

_LIT(KAmpersandPipe, "&|");

_LIT(KNewLine1, "\r");

_LIT(KNewLine2, "\n");

_LIT(KNewLine3, "\r\n");

_LIT(KNewLine4, "\n\r");

_LIT(KSemicolon, ";");

_LIT(KDollar, "$");

void MParserObserver::AboutToExecuteLine(const TDesC&, const TDesC&)

	{

	}

void MParserObserver::LineReturned(TInt)

	{

	}

CParser* CParser::NewL(TUint aMode, const TDesC& aDes, RIoSession& aIoSession, RIoReadHandle& aStdin, RIoWriteHandle& aStdout, RIoWriteHandle& aStderr, IoUtils::CEnvironment& aEnv, CCommandFactory& aFactory, MParserObserver* aObserver, TInt aStartingLineNumber)

	{

	CParser* self = new(ELeave) CParser(aMode, aIoSession, aStdin, aStdout, aStderr, aEnv, aFactory, aObserver, aStartingLineNumber);

	CleanupStack::PushL(self);

	self->ConstructL(&aDes, NULL);

	CleanupStack::Pop();

	return self;

	}

CParser* CParser::NewL(TUint aMode, RIoReadHandle& aSourceHandle, RIoSession& aIoSession, RIoReadHandle& aStdin, RIoWriteHandle& aStdout, RIoWriteHandle& aStderr, IoUtils::CEnvironment& aEnv, CCommandFactory& aFactory, MParserObserver* aObserver)

	{

	CParser* self = new(ELeave) CParser(aMode, aIoSession, aStdin, aStdout, aStderr, aEnv, aFactory, aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(NULL, &aSourceHandle);

	CleanupStack::Pop();

	return self;

	}

CParser::~CParser()

	{

	delete iForegroundPipeLine;

	iBackgroundPipeLines.ResetAndDestroy();

	delete iLexer1;

	delete iLexer2;

	delete iCompletionCallBack;

	delete iNextPipeLineCallBack;

	delete iExitCallBack;

	if (iOwnsIoHandles)

		{

		iStdin.Close();

		iStdout.Close();

		iStderr.Close();

		}

	}

CParser::CParser(TUint aMode, RIoSession& aIoSession, RIoReadHandle& aStdin, RIoWriteHandle& aStdout, RIoWriteHandle& aStderr, IoUtils::CEnvironment& aEnv, CCommandFactory& aFactory, MParserObserver* aObserver, TInt aStartingLineNumber)

	: iMode(aMode), iIoSession(aIoSession), iStdin(aStdin), iStdout(aStdout), iStderr(aStderr), iEnv(aEnv), iFactory(aFactory), iObserver(aObserver), iCompletionError(aStderr, aEnv), iNextLineNumber(aStartingLineNumber)

	{

	}

void CParser::ConstructL(const TDesC* aDes, RIoReadHandle* aSourceHandle)

	{

	if (iObserver)

		{

		iCompletionCallBack = new(ELeave) CAsyncCallBack(TCallBack(CompletionCallBack, this), CActive::EPriorityStandard);

		}

	iNextPipeLineCallBack = new(ELeave) CAsyncCallBack(TCallBack(NextCallBack, this), CActive::EPriorityStandard);

	iLexer1 = CLexer::NewL(CLexer::EHandleSingleQuotes | CLexer::EHandleDoubleQuotes | CLexer::EHandleComments);

	iLexer1->DefineTokenTypeL(TToken::EDoublePipe, KDoublePipe);

	iLexer1->DefineTokenTypeL(TToken::EDoubleAmpersand, KDoubleAmpersand);

	iLexer1->DefineTokenTypeL(TToken::EAmpersandPipe, KAmpersandPipe);

	iLexer1->DefineTokenTypeL(TToken::ENewLine, KNewLine1);

	iLexer1->DefineTokenTypeL(TToken::ENewLine, KNewLine2);

	iLexer1->DefineTokenTypeL(TToken::ENewLine, KNewLine3);

	iLexer1->DefineTokenTypeL(TToken::ENewLine, KNewLine4);

	iLexer1->DefineTokenTypeL(TToken::ESemicolon, KSemicolon);

	if (aDes)

		{

		iLexer1->Set(*aDes, iEnv.EscapeChar());

		}

	else

		{

		iLexer1->Set(*aSourceHandle, iEnv.EscapeChar());

		}

	iLexer2 = CLexer::NewL(CLexer::EHandleSingleQuotes | CLexer::EHandleDoubleQuotes);

	iLexer2->DefineTokenTypeL(TToken::EPipe, KPipe);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdinFromFile, KRedirectStdinFromFile);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdoutToFile, KRedirectStdoutToFile1);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdoutToFile, KRedirectStdoutToFile2);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdoutToFileAppend, KRedirectStdoutToFileAppend1);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdoutToFileAppend, KRedirectStdoutToFileAppend2);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStdoutToStderr, KRedirectStdoutToStderr);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStderrToFile, KRedirectStderrToFile);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStderrToFileAppend, KRedirectStderrToFileAppend);

	iLexer2->DefineTokenTypeL(TToken::ERedirectStderrToStdout, KRedirectStderrToStdout);

	iLexer2->DefineTokenTypeL(TToken::EAmpersand, KAmpersand);

	if (iMode & EExportLineNumbers)

		{

		iEnv.SetL(KScriptLine, iNextLineNumber++);

		}

	if (iMode & EKeepGoing)

		{

		iEnv.SetL(KKeepGoing, 1);

		}

	}

void CParser::Start()

	{

	CreateNextPipeLine(NULL);

	}

void CParser::Start(TBool& aIsForeground)

	{

	CreateNextPipeLine(&aIsForeground);

	}

void CParser::Kill()

	{

	iAbort = ETrue;

	if (iForegroundPipeLine)

		{

		iForegroundPipeLine->Kill();

		}

	const TInt numBackground = iBackgroundPipeLines.Count();

	for (TInt i = 0; i < numBackground; ++i)

		{

		iBackgroundPipeLines[i]->Kill();

		}

	}

TInt CParser::Suspend()

	{

	TInt ret = KErrNone;

	if (iForegroundPipeLine)

		{

		TInt err = iForegroundPipeLine->Suspend();

		if (err)

			{

			ret = err;

			}

		}

	const TInt numBackground = iBackgroundPipeLines.Count();

	for (TInt i = 0; i < numBackground; ++i)

		{

		TInt err = iBackgroundPipeLines[i]->Suspend();

		if (err && (ret == KErrNone))

			{

			ret = err;

			}

		}

	return ret;

	}

TInt CParser::Resume()

	{

	TInt ret = KErrNone;

	if (iForegroundPipeLine)

		{

		TInt err = iForegroundPipeLine->Resume();

		if (err)

			{

			ret = err;

			}

		}

	const TInt numBackground = iBackgroundPipeLines.Count();

	for (TInt i = 0; i < numBackground; ++i)

		{

		TInt err = iBackgroundPipeLines[i]->Resume();

		if (err && (ret == KErrNone))

			{

			ret = err;

			}

		}

	return ret;

	}

TInt CParser::BringToForeground()

	{

	if (iForegroundPipeLine)

		{

		return iForegroundPipeLine->BringToForeground();

		}

	else if (iBackgroundPipeLines.Count() == 1)

		{

		return iBackgroundPipeLines[0]->BringToForeground();

		}

	return KErrGeneral;

	}

void CParser::SendToBackground()

	{

	if (iForegroundPipeLine)

		{

		iForegroundPipeLine->SendToBackground();

		}

	}

TInt CParser::Reattach(RIoEndPoint& aStdinEndPoint, RIoEndPoint& aStdoutEndPoint, RIoEndPoint& aStderrEndPoint)

	{

	RIoReadHandle stdin;

	RIoWriteHandle stdout;

	RIoWriteHandle stderr;

	TInt err = stdin.Create(iIoSession);

	if (err == KErrNone)

		{

		err = stdout.Create(iIoSession);

		if (err == KErrNone)

			{

			err = stderr.Create(iIoSession);

			if (err == KErrNone)

				{

				err = aStdinEndPoint.Attach(stdin, RIoEndPoint::EBackground);

				if (err == KErrNone)

					{

					err = aStdoutEndPoint.Attach(stdout);

					if (err == KErrNone)

						{

						err = aStderrEndPoint.Attach(stderr);

						if (err == KErrNone)

							{

							if (iForegroundPipeLine)

								{

								err = iForegroundPipeLine->Reattach(aStdinEndPoint, aStdoutEndPoint, aStderrEndPoint);

								}

							if (err == KErrNone)

								{

								const TInt numBackground = iBackgroundPipeLines.Count();

								for (TInt i = 0; i < numBackground; ++i)

									{

									err = iBackgroundPipeLines[i]->Reattach(aStdinEndPoint, aStdoutEndPoint, aStderrEndPoint);

									if (err)

										{

										break;

										}

									}

								}

							}

						}

					}

				}

			}

		}

	if (err == KErrNone)

		{

		iStdin = stdin;

		iStdout = stdout;

		iStderr = stderr;

		iOwnsIoHandles = ETrue;

		}

	else

		{

		stdin.Close();

		stdout.Close();

		stderr.Close();

		}

	return err;

	}

TBool CParser::IsDisownable() const

	{

	if (iForegroundPipeLine && !iForegroundPipeLine->IsDisownable())

		{

		return EFalse;

		}

	const TInt numBackground = iBackgroundPipeLines.Count();

	for (TInt i = 0; i < numBackground; ++i)

		{

		if (!(iBackgroundPipeLines[i]->IsDisownable()))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

void CParser::Disown()

	{

	if (iForegroundPipeLine)

		{

		iForegroundPipeLine->Disown();

		}

	const TInt numBackground = iBackgroundPipeLines.Count();

	for (TInt i = 0; i < numBackground; ++i)

		{

		iBackgroundPipeLines[i]->Disown();

		}

	}

TBool HandleRedirectionL(TToken::TType aTokenType, const TDesC& aCwd, CLexer& aLexer, RPipeSection& aPipeSection)

	{

	RPipeSection::TRedirection* redirection;

	switch (aTokenType)

		{

		case TToken::ERedirectStdinFromFile:

			{

			redirection = &aPipeSection.iStdinRedirection;

			break;

			}

		case TToken::ERedirectStdoutToFile:

		case TToken::ERedirectStdoutToFileAppend:

		case TToken::ERedirectStdoutToStderr:

			{

			redirection = &aPipeSection.iStdoutRedirection;

			break;

			}

		case TToken::ERedirectStderrToFile:

		case TToken::ERedirectStderrToFileAppend:

		case TToken::ERedirectStderrToStdout:

			{

			redirection = &aPipeSection.iStderrRedirection;

			break;

			}

		default:

			{

			redirection = NULL;

			ASSERT(EFalse);

			}

		}

	if (aTokenType == TToken::ERedirectStderrToStdout)

		{

		redirection->iType = RPipeSection::TRedirection::EHandle;

		redirection->iHandle = RPipeSection::TRedirection::EStdout;

		}

	else if (aTokenType == TToken::ERedirectStdoutToStderr)

		{

		redirection->iType = RPipeSection::TRedirection::EHandle;

		redirection->iHandle = RPipeSection::TRedirection::EStderr;

		}

	else

		{

		if (aLexer.MoreL())

			{

			redirection->iType = ((aTokenType == TToken::ERedirectStdoutToFileAppend) || (aTokenType == TToken::ERedirectStderrToFileAppend)) ? RPipeSection::TRedirection::EFileAppend : RPipeSection::TRedirection::EFile;

			TToken fileName(aLexer.NextTokenL());

			redirection->SetFileNameL(aCwd, fileName.String());

			}

		else

			{

			return EFalse;

			}

		}

	return ETrue;

	}

void CleanupPipeSectionsArray(TAny* aArray)

	{

	RArray<RPipeSection>* array = static_cast<RArray<RPipeSection>*>(aArray);

	const TInt numSections = array->Count();

	for (TInt i = 0; i < numSections; ++i)

		{

		(*array)[i].Close();

		}

	array->Close();

	}

void CParser::CreateNextPipeLine(TBool* aIsForeground)

	{

	TRAPD(err, CreateNextPipeLineL(aIsForeground));

	if (err && iObserver)

		{

		iCompletionError.Set(err, TError::EFailedToCreatePipeLine);

		iCompletionCallBack->CallBack();

		}

	}

void CParser::CreateNextPipeLineL(TBool* aIsForeground)

	{

	// Parsing is now carried out in three main steps:

	//

	// 1) Use iLexer1 to find the next "pipe-line's worth" of data (carried out by FindNextPipeLine).

	// 2) Expand environment variables in this data into a new HBufC ('expandedPipeLine' returned by ExpandVariablesLC).

	// 3) Use iLexer2 to parse the data in this expanded descriptor.

	if (aIsForeground)

		{

		*aIsForeground = ETrue;

		}

	TPtrC pipeLineData;

	TBool reachedLineEnd(EFalse);

	FindNextPipeLineL(pipeLineData, iCondition, reachedLineEnd);

	HBufC* expandedPipeLine = ExpandVariablesLC(pipeLineData);

	iLexer2->Set(*expandedPipeLine, iEnv.EscapeChar());

	const TDesC& cwd = iEnv.Pwd();

	RArray<RPipeSection> pipeSections;

	CleanupStack::PushL(TCleanupItem(CleanupPipeSectionsArray, &pipeSections));

	RPipeSection pipeSection;

	CleanupClosePushL(pipeSection);

	TInt offset = iLexer2->CurrentOffset();

	TBool background(EFalse);

	while (iLexer2->MoreL())

		{

		TToken token(iLexer2->NextTokenL());

		switch (token.Type())

			{

			case TToken::EPipe:

				{

				pipeSection.iFullName.Set(iLexer2->Ptr() + offset, iLexer2->CurrentOffset() - offset - token.String().Length());

				offset = iLexer2->CurrentOffset();

				User::LeaveIfError(pipeSections.Append(pipeSection));

				new(&pipeSection) RPipeSection;

				break;

				}

			case TToken::EAmpersand:

				{

				background = ETrue;

				break;

				}

			case TToken::ERedirectStdinFromFile:

			case TToken::ERedirectStdoutToFile:

			case TToken::ERedirectStdoutToFileAppend:

			case TToken::ERedirectStdoutToStderr:

			case TToken::ERedirectStderrToFile:

			case TToken::ERedirectStderrToFileAppend:

			case TToken::ERedirectStderrToStdout:

				{

				if (HandleRedirectionL(token.Type(), cwd, *iLexer2, pipeSection))

					{

					break;

					}

				// Deliberate fall through - if it wasn't possible to handle the redirection, treat token as a string.

				}

			case TToken::EString:

			default:

				{

				if (token.String().Length() > 0)

					{

					if (pipeSection.iCommandName.Length() == 0)

						{

						pipeSection.iCommandName.Set(token.String());

						}

					else

						{

						User::LeaveIfError(pipeSection.iCommandArguments.Append(TPtrC(token.String())));

						}

					}

				break;

				}

			}

		}

	if (pipeSection.iCommandName.Length() > 0)

		{

		_LIT(KExit, "exit");

		if ((pipeSections.Count() == 0) && (pipeSection.iCommandName.CompareF(KExit) == 0) && (pipeSection.iCommandArguments.Count() == 0))

			{

			// Special case the handling of 'exit'. This allows the concept of 'local commands' (i.e. commands that run in either fshell's main

			// thread or in the thread belonging to a 'source' or 'debug' command) to be dropped. That's a good thing, because local commands

			// can't synchronously interact with iosrv without risk of deadlock when two or more thread commands are run in a pipe-line. 

			CleanupStack::PopAndDestroy(2, &pipeSections);

			}

		else

			{

			pipeSection.iFullName.Set(iLexer2->Ptr() + offset, iLexer2->CurrentOffset() - offset);

			User::LeaveIfError(pipeSections.Append(pipeSection));

			CleanupStack::Pop(&pipeSection);

			if ((iMode & EDebug) && iObserver)

				{

				iObserver->AboutToExecuteLine(pipeLineData, *expandedPipeLine);

				}

			if (background)

				{

				CPipeLine* pipeLine = CPipeLine::NewLC(iIoSession, iStdin, iStdout, iStderr, iEnv, iFactory, pipeSections, background, this, iCompletionError);

				User::LeaveIfError(iBackgroundPipeLines.Append(pipeLine));

				CleanupStack::Pop(pipeLine);

				}

			else

				{

				ASSERT(iForegroundPipeLine == NULL);

				iForegroundPipeLine = CPipeLine::NewL(iIoSession, iStdin, iStdout, iStderr, iEnv, iFactory, pipeSections, background, this, iCompletionError);

				}

			CleanupStack::PopAndDestroy(&pipeSections);

			if (aIsForeground && !iLexer1->MoreL())

				{

				*aIsForeground = !background;

				}

			if (background && iLexer1->MoreL())