// f32\sfat32\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(!IsSequentialMode() && 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);

    }