diff -r b3cee849fa46 -r fad26422216a launcher/engine/src/e32image.cpp
--- a/launcher/engine/src/e32image.cpp	Tue Aug 31 15:15:20 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,846 +0,0 @@
-/*
-* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of "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:
-*
-*/
-
-
-
-#include "e32image.h"
-#include "e32imageheaders.h"
-#include "launchertraces.h"
-
-
-const TInt KMaxHeaderSize = sizeof(E32ImageHeaderV) + 65536/8;
-
-SCapabilitySet AllCapabilities;
-SCapabilitySet DisabledCapabilities;
-
-// ---------------------------------------------------------------------------
-
-E32ImageReader* E32ImageReader::NewLC()
-    {
-    E32ImageReader* self = new(ELeave) E32ImageReader;
-    CleanupStack::PushL(self);
-    self->ConstructL();
-    return self;
-    }
-
-// ---------------------------------------------------------------------------
-
-E32ImageReader::E32ImageReader()
-    {
-    }
-
-// ---------------------------------------------------------------------------
-
-void E32ImageReader::ConstructL()
-    {
-    LOGSTRING("Launcher: E32ImageReader::ConstructL");
-
-    iEnv = CEikonEnv::Static();
-    }
-
-// ---------------------------------------------------------------------------
-
-CDesCArray* E32ImageReader::ListOfDLLsL(const TDesC& aFullPathToE32Image)
-    {
-    LOGSTRING("Launcher: E32ImageReader::ListOfDLLsL");
-
-    // open the file for reading
-    User::LeaveIfError( iFile.Open(iEnv->FsSession(), aFullPathToE32Image, EFileRead) );
-    CleanupClosePushL(iFile);
-    
-    // get local copies of capability sets
-    TCapabilitySet caps;
-    caps.SetAllSupported();
-    AllCapabilities=*(SCapabilitySet*)∩︀
-    caps.SetDisabled();
-    DisabledCapabilities=*(SCapabilitySet*)∩︀
-
-    // read the header of the image
-    User::LeaveIfError( E32ImageHeader::New(iHeader, iFile) );
-
-    // set stuff
-    iHeapSizeMin = iHeader->iHeapSizeMin;
-    iHeapSizeMax = iHeader->iHeapSizeMax;
-    iStackSize = iHeader->iStackSize;
-    iPriority = iHeader->ProcessPriority();
-    iDepCount = iHeader->iDllRefTableCount;
-    iExportDirCount = iHeader->iExportDirCount;
-    iExportDir = iHeader->iExportDirOffset-iHeader->iCodeOffset;
-    iTextSize = iHeader->iTextSize;
-    iCodeSize = iHeader->iCodeSize;
-    iDataSize = iHeader->iDataSize;
-    iBssSize = iHeader->iBssSize;
-    iTotalDataSize = iDataSize+iBssSize;
-    iFileEntryPoint = iHeader->iEntryPoint;
-    iEntryPtVeneer = 0;
-    iExceptionDescriptor = iHeader->ExceptionDescriptor();
-    if (iHeader->iExportDirOffset)
-        iExportDirLoad=iExportDir;
-    
-    // allocate data for the code area
-    iCodeLoadAddress = (TUint32)User::Alloc(iCodeSize);
-    
-    // load data from the binary
-    User::LeaveIfError( LoadData() );
-
-    // create an array for the dll names from the import list
-    CDesCArray* dllArray = new(ELeave) CDesCArrayFlat(100);
-    CleanupStack::PushL(dllArray);
-
-    // get the dll names from the import section
-    E32ImportSection* importSection = (E32ImportSection *)iImportData;
-    E32ImportBlock* block;
-    if(importSection)
-        block = (E32ImportBlock*)(importSection+1);
-    else
-        block = NULL;
-    iNextImportPos = 0;
-
-    // loop through all import data blocks
-    for (TInt i=0; i<iDepCount; i++)
-        {
-        // get a pointer to the dll name
-        TPtrC8 dllname = (const TText8*)((TUint32)iImportData + block->iOffsetOfDllName);
-        TBuf8<KMaxKernelName> rootname;
-        if (dllname.Length() > KMaxKernelName)
-            User::Leave( KErrNotSupported );
-        
-        // parse the filename
-        TFileNameInfo fni;
-        User::LeaveIfError( fni.Set(dllname, TFileNameInfo::EAllowUid) );
-        fni.GetName(rootname, TFileNameInfo::EIncludeBaseExt);
-
-        // append the name to the dll name array
-        TFileName dllName16;
-        dllName16.Copy(rootname);
-        dllArray->AppendL(dllName16);
-
-        // get the next block
-        TUint impfmt = iHeader->ImportFormat();
-        block = (E32ImportBlock*)block->NextBlock(impfmt);
-        }
-
-    CleanupStack::Pop();  //dllArray
-    CleanupStack::PopAndDestroy(); //iFile
-
-    // free memory
-    delete iHeader;
-    iHeader = NULL;
-    delete iImportSection;
-    iImportSection = NULL;
-    delete iCodeRelocSection;
-    iCodeRelocSection = NULL;
-    delete iDataRelocSection;
-    iDataRelocSection = NULL;
-    
-    User::Free((TAny*)iCodeLoadAddress);
-    User::Free(iRestOfFileData);
-    User::Free(iCurrentImportList);
-    if (iExportDirLoadAllocated)
-        User::Free((TAny*)iExportDirLoad);
-
-    return dllArray;
-    }
-
-// ---------------------------------------------------------------------------
-
-E32ImageReader::~E32ImageReader()
-    {
-    LOGSTRING("Launcher: E32ImageReader::~E32ImageReader");
-    }
-
-
-// ---------------------------------------------------------------------------
-
-TInt FileRead(RFile& aFile, TUint8* aDest, TInt aSize)
-    {
-    TPtr8 p(aDest,aSize,aSize);
-    return aFile.Read(p,aSize);
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageHeader::New(E32ImageHeader*& aHdr, RFile& aFile)
-    {
-    LOGSTRING("Launcher: E32ImageHeader::New");
-
-    E32ImageHeader* h = NULL;
-    TInt hdrsz = 0;
-    TInt filesize;
-    TInt r = aFile.Size(filesize);
-    if (r!=KErrNone)
-        return r;
-    E32ImageHeader bh;
-    r = FileRead(aFile, (TUint8*)&bh, sizeof(E32ImageHeader));
-    if (r==KErrNone)
-        {
-        hdrsz = bh.TotalSize();
-        if ( (TUint(hdrsz) > TUint(KMaxHeaderSize)) || (TUint(hdrsz) < TUint(sizeof(bh))) )
-            return KErrCorrupt;
-        }
-    h = (E32ImageHeader*)User::Alloc(hdrsz);
-    if (!h)
-        return KErrNoMemory;
-    wordmove(h, &bh, sizeof(E32ImageHeader));
-    if (hdrsz > (TInt)sizeof(E32ImageHeader))
-        r = FileRead(aFile, (TUint8*)(h + 1), hdrsz - sizeof(E32ImageHeader));
-    if (r==KErrNone)
-        r = h->IntegrityCheck(filesize);
-    if (r==KErrNone)
-        {
-        if (h->HeaderFormat() >= KImageHdrFmt_V)
-            {
-            // Overide capabilities in image
-            for(TInt i=0; i<SCapabilitySet::ENCapW; i++)
-                {
-                ((E32ImageHeaderV*)h)->iS.iCaps[i] |= DisabledCapabilities[i];
-                ((E32ImageHeaderV*)h)->iS.iCaps[i] &= AllCapabilities[i];
-                }
-            }
-        aHdr = h;
-        }
-    else
-        {
-        delete h;
-        aHdr = NULL;
-        }
-    return r;
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageHeader::IntegrityCheck(TInt aFileSize)
-    {
-    LOGSTRING("Launcher: E32ImageHeader::IntegrityCheck");
-    
-    TInt hdrsz = TotalSize();
-    TUint hdrfmt = HeaderFormat();
-    TUidType uids = *(const TUidType*)&iUid1;
-    E32ImageHeaderV* v = NULL;
-    TCheckedUid chkuid(uids);
-    const TUint32* pChkUid = (const TUint32*)&chkuid;
-
-    if (pChkUid[3] != iUidChecksum)
-        return KErrCorrupt;    
-
-    if (hdrfmt == KImageHdrFmt_V)
-        {
-        TUint32 supplied_crc = iHeaderCrc;
-        iHeaderCrc = KImageCrcInitialiser;
-        TUint32 crc = 0;
-        Mem::Crc32(crc, this, hdrsz);
-        iHeaderCrc = supplied_crc;
-        if (crc != supplied_crc)
-            return KErrCorrupt;    
-        v = (E32ImageHeaderV*)this;
-        TUint total_eds = v->iExportDescSize + sizeof(v->iExportDescSize) + sizeof(v->iExportDescType);
-        total_eds = (total_eds + 3) &~ 3;
-        if (total_eds + (TUint)_FOFF(E32ImageHeaderV, iExportDescSize) != (TUint)hdrsz)
-            return KErrCorrupt;
-        if (TUint(v->iExportDescType) > KImageHdr_ExpD_SparseBitmap8)
-            return KErrNotSupported;
-        }
-    else if (hdrfmt >= KImageHdrFmt_V)
-        return KErrNotSupported; 
-
-    TCpu cpu = CpuIdentifier();
-    TUint abi = ABI();
-    TUint impfmt = ImportFormat();
-    TUint compression = CompressionType();
-
-    TUint uncompressed_size = compression ? UncompressedFileSize() : (TUint)aFileSize;
-
-    if (iSignature != 0x434f5045) // 'EPOC'
-        return KErrCorrupt;
-    if (iCodeSize<0)
-        return KErrCorrupt;
-    if (iDataSize<0)
-        return KErrCorrupt;
-    if (iHeapSizeMin<0)
-        return KErrCorrupt;
-    if (iHeapSizeMax<iHeapSizeMin)
-        return KErrCorrupt;
-    if (iStackSize<0)
-        return KErrCorrupt;
-    if (iBssSize<0)
-        return KErrCorrupt;
-    if (iDllRefTableCount<0)
-        return KErrCorrupt;
-    if (iExportDirOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (TUint(iExportDirCount)>65535)
-        return KErrCorrupt;
-    if (iTextSize<0)
-        return KErrCorrupt;
-    if (iCodeSize<iTextSize)
-        return KErrCorrupt;
-    if (iCodeOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (iDataOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (iImportOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (iCodeRelocOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (iDataRelocOffset >= uncompressed_size)
-        return KErrCorrupt;
-    if (TUint(iCodeSize+iDataSize) > uncompressed_size)
-        return KErrCorrupt;
-
-    if (abi>KImageABI_EABI)
-        return KErrNotSupported;
-    if (impfmt>KImageImpFmt_PE2)
-        return KErrNotSupported;
-    if (iUid1 != (TUint32)KExecutableImageUidValue && iUid1 != (TUint32)KDynamicLibraryUidValue)
-        return KErrNotSupported;
-    TUint32 mv = ModuleVersion();
-    if (mv >= 0x80000000u || (mv & 0x0000ffffu) > 0x8000u)
-        return KErrNotSupported;
-
-    return KErrNone;
-    }
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::LoadData()
-    {
-    LOGSTRING("Launcher: E32ImageReader::LoadData");
-
-    TInt remainder;
-    iFile.Size(remainder);
-    
-    remainder -= iHeader->TotalSize();
-    TUint32 compression = iHeader->CompressionType();
-    if (compression != KMyFormatNotCompressed)
-        {
-        remainder = iHeader->UncompressedFileSize() - iHeader->iCodeOffset;
-        }
-
-    remainder -= iHeader->iCodeSize;
-    
-    if (remainder > 0)
-        {
-        iRestOfFileData = (TUint8*)User::Alloc(remainder);
-        if (iRestOfFileData)
-            iRestOfFileSize=remainder;
-        else
-            return KErrNoMemory;
-        }
-
-    iConversionOffset = iHeader->iCodeOffset + iHeader->iCodeSize;
-
-    TInt r = LoadFile(compression);
-    if (r !=KErrNone)
-        return r;
-
-
-    TUint8* source=NULL;
-    if (iHeader->iImportOffset)
-        {
-        TUint bufferOffset=iHeader->iImportOffset-iConversionOffset;
-        
-        if(bufferOffset>iRestOfFileSize || bufferOffset+sizeof(E32ImportSection)>iRestOfFileSize)
-            return KErrCorrupt;
-        
-        source=iRestOfFileData+bufferOffset;
-        
-        iImportSection = new E32ImportSection;
-        
-        if (iImportSection)
-            Mem::Move((TText8*)iImportSection, source, sizeof(E32ImportSection));
-        else
-            return KErrNoMemory;
-        }
-
-    iCodeDelta = iCodeRunAddress-iHeader->iCodeBase;
-    iDataDelta = iDataRunAddress-iHeader->iDataBase;
-
-    if (r==KErrNone)
-        r = ReadImportData();
-
-    return r;
-    }
-
-// ---------------------------------------------------------------------------
-
-TUint8* E32ImageReader::MemoryMove(TAny* aDestination, const TAny* aSource, TInt aNumberofBytes)
-    {
-    return Mem::Move(aDestination, aSource, aNumberofBytes);
-    }
-
-// ---------------------------------------------------------------------------
-
-GLDEF_C TInt svRelocateExports(TAny* aPtr)
-    {
-    E32ImageReader* pI=(E32ImageReader*)aPtr;
-    TUint32* destExport=(TUint32*)pI->iExportDirLoad;
-    TInt i=pI->iExportDirCount;
-    TUint32 codeBase=pI->iCodeRunAddress;
-    while (i-->0)
-        *destExport+++=codeBase;
-    return 0;
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::LoadFile(TUint32 aCompression)
-    {
-    LOGSTRING("Launcher: E32ImageReader::LoadFile");
-
-    TInt r(KErrNone);
-
-    if (aCompression == KMyFormatNotCompressed)
-        r=LoadFileNoCompress();
-    
-    else if (aCompression == KMyUidCompressionDeflate)
-        {
-        TRAP(r, LoadFileInflateL());
-        }
-    
-    else
-        r = KErrNotSupported;
-    
-    return r;
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::LoadFileNoCompress()
-    {
-    LOGSTRING("Launcher: E32ImageReader::LoadFileNoCompress");
-
-    TInt r(KErrNone);
-
-    if (iHeader->iCodeSize)
-        {
-        r = Read(iHeader->iCodeOffset, (TText8*)iCodeLoadAddress, iCodeSize);
-        }
-
-    if (r != KErrNone)
-        {
-        return r;
-        }
-
-    if (iRestOfFileSize)
-        {
-        r = Read(iConversionOffset, (TText8*)iRestOfFileData, iRestOfFileSize);
-        }
-    
-    return r;
-    }
-
-// ---------------------------------------------------------------------------
-
-void FileCleanup(TAny* aPtr)
-    {
-    TFileInput* f=(TFileInput*)aPtr;
-    f->Cancel();
-    delete f;
-    }
-
-// ---------------------------------------------------------------------------
-
-void E32ImageReader::LoadFileInflateL()
-    {
-    LOGSTRING("Launcher: E32ImageReader::LoadFileInflateL");
-
-    TInt pos = iHeader->TotalSize();
-    User::LeaveIfError(iFile.Seek(ESeekStart,pos));
-
-    TFileInput* file = new (ELeave) TFileInput(iFile);
-    CleanupStack::PushL(TCleanupItem(&FileCleanup,file));
-    CInflater* inflater = CInflater::NewLC(*file);
-    
-    if (iHeader->iCodeSize)
-        {
-        TInt count = inflater->ReadL((TUint8*)iCodeLoadAddress, iCodeSize, &MemoryMove);
-        
-        if(count!=iCodeSize)
-            User::Leave(KErrCorrupt);
-        }
-
-    if (iRestOfFileSize)
-        {
-        TUint32 count = inflater->ReadL(iRestOfFileData, iRestOfFileSize, &Mem::Move);
-        
-        if(count!=iRestOfFileSize)
-            User::Leave(KErrCorrupt);
-        }
-    
-    CleanupStack::PopAndDestroy(2,file);
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::Read(TText8* aDest, TInt aSize)
-    {
-    TPtr8 p(aDest,aSize,aSize);
-    return iFile.Read(p,aSize);
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::Read(TInt aPos, TText8* aDest, TInt aSize)
-    {
-    TPtr8 p(aDest,aSize,aSize);
-    if (aPos<0)
-        return KErrCorrupt;
-    return iFile.Read(aPos,p,aSize);
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt E32ImageReader::ReadImportData()
-    {
-    LOGSTRING("Launcher: E32ImageReader::ReadImportData");
-
-    if (!iHeader->iImportOffset)
-        return KErrNone;
-    
-    TUint32 bufferOffset = iHeader->iImportOffset-iConversionOffset;
-    
-    if(bufferOffset>iRestOfFileSize || bufferOffset+iImportSection->iSize>iRestOfFileSize)
-        return KErrCorrupt;
-    
-    iImportData = (TUint32*)(iRestOfFileData+bufferOffset);
-    
-    E32ImportSection* s = (E32ImportSection*)iImportData;
-    E32ImportBlock* b = (E32ImportBlock*)(s + 1);
-    TUint impfmt = iHeader->ImportFormat();
-    TInt i;
-    TInt n = 0;
-    
-    for (i=0; i<iDepCount; ++i)
-        {
-        if (b->iNumberOfImports > n)
-            n = b->iNumberOfImports;
-        b = (E32ImportBlock*)b->NextBlock(impfmt);
-        }
-    
-    iCurrentImportList = (TUint32*)User::Alloc(n * sizeof(TUint32));
-    
-    if (!iCurrentImportList)
-        return KErrNoMemory;
-    
-    return KErrNone;
-    }
-
-// ---------------------------------------------------------------------------
-
-inline CInflater::CInflater(TBitInput& aInput)
-    :iBits(&aInput),iEncoding(0),iOut(0)
-    {}
-
-// ---------------------------------------------------------------------------
-
-void CInflater::ConstructL()
-    {
-    iEncoding=new(ELeave) TEncoding;
-    InitL();
-    iLen=0;
-    iOut=new(ELeave) TUint8[KDeflateMaxDistance];
-    iAvail=iLimit=iOut;
-    }
-
-// ---------------------------------------------------------------------------
-
-CInflater* CInflater::NewLC(TBitInput& aInput)
-    {
-    CInflater* self=new(ELeave) CInflater(aInput);
-    CleanupStack::PushL(self);
-    self->ConstructL();
-    return self;
-    }
-
-// ---------------------------------------------------------------------------
-
-CInflater::~CInflater()
-    {
-    delete iEncoding;
-    delete [] iOut;
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt CInflater::ReadL(TUint8* aBuffer,TInt aLength, TMemoryMoveFunction aMemMovefn)
-    {
-    TInt tfr=0;
-    for (;;)
-        {
-        TInt len=Min(aLength,iLimit-iAvail);
-        if (len && aBuffer)
-            {
-            aMemMovefn(aBuffer,iAvail,len);
-            aBuffer+=len;
-            }
-        aLength-=len;
-        iAvail+=len;
-        tfr+=len;
-        if (aLength==0)
-            return tfr;
-        len=InflateL();
-        if (len==0)
-            return tfr;
-        iAvail=iOut;
-        iLimit=iAvail+len;
-        }
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt CInflater::SkipL(TInt aLength)
-    {
-    return ReadL(0,aLength,Mem::Move);
-    }
-
-// ---------------------------------------------------------------------------
-
-void CInflater::InitL()
-    {
-    Huffman::InternalizeL(*iBits,iEncoding->iLitLen,KDeflationCodes);
-
-    if (!Huffman::IsValid(iEncoding->iLitLen,TEncoding::ELitLens) ||
-        !Huffman::IsValid(iEncoding->iDistance,TEncoding::EDistances))
-        User::Leave(KErrCorrupt);
-
-    Huffman::Decoding(iEncoding->iLitLen,TEncoding::ELitLens,iEncoding->iLitLen);
-    Huffman::Decoding(iEncoding->iDistance,TEncoding::EDistances,iEncoding->iDistance,KDeflateDistCodeBase);
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt CInflater::InflateL()
-    {
-    TUint8* out=iOut;
-    TUint8* const end=out+KDeflateMaxDistance;
-    const TUint32* tree=iEncoding->iLitLen;
-    if (iLen<0)    // EOF
-        return 0;
-    if (iLen>0)
-        goto useHistory;
-
-    while (out<end)
-        {
-        // get a huffman code
-        {
-        TInt val=iBits->HuffmanL(tree)-TEncoding::ELiterals;
-        if (val<0)
-            {
-            *out++=TUint8(val);
-            continue;        
-            }
-        if (val==TEncoding::EEos-TEncoding::ELiterals)
-            {    
-            iLen=-1;
-            break;
-            }
-        
-        TInt code=val&0xff;
-        if (code>=8)
-            {    
-            TInt xtra=(code>>2)-1;
-            code-=xtra<<2;
-            code<<=xtra;
-            code|=iBits->ReadL(xtra);
-            }
-        if (val<KDeflateDistCodeBase-TEncoding::ELiterals)
-            {
-            iLen=code+KDeflateMinLength;
-            tree=iEncoding->iDistance;
-            continue;        
-            }
-        
-        iRptr=out-(code+1);
-        if (iRptr+KDeflateMaxDistance<end)
-            iRptr+=KDeflateMaxDistance;
-        }
-useHistory:
-        TInt tfr=Min(end-out,iLen);
-        iLen-=tfr;
-        const TUint8* from=iRptr;
-        do
-            {
-            *out++=*from++;
-            if (from==end)
-                from-=KDeflateMaxDistance;
-            } while (--tfr!=0);
-        iRptr=from;
-        tree=iEncoding->iLitLen;
-        };
-    
-    return out-iOut;
-    }
-
-// ---------------------------------------------------------------------------
-
-TFileInput::TFileInput(RFile& aFile)
-    :iFile(aFile),iReadBuf(iBuf1),iPtr(iBuf1,KBufSize)
-    {
-    aFile.Read(iPtr,iStat);
-    }
-
-// ---------------------------------------------------------------------------
-
-void TFileInput::Cancel()
-    {
-    if (iReadBuf)
-        User::WaitForRequest(iStat);
-    }
-
-// ---------------------------------------------------------------------------
-
-void TFileInput::UnderflowL()
-    {
-    TUint8* b=iReadBuf;
-    ASSERT(b!=NULL);
-    User::WaitForRequest(iStat);
-    iReadBuf=0;
-    User::LeaveIfError(iStat.Int());
-    if(iPtr.Length()==0)
-        User::Leave(KErrCorrupt);
-    Set(b,iPtr.Length()*8);
-    
-    b = b==iBuf1 ? iBuf2 : iBuf1;
-    iPtr.Set(b,0,KBufSize);
-    iFile.Read(iPtr,iStat);
-    iReadBuf=b;
-    }
-
-// ---------------------------------------------------------------------------
-
-TFileNameInfo::TFileNameInfo()
-    {
-    memclr(this, sizeof(TFileNameInfo));
-    }
-
-// ---------------------------------------------------------------------------
-
-TInt TFileNameInfo::Set(const TDesC8& aFileName, TUint aFlags)
-    {
-    iUid = 0;
-    iVersion = 0;
-    iPathPos = 0;
-    iName = aFileName.Ptr();
-    iLen = aFileName.Length();
-    iExtPos = aFileName.LocateReverse('.');
-    if (iExtPos<0)
-        iExtPos = iLen;
-    TInt osq = aFileName.LocateReverse('[');
-    TInt csq = aFileName.LocateReverse(']');
-    if (!(aFlags & EAllowUid) && (osq>=0 || csq>=0))
-        {
-        return KErrBadName;
-        }
-    if (osq>=iExtPos || csq>=iExtPos)
-        {
-        return KErrBadName;
-        }
-    TInt p = iExtPos;
-    if ((aFlags & EAllowUid) && p>=10 && iName[p-1]==']' && iName[p-10]=='[')
-        {
-        TPtrC8 uidstr(iName + p - 9, 8);
-        TLex8 uidlex(uidstr);
-        TUint32 uid = 0;
-        TInt r = uidlex.Val(uid, EHex);
-        if (r==KErrNone && uidlex.Eos())
-            iUid = uid, p -= 10;
-        }
-    iUidPos = p;
-    TInt ob = aFileName.LocateReverse('{');
-    TInt cb = aFileName.LocateReverse('}');
-    if (ob>=iUidPos || cb>=iUidPos)
-        {
-        return KErrBadName;
-        }
-    if (ob>=0 && cb>=0 && p-1==cb)
-        {
-        TPtrC8 p8(iName, p);
-        TInt d = p8.LocateReverse('.');
-        TPtrC8 verstr(iName+ob+1, p-ob-2);
-        TLex8 verlex(verstr);
-        if (ob==p-10 && d<ob)
-            {
-            TUint32 ver = 0;
-            TInt r = verlex.Val(ver, EHex);
-            if (r==KErrNone && verlex.Eos())
-                iVersion = ver, p = ob;
-            }
-        else if (d>ob && p-1>d && (aFlags & EAllowDecimalVersion))
-            {
-            TUint32 maj = 0;
-            TUint32 min = 0;
-            TInt r = verlex.Val(maj, EDecimal);
-            TUint c = (TUint)verlex.Get();
-            TInt r2 = verlex.Val(min, EDecimal);
-            if (r==KErrNone && c=='.' && r2==KErrNone && verlex.Eos() && maj<32768 && min<32768)
-                iVersion = (maj << 16) | min, p = ob;
-            }
-        }
-    iVerPos = p;
-    if (iLen>=2 && iName[1]==':')
-        {
-        TUint c = iName[0];
-        if (c!='?' || !(aFlags & EAllowPlaceholder))
-            {
-            c |= 0x20;
-            if (c<'a' || c>'z')
-                {
-                return KErrBadName;
-                }
-            }
-        iPathPos = 2;
-        }
-    TPtrC8 pathp(iName+iPathPos, iVerPos-iPathPos);
-    if (pathp.Locate('[')>=0 || pathp.Locate(']')>=0 || pathp.Locate('{')>=0 || pathp.Locate('}')>=0 || pathp.Locate(':')>=0)
-        {
-        return KErrBadName;
-        }
-    iBasePos = pathp.LocateReverse('\\') + 1 + iPathPos;
-
-    return KErrNone;
-    }
-
-// ---------------------------------------------------------------------------
-
-void TFileNameInfo::GetName(TDes8& aName, TUint aFlags) const
-    {
-    if (aFlags & EIncludeDrive)
-        aName.Append(Drive());
-    if (aFlags & EIncludePath)
-        {
-        if (PathLen() && iName[iPathPos]!='\\')
-            aName.Append('\\');
-        aName.Append(Path());
-        }
-    if (aFlags & EIncludeBase)
-        aName.Append(Base());
-    if ((aFlags & EForceVer) || ((aFlags & EIncludeVer) && VerLen()) )
-        {
-        aName.Append('{');
-        aName.AppendNumFixedWidth(iVersion, EHex, 8);
-        aName.Append('}');        
-        }
-    if ((aFlags & EForceUid) || ((aFlags & EIncludeUid) && UidLen()) )
-        {
-        aName.Append('[');
-        aName.AppendNumFixedWidth(iUid, EHex, 8);
-        aName.Append(']');
-        }
-    if (aFlags & EIncludeExt)
-        aName.Append(Ext());
-    }
-
-// ---------------------------------------------------------------------------