1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // $Header$

    15 // The CTEngine is the class that manages the test infrastructure

    16 // It knows how to process scripts and where to find command knowledge

    17 // The plan is:

    18 // Process console command line or command line supplied script

    19 // read in each line (or command) and process that (if appropriate)

    20 // Include Files  

    21 // 

    22 //

    23 

    24 #include <e32std.h>

    25 #include <s32file.h>

    26 #include <f32file.h>

    27 #include <e32hal.h>

    28 #include <fbs.h>

    29 

    30 //-----------------------------------------------------------------------------

    31 

    32 const TInt KMaxLogEntrySize = 512;

    33 const TInt KMaxUserEntrySize = 128;

    34 

    35 //-----------------------------------------------------------------------------

    36 

    37 //	result define names

    38 _LIT(KLastResultCode, "$LastResult$");

    39 _LIT(KLastErrorCode, "$LastError$");

    40 

    41 //-----------------------------------------------------------------------------

    42 

    43 #include "TEngine.h"

    44 

    45 //-----------------------------------------------------------------------------

    46 // This is used by the CallCmdFile, CloseCmdFile and CloseCmdFiles member

    47 // functions to alter the command file context. This function defines the

    48 // call argument tags %0%, %1%, ... %k% to those of the present cmd file.

    49 // If there is no command file, then the argument tags (all) are removed.

    50 

    51 #if !defined(TEMPLATED_CATALOGUE)

    52 

    53 LOCAL_C void SetContextL(CCatalogue *aCatalog, CCmdFile* aCmdFile )

    54 

    55 #else

    56 

    57 template <class T>

    58 LOCAL_C void SetContextL(CCatalogue<T> *aCatalog, CCmdFile* aCmdFile )

    59 

    60 #endif

    61 

    62 {

    63 if ( aCmdFile == NULL )

    64 	{

    65 	// No command file = console context: parameter markers are not

    66 	// recognised at all i.e. remove them all.

    67 	TBuf<6> buf;

    68 	TInt i;

    69 	for ( i = 0; i <= TFR_MAX_CALL_ARGUMENTS; ++i )

    70 		{

    71 		buf.Format( _L("%%%d%%"), i );

    72 		aCatalog->Delete(buf);

    73 		}

    74 	}

    75 else

    76 	{

    77 	// Command file context: parameters markers will be mapped to the

    78 	// file name, to the call arguments and to "".

    79 	TBuf<6> buf;

    80 	TPtrC   arg;

    81 	TInt    i;

    82 	TInt		iArgs = aCmdFile->Argc();

    83 

    84 	for ( i = 0; ( (i < TFR_MAX_CALL_ARGUMENTS) && (i < iArgs) ); ++i )

    85 		{

    86 		buf.Format(_L("%%%d%%"), i);

    87 		arg.Set(aCmdFile->Argv(i));

    88 		aCatalog->Delete(buf);

    89 		aCatalog->AddL(buf,arg);

    90 		}

    91 

    92 	for ( ; i < 10; ++i )

    93 		{

    94 		buf.Format(_L("%%%d%%"), i);

    95 		aCatalog->Delete(buf);

    96 		aCatalog->AddL(buf, _L(""));

    97 		}

    98 	}

    99 

   100 }

   101 

   102 //-----------------------------------------------------------------------------

   103 //    Overflow handler.

   104 

   105 void TTestMachineOverflow::Overflow( TDes16& aDes)

   106 {

   107 _LIT(KErrOverflowMsg, "...");

   108 if( aDes.MaxLength() >= KErrOverflowMsg().Length() + aDes.Length() )

   109 	aDes.Append(KErrOverflowMsg);

   110 }

   111 

   112 //-----------------------------------------------------------------------------

   113 //	NewL for Console interface

   114 

   115 CTEngine* CTEngine::NewL( CConsoleBase* aConsole )

   116 {

   117 CTEngine* self = NewLC(aConsole);

   118 CleanupStack::Pop(self);

   119 return self; 

   120 }

   121 

   122 //-----------------------------------------------------------------------------

   123 //	NewLC for Console Interface

   124 

   125 CTEngine* CTEngine::NewLC( CConsoleBase* aConsole )

   126 {

   127 CTEngine* self = new (ELeave) CTEngine(aConsole);

   128 CleanupStack::PushL(self);

   129 self->ConstructL();

   130 return self;

   131 }

   132 

   133 //-----------------------------------------------------------------------------

   134 //	Destructor

   135 

   136 CTEngine::~CTEngine()

   137 {

   138 Cancel();

   139 

   140 	iTimer.Close();

   141 	iFileServer.Close();

   142 	delete iCmdFile;

   143 	delete iLogFile;

   144 

   145 	delete iConsoleReader;

   146 	delete iDomain;

   147 	delete iDefines;

   148 	delete iIFPile;

   149 	delete iLogPile;

   150  	delete iCmdPile;

   151 }

   152 

   153 //-----------------------------------------------------------------------------

   154 

   155 void CTEngine::ConstructL()

   156 {

   157 

   158 iConsoleEnabled = ( iConsole != NULL );    

   159 

   160 iCmdPile = CPile<CCmdFile>::NewL();

   161 iLogPile = CPile<CLogFile>::NewL();

   162 iIFPile = CPile<CIFControl>::NewL();

   163 

   164 

   165 #if !defined(TEMPLATED_CATALOGUE)

   166 iDefines = CCatalogue::NewL();

   167 #else

   168 iDefines = CCatalogue<CLabeledText>::NewL();

   169 #endif

   170 

   171 

   172 //	domain specific catalogue of items. This provides

   173 //	a mechanism by which we can disassociate the framework

   174 //	from the domain specific commands/data requirements

   175 iDomain = CObjCatalogue::NewL();

   176 

   177 iConsoleReader = CConsoleReader::NewL(*iConsole);

   178 TInt r = iTimer.CreateLocal();

   179 

   180 if (r!=KErrNone)

   181 	User::Leave(r);

   182 

   183 //	Provide access to the fileserver

   184 User::LeaveIfError(iFileServer.Connect());

   185 

   186 //	This is normally true (to enable replication of printed

   187 //	output to log (if enabled)

   188 iLogActivity = ETrue;

   189 

   190 //	show the unprocessed command lines on screen and log

   191 SetShowCmdLine(ETrue);

   192 }

   193 

   194 //-----------------------------------------------------------------------------

   195 

   196 CTEngine::CTEngine(CConsoleBase* aConsole)

   197 	: 

   198 	CActive(EPriorityStandard), 

   199 	iStopped(ETrue), 

   200 	iEchoMode(ETrue),

   201 	iConsole(aConsole)

   202 {

   203 iConsoleEnabled = ( iConsole != NULL );    

   204 

   205 iCmdPath.Zero();

   206 iLogPath.Zero();

   207 iCmdline.Zero();

   208 iCommand.Zero();

   209 iPrompt.Copy(THA_CommandPrompt);

   210 

   211 CActiveScheduler::Add(this);

   212 }

   213 

   214 //-----------------------------------------------------------------------------

   215 

   216 void CTEngine::SetCmdFamily(CCmdFamily* aCmdFamily)

   217 {

   218 iCmdFamily = aCmdFamily;

   219 if (aCmdFamily != NULL) 

   220 	aCmdFamily->SetMachine( this );

   221 }

   222 

   223 //-----------------------------------------------------------------------------

   224 

   225 TBool CTEngine::ConsoleEnabled( )

   226 {

   227 return ( iConsoleEnabled );

   228 }

   229 

   230 //-----------------------------------------------------------------------------

   231 

   232 void CTEngine::DisableConsole()

   233 {

   234 iConsoleEnabled = EFalse;

   235 }

   236 

   237 //-----------------------------------------------------------------------------

   238 

   239 void CTEngine::EnableConsole()

   240 {

   241 iConsoleEnabled = (iConsole != NULL);

   242 }

   243 

   244 //-----------------------------------------------------------------------------

   245 

   246 CConsoleBase* CTEngine::Console() const

   247 {

   248 return (iConsole);

   249 }

   250 

   251 //-----------------------------------------------------------------------------

   252 

   253 void CTEngine::Write(const TDesC& aText)

   254 {    

   255 if (ConsoleEnabled()) 

   256 	iConsole->Write(aText);

   257 }

   258 

   259 //-----------------------------------------------------------------------------

   260 

   261 void CTEngine::Writeln( const TDesC& aText )

   262 {

   263 if (ConsoleEnabled())

   264 	{

   265 	iConsole->Write(aText);

   266 	iConsole->Write(TFR_KTxtNewLine);

   267 	}

   268 }

   269 

   270 //-----------------------------------------------------------------------------

   271 

   272 void CTEngine::Writeln()

   273 {    

   274 if (ConsoleEnabled()) 

   275 	iConsole->Write(TFR_KTxtNewLine);

   276 }

   277 

   278 //-----------------------------------------------------------------------------

   279 

   280 void CTEngine::Printf( TRefByValue<const TDesC> aFmt, ... )

   281 {    

   282 VA_LIST list;

   283 VA_START( list, aFmt );

   284 Printf( aFmt, list ); 

   285 }

   286 

   287 //-----------------------------------------------------------------------------

   288 

   289 void CTEngine::Printf( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   290 {

   291 if ( ConsoleEnabled() )

   292 	{

   293 	iPrintBuf.Zero();

   294 	TRAPD(error,iPrintBuf.AppendFormatList( aFmt, aList, &iOverflow));

   295 	if ( error == KErrNone )

   296 		{

   297 		iConsole->Write( iPrintBuf );

   298 		}

   299 	else

   300 		{

   301 		iConsole->Write( TFR_KTxtErrPrintOflo );

   302 		iConsole->Write( TFR_KTxtNewLine );

   303 		}

   304 	}

   305 }

   306 

   307 //-----------------------------------------------------------------------------

   308 

   309 void CTEngine::Printfln( TRefByValue<const TDesC> aFmt, ... )

   310 {    

   311 VA_LIST list;

   312 VA_START( list, aFmt );

   313 Printfln( aFmt, list );

   314 }

   315 

   316 //-----------------------------------------------------------------------------

   317 

   318 void CTEngine::Printfln( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   319 {

   320 if ( ConsoleEnabled( ) )

   321 	{

   322 	iPrintBuf.Zero();

   323 	TInt error = KErrNone;

   324 	TRAP(error,iPrintBuf.AppendFormatList( aFmt, aList, &iOverflow));

   325 	if ( error != KErrNone ) 

   326 		return;

   327 	TRAP(error,iPrintBuf.AppendFormat( _L("%S"), &iOverflow, &TFR_KTxtNewLine ));

   328 	if (error == KErrNone )

   329 		{

   330 		iConsole->Write( iPrintBuf );

   331 		}

   332 	else

   333 		{

   334 		iConsole->Write( TFR_KTxtErrPrintOflo );

   335 		iConsole->Write( TFR_KTxtNewLine );

   336 		}

   337 	}

   338 }

   339 

   340 //-----------------------------------------------------------------------------

   341 

   342 void CTEngine::Pause(const TDesC& aPrompt)

   343 {

   344 if (ConsoleEnabled())

   345 	{

   346 	iCmdline.Zero();

   347 	iConsole->Write(aPrompt);

   348 	if (!IsActive())

   349 		SetActive();

   350 	iConsoleReader->ReadChar(iCmdline, iStatus);

   351 	}

   352 else

   353 	CompleteRequest();

   354 }

   355 

   356 //-----------------------------------------------------------------------------

   357 

   358 void CTEngine::Hold(TTimeIntervalMicroSeconds32 aInterval)

   359 {

   360 iTimer.After(iStatus, aInterval);

   361 SetActive();

   362 }

   363 

   364 //-----------------------------------------------------------------------------

   365 

   366 TInt CTEngine::SetCmdPath( const TDesC& aPath )

   367 {

   368 if (aPath.Length() == 0)

   369 	{

   370 	Printf(_L("Path is set to: %S\r\n"), &iCmdPath);

   371 	return KErrNone;

   372 	}

   373 

   374 if (iParse.SetNoWild( aPath, NULL, NULL ) != KErrNone)

   375 	return KErrArgument;

   376 

   377 if (!iParse.PathPresent() || iParse.NameOrExtPresent())

   378 	return KErrArgument;

   379 

   380 //	set it

   381 iCmdPath.Copy(aPath);

   382 

   383 //	echo it

   384 Printf(_L("Path is set to: %S\r\n"), &iCmdPath);

   385 

   386 return KErrNone;

   387 }

   388 

   389 //-----------------------------------------------------------------------------

   390 

   391 TPtrC CTEngine::CmdPath() const

   392 {

   393 TPtrC path(iCmdPath);

   394 return path;

   395 }

   396 

   397 //-----------------------------------------------------------------------------

   398 

   399 TPtrC CTEngine::FileName() const

   400 {

   401 TPtrC fileName(iFileName);

   402 return fileName;

   403 }

   404 

   405 //-----------------------------------------------------------------------------

   406 //	parameterless version

   407 

   408 TInt CTEngine::CallCmdFile(const TDesC& aFile)

   409 {

   410 return CallCmdFile(aFile, _L(""));

   411 }

   412 

   413 //-----------------------------------------------------------------------------

   414 

   415 TInt CTEngine::CallCmdFile(const TDesC &aFile, const TDesC &aArgs)

   416 {

   417 // Make CCmdFile object.

   418 CCmdFile *file = NULL;

   419 TRAPD(error, file = CCmdFile::NewL());

   420 if ( error != KErrNone ) 

   421 	return error;

   422 

   423 error = file->Open(iCmdPath, aFile);

   424 if ( error != KErrNone )

   425 	{

   426 	delete file;

   427 

   428 	//	print file x not found echo it

   429 	Printf(_L("Error: file [%S] not found\r\n"), &aFile);

   430 	Printf(_L("       Check file path <%S>\r\n"), &iCmdPath);

   431 	return error;

   432 	}

   433 

   434 // Save file name and arguments.

   435 TRAP(error, file->AddArgsL(aFile));

   436 if (error == KErrNone) 

   437 	TRAP(error, file->AddArgsL(aArgs));

   438 

   439 if ( error != KErrNone )

   440 	{

   441 	delete file;

   442 	return error;

   443 	}

   444 

   445 // Check that not too many call arguments.

   446 if ( file->Argc() > (TFR_MAX_CALL_ARGUMENTS + 1))

   447 	{

   448 	delete file;

   449 	return error = KErrArgument;

   450 	}

   451 

   452 // Push present command file to cmdfile pile.

   453 TRAP(error, iCmdPile->PushL( iCmdFile ));

   454 if ( error != KErrNone )

   455 	{

   456 	delete file;

   457 	return error;

   458 	}

   459 

   460 // Switch context to the called command file.

   461 iCmdFile = file;

   462 file = NULL;

   463 TRAP(error, SetContextL(iDefines, iCmdFile));

   464 return error;

   465 }

   466 

   467 //-----------------------------------------------------------------------------

   468 

   469 CCmdFile* CTEngine::CmdFile()

   470 {

   471 return iCmdFile;

   472 }

   473 

   474 //-----------------------------------------------------------------------------

   475 

   476 TInt CTEngine::CloseCmdFile()

   477 {

   478 // Get rid of the present command file (NULL iCmdFile is Ok).

   479 delete iCmdFile;

   480 iCmdFile = NULL;

   481 

   482 // Pop the previous one from the pile (returns NULL if none).

   483 iCmdFile = iCmdPile->Pop();

   484 

   485 // Switch context to that file (NULL iCmdFile does no harm).

   486 TRAPD(error,SetContextL(iDefines,iCmdFile));

   487 return error;

   488 }

   489 

   490 //-----------------------------------------------------------------------------

   491 

   492 void CTEngine::CloseCmdFiles()

   493 {

   494 // Pop and delete all previous command files from the file pile.

   495 iCmdPile->Empty();

   496 

   497 // Get rid of the present file as well (NULL iCmdFile is Ok).

   498 delete iCmdFile;

   499 iCmdFile = NULL;

   500 

   501 // Switch context to "no command file" (since iCmdFile = NULL).

   502 TRAP_IGNORE(SetContextL(iDefines,iCmdFile)); // doesn't LEAVE, see yourself

   503 }

   504 

   505 //-----------------------------------------------------------------------------

   506 

   507 TInt CTEngine::SetLogPath( const TDesC& aPath )

   508 {

   509 if (aPath.Length() == 0)

   510 	{

   511 	iLogPath.Zero();

   512 	return KErrNone;

   513 	}

   514 

   515 if (iParse.SetNoWild( aPath, NULL, NULL ) != KErrNone)

   516 	return KErrArgument;

   517 

   518 if (!iParse.PathPresent() || iParse.NameOrExtPresent())

   519 	return KErrArgument;

   520 

   521 TInt error;

   522 RFs fs;

   523 if (error = fs.Connect(), error == KErrNone)

   524 	{

   525 	error = fs.MkDirAll( iParse.DriveAndPath());

   526 	if (error == KErrAlreadyExists) 

   527 		error = KErrNone;

   528 

   529 	fs.Close();

   530 	if (error == KErrNone) 

   531 		iLogPath.Copy(aPath);

   532 	}

   533 return error;

   534 }

   535 

   536 //-----------------------------------------------------------------------------

   537 

   538 TPtrC CTEngine::LogPath() const

   539 {

   540 TPtrC logpath(iLogPath);

   541 return logpath;

   542 }

   543 

   544 //-----------------------------------------------------------------------------

   545 

   546 TInt CTEngine::OpenLogFile(const TDesC& aFile)

   547 {

   548 // Construct a full log file.

   549 TInt error = iParse.Set(aFile, NULL, &iLogPath);

   550 if (error != KErrNone) 

   551 	return error;

   552 

   553 // Construct and open the new log file.

   554 CLogFile* file = NULL;

   555 TRAP(error, file = CLogFile::NewL());

   556 if ( error != KErrNone ) 

   557 	return error;

   558 

   559 error = file->Open( iParse.FullName() );

   560 if ( error == KErrNone && iLogFile != NULL )

   561 	{

   562 	// Close and save the present log file.

   563 	iLogFile->Close();

   564 	TRAP(error, iLogPile->PushL(iLogFile));

   565 	if ( error == KErrNone ) 

   566 		iLogFile = NULL;

   567 	}

   568 

   569 if (error == KErrNone)

   570 	{

   571 	// Switch the log file.

   572 	file->PrintHeading();

   573 	iLogFile = file;

   574 	file = NULL;

   575 	}

   576 

   577 delete file; // is NULL if no errors!

   578 return error;

   579 }

   580 

   581 //-----------------------------------------------------------------------------

   582 

   583 CLogFile *CTEngine::LogFile()

   584 {

   585 return iLogFile;

   586 }

   587 

   588 //-----------------------------------------------------------------------------

   589 

   590 TInt CTEngine::CloseLogFile( )

   591 {

   592 delete iLogFile;

   593 iLogFile = NULL;

   594 iLogFile = iLogPile->Pop();

   595 TInt error = KErrNone;

   596 if ( iLogFile != NULL )

   597 	error = iLogFile->Open();

   598 return error;

   599 }

   600 

   601 //-----------------------------------------------------------------------------

   602 

   603 void CTEngine::CloseLogFiles()

   604 {

   605 TInt count = iLogPile->Count();

   606 while (count > 0 )

   607 	{

   608 	CLogFile* file = iLogPile->Pop();

   609 	delete file; // NULL does no harm!

   610 	}

   611 

   612 delete iLogFile;

   613 iLogFile = NULL;

   614 }

   615 

   616 //-----------------------------------------------------------------------------

   617 

   618 void CTEngine::LogWrite( const TDesC& aText )

   619 {

   620 if ( iLogFile != NULL ) 

   621 	iLogFile->Write( aText );

   622 }

   623 

   624 //-----------------------------------------------------------------------------

   625 

   626 void CTEngine::LogWriteln( const TDesC& aText )

   627 {

   628 if ( iLogFile != NULL ) 

   629 	iLogFile->Writeln( aText );

   630 }

   631 

   632 //-----------------------------------------------------------------------------

   633 

   634 void CTEngine::LogWriteln()

   635 {

   636 if ( iLogFile != NULL ) 

   637 	iLogFile->Writeln();

   638 }

   639 

   640 //-----------------------------------------------------------------------------

   641 

   642 void CTEngine::LogPrintf( TRefByValue<const TDesC> aFmt, ... )

   643 {

   644 VA_LIST list;

   645 VA_START(list, aFmt);

   646 LogPrintf(aFmt, list);

   647 }

   648 

   649 //-----------------------------------------------------------------------------

   650 

   651 void CTEngine::LogPrintf( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   652 {

   653 if (iLogFile != NULL) 

   654 	iLogFile->Printf(aFmt, aList);

   655 }

   656 

   657 //-----------------------------------------------------------------------------

   658 

   659 void CTEngine::LogPrintfln( TRefByValue<const TDesC> aFmt, ... )

   660 {

   661 VA_LIST list;

   662 VA_START(list, aFmt);

   663 LogPrintfln(aFmt, list);

   664 }

   665 

   666 //-----------------------------------------------------------------------------

   667 

   668 void CTEngine::LogPrintfln( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   669 {

   670 if (iLogFile != NULL)

   671 	{

   672 	iLogFile->Printf(aFmt, aList);

   673 	iLogFile->Writeln();

   674 	}

   675 }

   676 

   677 //-----------------------------------------------------------------------------

   678 //    Standard message output:

   679 //    - CTEngine::MsgWrite

   680 //    - CTEngine::MsgWriteln

   681 //    - CTEngine::MsgWriteln

   682 //    - CTEngine::MsgPrintf

   683 //    - CTEngine::MsgPrintf

   684 //    - CTEngine::MsgPrintfln

   685 //    - CTEngine::MsgPrintfln

   686 //

   687 //	A message goes to the log if there is one open. The message is printed

   688 //	to the display as well, except when having echo mode off and running a

   689 //	command file.

   690 //

   691 //-----------------------------------------------------------------------------

   692 

   693 void CTEngine::MsgWrite(const TDesC& aText)

   694 {

   695 LogWrite(aText);

   696 if (EchoMode() || (iCmdFile == NULL)) 

   697 	Write(aText);

   698 }

   699 

   700 //-----------------------------------------------------------------------------

   701 

   702 void CTEngine::MsgWriteln(const TDesC& aText)

   703 {

   704 LogWriteln(aText);

   705 if (EchoMode() || (iCmdFile == NULL)) 

   706 	Writeln(aText);

   707 }

   708 

   709 //-----------------------------------------------------------------------------

   710 

   711 void CTEngine::MsgWriteln()

   712 {

   713 LogWriteln();

   714 if (EchoMode() || (iCmdFile == NULL)) 

   715 	Writeln();

   716 }

   717 

   718 //-----------------------------------------------------------------------------

   719 

   720 void CTEngine::MsgPrintf( TRefByValue<const TDesC> aFmt, ... )

   721 {

   722 VA_LIST list;

   723 VA_START( list, aFmt  );

   724 MsgPrintf( aFmt, list );

   725 }

   726 

   727 //-----------------------------------------------------------------------------

   728 

   729 void CTEngine::MsgPrintf( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   730 {

   731 if ( EchoMode() || (iCmdFile == NULL) ) 

   732 	{

   733 	VA_LIST clone;

   734 	Mem::Move( &clone, &aList, sizeof(VA_LIST) );

   735 	LogPrintf( aFmt, aList );

   736 	Printf( aFmt, clone );

   737 	}

   738 else

   739 	{

   740 	LogPrintf( aFmt, aList );

   741 	}

   742 }

   743 

   744 //-----------------------------------------------------------------------------

   745 

   746 void CTEngine::MsgPrintfln( TRefByValue<const TDesC> aFmt, ... )

   747 {

   748 VA_LIST list;

   749 VA_START( list, aFmt );

   750 MsgPrintfln( aFmt, list );

   751 }

   752 

   753 //-----------------------------------------------------------------------------

   754 

   755 void CTEngine::MsgPrintfln( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

   756 {

   757 if ( EchoMode() || (iCmdFile == NULL) ) 

   758 	{

   759 	VA_LIST clone;

   760 	Mem::Move( &clone, &aList, sizeof(VA_LIST) );

   761 	LogPrintfln( aFmt, aList );

   762 	Printfln( aFmt, clone );

   763 	}

   764 else

   765 	LogPrintfln(aFmt, aList);

   766 }

   767 

   768 //-----------------------------------------------------------------------------

   769 

   770 TInt CTEngine::SetPrompt(const TDesC& aPrompt)

   771 {

   772 // Return error in case a too long prompt was proposed.

   773 if (aPrompt.Length() > iPrompt.MaxLength()) 

   774 	return KErrTooBig;

   775 

   776 // Otherwise alter trhe prompt and return Ok.

   777 iPrompt.Copy(aPrompt);

   778 return KErrNone;

   779 }

   780 

   781 //-----------------------------------------------------------------------------

   782 

   783 TPtrC CTEngine::Prompt() const

   784 {

   785 TPtrC prompt(iPrompt);

   786 return prompt;

   787 }

   788 

   789 //-----------------------------------------------------------------------------

   790 //	Run

   791 //	Start things off! We have a variety of options: 

   792 //	1.	interactive. (no params) => Call Run()

   793 //	2.	semi-interactive. (some params, no script) => Call Run(Args)

   794 //	3.  automatic. (some params & script) => Run(Script, Args)

   795 

   796 void CTEngine::Run()

   797 {

   798 if (!IsActive())

   799 	{

   800 	// Start the engine and set the state to get the next cmd

   801 	iStopped   = EFalse;

   802 	iState = EGetNextCmd;

   803 

   804 	// Complete request

   805 	CompleteRequest();

   806 	}

   807 }

   808 

   809 //-----------------------------------------------------------------------------

   810 

   811 TInt CTEngine::Run(const TDesC& aFile)

   812 {

   813 return Run(aFile, _L(""));

   814 }

   815 

   816 //-----------------------------------------------------------------------------

   817 

   818 TInt CTEngine::Run(const TDesC& aFile, const TDesC& aArgs)

   819 {

   820 iStopped = EFalse;

   821 

   822 // Open (call) the command file. Stop test engine if fails.

   823 TInt error = CallCmdFile(aFile, aArgs);

   824 if (error != KErrNone) 

   825 	StopEngine();

   826 

   827 // Keep going until stopped or reading the commands fails.

   828 while ((!iStopped) && (error == KErrNone))

   829 	{

   830 	error = ReadCmdline(EFalse);

   831 	if (error == KErrNone)

   832 		{

   833 		if (MakeCommand() == KErrNone)

   834 			{

   835 			TRAP(error,(void) ObeyCommandL()); 

   836 			}

   837 		}

   838 	}

   839 

   840 // Make sure that command files and log files get closed and return.

   841 CloseCmdFiles();

   842 CloseLogFiles();

   843 return error;

   844 }

   845 

   846 //-----------------------------------------------------------------------------

   847 //	CTEngine::Terminate

   848 //

   849 //	Terminate processing of command files. If not inside a command file,

   850 //	then does not do anything - doesn't even close the opened log files.

   851 

   852 void  CTEngine::Terminate()

   853 {

   854 // Inside command file?

   855 if (iCmdFile != NULL)

   856 	{

   857 

   858 	// Close all command files.

   859 	CloseCmdFiles();

   860 

   861 	// Close all log files. Write the "run aborted" message to the end

   862 	// of every log file.

   863 	while (iLogPile->Count() > 0)

   864 		{

   865 		// There is yet at least one log file in pile: write the abort

   866 		// message and close => previous file in pile will be opened.

   867 		LogWriteln( TFR_KTxtMsgRunAborted );

   868 		(void)CloseLogFile();

   869 		}

   870 

   871 	// Close the very last log file too. Having iLogFile = NULL is not

   872 	// checkd in here because that doesn't do any harm.

   873 	LogWriteln( TFR_KTxtMsgRunAborted );

   874 	delete iLogFile;

   875 	iLogFile = NULL;

   876 

   877 	// Print abort message to console too.

   878 	Writeln( TFR_KTxtMsgRunAborted );

   879 	}

   880 }

   881 

   882 //-----------------------------------------------------------------------------

   883 

   884 void CTEngine::StopEngine( )

   885 {

   886 iStopped = ETrue;

   887 CloseCmdFiles();

   888 

   889 // Print message to console

   890 Writeln(TFR_KTxtMsgRunStopped);

   891 }

   892 

   893 //-----------------------------------------------------------------------------

   894 

   895 TBool CTEngine::Stopped()

   896 {

   897 return iStopped;

   898 }

   899 

   900 //-----------------------------------------------------------------------------

   901 

   902 void CTEngine::SetEchoMode(const TBool &aBoolean)

   903 {

   904 iEchoMode = aBoolean;

   905 }

   906 

   907 //-----------------------------------------------------------------------------

   908 

   909 TBool CTEngine::EchoMode()

   910 {

   911 return iEchoMode;

   912 }

   913 

   914 //-----------------------------------------------------------------------------

   915 

   916 #if !defined(TEMPLATED_CATALOGUE)

   917 CCatalogue *CTEngine::Defines()

   918 #else

   919 CCatalogue<CLabeledText> *CTEngine::Defines()

   920 #endif

   921 {

   922 return iDefines;

   923 }

   924 

   925 //-----------------------------------------------------------------------------

   926 

   927 TInt CTEngine::ReadCmdline(TBool aConsole)

   928 {

   929 

   930 // Reset cmd.

   931 iCmdline.Zero();

   932 

   933 TInt error = KErrNone;

   934 if (iCmdFile != NULL)

   935 	error = ReadCmdFile();

   936 

   937 else

   938 	// Set error to imply that the end of the cmd file has been reached

   939 	error = KErrEof;

   940 

   941 if ((error == KErrEof) && aConsole )

   942 	// Get the next cmd line from the console

   943 	error = ReadConsole();

   944 

   945 return error;

   946 }

   947 

   948 //-----------------------------------------------------------------------------

   949 //	Read command line (iCmdline) from command files.

   950 

   951 TInt CTEngine::ReadCmdFile()

   952 {

   953 

   954 // Reset cmd and read from the command files. Close files if at end.

   955 iCmdline.Zero();

   956 TInt error = KErrEof;

   957 while ((iCmdFile != NULL) && (error == KErrEof))

   958 	{

   959 	error = iCmdFile->Read(iCmdline);

   960 	if (error == KErrEof)

   961 		{

   962 		error = CloseCmdFile();

   963 		if (error == KErrNone) 

   964 			error = KErrEof;

   965 		}

   966 	else

   967 		CompleteRequest();

   968 

   969 	}

   970 

   971 return error;

   972 }

   973 

   974 //-----------------------------------------------------------------------------

   975 //	Read command line (iCmdline) from console.

   976 

   977 TInt CTEngine::ReadConsole()

   978 {

   979 // Get cmd from console - first write prompt.

   980 iConsole->Write(iPrompt);

   981 iConsoleReader->ReadLine(iCmdline, iStatus);

   982 SetActive();

   983 

   984 return KErrNone;

   985 }

   986 

   987 //-----------------------------------------------------------------------------

   988 

   989 TPtrC CTEngine::GetDefine(const TDesC &aTag) const

   990 {

   991 TPtrC iVal;

   992 TInt len = aTag.Length();

   993 

   994 for (TInt i = 0; i < iDefines->Count(); ++i)

   995 	{

   996 	CLabeledText *tag = iDefines->At(i);

   997 	TInt pos = tag->Label().Find(aTag);

   998 	//make sure that 'xyz' does not match with '$xyz_abcd$' 

   999 	if ( (pos == 1) && (tag->Label().Length() == len+2) )

  1000 		{

  1001 		iVal.Set(tag->Value());

  1002 		break;

  1003 		}

  1004 	}

  1005 

  1006 return iVal;

  1007 }

  1008 

  1009 //-----------------------------------------------------------------------------

  1010 //	Make the command (iCommand) to obey. Copies the command line (iCmdline)

  1011 //	to the iCommand buffer and expands the tags to their defined values. If

  1012 //	fails, prints out the original command line and an error message.

  1013 

  1014 TInt CTEngine::MakeCommand()

  1015 {

  1016 TInt error = KErrNone;

  1017 

  1018 // Copy command line from iCmdline buffer to iCommand buffer.

  1019 iCommand.Copy(iCmdline);

  1020 

  1021 // Expand tags = replace tag markers with their defined values.

  1022 TInt  counter = 0;

  1023 TBool proceed = ETrue;

  1024 while (proceed && (error == KErrNone))

  1025 	{

  1026 	// One round = replace all tag labels with their values and

  1027 	// alter the proceed to ETrue in replaced one or more tags.

  1028 	proceed = EFalse;

  1029 	for (TInt i = 0; i < iDefines->Count(); ++i)

  1030 		{

  1031 		CLabeledText *tag = iDefines->At(i);

  1032 		TInt pos = iCommand.Find(tag->Label());

  1033 		if (pos >= 0)

  1034 			{

  1035 

  1036 			// More than a hundred replacements as the whole is

  1037 			// propably due to an infinite loop ( recursive tag

  1038 			// definitions ): 

  1039 			if (counter > 99)

  1040 				{

  1041 				// Propably recursive tag definitions.

  1042 				MsgWriteln(TfrLex::Trim(iCmdline));

  1043 				MsgWriteln(TFR_KTxtErrRecursiveTags);

  1044 				error = KErrOverflow;

  1045 				break;

  1046 				}

  1047 

  1048 			// Check that this very tag replacement won't cause

  1049 			// overflow in command buffer.

  1050 			TInt newlength = iCommand.Length() - tag->Label().Length();

  1051 			newlength += tag->Value().Length();

  1052 			if (newlength > iCommand.MaxLength())

  1053 				{

  1054 				// Command has grown too big in size.

  1055 				MsgWriteln(TfrLex::Trim( iCmdline));

  1056 				MsgWriteln(TFR_KTxtErrTooLongCmd);

  1057 				error = KErrOverflow;

  1058 				break;

  1059 				}

  1060 

  1061 			// Fine, replace the tag with its defined value and

  1062 			// mark that there shall be at least one more round.

  1063 			proceed = ETrue;

  1064 			iCommand.Replace(pos, tag->Label().Length(), tag->Value());

  1065 			++counter; // keep up total count of replacements.

  1066 			}

  1067 		} // end-for

  1068 	} // end-while

  1069 

  1070 // Return if everything went fine.

  1071 if ( error == KErrNone ) 

  1072 	return error;

  1073 

  1074 // Otherwise terminate command files, unless when in check mode.

  1075 if ( (iCmdFamily == NULL) || !iCmdFamily->Switch(CCmdFamily::EParseOnly) )

  1076 	Terminate();

  1077 

  1078 return error;

  1079 }

  1080 

  1081 //-----------------------------------------------------------------------------

  1082 

  1083 TInt CTEngine::ObeyCommandL()

  1084 {

  1085 TInt error = KErrNone;

  1086 

  1087 // The command is handled without the leading/trailing spaces.

  1088 TPtrC cmd = TfrLex::Trim(iCommand);

  1089 

  1090 // The command shall be echoed if echo mode is On and command

  1091 // was read from a command file. 

  1092 TBool doEcho = (iEchoMode && (iCmdFile != NULL));

  1093 

  1094 // Check if command begins with @ character and remove if yes.

  1095 // That kind of commands aren't echoed afterall.

  1096 if (cmd.Match(_L("@*")) == 0)

  1097 	{

  1098 	// Command is not echoed afterall.

  1099 	doEcho = EFalse;

  1100 

  1101 	// Remove @ and them trim once more.

  1102 	cmd.Set(cmd.Ptr()+1, cmd.Length()-1);

  1103 	cmd.Set(TfrLex::TrimLeft(cmd));

  1104 	}

  1105 

  1106 //	Look up from Command Family if there's a registered command to

  1107 //	handle this very command string. If there is no Command Family

  1108 //	then there is no handler either.

  1109 //	bear in mind that we have to possibly skip a valid command if

  1110 //	our if mode directs us... 

  1111 CCmdBase *handler = NULL; 

  1112 if (iCmdFamily != NULL) 

  1113 	handler = iCmdFamily->Recognize(cmd);

  1114 

  1115 if (handler != NULL)

  1116 	{

  1117 	TBool stepover = DetermineStepover(handler);

  1118 

  1119 	if (!stepover)

  1120 		{

  1121 		// This one shall be processed.

  1122 		// ----------------------------

  1123 		// Echo the original input command to the display.

  1124 

  1125 		//	log command and display the command on the screen if appropriate

  1126 		if (iShowCmdLine)

  1127 			MsgWriteln(iCmdline);	

  1128 		else if (doEcho) 

  1129 			Writeln(TfrLex::TrimRight(iCommand));

  1130 

  1131 		//	Write into the log unless that has been prevented.

  1132 		//	and then process the command.

  1133 		error = handler->ProcessL(cmd);

  1134 		}

  1135 	else