// Copyright (c) 2003-2010 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:

// NetDial Script Commands

// 

//

/**

 @file Scommand.cpp 

*/

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "SCOMMANDTraces.h"

#endif

#include "SSCRREAD.H"

#include "SSCREXEC.H"

#include "SIO.H"

// Command names

_LIT(KSetCommand,"SET");

_LIT(KSendCommand,"SEND");

_LIT(KWaitCommand,"WAIT");

_LIT(KLoopCommand,"LOOP");

_LIT(KGotoCommand,"GOTO");

_LIT(KExitCommand,"EXIT");

_LIT(KDTRCommand,"DTR");

_LIT(KDropDTRCommand,"RAISE");

_LIT(KRaiseDTRCommand,"DROP");

_LIT(KReadCommand,"READ");

_LIT(KCharmapCommand,"CHARMAP");

_LIT(KTempVarName,"$$TMPVAR$$%d");	//< Temporary variable name

// Characters used in scripts

const TText KCommentChar='!';	

const TText KPlusChar='+';

const TText KQuoteChar='\"';

const TText KOpenChevronChar='<';

const TText KCloseChevronChar='>';

const TText KOpenExprChar='{';

const TText KCloseExprChar='}';

const TText KEqualsChar='=';

const TText KTabChar='\t';

const TText KSpaceChar=' ';

const TText KColonChar=':';

const TText KOpenSquareBracketChar='[';

const TText KCloseSquareBracketChar=']';

const TInt KLabelArrayGranularity=5;

const TInt32 KMinScriptInteger=0;

const TInt32 KMaxScriptInteger=500000;

const TReal KMinScriptReal=0.0;

const TReal KMaxScriptReal=500000.0;

const TInt KMinLoopCounter=1;

const TInt KMaxLoopCounter=10000;

//

// Glossary

// ========

// String				- a text string enclosed in ".."

// Character			- a single character expressed numnerically enclosed in <..>

// Variable				- named variable (preset or set in script) ending in $

// Expression			- any one of the three above

// Compound expression	- a number of expressions concatenated with +

// Token				- an expression, compound expression, label or command

//

//

// CScriptCommandBase definitions

//

CScriptCommandBase::CScriptCommandBase(TScriptStatus& aStatus,CScriptReader* aScriptReader,CScriptVarMan* aVarMan,CScriptCharacterConverter* aCharConv)

	: iScriptReader(aScriptReader), iVarMan(aVarMan), iCharConv(aCharConv), iTempVarNum(0), iStatus(aStatus)

/**

Constructor for CScriptCharacterConverter.

*/

	{}

CScriptCommandBase::~CScriptCommandBase()

/**

Destructor.

*/

	{}

void CScriptCommandBase::ConstructL()

/**

Instantiates member variables.

*/

	{}

void CScriptCommandBase::Cleanup()

/**

Cleanup.

*/

	{}

TPtrC CScriptCommandBase::ParseCompoundExpressionL(TInt& aOffset)

/**

Parses a compound string expression starting at aOffset into a single string

constant and returns it.

*/

	{

	TPtrC wholeExpr;

	wholeExpr.Set(ParseExpressionL(aOffset));

	TBuf<KMaxVarNameLength> varName;

	varName.Format(KTempVarName,iTempVarNum++);

	iVarMan->AddVariableL(varName,wholeExpr);

	HBufC* val=NULL;

	HBufC* oldVal=NULL;

	FOREVER

		{

		EatSpaces(aOffset);

		if (aOffset>=iStatus.iLine.Length())

			break;

		if (iStatus.iLine[aOffset]!=KPlusChar)

			break;

		TPtrC nextExpr;

		nextExpr.Set(ParseExpressionL(++aOffset));

		val=HBufC::NewLC(wholeExpr.Length()+nextExpr.Length());

		TPtr currentExpr(val->Des());

		currentExpr.Append(wholeExpr);

		currentExpr.Append(nextExpr);

		varName.Format(KTempVarName,iTempVarNum++);

		iVarMan->AddVariableL(varName,val->Des());

		CleanupStack::Pop();

		wholeExpr.Set(val->Des());

		delete oldVal;

		oldVal=val;

		}

	delete val;

	User::LeaveIfError(iVarMan->FindVariable(varName,wholeExpr));

	return wholeExpr;

	}

TPtrC CScriptCommandBase::ParseExpressionL(TInt& aOffset)

/**

Parses string expression starting at aOffset according to starting character

and returns value.

*/

	{

	EatSpaces(aOffset);

	if(iStatus.iLine.Length()<=aOffset)

		User::Leave(KErrNoExpression);

	switch(iStatus.iLine[aOffset])		//switch(iLine[aOffset+1])

		{

	case KQuoteChar:

		aOffset++;							// skip quote char

		return ParseStringL(aOffset);

	case KOpenChevronChar:

		aOffset++;							// skip chevron char

		return ParseCharacterL(aOffset);

	default:

		return ParseVariableL(aOffset);

		}

	}

TPtrC CScriptCommandBase::ParseStringL(TInt& aOffset)

/**

Parses a string constant enclosed in "" and returns its value.

*/

	{

	return ParseEnclosedStringL(aOffset,KQuoteChar,KErrMissingQuote);

	}

TPtrC CScriptCommandBase::ParseCharacterL(TInt& aOffset)

/**

Parses a character enclosed in <> and returns its value.

*/

	{

	TPtrC charString=ParseEnclosedStringL(aOffset,KCloseChevronChar,KErrMissingChevron);

	TRadix radix=EDecimal;

	TInt len=charString.Length();

	if (len>2)

		{

		if(charString[0]=='0')

			{

			switch(charString[1])

				{

			case 'x':

			case 'X':

				len-=2;

				radix=EHex;

				break;

			case 'd':

			case 'D':

				len-=2;

				radix=EDecimal;

				break;

			case 'o':

			case 'O':

				len-=2;

				radix=EOctal;

				break;

			case 'b':

			case 'B':

				len-=2;

				radix=EBinary;

				break;

			default:

				break;

				}

			}

		}

	TLex lex(charString.Right(len));

	TUint val=0;

	if (lex.Val(val,radix)!=KErrNone)

		User::Leave(KErrInvalidNumber);

	TBuf<1> character=(TText*)&val;

	TBuf<KMaxVarNameLength> varName;

	varName.Format(KTempVarName,iTempVarNum++);

	iVarMan->AddVariableL(varName,character);

	TPtrC temp;

	iVarMan->FindVariable(varName,temp);

	return temp;

	}

TPtrC CScriptCommandBase::ParseVariableL(TInt& aOffset)

/**

Parses a variable and returns its value.

*/

	{

	TInt end=FindTokenEnd(aOffset);

	TPtrC varName=iStatus.iLine.Mid(aOffset,end-aOffset);

	aOffset=end;

	TPtrC varValue;

	if (iVarMan->FindVariable(varName,varValue)==KErrNotFound)

		{

		if(!iStatus.iSkip)

			User::Leave(KErrVariableNotFound);

		return TPtrC();

		}

	return varValue;

	}

TInt32 CScriptCommandBase::ParseIntegerL(TInt& aOffset)

/**

Parses an integer and returns its value.

*/

	{

	EatSpaces(aOffset);

	TLex lex(iStatus.iLine);

	lex.Inc(aOffset);

	TInt32 val=0;

	if (lex.Val(val)!=KErrNone)

		{

		User::Leave(KErrInvalidNumber);

		return KMinScriptInteger;

		}

	if ((val<KMinScriptInteger) || (val>KMaxScriptInteger))

		{

		User::Leave(KErrNumberOutOfRange);

		return KMinScriptInteger;

		}

	aOffset=lex.Offset();

	return val;

	}

TReal CScriptCommandBase::ParseRealL(TInt& aOffset)

/**

Parses a real number and returns its value.

*/

	{

	EatSpaces(aOffset);

	TLex lex(iStatus.iLine);

	lex.Inc(aOffset);

	TReal val=0.0;

	if (lex.Val(val)!=KErrNone)

		{	

		User::Leave(KErrInvalidNumber);

		return KMinScriptReal;

		}

	if ((val<KMinScriptReal) || (val>KMaxScriptReal))

		{

		User::Leave(KErrNumberOutOfRange);

		return KMinScriptReal;

		}

	aOffset=lex.Offset();

	return val;

	}

TPtrC CScriptCommandBase::ParseCharacterTypeL(TInt& aOffset)

/**

Parses character type.

*/

	{

	EatSpaces(aOffset);

	if(iStatus.iLine.Length()<=aOffset)		// nothing specified so assume default

		return TPtrC();

	TInt startChar=aOffset;

	if (iStatus.iLine[startChar++]!=KOpenSquareBracketChar)

		return TPtrC();				// No open bracket so assume default

	aOffset=startChar;

	return ParseEnclosedStringL(aOffset,KCloseSquareBracketChar,KErrMissingBracket);

	}

HBufC8* CScriptCommandBase::ConvertLC(const TDesC& aString,TInt& aOffset)

/**

Converts to correct character set.

*/

	{

	TBuf<KMaxCharacterTypeLength> type=ParseCharacterTypeL(aOffset);

	return iCharConv->ConvertLC(aString,type);

	}

TInt CScriptCommandBase::FindTokenEnd(TInt aOffset)

/**

Finds end of string beginning at aOffset and returns length.

*/

	{

	__ASSERT_DEBUG(aOffset<=iStatus.iLine.Length(), NetDialPanic(EOffsetExceedsLineLength));

	if(aOffset==iStatus.iLine.Length())

		return aOffset;

	TInt end;

	for (end=aOffset; IsValidChar(iStatus.iLine[end]); end++)

		{

		if (end>=(iStatus.iLine.Length()-1))

			{

			end++;

			break;

			}

		}

	return end;

	}

TBool CScriptCommandBase::IsValidChar(const TText& aChar)

/**

Checks if aChar is a valid character in a script command.

*/

	{

	return TChar(aChar).IsAlphaDigit() || (aChar==KDollarChar) || (aChar==KUnderscoreChar) || (aChar==KCommentChar);

	}

void CScriptCommandBase::EatSpaces(TInt& aOffset)

/**

Ignores spaces, tabs, line feeds and carriage returns and sets aOffset to 

next non-blank character, or end of line

*/

	{

	if(aOffset>=iStatus.iLine.Length())

		return;

	while((iStatus.iLine[aOffset]==KSpaceChar) || (iStatus.iLine[aOffset]==KTabChar) || (iStatus.iLine[aOffset]==KLineFeed) || (iStatus.iLine[aOffset]==KCarriageReturn))

		{

		aOffset++;

		if(aOffset>=iStatus.iLine.Length())

			break;

		}

	}

void CScriptCommandBase::EatSpacesAndLinesL()

/**

Ignores spaces and empty lines and sets aOffset to next non-blank character.

*/

	{

	EatSpaces(iStatus.iOffset);

	while(iStatus.iOffset>=iStatus.iLine.Length())

		{

		User::LeaveIfError(iScriptReader->GetNextLine());		// This also resets iStatus.iOffset

		EatSpaces(iStatus.iOffset);

		}	

	}

void CScriptCommandBase::EatSpacesAndLinesAndCommentsL()

/**

Ignores spaces, empty lines and comments and sets aOffset to next non-blank or 

non-comment character

*/

	{

	EatSpacesAndLinesL();

	while (iStatus.iLine[iStatus.iOffset]==KCommentChar)

		{

		iStatus.iOffset=iStatus.iLine.Length();

		EatSpacesAndLinesL();		// this will reset iStatus.iOffset if necessary

		}

	}	

TPtrC CScriptCommandBase::ParseEnclosedStringL(TInt& aOffset,TText aChar,TInt aError)

/**

Parses enclosed string

*/

	{

	if(aOffset>=iStatus.iLine.Length())

		User::Leave(aError);			// no end character before EOL

	TInt end=aOffset;

	while (end<iStatus.iLine.Length())

		{

		if (iStatus.iLine[end]==aChar)

			break;

		end++;

		}

	if (end>=iStatus.iLine.Length())

		User::Leave(aError);			// no end character before EOL

	TInt start=aOffset;

	aOffset=end+1;

	return iStatus.iLine.Mid(start,end-start);

	}

//

// CSetCommand definitions

//

CSetCommand* CSetCommand::NewL(TScriptStatus& aScriptStatus,CScriptReader* aScriptReader,CScriptVarMan* aVarMan,CScriptCharacterConverter* aCharConv)

/**

2 phased constructor for CSetCommand, first phase.

@param aScriptStatus is script status.

@param aScriptReader a pointer to script reader.

@param aVarMan a pointer to variable manager.

@param aCharConv a pointer to script character converter.

@exception Leaves if ConstructL() leaves, or not enough memory is available.

@return a new CSetCommand object.

*/

	{

	CSetCommand* c=new(ELeave) CSetCommand(aScriptStatus,aScriptReader,aVarMan,aCharConv);

	CleanupStack::PushL(c);

	c->ConstructL();

	CleanupStack::Pop();

	return c;

	}

CSetCommand::CSetCommand(TScriptStatus& aScriptStatus,CScriptReader* aScriptReader,CScriptVarMan* aVarMan,CScriptCharacterConverter* aCharConv)

	: CScriptCommandBase(aScriptStatus,aScriptReader,aVarMan,aCharConv)

/**

Constructor for CSetCommand, used in the first phase of construction.

@param aScriptStatus is script status.

@param aScriptReader a pointer to script reader.

@param aVarMan a pointer to variable manager.

@param aCharConv a pointer to script character converter.

*/

	{}

CSetCommand::~CSetCommand()

/**

Destructor.

*/

	{}

TBool CSetCommand::ParseL()

/**

Parses a SET command. Determines variable name and value and adds to variable list.

*/

	{

	EatSpacesAndLinesAndCommentsL();

	TInt end=FindTokenEnd(iStatus.iOffset);

	if (iStatus.iLine.Mid(iStatus.iOffset,end-iStatus.iOffset).CompareF(KSetCommand)==KErrNone)

		{

		if (!iStatus.iSkip)

			{

			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSETCOMMAND_PARSEL_1, "Script:\tExecuting Set");

			}

		iStatus.iOffset=end;

		EatSpaces(iStatus.iOffset);

		end=FindTokenEnd(iStatus.iOffset);

		TPtrC varName=iStatus.iLine.Mid(iStatus.iOffset,end-iStatus.iOffset);

		EatSpaces(end);

		if (iStatus.iLine[end++]!=KEqualsChar)

			User::Leave(KErrNoEquals);

		EatSpaces(end);

		TPtrC value=ParseCompoundExpressionL(end);

		if (!iStatus.iSkip)

			{

			iVarMan->AddVariableL(varName,value);

			OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSETCOMMAND_PARSEL_2, "Script:\tSet Var: %S  To %S",varName,value);

			}

		iStatus.iOffset=end;

		return ETrue;		// Consumed

		}

	return EFalse;			// Not Consumed

	}

//

// CSendCommand definitions

//

CSendCommand* CSendCommand::NewL(TScriptStatus& aScriptStatus,CScriptReader* aScriptReader,CScriptVarMan* aVarMan,CScriptCharacterConverter* aCharConv,CScriptIO* aScriptIO)

/**

2 phased constructor for CSendCommand, first phase.

@param aScriptStatus is script status.

@param aScriptReader a pointer to script reader.

@param aVarMan a pointer to variable manager.

@param aCharConv a pointer to script character converter.

@param aScriptIO a pointer to serial comms I/O handler.

@exception Leaves if ConstructL() leaves, or not enough memory is available.

@return a new CSendCommand object.

*/

	{

	CSendCommand* c=new(ELeave) CSendCommand(aScriptStatus,aScriptReader,aVarMan,aCharConv,aScriptIO);

	CleanupStack::PushL(c);

	c->ConstructL();

	CleanupStack::Pop();

	return c;

	}

CSendCommand::CSendCommand(TScriptStatus& aScriptStatus,CScriptReader* aScriptReader,CScriptVarMan* aVarMan,CScriptCharacterConverter* aCharConv,CScriptIO* aScriptIO)

	: CScriptCommandBase(aScriptStatus,aScriptReader,aVarMan,aCharConv), iScriptIO(aScriptIO)