// f32\sfat\sl_file.cpp

	{

	__PRINT1(_L("CFatFileCB created 0x%x"),this);

	}

	{

	__PRINT1(_L("~CFatFileCB deleted 0x%x"),this);

	        }

	}

	{

	iSeekIndex = new TUint32[KSeekIndexSize];

	if (iSeekIndex == NULL)

		return;

	Mem::FillZ(iSeekIndex, sizeof(TUint32) * KSeekIndexSize);

	iSeekIndexSize=CalcSeekIndexSize(FCB_FileSize());

	}

	{

	TInt clusterOffset=aClusterOffset;

	TInt seekPos=(aNewRelCluster>>iSeekIndexSize)-1;

	__ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

	while(seekPos>=0 && iSeekIndex[seekPos]==0 && clusterOffset!=0)

		{

		seekPos--;

		clusterOffset--;

		}

	if (clusterOffset==0) // Counted back to the current cluster

		return(aClusterOffset);

	if (seekPos<0)

		{

		iCurrentPos.iCluster=FCB_StartCluster();

		return(aNewRelCluster);

		}

	iCurrentPos.iCluster=iSeekIndex[seekPos];

	return(aNewRelCluster-((seekPos+1)<<iSeekIndexSize));

	}

	{

	TInt seekPos=(aRelCluster>>iSeekIndexSize)-1;

	__ASSERT_DEBUG(seekPos<KSeekIndexSize,Fault(EFatFileSeekIndexTooSmall));

	__ASSERT_DEBUG(seekPos>=0,Fault(EFatFileSeekIndexTooSmall2));

	iSeekIndex[seekPos] = aStoredCluster;

	}

	{

	__PRINT1(_L("CFatFileCB::CheckPosL(%d)"), aPos);

	if (aPos==iCurrentPos.iPos)

		return;

	TUint newRelCluster=aPos>>ClusterSizeLog2();

	if ( aPos && (aPos==(newRelCluster<<ClusterSizeLog2())) )

		newRelCluster--;

	TUint oldRelCluster=iCurrentPos.iPos>>ClusterSizeLog2();

	if ( iCurrentPos.iPos && (iCurrentPos.iPos==(oldRelCluster<<ClusterSizeLog2())) )

		oldRelCluster--;	

	TInt clusterOffset=newRelCluster-oldRelCluster;

	TUint32 oldCluster=iCurrentPos.iCluster;

	iCurrentPos.iPos=aPos;

	if (clusterOffset==0)

		return;

	TInt seekOffset=clusterOffset;

	if (iSeekIndex!=NULL)

		{ // Can alter iCurrentPos.iCluster

		seekOffset=SeekToPosition(newRelCluster,seekOffset);

		if (seekOffset==0)

			return;

		}

	if (clusterOffset==-1 && seekOffset!=1)

		{ // Check previous cluster

		TUint32 cluster=oldCluster-1;

		if (FAT().GetNextClusterL(cluster) && cluster==oldCluster)

			{

			return;

			}

		}

	if (seekOffset<0)

		{

		seekOffset=newRelCluster;

		iCurrentPos.iCluster=FCB_StartCluster();

		}

	while (seekOffset--)

		{

		if (iSeekIndex!=NULL && cluster && (cluster>>iSeekIndexSize)<<iSeekIndexSize==cluster)

			SetSeekIndexValueL(cluster,iCurrentPos.iCluster);

		}

	}

	{

	__PRINT1(_L("CFatFileCB::SetupL[0x%x]"), this);

	iCurrentPos.iCluster= FatMount().StartCluster(aFatDirEntry);

	iCurrentPos.iPos=0;

	SetModified(aFatDirEntry.Time(FatMount().TimeOffset()));

	iFileDosEntryPos = aFileDosEntryPos;

	}

	{

	__PRINT3(_L("CFatFileCB::ReadL[0x%x] pos=%LU len=%d"), this, aPos, aLength);

	CheckPosL(I64LOW(aPos));

	const TUint startPos = iCurrentPos.iPos;

	const TUint curSize  = FCB_FileSize();

	const TUint length   = (TUint)aLength;

	if((startPos + length > curSize) || (startPos > startPos + length) )

		aLength=curSize-startPos;

	{

	ReadL(TInt64(aFilePos),aLength,(TDes8*) aTrg,aMessage, 0);

	}

	{

	__PRINT3(_L("CFatFileCB::WriteL[0x%x] pos=%LU len=%d"), this, aPos, aLength);

	// FAT supports 32 bits only for file size

   	TUint64 endPos = aPos + aLength;

   	if(endPos > KMaxSupportedFatFileSize)

   		User::Leave(KErrNotSupported);

  	CheckPosL(pos);

	const TUint startCluster = FCB_StartCluster();

	const TUint length       = (TUint)aLength;

	endPos = iCurrentPos.iPos + length; 

	if ((endPos           > FCB_FileSize()) ||

	    (iCurrentPos.iPos > endPos)         ) // Overflow condition 

		DoSetSizeL(iCurrentPos.iPos+length,EFalse);

	TUint startPos=iCurrentPos.iPos;

	TUint badcluster=0;

	TUint goodcluster=0;

	if (ret == KErrCorrupt || ret == KErrDied)

		{

			{ //Empty File, revert all the clusters allocated.

			const TUint32 cluster = FCB_StartCluster();

			FCB_SetStartCluster(0);

			FCB_SetFileSize(0);

			IndicateFileSizeModified(ETrue);

			FlushAllL();

			iCurrentPos.iCluster = 0;

			iCurrentPos.iPos = 0;

			FAT().FreeClusterListL(cluster);

			FAT().FlushL();

			}

		else

			{ //Calculate the clusters required based on file size, revert extra clusters if allocated.

			const TUint curSize = FCB_FileSize();

			TUint ClustersNeeded = curSize >> ClusterSizeLog2();

			if(curSize > (ClustersNeeded << ClusterSizeLog2()))

				{

				ClustersNeeded++;

				}

			TUint32 cluster = FCB_StartCluster();

			while(--ClustersNeeded)

				{

				FAT().GetNextClusterL(cluster);

				}

			iCurrentPos.iCluster = cluster;

			if (FAT().GetNextClusterL(cluster))

				{

				FAT().FreeClusterListL(cluster);

				}

			FAT().WriteFatEntryEofL(iCurrentPos.iCluster);

			FAT().FlushL();

			}

		}

	User::LeaveIfError(ret);

	if(badcluster != 0)

		{

		if(FCB_StartCluster() == badcluster)

			{

			FlushStartClusterL();

			}

		else

			{

			TUint32 aCluster = FCB_StartCluster();

			do

				{

					{

					FAT().WriteL(aCluster, goodcluster);

					FAT().FlushL();

					break;

					}

				}

			while(FAT().GetNextClusterL(aCluster));

			}

		}

	aLength=iCurrentPos.iPos-startPos;

	if(FatMount().IsRuggedFSys() && pos+(TUint)aLength > FCB_FileSize())

		{

		WriteFileSizeL(pos+aLength);

		}

	}

	{

	WriteL(TInt64(aFilePos),aLength,(TDesC8*) aSrc,aMessage, 0);

	}

	{

	TInt maxNewIndex=aNewSize>>(ClusterSizeLog2()+aNewMult);

	TInt    index=0;

	TInt	indexEnd=KSeekIndexSize;

	TInt	newValEnd=maxNewIndex;

	if (iSeekIndexSize<aNewMult)

		{

		TInt newVal=index;

		TInt step=1<<(aNewMult-iSeekIndexSize);

		index+=step-1;

		while(index<indexEnd && newVal<newValEnd)

			{

			iSeekIndex[newVal] =  iSeekIndex[index];

			newVal++;

			index+=step;

			}

		while(newVal<indexEnd)

			iSeekIndex[newVal++] =  0;

		}

	else

		{

		TInt diffSize = iSeekIndexSize-aNewMult;

		TInt oldVal=(KSeekIndexSize>>diffSize) - 1;

		TInt newVal=indexEnd-1;

		TInt skip=(1<<diffSize)-1;

		if ((iSeekIndexSize - aNewMult) > KSeekIndexSizeLog2)

			{

			}

		else

			{

			while(newVal>=index)

				{

				iSeekIndex[newVal--] =  iSeekIndex[oldVal--];

				for(TInt i=skip;i>0;i--)

					{	

					iSeekIndex[newVal--] = 0;

					}

				}

			}

		}

	iSeekIndexSize=aNewMult;

	}

	{

	if (!iSeekIndex)

	    return;

    	{

    	//-- zero fill all the array

		return;

    	}

	// Files that fill up a cluster exactly do not have a trailing empty

	// cluster. So the entry for that position must also be invalidated

	aNewSize--;

	TInt firstInvalidIndex=aNewSize>>(iSeekIndexSize+ClusterSizeLog2());

	TInt indexLen=KSeekIndexSize-firstInvalidIndex;

	Mem::FillZ(iSeekIndex+firstInvalidIndex, indexLen * sizeof(TUint32));

	}

	{

	TInt count = 0;

	const TUint indexSize=KSeekIndexSize<<ClusterSizeLog2();//KSeekIndexSize=128

	if (aSize<=indexSize)

	  return(count);

	while((aSize>>=1)>0)

		{

		count++;

		}

	return (count - (KSeekIndexSizeLog2 + ClusterSizeLog2()) + 1);

	}

	{

	__PRINT2(_L("CFatFileCB::SetSizeL[0x%x] sz=%LU"), this, aSize);

	//-- max. file size for FAT is 4GB-1

	if (I64HIGH(aSize))

		User::Leave(KErrNotSupported);

	}