// Copyright (c) 2002-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:
// $Header$
// The CTEngine is the class that manages the test infrastructure
// It knows how to process scripts and where to find command knowledge
// The plan is:
// Process console command line or command line supplied script
// read in each line (or command) and process that (if appropriate)
// rev:	mjdavey, symbian@mjdss.com, July 2002
// for:	Typhoon (7.0s) & JetStream (8.0)
// Include Module Definition & Files  
// 
//

#include "CCmdFile.h" 

//-----------------------------------------------------------------------------

CCmdFile *CCmdFile::NewL( )
{
CCmdFile* self = NewLC( );
CleanupStack::Pop();
return self; 
}

//-----------------------------------------------------------------------------

CCmdFile *CCmdFile::NewLC()
{
CCmdFile* self = new (ELeave) CCmdFile();
CleanupStack::PushL(self);
self->ConstructL( );
return self;
}

//-----------------------------------------------------------------------------

CCmdFile::~CCmdFile()
{
Close();
iArgs->ResetAndDestroy();
delete iArgs;
iArgs = NULL;
}

//-----------------------------------------------------------------------------

void CCmdFile::ConstructL()
{
iFileName.Zero();
iBuf.Set( NULL, 0 );
iLine = 0;
iArgs = new (ELeave) CArrayPtrSeg<HBufC>(32);
}

//-----------------------------------------------------------------------------
//	Reads the whole file into memory
//	Not necessarily ideal - really want to read in line by line as required...

TInt CCmdFile::Open(const TDesC& aPath, const TDesC& aFile)
{
// Construct full file name and open the file.
TInt error = iParse.Set( aFile, NULL, &aPath );
if (error == KErrNone) 
	error = Open(iParse.FullName());
return error;
}

//-----------------------------------------------------------------------------

TInt CCmdFile::Open(const TDesC& aFile)
{
// Close if file is open. Note: the Close() resets the member data.
Close();

// Connect to file server.
RFs fs;
TInt error;
error = fs.Connect();
if ( error != KErrNone )
  return error;

// Open the file.
RFile file;
error = file.Open( fs, aFile, EFileStreamText|EFileRead );
if ( error != KErrNone )
  {
	fs.Close();
  return error;
  }

// Get file size.
TInt size;
error = file.Size( size );
if ( error != KErrNone )
  {
  file.Close();
  fs.Close();
  return error;
  }

// Tackle an empty file => nothing in the iBuf buffer.
if ( size == 0 )
  {
  file.Close();
  fs.Close();
  iFileName.Copy( aFile );
  return error; // = KErrNone
  }

// Allocate buffer, read in whole file and close it.
TUint8* buf = (TUint8*)User::Alloc( size );
if ( buf == NULL )
  // No memory.
  {
  file.Close();
  fs.Close();
  return ( error = KErrNoMemory );
  }

TPtr8 ptr( buf, size );
error = file.Read( ptr );
file.Close();
fs.Close();
if ( error != KErrNone )
  // Read error.
  {
  delete buf;
  file.Close();
  fs.Close();
  return error;
  }

file.Close();   // Close file
fs.Close();     // Close session

#ifndef _UNICODE
// Set iBuf from which to give lines in Read.
iBuf.Set( (TText*)buf, size/sizeof(TText) );
#else
//	Tackle UNICODE and NON-UNICODE Text files.
//	the cast is necessary  in order to remove a warning.
//	It's safe because a size variable it's always positive
if ( (TUint)size >= sizeof(TText) && buf[0] == 0xFF && buf[1] == 0xFE ) 
  {
  // UNICODE: loose 0xFF,0xFE from beginning of the file.
  Mem::Move( buf, buf+sizeof(TText), size-sizeof(TText) );
  iBuf.Set( (TText*)buf, size/sizeof(TText)-1 );
  }
else
//  Remark: the size is known to be greater than zero here.
  {
  // NON-UNICODE: convert and replace the original buffer.
  // a) make new buffer
  TText* newbuf = (TText*)User::Alloc( size*sizeof(TText) );
  if ( newbuf == NULL )
      // No memory.
      {
      delete buf;
      return ( error = KErrNoMemory );
      }
  // b) convert from old to new buffer
  TInt i;
  for ( i = 0; i < size; i++ ) newbuf[i] = buf[i];
  // c) replace and delete the old one
  iBuf.Set( newbuf, size );
  delete buf;
  }
#endif
// Set file name, rewind and return Ok (error = KErrNone).
iFileName.Copy( aFile );
Rewind();
return error; // = KErrNone
}

//-----------------------------------------------------------------------------
//	reads a line in 

TInt CCmdFile::Read(TDes& aDes)
{

// No data.
aDes.Zero();

// Return End-of-file if there's nothing; also if no file open.
if ( iBuf.Ptr() == NULL || iBuf.Length() == 0 ) 
	return KErrEof;

// Return End-of-file also after giving everything from buffer.
iLex.Mark();
if (iLex.Eos()) 
	return KErrEof;

//	Otherwise eat characters up to the end of the line/file and hand over the characters into the descriptor. 
//	The following skips CRs and handles every LF as end-of-line and hopefully
//	works right with LF, CRLF and LFCR terminated lines. The CR alone will not do as the end-of-line.
TChar ch;
while ( !iLex.Eos() && ( ch = iLex.Get(), ch != '\n' ) )
  {
  if ( (ch != '\r') && (aDes.Length() < aDes.MaxLength()) )
		aDes.Append(ch);
  }

// Increment line number (read counter) and return KErrNone.
++iLine;
return KErrNone;
}

//-----------------------------------------------------------------------------

TInt CCmdFile::Rewind()
{
iLex  = iBuf;
iLine = 0;
return KErrNone;
}

//-----------------------------------------------------------------------------

void CCmdFile::Close()
{
//
// Reset member data.
if (iBuf.Ptr() != NULL) 
	delete (TText*)iBuf.Ptr();

iBuf.Set( NULL, 0 );
iLine = 0;
iFileName.Zero();
}

//-----------------------------------------------------------------------------
//	Add more arguments (makes copies). L E A V E S  on failure.

void CCmdFile::AddArgsL( const TDesC& aArgs )
{
TLex  parse(aArgs);
TPtrC argv;
while (argv.Set(TfrLex::GetL(parse)), argv.Length() > 0)
  {
  argv.Set(TfrLex::Peel(argv));
  HBufC* buf = argv.AllocL();
  iArgs->AppendL( buf );
  }
}

//-----------------------------------------------------------------------------
//	Get argument count.

TInt CCmdFile::Argc() const
{
return iArgs->Count();
}

//-----------------------------------------------------------------------------
//	get the i'th argument, legal i assumed.

TPtrC CCmdFile::Argv(TInt aIndex) const
{
TPtrC argv ((iArgs->At(aIndex))->Des());
return argv;
}

//-----------------------------------------------------------------------------
//	Get file name. Having no file does no harm (returns empty name).

TPtrC CCmdFile::FileName() const
{
TPtrC filename(iFileName);
return filename;
}

//-----------------------------------------------------------------------------
//	Get line number (= count of lines read so fat). Having no file does no
//	harm (returns line number 0).

TInt CCmdFile::Line()
{
return iLine;
}

//-----------------------------------------------------------------------------