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

// All rights reserved.

// This component and the accompanying materials are made available

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

// f32\sfsrv\cl_parse.cpp

// 

//

#include "cl_std.h"

const TInt KLexComponents=4;

const TInt KLexNames=3;

EXPORT_C TParseBase::TParseBase()

	: iWild(0)

/**

Default constructor.

*/

	{

	Mem::FillZ(&iField[0],sizeof(iField));

	}

TInt TParseBase::ParseDrive(TLex& aName,TBool& aDone)

//

// Parse the drive name.

//

	{

	TPtrC d=aName.RemainderFromMark();

	if (d.Length()<2 || d[1]!=KDriveDelimiter)

		return(KErrNone);	//must be Drive delimeter and longer that tow to be valid drive

	TCharF c=d[0];

	if (!c.IsAlpha())		//must be alphaber letter 

		return(KErrBadName);

	if (!aDone)

		{

		if(iMod)

			NameBuf()+=d.Left(2);

		aDone=ETrue;

		}

	aName.SkipAndMark(2);

	return(KErrNone);

	}

TInt TParseBase::ParsePath(TLex& aName,TBool& aDone)

//

// Parse the path.

//

	{

	TPtrC d=aName.RemainderFromMark();

	if (d.Length() && d[0]!=KPathDelimiter)

		return(KErrNone); // Require first char of path to be a '\'

	TInt n=d.LocateReverse(KPathDelimiter)+1;

	if (n && !aDone)

		{

		if(iMod)

			{

			if (NameBuf().Length()+n>KMaxFileName)

				return(KErrBadName);

			NameBuf()+=d.Left(n);

			}

		aDone=ETrue;

		}

	aName.SkipAndMark(n);

	return(KErrNone);

	}

LOCAL_C TBool IsSpace(const TDesC& aDes)

//

// Returns ETrue if aDes only contains spaces or is zero length

//

	{

	TInt len=aDes.Length();

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

		{

		TChar txt=aDes[i];

		if (!txt.IsSpace())

			return(EFalse);

		}

	return(ETrue);

	}

TInt TParseBase::ParseName(TLex& aName,TBool& aDone)

//

// Parse the name.

//

	{

	TPtrC d=aName.RemainderFromMark();

	if (d.Locate(KPathDelimiter)!=KErrNotFound)

		return(KErrBadName); // Illegal name - filenames cannot contain a '\'

	TInt n=d.LocateReverse(KExtDelimiter);

	if (n==KErrNotFound)

		{

		n=d.Length();

		if (IsSpace(d.Left(n)))

			return(KErrNone);

		}

	TPtrC v=d.Left(n);

	if (n && !aDone)

		{

		if (v.Locate(KMatchOne)!=KErrNotFound)	//	Found ? in the name

			iWild|=(EWildName|EWildEither|EWildIsKMatchOne);		

		if (v.Locate(KMatchAny)!=KErrNotFound)	//	Found * in the name

			iWild|=(EWildName|EWildEither|EWildIsKMatchAny);		

		if(iMod)

			{

			if (NameBuf().Length()+n>KMaxFileName)	

				return(KErrBadName);

			NameBuf()+=v;

			if (n==d.Length())

				NameBuf().TrimRight();

			}

		aDone=ETrue;

		}

	aName.SkipAndMark(n);

	return(KErrNone);

	}

TInt TParseBase::ParseExt(TLex& aName,TBool& aDone)

//

// Parse the extension.

//

	{

	TPtrC d=aName.RemainderFromMark();

	if (d.Length() && !IsSpace(d) && !aDone)

		{

		if (d.Locate(KMatchOne)!=KErrNotFound) //	Found ? in the name

			iWild|=(EWildExt|EWildEither|EWildIsKMatchOne);

		if (d.Locate(KMatchAny)!=KErrNotFound) //	Found * in the name

			iWild|=(EWildExt|EWildEither|EWildIsKMatchAny);

		if(iMod)

			{

			if (NameBuf().Length()+d.Length()>KMaxFileName)

				return(KErrBadName);

			NameBuf()+=d;

			NameBuf().TrimRight();

			}

		else

			aName.SkipAndMark(d.Length());

		aDone=ETrue;

		}

	return(KErrNone);

	}

TInt TParseBase::Set(const TDesC* aName,const TDesC* aRelated,const TDesC* aDefault,TBool allowWild)

//

// Parse a name. Optionally allow wild cards.

//

	{

	TInt (TParseBase::*parse[KLexComponents])(TLex& aName,TBool& aDone);

	parse[0]=&TParseBase::ParseDrive;

	parse[1]=&TParseBase::ParsePath;

	parse[2]=&TParseBase::ParseName;

	parse[3]=&TParseBase::ParseExt;

	iWild=0;

	Mem::FillZ(&iField[0],sizeof(iField));

	TLex name(*aName);

	TLex def;

	TLex rel;

	TInt lexnames;

	if(iMod)

		{

		if (aRelated)

			rel=(*aRelated);

		if (aDefault)

			def=(*aDefault);

		NameBuf().Zero();

		lexnames = KLexNames;

		}

	else

		{

		lexnames = 1;

		}

	TLex* lex[KLexNames];

	lex[0]=(&name);

	lex[1]=(&rel);

	lex[2]=(&def);

	name.Mark();

	rel.Mark();

	def.Mark();

	TInt r;

	TInt pos=0;

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

		{

		TBool done=EFalse;

		for (TInt j=0;j<lexnames;j++)

			{

			if ((r=(this->*parse[i])(*lex[j],done))<KErrNone)

				return(r);

			if (j==0 && done)

				iField[i].present=ETrue;

			}

		TInt len;

		if(iMod)

			len=NameBuf().Length()-pos;

		else

			len=name.MarkedOffset()-pos;

		iField[i].len=(TUint8)len;

		iField[i].pos=(TUint8)pos;

		pos+=len;

		}

	if (!allowWild && iWild)

		return(KErrBadName);

	if (iField[EPath].len==1)

		iWild|=EIsRoot;

	return(KErrNone);

	}

EXPORT_C TInt TParseBase::PopDir()

/**

Removes the last directory from the path in the fully parsed specification.

This function may be used to navigate up one level in a directory hierarchy.

An error is returned if the specified directory is the root.

@return KErrNone if successful, otherwise one of the other system-wide error 

        codes.

*/

	{

	if (IsRoot())

		return(KErrGeneral);

	TInt len;

	if (iField[EName].pos==0 && NameBuf().Length()==256)

		len=256;

	else

		len=iField[EName].pos;

	TPtrC p(NameBuf().Ptr(),len-1);

	TInt pos=p.LocateReverse(KPathDelimiter)+1;

	len-=pos;

	NameBuf().Delete(pos,len);

	iField[EName].pos=(TUint8)(iField[EName].pos-len);

	iField[EExt].pos=(TUint8)(iField[EExt].pos-len);

	iField[EPath].len=(TUint8)(iField[EPath].len-len);

	if (iField[EPath].len==1)

		iWild|=EIsRoot;

	return(KErrNone);

	}

EXPORT_C TInt TParseBase::AddDir(const TDesC& aName)

/**

Adds a single directory onto the end of the path in

the fully parsed specification. 

The directory is inserted between the final directory, and the filename, if 

there is one.

@param aName The directory to be added. It must not start with a \\ otherwise 

             the function does not recognise it as a valid directory name

             and an error is returned.

             The directory name must not end with a \\ since the function 

             adds this automatically. It must not exceed the maximum

             filename length, KMaxFileName characters, otherwise  an error

             is returned.

@return KErrNone if successful, otherwise another of the system-wide error 

        codes.   

@see KMaxFileName

*/

	{

	if (aName.Length()==0)

		return(KErrNone);

	TInt len=aName.Length()+1;

	if ((len+NameBuf().Length())>NameBuf().MaxLength())

		return(KErrGeneral);

	TInt pos=aName.Locate(KPathDelimiter);

	if (pos!=KErrNotFound)

		return(KErrBadName);

	TFileName n=aName;

	n.Append(KPathDelimiter);

	NameBuf().Insert(iField[EName].pos,n);

	iField[EPath].len=(TUint8)(iField[EPath].len+len);

	iField[EName].pos=(TUint8)(iField[EName].pos+len);

	iField[EExt].pos=(TUint8)(len+iField[EExt].pos);

	if (IsRoot())

		iWild&=~EIsRoot;

	return(KErrNone);

	}

EXPORT_C const TDesC& TParseBase::FullName() const

/**

Gets the complete file specification.

This is in the form:

drive-letter: \\path\\filename.extension

@return The fully parsed file specification.

*/

	{

	return(NameBufC());

	}

EXPORT_C TPtrC TParseBase::Drive() const

/**

Gets the drive letter.

The drive letter is in the form:

drive-letter:

Note that the drive letter is folded.

@return The drive letter and colon.

*/

	{

	const SField& f=iField[EDrive];

	return(NameBufC().Mid(f.pos,f.len));

	}

EXPORT_C TPtrC TParseBase::Path() const

/**

Gets the path.

The path is in the form:

\\path\\

@return The path. It always begins and ends in a backslash.

*/

	{

	const SField& f=iField[EPath];

	return(NameBufC().Mid(f.pos,f.len));

	}

EXPORT_C TPtrC TParseBase::DriveAndPath() const

/**

Gets the drive letter and path.

This is in the form

drive-letter:\\path\\

Note that the drive letter is folded

@return The drive and path.

*/

	{

	const SField& f=iField[EDrive];

	return(NameBufC().Mid(f.pos,f.len+iField[EPath].len));

	}

EXPORT_C TPtrC TParseBase::Name() const

/**

Gets the filename.

This is in the form

filename

@return The filename.

*/

	{

	const SField& f=iField[EName];

	return(NameBufC().Mid(f.pos,f.len));

	}

EXPORT_C TPtrC TParseBase::Ext() const

/**

Gets the extension.

This is in the form:

.extension

@return The extension and preceding dot.

*/

	{

	const SField& f=iField[EExt];

	return(NameBufC().Mid(f.pos,f.len));

	}

EXPORT_C TPtrC TParseBase::NameAndExt() const

/**

Gets the filename and extension.

This is in the form:

filename.ext

@return The filename and extension.

*/

	{

	const SField& f=iField[EName];

	return(NameBufC().Mid(f.pos,f.len+iField[EExt].len));

	}

EXPORT_C TBool TParseBase::DrivePresent() const

/**

Tests whether a drive is present.

Note that this function refers to a component 

in the aName argument specified in calls to TParse::Set(), TParse::SetNoWild() 

or RFs::Parse(), not to the resulting fully parsed file specification.

@return True if a drive present, false if not.

@see TParse

@see RFs

*/

	{

	return(iField[EDrive].present);

	}

EXPORT_C TBool TParseBase::PathPresent() const

/**

Tests whether a path is present.

Note that this function refers to a component 

in the aName argument specified in calls to TParse::Set(), TParse::SetNoWild() 

or RFs::Parse(), not to the resulting fully parsed file specification.

@return True if a path present, false if not.

@see TParse

@see RFs

*/

	{

	return(iField[EPath].present);

	}

EXPORT_C TBool TParseBase::NamePresent() const

/**

Tests whether a file name is present.

Note that this function refers to a component 

in the aName argument specified in calls to TParse::Set(), TParse::SetNoWild() 

or RFs::Parse(), not to the resulting fully parsed file specification.

This function returns true even if the filename specified in aName contains 

only wildcards. It only returns false if nothing is specified.

@return True if a name present, false if not.

*/

	{

	return(iField[EName].present);

	}

EXPORT_C TBool TParseBase::ExtPresent() const

/**

Tests whether an extension is present.

Note that this function refers to a component

in the aName argument specified in calls to TParse::Set(), TParse::SetNoWild() 

or RFs::Parse(), not to the resulting fully parsed file specification.

This function returns true even if the extension contains only wildcards. 

It only returns false if nothing is specified.