// 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.

 @return True if an extension present, false if not.

 */

 	{

 	return(iField[EExt].present);

 	}

 EXPORT_C TBool TParseBase::NameOrExtPresent() const

 /**

 Tests whether a filename or an extension are 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 or extension specified in 

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

 @return True if either a name or an extension or both are present,

         otherwise false.

 */

 	{

 	return(iField[EName].present || iField[EExt].present);

 	}

 EXPORT_C TBool TParseBase::IsRoot() const

 /**

 Tests whether the path in the fully parsed specification is the root directory.

 @return True if path is root, false if not.

 */

 	{

 	return(iWild&EIsRoot);

 	}

 EXPORT_C TBool TParseBase::IsWild() const

 /**

 Tests whether the filename or the extension in the fully parsed specification 

 contains one or more wildcard characters.

 @return True if wildcards are present, false if not.

 */

 	{

 	return(iWild&EWildEither);	

 	}

 EXPORT_C TBool TParseBase::IsKMatchOne() const

 /**

 Tests whether the name or the extension contains a question mark wildcard.

 @return True if either the name or extension has a ? wild card,

         false otherwise.

 */

 	{

 	return(iWild&EWildIsKMatchOne);	

 	}

 EXPORT_C TBool TParseBase::IsKMatchAny() const

 /**

 Tests whether the name or the extension contains asterisk wildcards.

 @return True if either the name or extension has a * wild card,

         false otherwise.

 */

 	{

 	return(iWild&EWildIsKMatchAny);	

 	}

 EXPORT_C TBool TParseBase::IsNameWild() const

 /**

 Tests whether the filename in the fully parsed specification contains one or 

 more wildcard characters.

 @return True if the filename contains wildcard characters, false if not.

 */

 	{

 	return(iWild&EWildName);

 	}

 EXPORT_C TBool TParseBase::IsExtWild() const

 /**

 Tests whether the extension in the fully parsed specification contains one 

 or more wildcard characters.

 @return True if the extension contains wildcard characters, false if not.

 */

 	{

 	return(iWild&EWildExt);

 	}

 EXPORT_C TParse::TParse()

 /**

 Default constructor.

 */

 	{

 	iMod=1;

 	}

 EXPORT_C TInt TParse::Set(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault)

 /**

 Parses a file specification, allowing wildcards in the filename and extension.

 This function sets up the TParse object so that it can be used to provide 

 useful information.

 @param aName    The file specification to be parsed.

 @param aRelated The related file specification. This is optional,

                 set to NULL to  omit.

 @param aDefault The default file specification. This is optional,

                 set to NULL to omit.

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

         codes.

 */

 	{

 	return(TParseBase::Set(&aName,aRelated,aDefault,ETrue));

 	}

 EXPORT_C TInt TParse::SetNoWild(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault)

 /**

 Parses a file specification; disallows wildcards in any part of the file name 

 or extension.

 If you need to specify wildcards use Set(). Otherwise, this 

 function behaves in the same way as Set().

 @param aName    The file specification to be parsed.

 @param aRelated The related file specification. This is optional,

                 set to NULL to omit.

 @param aDefault The default file specification. This is optional,

                 set to NULL to omit.

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

         codes.

 @see TParse::Set

 */

 	{

 	return(TParseBase::Set(&aName,aRelated,aDefault,EFalse));

 	}

 EXPORT_C TDes& TParse::NameBuf()

 /**

 Gets a reference to the descriptor containing the file specification passed to

 the constructor of this object. 

 @return A reference to the descriptor containing the filename.

 */

 	{

 	return(iNameBuf);

 	}

 EXPORT_C const TDesC& TParse::NameBufC() const

 /**

 Gets a const reference to the descriptor containing the file specification

 passed to the constructor of this object. 

 @return A const reference to the descriptor containing the file specification.

 */

 	{

 	return(iNameBuf);

 	}

 EXPORT_C TParsePtr::TParsePtr(TDes& aName)

 	: iNameBuf((TText*)aName.Ptr(),aName.Length(),aName.MaxLength())

 /**

 Constructor taking a reference to a filename.

 The specified filename is parsed and if this fails, a panic is raised.

 @param aName Reference to the filename to be parsed. On return contains

              the fully parsed path specification. If a filename and extension

              are specified, they may both contain wildcards.

              The maximum length is KMaxFileName characters.

 @panic FSCLIENT 24 if the the specified name fails to parse.

 @see KMaxFileName

 */

 	{

 	iMod=1;

 	TInt r=TParseBase::Set(&aName,NULL,NULL,ETrue);

 	__ASSERT_ALWAYS(r==KErrNone,Panic(EParsePtrBadDescriptor0));

 	}

 EXPORT_C TDes& TParsePtr::NameBuf()

 /**

 Gets a reference to the descriptor containing the filename passed to

 the constructor of this object. 

 @return A reference to the descriptor containing the filename.

 */

 	{

 	return(iNameBuf);

 	}

 EXPORT_C const TDesC& TParsePtr::NameBufC() const

 /**

 Gets a const reference to the descriptor containing the filename passed to

 the constructor of this object. 

 @return A const reference to the descriptor containing the filename.

 */

 	{

 	return(iNameBuf);

 	}

 EXPORT_C TParsePtrC::TParsePtrC(const TDesC& aName)

 /**

 Constructor taking a constant reference to a filename.

 The filename is parsed and if this fails, a panic is raised.

 Note that the filename cannot be modified using this class.

 @param aName Constant reference to the filename to be parsed.

              On return contains the fully parsed filename.

              If a file and extension are specified, they may both

              contain wildcards.

              The maximum length is KMaxFileName characters.

 @panic FSCLIENT 24 if the the specified name fails to parse.

 @see KMaxFileName

 */

 	{

 	iMod=0;

 	iNameBuf.Set(aName);

 	TInt r = TParseBase::Set(&aName,NULL,NULL,ETrue);

 	__ASSERT_ALWAYS(r==KErrNone,Panic(EParsePtrBadDescriptor0));

 	}

 EXPORT_C TDes& TParsePtrC::NameBuf()

 /**

 Gets a reference to the descriptor containing the filename passed to

 the constructor of this object. 

 @return A reference to the descriptor containing the filename.

 */

 	{

 	Panic(EParsePtrCAccessError);

 	return(*(TDes*)&iNameBuf);

 	}

 EXPORT_C const TDesC& TParsePtrC::NameBufC() const

 /**

 Gets a const reference to the descriptor containing the filename passed to

 the constructor of this object. 

 @return A const reference to the descriptor containing the filename.

 */

 	{

 	return(iNameBuf);

 	}