FCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfat/fat

equal deleted inserted replaced

-:a41df078684a
+:4122176ea935
 /**
 @file
 @internalTechnology
 */
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//!!
+//!! WARNING!! DO NOT edit this file !! '\sfat' component is obsolete and is not being used. '\sfat32'replaces it
+//!!
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 #include "sl_std.h"
 #include "sl_fatcache.h"
 #include "fat_table.h"
 @param aLocDrvCaps local drive attributes
 @leave KErrNoMemory
 @return Pointer to the Fat table
 */
 CFatTable* CFatTable::NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps)
-	{
+{
 CFatTable* pFatTable=NULL;
 switch(aLocDrvCaps.iType)
 {
 case EMediaRam:
-		    {//-- this is RAM media, try to create CRamFatTable instance.
+{//-- this is RAM media, try to create CRamFatTable instance.
 const TFatType fatType = aOwner.FatType();
 if(fatType != EFat16 )
 {//-- CRamFatTable doesn't support FAT12; FAT16 only.
 __PRINT1(_L("CFatTable::NewL() CRamFatTable doesn't support this FAT type:%d"), fatType);
 }
 break;
 default:
 //-- other media
-		    pFatTable = CAtaFatTable::NewL(aOwner);
+pFatTable = CAtaFatTable::NewL(aOwner);
 break;
 };
-	return pFatTable;
+return pFatTable;
-	}
+}
 CFatTable::CFatTable(CFatMountCB& aOwner)
 {
 iOwner = &aOwner;
 ASSERT(iOwner);
 /**
 Initialise the object, get data from the owning CFatMountCB
 */
 void CFatTable::InitializeL()
-	{
+{
-	ASSERT(iOwner);
+ASSERT(iOwner);
 //-- get FAT type from the owner
 iFatType = iOwner->FatType();
 ASSERT(IsFat12() || IsFat16());
 iFreeClusterHint = KFatFirstSearchCluster;
 //-- cache the media attributes
-	TLocalDriveCapsV2 caps;
+TLocalDriveCapsV2 caps;
-	TPckg<TLocalDriveCapsV2> capsPckg(caps);
+TPckg<TLocalDriveCapsV2> capsPckg(caps);
 User::LeaveIfError(iOwner->LocalDrive()->Caps(capsPckg));
-	iMediaAtt = caps.iMediaAtt;
+iMediaAtt = caps.iMediaAtt;
 //-- obtain maximal number of entries in the table
 iMaxEntries = iOwner->UsableClusters()+KFatFirstSearchCluster; //-- FAT[0] & FAT[1] are not in use
 __PRINT3(_L("CFatTable::InitializeL(), drv:%d, iMediaAtt = %08X, max Entries:%d"), iOwner->DriveNumber(), iMediaAtt, iMaxEntries);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Decrements the free cluster count.
 @param  aCount a number of clusters
 */
 void CFatTable::IncrementFreeClusterCount(TUint32 aCount)
 {
-	const TUint32 newVal = iFreeClusters+aCount;
+const TUint32 newVal = iFreeClusters+aCount;
 __ASSERT_DEBUG(newVal<=MaxEntries(), Fault(EFatCorrupt));
 iFreeClusters = newVal;
 }
 TTime   timeStart;
 TTime   timeEnd;
 timeStart.UniversalTime(); //-- take start time
 //-- walk through whole FAT table looking for free clusters
-	for(TUint i=KFatFirstSearchCluster; i<MaxEntries(); ++i)
+for(TUint i=KFatFirstSearchCluster; i<MaxEntries(); ++i)
 {
-	    if(ReadL(i) == KSpareCluster)
+if(ReadL(i) == KSpareCluster)
 {//-- found a free cluster
-		    ++freeClusters;
+++freeClusters;
 if(!firstFreeCluster)
 firstFreeCluster = i;
 }
-	}
+}
 timeEnd.UniversalTime(); //-- take end time
 const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);
 __PRINT1(_L("#- CFatTable::CountFreeClustersL() finished. Taken:%d ms"), msScanTime);
 (void)msScanTime;
 @param aMaxCount Maximum cluster required
 @leave System wide error values
 @return Number of contiguous clusters from aStartCluster.
 */
 TInt CFatTable::CountContiguousClustersL(TUint32 aStartCluster,TInt& anEndCluster,TUint32 aMaxCount) const
-	{
+{
-	__PRINT2(_L("CFatTable::CountContiguousClustersL() start:%d, max:%d"),aStartCluster, aMaxCount);
+__PRINT2(_L("CFatTable::CountContiguousClustersL() start:%d, max:%d"),aStartCluster, aMaxCount);
-	TUint32 clusterListLen=1;
+TUint32 clusterListLen=1;
-	TInt endCluster=aStartCluster;
+TInt endCluster=aStartCluster;
-	TInt64 endClusterPos=DataPositionInBytes(endCluster);
+TInt64 endClusterPos=DataPositionInBytes(endCluster);
-	while (clusterListLen<aMaxCount)
+while (clusterListLen<aMaxCount)
-		{
+{
-		TInt oldCluster=endCluster;
+TInt oldCluster=endCluster;
-		TInt64 oldClusterPos=endClusterPos;
+TInt64 oldClusterPos=endClusterPos;
-		if (GetNextClusterL(endCluster)==EFalse || (endClusterPos=DataPositionInBytes(endCluster))!=(oldClusterPos+(1<<iOwner->ClusterSizeLog2())))
+if (GetNextClusterL(endCluster)==EFalse || (endClusterPos=DataPositionInBytes(endCluster))!=(oldClusterPos+(1<<iOwner->ClusterSizeLog2())))
-			{
+{
-			endCluster=oldCluster;
+endCluster=oldCluster;
-			break;
+break;
-			}
+}
-		clusterListLen++;
+clusterListLen++;
-		}
+}
-	anEndCluster=endCluster;
+anEndCluster=endCluster;
-	return(clusterListLen);
+return(clusterListLen);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Extend a file or directory cluster chain, leaves if there are no free clusters (the disk is full).
 @param aCluster FAT entry index to start with.
 @leave KErrDiskFull + system wide error codes
 */
 void CFatTable::ExtendClusterListL(TUint32 aNumber,TInt& aCluster)
-	{
+{
-	__PRINT2(_L("CFatTable::ExtendClusterListL() num:%d, clust:%d"), aNumber, aCluster);
+__PRINT2(_L("CFatTable::ExtendClusterListL() num:%d, clust:%d"), aNumber, aCluster);
-	__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
+__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
-	while(aNumber && GetNextClusterL(aCluster))
+while(aNumber && GetNextClusterL(aCluster))
-		aNumber--;
+aNumber--;
 if(!aNumber)
 return;
-	if (iFreeClusters<aNumber)
+if (iFreeClusters<aNumber)
-		{
+{
-		__PRINT(_L("CFatTable::ExtendClusterListL - leaving KErrDirFull"));
+__PRINT(_L("CFatTable::ExtendClusterListL - leaving KErrDirFull"));
-		User::Leave(KErrDiskFull);
+User::Leave(KErrDiskFull);
-		}
+}
 TUint32 freeCluster = 0;
 //-- note: this can be impoved by trying to fing as long chain of free clusters as possible in FindClosestFreeClusterL()
 for(TUint i=0; i<aNumber; ++i)
-		{
+{
 freeCluster = FindClosestFreeClusterL(aCluster);
-		WriteFatEntryEofL(freeCluster); //	Must write EOF for FindClosestFreeCluster to work again
+WriteFatEntryEofL(freeCluster); //  Must write EOF for FindClosestFreeCluster to work again
-		WriteL(aCluster,freeCluster);
+WriteL(aCluster,freeCluster);
-		aCluster=freeCluster;
+aCluster=freeCluster;
-		}
+}
 //-- decrement number of available clusters
 DecrementFreeClusterCount(aNumber);
 //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from
 SetFreeClusterHint(aCluster);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Allocate and mark as EOF a single cluster as close as possible to aNearestCluster
 @param aNearestCluster Cluster the new cluster should be nearest to
 @leave System wide error codes
 @return The cluster number allocated
 */
 TUint32 CFatTable::AllocateSingleClusterL(TUint32 aNearestCluster)
-	{
+{
-	__PRINT1(_L("CFatTable::AllocateSingleCluster() nearest:%d"), aNearestCluster);
+__PRINT1(_L("CFatTable::AllocateSingleCluster() nearest:%d"), aNearestCluster);
-	if (iFreeClusters==0)
+if (iFreeClusters==0)
-		User::Leave(KErrDiskFull);
+User::Leave(KErrDiskFull);
-	const TInt freeCluster=FindClosestFreeClusterL(aNearestCluster);
+const TInt freeCluster=FindClosestFreeClusterL(aNearestCluster);
-	WriteFatEntryEofL(freeCluster);
+WriteFatEntryEofL(freeCluster);
-	DecrementFreeClusterCount(1);
+DecrementFreeClusterCount(1);
 //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from.
 SetFreeClusterHint(freeCluster);
-	return(freeCluster);
+return(freeCluster);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Allocate and link a cluster chain, leaves if there are not enough free clusters.
 @param aNearestCluster Cluster the new chain should be nearest to
 @leave System wide error codes
 @return The first cluster number allocated
 */
 TUint32 CFatTable::AllocateClusterListL(TUint32 aNumber, TUint32 aNearestCluster)
-	{
+{
 __PRINT2(_L("#>> CFatTable::AllocateClusterList() N:%d,NearestCL:%d"),aNumber,aNearestCluster);
-	__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
+__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));
-	if (iFreeClusters<aNumber)
+if (iFreeClusters<aNumber)
-		{
+{
-		__PRINT(_L("CFatTable::AllocateClusterListL - leaving KErrDirFull"));
+__PRINT(_L("CFatTable::AllocateClusterListL - leaving KErrDirFull"));
-		User::Leave(KErrDiskFull);
+User::Leave(KErrDiskFull);
-		}
+}
 TInt firstCluster = aNearestCluster = AllocateSingleClusterL(aNearestCluster);
-	if (aNumber>1)
+if (aNumber>1)
-		ExtendClusterListL(aNumber-1, (TInt&)aNearestCluster);
+ExtendClusterListL(aNumber-1, (TInt&)aNearestCluster);
-	return(firstCluster);
+return(firstCluster);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Notify the media drive about media areas that shall be treated as "deleted" if this feature is supported.
 FlushL(); //-- Commit the FAT changes to disk first to be safe
 const TUint bytesPerCluster = 1 << iOwner->ClusterSizeLog2();
 TInt64  byteAddress = 0;
-	TUint   deleteLen = 0;	// zero indicates no clusters accumulated yet
+TUint   deleteLen = 0;  // zero indicates no clusters accumulated yet
-	for (TUint i=0; i<clusterCount; ++i)
+for (TUint i=0; i<clusterCount; ++i)
-	{
+{
 const TUint currCluster = aFreedClusters[i];
 if (deleteLen == 0)
-		    byteAddress = DataPositionInBytes(currCluster); //-- start of the media range
+byteAddress = DataPositionInBytes(currCluster); //-- start of the media range
 deleteLen += bytesPerCluster;
 //-- if this is the last entry in the array or the net cluster number is not consecutive, notify the driver
-		if ((i+1) == clusterCount || aFreedClusters[i+1] != (currCluster+1))
+if ((i+1) == clusterCount || aFreedClusters[i+1] != (currCluster+1))
 {
 //__PRINT3(_L("DeleteNotify(%08X:%08X, %u), first cluster %u last cluster #%u"), I64HIGH(byteAddress), I64LOW(byteAddress), deleteLen);
-			//__PRINT2(_L("   first cluster %u last cluster #%u"), I64LOW((byteAddress - iOwner->ClusterBasePosition()) >> iOwner->ClusterSizeLog2()) + 2, cluster);
+//__PRINT2(_L("   first cluster %u last cluster #%u"), I64LOW((byteAddress - iOwner->ClusterBasePosition()) >> iOwner->ClusterSizeLog2()) + 2, cluster);
 const TInt r = iOwner->LocalDrive()->DeleteNotify(byteAddress, deleteLen);
-			if(r != KErrNone)
+if(r != KErrNone)
 {//-- if DeleteNotify() failed, it means that something terribly wrong happened to the NAND media;
 //-- in normal circumstances it can not happen. One of the reasons: totally worn out media.
 const TBool platSecEnabled = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement);
 __PRINT3(_L("CFatTable::DoFreedClustersNotify() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);
 {
 //-- if PlatSec is disabled, it's OK to ignore the NAND fault in release mode.
 __ASSERT_DEBUG(0, Fault(EFatBadLocalDrive));
 }
 }
 deleteLen = 0;
 }
 }
 @param aCluster Start cluster of cluster chain to free
 @leave System wide error codes
 */
 void CFatTable::FreeClusterListL(TUint32 aCluster)
-	{
+{
-	__PRINT1(_L("CFatTable::FreeClusterListL startCluster=%d"),aCluster);
+__PRINT1(_L("CFatTable::FreeClusterListL startCluster=%d"),aCluster);
-	if (aCluster == KSpareCluster)
+if (aCluster == KSpareCluster)
-		return;
+return;
-	//-- here we can store array of freed cluster numbers in order to
+//-- here we can store array of freed cluster numbers in order to
 //-- notify media drive about the media addresses marked as "invalid"
 RClusterArray deletedClusters;
-	CleanupClosePushL(deletedClusters);
+CleanupClosePushL(deletedClusters);
 //-- if ETrue, we need to notify media driver about invalidated media addressses
 const TBool bFreeClustersNotify = iMediaAtt & KMediaAttDeleteNotify;
 //-- this is a maximal number of FAT entries in the deletedClusters array.
 TUint32 currCluster = aCluster;
 TInt    nextCluster = aCluster;
 for(;;)
-		{
+{
 const TBool bEOF = !GetNextClusterL(nextCluster);
 WriteL(currCluster, KSpareCluster);
 lastKnownFreeCluster = Min(currCluster, lastKnownFreeCluster);
-		// Keep a record of the deleted clusters so that we can subsequently notify the media driver. This is only safe
+// Keep a record of the deleted clusters so that we can subsequently notify the media driver. This is only safe
-		// to do once the FAT changes have been written to disk.
+// to do once the FAT changes have been written to disk.
 if(bFreeClustersNotify)
 deletedClusters.Append(currCluster);
 ++cntFreedClusters;
 currCluster = nextCluster;
-		if (bEOF || aCluster == KSpareCluster)
+if (bEOF || aCluster == KSpareCluster)
-			break;
+break;
 if(bFreeClustersNotify && cntFreedClusters && (cntFreedClusters & (KSubListLen-1))==0)
 {//-- reached a limit of the entries in the array. Flush FAT cache, notify the driver and empty the array.
 IncrementFreeClusterCount(cntFreedClusters);
 cntFreedClusters = 0;
 SetFreeClusterHint(lastKnownFreeCluster);
 if(bFreeClustersNotify)
 DoFreedClustersNotify(deletedClusters);
-	CleanupStack::PopAndDestroy(&deletedClusters);
+CleanupStack::PopAndDestroy(&deletedClusters);
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Find a free cluster nearest to aCluster, Always checks to the right of aCluster first
 @param aCluster Cluster to find nearest free cluster to.
 @leave KErrDiskFull + system wide error codes
 @return cluster number found
 */
 TUint32 CFatTable::FindClosestFreeClusterL(TUint32 aCluster)
-	{
+{
 __PRINT2(_L("CFatTable::FindClosestFreeClusterL() drv:%d cl:%d"),iOwner->DriveNumber(),aCluster);
 if(!ClusterNumberValid(aCluster))
 {
 ASSERT(0);
 User::Leave(KErrCorrupt);
 }
 if(iFreeClusters==0)
-	    {//-- there is no at least 1 free cluster available
+{//-- there is no at least 1 free cluster available
-	__PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #1"));
+__PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #1"));
-		User::Leave(KErrDiskFull);
+User::Leave(KErrDiskFull);
 }
 //-- 1. look if the given index contains a free entry
 if(ReadL(aCluster) != KSpareCluster)
 {//-- no, it doesn't...
 //-- 2. look in both directions starting from the aCluster, looking in the right direction first
 else
 canGoLeft = EFalse;
 }
 if(!canGoRight && !canGoLeft)
-	        {
+{
-	    __PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #2"));
+__PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #2"));
 User::Leave(KErrDiskFull);
 }
 if (canGoRight && ReadL(rightIdx) == KSpareCluster)
-			{
+{
-			aCluster = rightIdx;
+aCluster = rightIdx;
-			break;
+break;
-			}
+}
-		if (canGoLeft && ReadL(leftIdx) == KSpareCluster)
+if (canGoLeft && ReadL(leftIdx) == KSpareCluster)
-			{
+{
-			aCluster = leftIdx;
+aCluster = leftIdx;
-			break;
+break;
-			}
+}
 }//for(..)
 }//if(ReadL(aCluster) != KSpareCluster)
 //-- the last known free cluster in the caller of this internal method.
 //    __PRINT1(_L("CFatTable::FindClosestFreeClusterL found:%d"),aCluster);
 return aCluster;
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Converts a cluster number to byte offset in the FAT
 @param aFatIndex Cluster number
 @return Number of bytes from the beginning of the FAT
 */
 TUint32 CFatTable::PosInBytes(TUint32 aFatIndex) const
-	{
+{
 switch(FatType())
 {
 case EFat12:
 return (((aFatIndex>>1)<<1) + (aFatIndex>>1)); //-- 1.5 bytes per FAT entry
 default:
 ASSERT(0);
 return 0;//-- get rid of warning
 };
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Checks if we have at least aClustersRequired clusters free in the FAT.
 /**
 Constructor
 */
 CAtaFatTable::CAtaFatTable(CFatMountCB& aOwner)
 :CFatTable(aOwner)
-	{
+{
-	}
+}
 /** factory method */
 CAtaFatTable* CAtaFatTable::NewL(CFatMountCB& aOwner)
 {
 void CAtaFatTable::CreateCacheL()
 {
 ASSERT(iOwner);
 const TUint32 fatSize=iOwner->FatSizeInBytes();
 __PRINT3(_L("CAtaFatTable::CreateCacheL drv:%d, FAT:%d, FAT Size:%d"), iOwner->DriveNumber(), FatType(), fatSize);
 //-- according to FAT specs:
 //-- FAT12 max size is 4084 entries or 6126 bytes                                               => create fixed cache for whole FAT
 //-- FAT16 min size is 4085 entries or 8170 bytes, max size is 65525 entries or 131048 bytes    => create fixed cache for whole FAT
 }
 break;
 default:
 ASSERT(0);
-		User::Leave(KErrCorrupt);
+User::Leave(KErrCorrupt);
 break;
 };
 ASSERT(iCache);
 }
 /**
 Flush the FAT cache on disk
 @leave System wide error codes
 */
 void CAtaFatTable::FlushL()
-	{
+{
 //-- the data can't be written if the mount is inconsistent
 iOwner->CheckStateConsistentL();
-	if (iCache)
+if (iCache)
-		iCache->FlushL();
+iCache->FlushL();
-	}
+}
 /**
 Clear any cached data
 @param aDiscardDirtyData if ETrue, non-flushed data in the cache will be discarded.
 */
 void CAtaFatTable::Dismount(TBool aDiscardDirtyData)
-	{
+{
-	if (iCache)
+if (iCache)
-		{
+{
 //-- cache's Close() can check if the cache is clean.
 //-- ignore dirty data in cache if the mount is not in consistent state (it's impossible to flush cache data)
 //-- or if we are asked to do so.
 const TBool bIgnoreDirtyData = aDiscardDirtyData || !iOwner->ConsistentState();
 iCache->Close(bIgnoreDirtyData);
-		delete iCache;
+delete iCache;
-		iCache=NULL;
+iCache=NULL;
-		}
+}
-	}
+}
 //---------------------------------------------------------------------------------------------------------------------------------------
 /**
 Invalidate whole FAT cache.
 @param aPos absolute media position where the region being invalidated starts.
 @param aLength length in bytes of region to invalidate / refresh
 */
 void CAtaFatTable::InvalidateCacheL(TInt64 aPos, TUint32 aLength)
-	{
+{
 __PRINT3(_L("CAtaFatTable::InvalidateCacheL() drv:%d, pos:%LU, len:%u,"), iOwner->DriveNumber(), aPos, aLength);
 if(I64HIGH(aPos) || !aLength || I64HIGH(aPos+aLength))
 return; //-- FAT tables can't span over 4G
 startFatEntry += KFatFirstSearchCluster;
 numEntries -= KFatFirstSearchCluster;
 }
 User::LeaveIfError(iCache->InvalidateRegion(startFatEntry, numEntries));
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Initialize the object, create FAT cache if required
 @leave KErrNoMemory
 */
 void CAtaFatTable::InitializeL()
-	{
+{
 __PRINT1(_L("CAtaFatTable::InitializeL() drv:%d"), iOwner->DriveNumber());
 CFatTable::InitializeL();
 //-- create the FAT cache.
 ASSERT(!iCache);
 CreateCacheL();
-	}
+}
 //-----------------------------------------------------------------------------
 /**
 Remount the FAT table. This method call means that the media parameters wasn't changed,
 @param aFatIndex FAT entry number to read
 @return FAT entry value
 */
 TUint32 CAtaFatTable::ReadL(TUint32 aFatIndex) const
-	{
+{
 if(!ClusterNumberValid(aFatIndex))
 {
 //ASSERT(0); //-- for some silly reason some callers pass 0 here and expect it to leave
 User::Leave(KErrCorrupt);
 }
 @param aFatIndex    aFatIndex FAT entry number to write
 @param aValue       FAT entry to write
 @leave
 */
 void CAtaFatTable::WriteL(TUint32 aFatIndex, TUint32 aValue)
-	{
+{
 const TUint32 KFat16EntryMask = 0x0FFFF;
 __PRINT2(_L("CAtaFatTable::WriteL() entry:%d, val:0x%x"), aFatIndex, aValue);
 if(!ClusterNumberValid(aFatIndex))
 {
 ASSERT(0);
 User::Leave(KErrCorrupt);
 }
 iCache->WriteEntryL(aFatIndex, aValue);
-	}
+}
 /**
 Get the next cluster in the chain from the FAT
 @leave
 @return False if end of cluster chain
 */
 TBool CFatTable::GetNextClusterL(TInt& aCluster) const
 {
-	__PRINT1(_L("CAtaFatTable::GetNextClusterL(%d)"), aCluster);
+__PRINT1(_L("CAtaFatTable::GetNextClusterL(%d)"), aCluster);
 const TInt nextCluster = ReadL(aCluster);
 TBool ret = EFalse;
 switch(FatType())
 default:
 ASSERT(0);
 return EFalse;//-- get rid of warning
 };
 if (ret)
 {
-		aCluster=nextCluster;
+aCluster=nextCluster;
-	    }
+}
 return ret;
 }
 /**
 Write EOF to aFatIndex
 @param aFatIndex index in FAT (cluster number) to be written
 */
 void CFatTable::WriteFatEntryEofL(TUint32 aFatIndex)
-	{
+{
-	__PRINT1(_L("CAtaFatTable::WriteFatEntryEofL(%d)"), aFatIndex);
+__PRINT1(_L("CAtaFatTable::WriteFatEntryEofL(%d)"), aFatIndex);
 //-- use EOF_16Bit (0x0ffff) for all types of FAT, FAT cache will mask it appropriately
 WriteL(aFatIndex, EOF_16Bit);
-	}
+}
 /**
 Mark cluster number aFatIndex in FAT as bad
 //-- use KBad_16Bit (0x0fff7) for all types of FAT, FAT cache will mask it appropriately
 WriteL(aFatIndex, KBad_16Bit);
 FlushL();
-	}
+}
 /**
 Return the location of a Cluster in the data section of the media
 @param aCluster to find location of
 @return Byte offset of the cluster data
 */
 TInt64 CAtaFatTable::DataPositionInBytes(TUint32 aCluster) const
-	{
+{
 __ASSERT_DEBUG(ClusterNumberValid(aCluster), Fault(EFatTable_InvalidIndex));
 const TInt clusterBasePosition=iOwner->ClusterBasePosition();
-	return(((TInt64(aCluster)-KFatFirstSearchCluster) << iOwner->ClusterSizeLog2()) + clusterBasePosition);
+return(((TInt64(aCluster)-KFatFirstSearchCluster) << iOwner->ClusterSizeLog2()) + clusterBasePosition);
-	}
+}

changeset 15	4122176ea935
parent 0	a41df078684a