Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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_entry.cpp
//
//
#include "cl_std.h"
/**
Default constructor.
*/
EXPORT_C TVolumeInfo::TVolumeInfo()
{
Mem::FillZ(this, sizeof(TVolumeInfo)); //-- zero-fill itself
new(&iName)TBufC<KMaxFileName>; //-- initialise broken descriptor
}
EXPORT_C TBool TEntry::IsReadOnly() const
/**
Tests whether the file or directory is read-only.
@return ETrue if entry is read-only, EFalse if not.
@see KEntryAttReadOnly
*/
{
return(iAtt&KEntryAttReadOnly);
}
EXPORT_C TBool TEntry::IsHidden() const
/**
Tests whether the file or directory is hidden.
@return ETrue if entry is hidden, EFalse if not.
@see KEntryAttHidden
*/
{
return(iAtt&KEntryAttHidden);
}
EXPORT_C TBool TEntry::IsSystem() const
/**
Tests whether the file or directory has the system attribute set.
@return ETrue if entry is a system entry, EFalse if not.
@see KEntryAttSystem
*/
{
return(iAtt&KEntryAttSystem);
}
EXPORT_C TBool TEntry::IsDir() const
/**
Tests whether the entry is a directory.
@return ETrue if entry indicates a directory, EFalse if not.
@see KEntryAttDir
*/
{
return(iAtt&KEntryAttDir);
}
EXPORT_C TBool TEntry::IsArchive() const
/**
Tests whether the file is an archive file.
@return ETrue if file is archive, EFalse if not.
@see KEntryAttArchive
*/
{
return(iAtt&KEntryAttArchive);
}
EXPORT_C TEntryArray::TEntryArray()
: iCount(0)
/**
Default constructor.
Initialises its count of contained TEntry objects to zero.
*/
{}
EXPORT_C TInt TEntryArray::Count() const
/**
Gets the number of entries in the array.
@return The number of entries in the array.
*/
{
if (iCount==KCountNeeded)
{
const TEntry* pE=(const TEntry*)iBuf.Ptr();
const TEntry* pEnd=PtrAdd(pE,iBuf.Length());
TInt c=0;
while (pE<pEnd)
{
c++;
pE=PtrAdd(pE,EntrySize(*pE, ETrue));
}
TEntryArray& me=(TEntryArray& )(*this);
me.iCount=c;
me.iIndex=0;
me.iPos=(const TEntry*)iBuf.Ptr();
}
return(iCount);
}
EXPORT_C const TEntry& TEntryArray::operator[](TInt anIndex) const
/**
Gets the directory entry at the specified index.
@param anIndex Index of the entry within the array.
This value is relative to zero.
@return On return contains the entry at the specified index.
@panic FSCLIENT 22 if anIndex is greater than or equal to the number
of elements in the array.
*/
{
__ASSERT_ALWAYS(anIndex<Count(),Panic(EEntryArrayBadIndex));
const TEntry* pE=iPos;
TInt ix=iIndex;
if (anIndex<ix)
{
ix=0;
pE=(const TEntry*)iBuf.Ptr();
}
while (ix<anIndex)
{
pE=PtrAdd(pE,EntrySize(*pE, ETrue));
ix++;
}
TEntryArray& me=(TEntryArray& )(*this);
me.iIndex=ix;
me.iPos=pE;
return(*pE);
}
EXPORT_C TEntry::TEntry()
/**
Default constructor.
*/
: iSizeHigh(0),
iReserved(0)
{}
EXPORT_C TEntry::TEntry(const TEntry& aEntry)
/**
Copy constructor.
@param aEntry The TEntry object to be copied.
*/
{
Copy(aEntry);
Unpack(); // Check that unpacking is safe here - we need to verify that wherever
// the entry is copied back into a TEntryArray that the iSizeHigh and
// iReserved members are re-packaged and the attribute set accordingly.
// (for example, CDir::Sort might do this, but I haven't checked - I know
// this uses the assignment operator, which is why that doesn't unpack...)
}
EXPORT_C TEntry& TEntry::operator=(const TEntry& aEntry)
/**
Assignment operator.
@param aEntry The TEntry object to be copied to this TEntry object.
@return A reference to this TEntry object.
*/
{
if(this!=&aEntry)
{
Copy(aEntry);
Unpack();
}
return(*this);
}
/**
@internalTechnology
@prototype
*/
inline void TEntry::Unpack()
{
if(iAtt & KEntryAttPacked)
{
/**
* This entry is still in a packed form, so unpack it now by copying high length
* and reserved bytes from the packed source to the to the unpacked target entry
*/
TUint32* pSizeHighSrc = PtrAdd((TUint32*)this, EntrySize(*this, EFalse));
iSizeHigh = *pSizeHighSrc++; // Copy iSizeHigh
iReserved = *pSizeHighSrc; // Copy iReserved
iAtt &= ~KEntryAttPacked;
}
}
/**
@internalTechnology
@prototype
*/
inline void TEntry::Copy(const TEntry& aEntry)
{
Mem::Copy(this,&aEntry,EntrySize(aEntry, ETrue));
if(!(iAtt & KEntryAttPacked))
{
iSizeHigh = aEntry.iSizeHigh;
iReserved = aEntry.iReserved;
}
}
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
/**
@internalTechnology
@prototype
*/
#else
/**
Returns the file size in 64 bits.
This can be used to find the size of a file whose size is more than 2 GB - 1.
@return The file size in 64 bits
@publishedAll
@prototype
@see TEntry::iSize
*/
#endif
EXPORT_C TInt64 TEntry::FileSize() const
{
#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
Panic(ENotImplemented);
return (KErrNotSupported); // To suppress warning!
#else
if(iAtt & KEntryAttPacked)
{
/**
* This entry is still in a packed form, so unpack it now by copying high length
* and reserved bytes from the packed source to the to the unpacked target entry
*/
TUint32* pSizeHighSrc = PtrAdd((TUint32*)this, Align4(EntrySize(*this, EFalse)));
return MAKE_TINT64(*pSizeHighSrc, iSize);
}
return MAKE_TINT64(iSizeHigh, iSize);
#endif
}