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

// Local CTestIniData class, derived from CIniData.lib

// 

//

#include <f32file.h>

#include <e32std.h>

#include "TestIniData.h"

// Default directory to look for INI file

_LIT(KIniFileDir,"C:\\System\\Data\\");

const TInt KTokenSize=40;

//

void CTestIniData::Panic(TTestIniPanic aPanic)

        {

        _LIT(KIniData,"CTestIniData");

        User::Panic(KIniData,aPanic);

        }

//

CTestIniData::CTestIniData() 

        : iPtr(NULL,0)

        {

        __DECLARE_NAME(_S("CTestIniData"));

        }

//

CTestIniData::~CTestIniData()

        {

        delete (TText*)iPtr.Ptr();

        delete iToken;

        delete iName;

        }

//

CTestIniData* CTestIniData::NewL(const TDesC& aName)

        {

        CTestIniData* p=new(ELeave) CTestIniData;

        CleanupStack::PushL(p);

        p->ConstructL(aName);

        CleanupStack::Pop();

        return p;

        }

//

//

// Allocate a buffer and Read file's contents into iPtr

//

void CTestIniData::ConstructL(const TDesC& aName)

        {

        // Allocate space for token

        iToken=HBufC::NewL(KTokenSize+2);       // 2 extra chars for [tokenName]

        // Connect to file server

        TAutoClose<RFs> fs;

        User::LeaveIfError(fs.iObj.Connect());

        fs.PushL();

        // Find file, given name

        TFindFile ff(fs.iObj);

        User::LeaveIfError(ff.FindByDir(aName, KIniFileDir));

        iName=ff.File().AllocL();

        // Open file

        TAutoClose<RFile> file;

        TInt size;

        User::LeaveIfError(file.iObj.Open(fs.iObj,*iName,EFileStreamText|EFileRead));

        file.PushL();

        // Get file size and read in

        User::LeaveIfError(file.iObj.Size(size));

        TText* data=(TText*)User::AllocL(size);

        iPtr.Set(data, size/sizeof(TText), size/sizeof(TText));

        TPtr8 dest((TUint8*)data, 0, size);

        User::LeaveIfError(file.iObj.Read(dest));

        TUint8* ptr = (TUint8*)data;

        //

        // This is orderred as FEFF assuming the processor is Little Endian

        // The data in the file is FFFE.                PRR 28/9/98

        //

        if(size>=(TInt)sizeof(TText) && iPtr[0]==0xFEFF)

        {

                // UNICODE Text file so lose the FFFE

                Mem::Copy(ptr, ptr+sizeof(TText), size-sizeof(TText));

                iPtr.Set(data, size/sizeof(TText)-1, size/sizeof(TText)-1);

        }

        else if(size)

        {

                // NON-UNICODE so convert to UNICODE

                TText* newdata = (TText*)User::AllocL(size*sizeof(TText));

                iPtr.Set(newdata, size, size);

                TInt i;

                for(i=0 ; i<size ; ++i)

                        iPtr[i]=ptr[i];

                delete data;

        }

        file.Pop();

        fs.Pop();

}

//

TBool CTestIniData::FindVar(const TDesC &aKeyName, TPtrC &aResult)

{

        TDesC dummySection = _L("");

        // Call with no section, so starts at beginning

        if (FindVar(dummySection, aKeyName, aResult))

                return(ETrue);

        else

                return(EFalse);

}

//

//

// Find a key's value given a section name and a key name

//

TBool CTestIniData::FindVar(const TDesC &aSectName,const TDesC &aKeyName,TPtrC &aResult)

        {

        __ASSERT_DEBUG(aSectName.Length()<=KTokenSize,Panic(ESectionNameTooBig));

        __ASSERT_DEBUG(aKeyName.Length()<=KTokenSize,Panic(EKeyNameTooBig));

        TInt posStartOfSection(0);

	TInt posEndOfSection(iPtr.Length()); // Default to the entire length of the ini data

        TPtrC SearchBuf;

        // If we have a section, set pos to section start

        TInt posI(0);   // Position in internal data Buffer

        if( aSectName.Length() > 0 )

        {

                TBool FoundSection(false);

                while ( ! FoundSection )

                {

                        // Move search buffer to next area of interest

                        SearchBuf.Set(iPtr.Mid(posI));

                        // Make up token "[SECTIONNAME]", to search for

                        TPtr sectionToken=iToken->Des();

                        _LIT(sectionTokenFmtString,"[%S]");

                        sectionToken.Format(sectionTokenFmtString,&aSectName);

                        // Search for next occurrence of aSectName

                        TInt posSB = SearchBuf.Find(sectionToken);

                        // If not found, return

                        if (posSB==KErrNotFound)

                                return(EFalse);

                        // Check this is at beginning of line (ie. non-commented)

                        // ie. Check preceding char was LF

                        if(posSB>0)

                        {

                                // Create a Buffer, starting one char before found subBuf

                                TPtrC CharBefore(SearchBuf.Right(SearchBuf.Length()-posSB+1));

                                // Check first char is end of prev

                                if(CharBefore[0] == '\n')

                                {

                                        FoundSection = ETrue;           // found

                                        posI = posI + posSB;

                                }

                                else

					{

                                        posI = posI + posSB + 1;        // try again

					}

				}

                        else

				{

                                FoundSection = ETrue;

				}

                }       // while ( ! FoundSection ) 

                // Set start of section, after section name, (incl '[' and ']')

                posStartOfSection = posI + aSectName.Length() + 2;

                // Set end of section, by finding begin of next section or end

                SearchBuf.Set(iPtr.Mid(posI));

                _LIT(nextSectionBuf,"\n[");

                TInt posSB = SearchBuf.Find(nextSectionBuf);

                if(posSB != KErrNotFound)

			{

                        posEndOfSection = posI + posSB;

			}

                else

			{

                        posEndOfSection = iPtr.Length();

			}

        }       // if( aSectName.Length() > 0 )

        // Look for key in ini file data Buffer

        posI = posStartOfSection;

        TBool FoundKey(false);

        while ( ! FoundKey )

        {

                // Search for next occurrence of aKeyName

		SearchBuf.Set(iPtr.Mid(posI,posEndOfSection-posI));

                TInt posSB = SearchBuf.Find(aKeyName);

                // If not found, return

                if (posSB==KErrNotFound)

                        return(EFalse);

                // Check this is at beginning of line (ie. non-commented)

                // ie. Check preceding char was CR or LF

                if(posSB>0)

                {

                        // Create a Buffer, starting one char before found subBuf

                        TPtrC CharBefore(SearchBuf.Right(SearchBuf.Length()-posSB+1));

			// Check if the first char is end of prev and also check 

			// if the token found is not a substring of another string  

			TBool beginningOK = ((CharBefore[0] == '\n') || (CharBefore[0] == ' ') || (CharBefore[0] == '\t'));

			TBool endingOK = ((CharBefore[aKeyName.Length()+1] == '=') || (CharBefore[aKeyName.Length()+1] == ' ') || (CharBefore[aKeyName.Length()+1] == '\t'));

			if (beginningOK && endingOK)

                        {

                                FoundKey = ETrue;

                                posI = posI + posSB;

                        }

                        else

				{

                                posI = posI + posSB + 1;

                }

			}

                else

			{

                        FoundKey = ETrue;

			}

        }       // while ( ! FoundKey )

        // Set pos, to just after '=' sign

        SearchBuf.Set(iPtr.Mid(posI));

        TInt posSB = SearchBuf.Locate('=');

        if(posSB==KErrNotFound)         // Illegal format, should flag this...

                return(EFalse);

        // Identify start and end of data (EOL or EOF)

        posI = posI + posSB + 1;        // 1 char after '='

        TInt posValStart = posI;

        TInt posValEnd;

        SearchBuf.Set(iPtr.Mid(posI));

        posSB = SearchBuf.Locate('\r');

        if(posSB!=KErrNotFound)

		{

                posValEnd = posI + posSB;

		}

        else

		{

                posValEnd = iPtr.Length();

		}

        // Check we are still in the section requested

        if( aSectName.Length() > 0 )

		{

                if( posValEnd > posEndOfSection )

			{

                        return(EFalse);

			}

		}

        // Parse Buffer from posn of key

        // Start one space after '='

        TLex lex(iPtr.Mid(posValStart, posValEnd-posValStart));

        lex.SkipSpaceAndMark();         // Should be at the start of the data

        aResult.Set(lex.MarkedToken().Ptr(),posValEnd-posValStart - lex.Offset() );

        return(ETrue);

        }

//

TBool CTestIniData::FindVar(const TDesC &aKeyName, TInt &aResult)

        {

        TPtrC ptr(NULL,0);

        if (FindVar(aKeyName,ptr))

                {

                TLex lex(ptr);

                if (lex.Val(aResult)==KErrNone)

                        return(ETrue);

                }

        return(EFalse);

        }

//

TBool CTestIniData::FindVar(const TDesC &aSection,const TDesC &aKeyName,TInt &aResult)

        {

        TPtrC ptr(NULL,0);

        if (FindVar(aSection,aKeyName,ptr))

                {

                TLex lex(ptr);

                if (lex.Val(aResult)==KErrNone)

                        return(ETrue);

                }

        return(EFalse);

		}