FCL/sftools/dev/build: comparison imgtools/romtools/rofsbuild/r

equal deleted inserted replaced

-:c7c26511138f
+:360bd6b35136
 #include <e32std_private.h>
 #include <e32rom.h>
 #include <u32std.h>
 #include <e32uid.h>
 #include <f32file.h>
+#include <malloc.h>
-#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+#include <map>
-	#include <iomanip>
+#include <queue>
-	#include <strstream>
+#include <iomanip>
-#else //!__MSVCDOTNET__
+#include <strstream>
-	#include <iomanip.h>
+#include "utf16string.h"
-#endif //__MSVCDOTNET__
 #ifdef _L
 #undef _L
+#endif
+#ifdef __LINUX__
+#define _alloca alloca
 #endif
 #include "h_utl.h"
 #include "r_obey.h"
 #include "rofs.h"
 #include "e32image.h"
 #include "patchdataprocessor.h"
+#include <filesystem.hpp>
+#include <thread/thread.hpp>
+#include <thread/mutex.hpp>
+#include <thread/condition_variable.hpp>
+#include "cache/cacheexception.hpp"
+#include "cache/cacheentry.hpp"
+#include "cache/cache.hpp"
+#include "cache/cachegenerator.hpp"
+#include "cache/cachevalidator.hpp"
+#include "cache/cacheablelist.hpp"
+#include "cache/cachemanager.hpp"
 extern TUint checkSum(const void* aPtr);
 extern ECompression gCompress;
 extern TUint gCompressionMethod;
 extern TInt  gCodePagingOverride;
 extern TInt  gDataPagingOverride;
 extern TInt  gLogLevel;
+extern bool gCache;
 TBool gDriveImage=EFalse;	// for drive image support.
 TInt TRomNode::Count=0;
 TRomNode* TRomNode::TheFirstNode = NULL;
 	temp2[i]=0;
 	return stricmp((const char*)&temp1[0], (const char*)&temp2[0]);
 	}
-TRomNode::TRomNode(TText* aName, TRomBuilderEntry* aEntry)
+TRomNode::TRomNode(const char* aName, TRomBuilderEntry* aEntry)
 //
 // Constructor
 //
 	:
 	iNextNode(NULL),
 	iParent(NULL), iSibling(0), iChild(0), iNextNodeForSameFile(0),
 	iTotalDirectoryBlockSize(0),
 	iTotalFileBlockSize(0),
 	iImagePosition(0),
 	iFileBlockPosition(0),
 	iAtt(sDefaultInitialAttr),
 	iAttExtra(0xFF),
 	iHidden(EFalse),
 	iEntry(aEntry),
 	iFileStartOffset(0),
 	iSize(0),
 	iOverride(0),
 	iFileUpdate(EFalse),
 iAlias(false)
 	{
-	iName = (TText*)NormaliseFileName((const char*)aName);
+	iName = NormaliseFileName(aName);
 	iIdentifier=TRomNode::Count++;
 	// Add this node to the flat linked list
 	if( !TheFirstNode )
 		{
 		{
 		iAtt = (TUint8)KEntryAttDir;
 		}
 	}
-TRomNode::~TRomNode()
+TRomNode::~TRomNode() {
-	{
 	if (iEntry && !iAlias)
-{
+		delete iEntry;
-		delete iEntry;
-}
-iEntry = 0;
 	if(iName)
-		free(iName);
+		delete []iName ;
-iName = 0;
+}
-	}
-TRomNode *TRomNode::FindInDirectory(TText *aName)
 //
 // Check if the TRomNode for aName exists in aDir, and if so, return it.
 //
-	{
+TRomNode *TRomNode::FindInDirectory(const char *aName) const{
 	TRomNode *entry=iChild; // first subdirectory or file
-	while (entry)
+	while (entry) {
-		{
+		if ((stricmp(aName, entry->iName)) == 0)
-		if ((stricmp((const char *)aName, (const char *)entry->iName))==0)
 			return entry;
 		else
 			entry=entry->iSibling;
-		}
+	}
 	return 0;
-	}
+}
 TInt indend = 0;
 	while(i > 0)
 	   {
 	     cout << "    ";
 	     i--;
 	   }
 };
 // displays the directory structure
 void TRomNode::DisplayStructure(ostream* aOut)
 	{
 	  indendStructure(indend);
 *aOut  << iName << "\n";
 	  if (iChild)
 	    {
 	      indend++;
 	      iChild->DisplayStructure(aOut);
 	      indend--;
 	    }
 	  if (iSibling)
 	    iSibling->DisplayStructure(aOut);
 		return;
 		}
 	Add(aChild);
 	}
-TRomNode* TRomNode::NewSubDir(TText *aName)
+TRomNode* TRomNode::NewSubDir(const char *aName) {
-	{
+	if (iEntry) {
-	if (iEntry)
-		{
 		Print(EError, "Adding subdirectory to a file!!!\n");
 		return 0;
-		}
+	}
-	TRomNode* node = new TRomNode(aName );
+	TRomNode* node = new TRomNode(aName);
-	if (node==0)
+	if (node==0){
-		{
 		Print(EError, "TRomNode::NewNode: Out of memory\n");
 		return 0;
-		}
+	}
 	node->iParent = this;
 	Add(node);
 	return node;
 	}
-void TRomNode::Add(TRomNode* aChild)
+void TRomNode::Add(TRomNode* aChild) {
-	{
+	if (iChild){ // this node is a non-empty directory
-	if (iChild) // this node is a non-empty directory
-		{
 		TRomNode* dir = iChild; // find where to link in the new node
 		while (dir->iSibling)
 			dir = dir->iSibling;
 		dir->iSibling = aChild;
-		}
+	}
 	else
 		iChild = aChild; // else just set it up as the child of the dir
 	aChild->iSibling = 0;
 	aChild->iParent = this;
 	}
-TInt TRomNode::SetAttExtra(TText *anAttWord, TRomBuilderEntry* aFile, enum EKeyword aKeyword)
 //
 // Set the file extra attribute byte from the letters passed
 // Note: The iAttExtra bits are inverted. '0' represent enabled
 //
-	{
+TInt TRomNode::SetAttExtra(char *anAttWord, TRomBuilderEntry* aFile, enum EKeyword aKeyword){
 	iAttExtra=0xFF;
 	if (anAttWord==0 || anAttWord[0]=='\0')
 		return Print(EError, "Missing argument for keyword 'exattrib'.\n");
-	for (TText *letter=anAttWord;*letter!=0;letter++)
+	for (char *letter=anAttWord;*letter!=0;letter++)
 		{
 		switch (*letter)
 			{
 		case 'u':
 			iAttExtra |= (KEntryAttUnique >> 23);	// '1' represents disabled in iAttExtra
 		}
 	return KErrNone;
 	}
-TInt TRomNode::SetAtt(TText *anAttWord)
+TInt TRomNode::SetAtt(char *anAttWord)
 //
 // Set the file attribute byte from the letters passed
 //
 	{
 	iAtt=0;
 	if (anAttWord==0 || anAttWord[0]=='\0')
 		return Print(EError, "Missing argument for keyword 'attrib'.\n");
-	for (TText *letter=anAttWord;*letter!=0;letter++)
+	for (char *letter=anAttWord;*letter!=0;letter++)
 		{
 		switch (*letter)
 			{
 		case 'R':
 		case 'w':
 		}
 	return KErrNone;
 	}
+// Calculates the amount of ROM space required to hold
-TInt TRomNode::CalculateEntrySize() const
+// this entry. The return is the actual size of the TRofsEntry
-	// Calculates the amount of ROM space required to hold
+// structure, not rounded up
-	// this entry. The return is the actual size of the TRofsEntry
+TInt TRomNode::CalculateEntrySize() const {
-	// structure, not rounded up
+	UTF16String unistr(iName);
-	{
+	TInt requiredSizeBytes = KRofsEntryHeaderSize +	unistr.bytes();
-	TInt requiredSizeBytes = KRofsEntryHeaderSize +	NameLengthUnicode();
 	return requiredSizeBytes;
 	}
 TInt TRomNode::CalculateDirectoryEntrySize( TInt& aDirectoryBlockSize,
 										    TInt& aFileBlockSize )
 	TInt offsetBytes=0;
 	TInt padBytes=0;
 	if( 0 == iTotalDirectoryBlockSize )
 		{
 		// need to calculate by walking children
 		if( !iChild )
 			{
 			return Print(EError, "TRomNode structure corrupt\n");
 			}
 				fileBlockSize += entrySize;
 				fileCount++;
 				}
 			node = node->iSibling;
 			}
 		offsetBytes = ((fileCount + dirCount) * 2) + 4; //the +4 are the two offset counts,
 		padBytes = offsetBytes % 4;
 		iTotalDirectoryBlockSize = dirBlockSize;
 		iTotalFileBlockSize = fileBlockSize;
 	}
 /**
 Place the files and it's attributes (incase of executables)
 Called for both rofs and datadrive creation.
 @param aDest   - Destination buffer.
 @param aOffset - offset value, used for rofs only.
 @param aMaxSize- Maximum size required for rofs.
 @return - Returns the number of bytes placed or a -ve error code.
 */
-TInt TRomNode::PlaceFile( TUint8* &aDest, TUint aOffset, TUint aMaxSize, CBytePair *aBPE )
+TInt TRomNode::PlaceFile( TUint8* &aDest, TUint aOffset, TUint aMaxSize, CBytePair *aBPE ){
 	//
 	// Place the file into the ROM image, making any necessary conversions
 	// along the way.
 	//
 	// Returns the number of bytes placed or a -ve error code.
-	{
 	TInt size=0;
 	// file hasn't been placed for drive image.
 	if(gDriveImage)
 	{
 		size = iEntry->PlaceFile(aDest,aMaxSize,aBPE);
 		iSize = size;
 	}
 		if (hdrfmt != KImageHdrFmt_V)
 			{
 			Print(EError,"%s: Can't load old format binary\n", iEntry->iFileName);
 			return KErrNotSupported;
 			}
 		// First need to check that it's a real image header
 		if( (TUint)size > sizeof(E32ImageHeader) )
 			{
 			if( ((TInt)hdr->iSignature == 0x434f5045u) && ((TInt)hdr->iUid1 == KExecutableImageUidValue || (TInt)hdr->iUid1 == KDynamicLibraryUidValue) )
 				{
 			//Offset in 32bit words from start of directory block
 			array[index].iOffset = (TUint16) ((((TUint8*) entry) - dirBlockBase) >> 2);
 			array[index].iIsDir = ETrue;
 			}
 		array[index].iEntry = entry;
 		index++;
+		entry->iNameOffset = KRofsEntryNameOffset;
-		entry->iNameOffset = KRofsEntryNameOffset;
 		entry->iAtt = node->iAtt;
 		entry->iAttExtra = node->iAttExtra;
 		TInt entryLen = KRofsEntryHeaderSize;
-		entryLen += node->NameCpy( (char*)&entry->iName, entry->iNameLength );
+		UTF16String unistr(node->iName);
+		if(!unistr.IsEmpty()){
+			entry->iNameLength = unistr.length();
+			memcpy(entry->iName,unistr.c_str(),unistr.bytes());
+			entryLen += unistr.bytes() ;
+		}
 		entryLen += (4 - entryLen) & 3;	// round up to nearest word
 		entry->iStructSize = (TUint16)entryLen;
 		if( node->IsFile() )
 			{
 			// node is a file, entry points to the file
 			// write an entry out into the file block
 		else
 			{
 			// node is a subdirectory, entry points to directory
 			pDirEntry->iFileAddress = node->iImagePosition;
 			node->iAtt |= KEntryAttDir;
 			// the size is just the size of the directory block
 			pDirEntry->iFileSize = node->iTotalDirectoryBlockSize;
 			pDirEntry = (TRofsEntry*)( (TUint8*)pDirEntry + entryLen );
 			}
 			aFileCount++;
 	current=current->iSibling;
 		}
 	}
-void TRomNode::Destroy()
 //
 // Follow the TRomNode tree, destroying it
 //
-	{
+void TRomNode::Destroy() {
 	TRomNode *current = this; // root has no siblings
 	while (current)
 		{
 		if (current->iChild)
 			current->iChild->Destroy();
 		TRomNode* prev=current;
 		current=current->iSibling;
 		delete prev;
 prev = 0;
 		}
-	}
+}
-TInt TRomNode::NameCpy(char* aDest, TUint8& aUnicodeLength )
-//
-// Safely copy a file name in the rom entry
-// Returns the number of bytes used. Write the length in unicode characters
-// into aUnicodeLength.
-//
-	{
-	if ((aDest==NULL) || (iName==NULL))
-		return 0;
-	const unsigned char* pSourceByte = (const unsigned char*)iName;
-	unsigned char* pTargetByte=(unsigned char*)aDest;
-	for (;;)
-		{
-		const TUint sourceByte=*pSourceByte;
-		if (sourceByte==0)
-			{
-			break;
-			}
-		if ((sourceByte&0x80)==0)
-			{
-			*pTargetByte=(unsigned char)sourceByte;
-			++pTargetByte;
-			*pTargetByte=0;
-			++pTargetByte;
-			++pSourceByte;
-			}
-		else if ((sourceByte&0xe0)==0xc0)
-			{
-			++pSourceByte;
-			const TUint secondSourceByte=*pSourceByte;
-			if ((secondSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(671);
-				}
-			*pTargetByte=(unsigned char)((secondSourceByte&0x3f)|((sourceByte&0x03)<<6));
-			++pTargetByte;
-			*pTargetByte=(unsigned char)((sourceByte>>2)&0x07);
-			++pTargetByte;
-			++pSourceByte;
-			}
-		else if ((sourceByte&0xf0)==0xe0)
-			{
-			++pSourceByte;
-			const TUint secondSourceByte=*pSourceByte;
-			if ((secondSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(672);
-				}
-			++pSourceByte;
-			const TUint thirdSourceByte=*pSourceByte;
-			if ((thirdSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(673);
-				}
-			*pTargetByte=(unsigned char)((thirdSourceByte&0x3f)|((secondSourceByte&0x03)<<6));
-			++pTargetByte;
-			*pTargetByte=(unsigned char)(((secondSourceByte>>2)&0x0f)|((sourceByte&0x0f)<<4));
-			++pTargetByte;
-			++pSourceByte;
-			}
-		else
-			{
-			Print(EError, "Bad UTF-8 '%s'", iName);
-			exit(674);
-			}
-		}
-	const TInt numberOfBytesInTarget=(pTargetByte-(unsigned char*)aDest); // this number excludes the trailing null-terminator
-	if (numberOfBytesInTarget%2!=0)
-		{
-		Print(EError, "Internal error");
-		exit(675);
-		}
-	aUnicodeLength = (TUint8)(numberOfBytesInTarget/2); // returns the length of aDest (in UTF-16 characters for Unicode, not bytes)
-	return numberOfBytesInTarget;
-	}
-TInt TRomNode::NameLengthUnicode() const
-//
-// Find the unicode lenght of the name
-//
-	{
-	if (iName==NULL)
-		return 0;
-	const unsigned char* pSourceByte = (const unsigned char*)iName;
-	TInt len = 0;
-	for (;;)
-		{
-		const TUint sourceByte=*pSourceByte;
-		if (sourceByte==0)
-			{
-			break;
-			}
-		if ((sourceByte&0x80)==0)
-			{
-			len += 2;
-			++pSourceByte;
-			}
-		else if ((sourceByte&0xe0)==0xc0)
-			{
-			++pSourceByte;
-			const TUint secondSourceByte=*pSourceByte;
-			if ((secondSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(671);
-				}
-			len += 2;
-			++pSourceByte;
-			}
-		else if ((sourceByte&0xf0)==0xe0)
-			{
-			++pSourceByte;
-			const TUint secondSourceByte=*pSourceByte;
-			if ((secondSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(672);
-				}
-			++pSourceByte;
-			const TUint thirdSourceByte=*pSourceByte;
-			if ((thirdSourceByte&0xc0)!=0x80)
-				{
-				Print(EError, "Bad UTF-8 '%s'", iName);
-				exit(673);
-				}
-			len += 2;
-			++pSourceByte;
-			}
-		else
-			{
-			Print(EError, "Bad UTF-8 '%s'", iName);
-			exit(674);
-			}
-		}
-	return len;
-	}
 void TRomNode::AddNodeForSameFile(TRomNode* aPreviousNode, TRomBuilderEntry* aFile)
 	{
 	// sanity checking
 	if (iNextNodeForSameFile != 0 || iEntry != aFile || (aPreviousNode && aPreviousNode->iEntry != iEntry))
 		{
 //**************************************
 // TRomBuilderEntry
 //**************************************
-TRomBuilderEntry::TRomBuilderEntry(const char *aFileName,TText *aName)
 //
 // Constructor
 //
-:iFirstDllDataEntry(0),	iName(0),iFileName(0),iNext(0), iNextInArea(0),
+TRomBuilderEntry::TRomBuilderEntry(const char *aFileName,const char *aName):
+iFirstDllDataEntry(0),	iName(0),iFileName(0),iNext(0), iNextInArea(0),
 iExecutable(EFalse), iFileOffset(EFalse), iCompressEnabled(0),
 iHidden(0), iRomNode(0), iRealFileSize(0)
 {
 	if (aFileName)
 		iFileName = NormaliseFileName(aFileName);
 	if (aName)
-		iName = (TText*)NormaliseFileName((const char*)aName);
+		iName = NormaliseFileName(aName);
 	memset(iUids,0 ,sizeof(TCheckedUid));
 }
+//
+// Destructor
+//
+TRomBuilderEntry::~TRomBuilderEntry() {
+	if(iFileName) {
+		delete []iFileName;
+		iFileName = 0;
+	}
-TRomBuilderEntry::~TRomBuilderEntry()
+	if(iName) {
-//
+		delete []iName;
-// Destructor
+		iName = 0 ;
-//
+	}
-	{
+}
-	if(iFileName)
-	{
-	free(iFileName);
-	}
-	iFileName = 0;
-	if(iName)
-	{
-	free(iName);
-	}
-	}
 void TRomBuilderEntry::SetRomNode(TRomNode* aNode)
 	{
 	aNode->AddNodeForSameFile(iRomNode, this);
 	iRomNode = aNode;
 	}
+//
-TInt isNumber(TText *aString)
+// Place the file in ROFS. Since we don't support compression yet all
-	{
+// we have to do is read the file into memory
-	if (aString==NULL)
+// compress it, if it isn't already compressed.
-		return 0;
+//
-	if (strlen((char *)aString)==0)
+// Returns the number of bytes used, or -ve error code
-		return 0;
+TInt TRomBuilderEntry::PlaceFile( TUint8* &aDest,TUint aMaxSize, CBytePair *aBPE ){
-	return isdigit(aString[0]);
-	}
-TInt getNumber(TText *aStr)
-	{
-	TUint a;
-	#ifdef __TOOLS2__
-	istringstream val((char *)aStr);
-	#else
-	istrstream val((char *)aStr,strlen((char *)aStr));
-	#endif
-#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
-	val >> setbase(0);
-#endif //__MSVCDOTNET__
-	val >> a;
-	return a;
-	}
-TInt TRomBuilderEntry::PlaceFile( TUint8* &aDest,TUint aMaxSize, CBytePair *aBPE )
-	//
-	// Place the file in ROM. Since we don't support compression yet all
-	// we have to do is read the file into memory
-	// compress it, if it isn't already compressed.
-	//
-	// Returns the number of bytes used, or -ve error code
-	{
 	TUint compression = 0;
 	TBool executable = iExecutable;
 	Print(ELog,"Reading file %s to image\n", iFileName );
-	TUint32 size=HFile::GetLength((TText*)iFileName);
+	TUint32 size = HFile::GetLength(iFileName);
 	if (size==0)
 		Print(EWarning, "File %s does not exist or is 0 bytes in length.\n",iFileName);
-if (aDest == NULL) {
+	if (aDest == NULL) {
-aMaxSize = size*2;
+		aMaxSize = size << 1;
-aMaxSize = (aMaxSize>0) ? aMaxSize : 2;
+		aMaxSize = (aMaxSize>0) ? aMaxSize : 2;
-aDest = new TUint8[aMaxSize];
+		aDest = new TUint8[aMaxSize];
 }
 	if (executable)
-		{
+	{
 		// indicate if the image will overflow without compression
-	TBool overflow;
+		TBool overflow;
-			if(size>aMaxSize)
+		if(size>aMaxSize)
 			overflow = ETrue;
 		else
 			overflow = EFalse;
 		// try to compress this executable
 		E32ImageFile f(aBPE);
 		TInt r = f.Open(iFileName);
 		// is it really a valid E32ImageFile?
 		if (r != KErrNone)
-			{
+		{
 			Print(EWarning, "File '%s' is not a valid executable.  Placing file as data.\n", iFileName);
 			executable = EFalse;
-			}
+		}
 		else
-			{
+		{
 			if(iRomNode->iOverride & KOverrideDllData)
 			{
 				DllDataEntry *aDllEntry = iRomNode->iEntry->GetFirstDllDataEntry();
 				TLinAddr* aExportTbl;
 				TUint aDataAddr;
 				char *aCodeSeg, *aDataSeg;
 				aExportTbl = (TLinAddr*)((char*)f.iData + f.iOrigHdr->iExportDirOffset);
 				// const data symbol may belong in the Code section. If the address lies within the Code or data section limits,
 				// get the corresponding location and update it.While considering the Data section limits
 				// don't include the Bss section, as it doesn't exist as yet in the image.
 				while( aDllEntry ){
 					if(aDllEntry->iOrdinal != (TUint32)-1){
 						if(aDllEntry->iOrdinal < 1 || aDllEntry->iOrdinal > (TUint)f.iOrigHdr->iExportDirCount){
 							Print(EWarning, "Invalid ordinal %d specified for DLL %s\n", aDllEntry->iOrdinal, iRomNode->iName);
 							aDllEntry = aDllEntry->NextDllDataEntry();
 							continue;
 						}
-				//	Get the address of the data field via the export table.
+						//	Get the address of the data field via the export table.
-					aDataAddr = (TInt32)(aExportTbl[aDllEntry->iOrdinal - 1] + aDllEntry->iOffset);
+						aDataAddr = (TInt32)(aExportTbl[aDllEntry->iOrdinal - 1] + aDllEntry->iOffset);
-					if( aDataAddr >= f.iOrigHdr->iCodeBase && aDataAddr <= (f.iOrigHdr->iCodeBase + f.iOrigHdr->iCodeSize)){
+						if( aDataAddr >= f.iOrigHdr->iCodeBase && aDataAddr <= (f.iOrigHdr->iCodeBase + f.iOrigHdr->iCodeSize)){
-						aCodeSeg = (char*)(f.iData + f.iOrigHdr->iCodeOffset);
+							aCodeSeg = (char*)(f.iData + f.iOrigHdr->iCodeOffset);
-						aLocation = (void*)(aCodeSeg + aDataAddr - f.iOrigHdr->iCodeBase );
+							aLocation = (void*)(aCodeSeg + aDataAddr - f.iOrigHdr->iCodeBase );
-						memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
+							memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
-					}
+						}
-					else if(aDataAddr >= f.iOrigHdr->iDataBase && aDataAddr <= (f.iOrigHdr->iDataBase + f.iOrigHdr->iDataSize)){
+						else if(aDataAddr >= f.iOrigHdr->iDataBase && aDataAddr <= (f.iOrigHdr->iDataBase + f.iOrigHdr->iDataSize)){
-						aDataSeg = (char*)(f.iData + f.iOrigHdr->iDataOffset);
+							aDataSeg = (char*)(f.iData + f.iOrigHdr->iDataOffset);
-						aLocation = (void*)(aDataSeg + aDataAddr - f.iOrigHdr->iDataBase );
+							aLocation = (void*)(aDataSeg + aDataAddr - f.iOrigHdr->iDataBase );
-						memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
+							memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
-					}
+						}
-					else
+						else
-					{
+						{
-						Print(EWarning, "Patchdata failed as address pointed by ordinal %d of DLL %s doesn't lie within Code or Data section limits\n", aDllEntry->iOrdinal, iRomNode->iName);
+							Print(EWarning, "Patchdata failed as address pointed by ordinal %d of DLL %s doesn't lie within Code or Data section limits\n", aDllEntry->iOrdinal, iRomNode->iName);
-					}
+						}
 					}
 					else if(aDllEntry->iDataAddress != (TLinAddr)-1){
 						aDataAddr = aDllEntry->iDataAddress + aDllEntry->iOffset;
-					if( aDataAddr >= f.iOrigHdr->iCodeBase && aDataAddr <= (f.iOrigHdr->iCodeBase + f.iOrigHdr->iCodeSize)){
+						if( aDataAddr >= f.iOrigHdr->iCodeBase && aDataAddr <= (f.iOrigHdr->iCodeBase + f.iOrigHdr->iCodeSize)){
-						aCodeSeg = (char*)(f.iData + f.iOrigHdr->iCodeOffset);
+							aCodeSeg = (char*)(f.iData + f.iOrigHdr->iCodeOffset);
-						aLocation = (void*)(aCodeSeg + aDataAddr - f.iOrigHdr->iCodeBase );
+							aLocation = (void*)(aCodeSeg + aDataAddr - f.iOrigHdr->iCodeBase );
-						memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
+							memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
-					}
+						}
-					else if(aDataAddr >= f.iOrigHdr->iDataBase && aDataAddr <= (f.iOrigHdr->iDataBase + f.iOrigHdr->iDataSize)){
+						else if(aDataAddr >= f.iOrigHdr->iDataBase && aDataAddr <= (f.iOrigHdr->iDataBase + f.iOrigHdr->iDataSize)){
-						aDataSeg = (char*)(f.iData + f.iOrigHdr->iDataOffset);
+							aDataSeg = (char*)(f.iData + f.iOrigHdr->iDataOffset);
-						aLocation = (void*)(aDataSeg + aDataAddr - f.iOrigHdr->iDataBase );
+							aLocation = (void*)(aDataSeg + aDataAddr - f.iOrigHdr->iDataBase );
-						memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
+							memcpy(aLocation, &aDllEntry->iNewValue, aDllEntry->iSize);
-					}
+						}
-					else
+						else
-					{
+						{
-						Print(EWarning, "Patchdata failed as address 0x%x of DLL %s doesn't lie within Code or Data section limits\n", aDllEntry->iOrdinal, iRomNode->iName);
+							Print(EWarning, "Patchdata failed as address 0x%x of DLL %s doesn't lie within Code or Data section limits\n", aDllEntry->iOrdinal, iRomNode->iName);
-					}
+						}
 					}
 					aDllEntry = aDllEntry->NextDllDataEntry();
-					}
+				}
 			}
 			compression = f.iHdr->CompressionType();
 			Print(ELog,"Original file:'%s' is compressed by method:%08x\n", iFileName, compression);
 				oldFileComp = 0;
 			}
 			if( iCompressEnabled != ECompressionUnknown)
 			{
 				// The new state would be as stated in obey file, i.e.
 				// filecompress or fileuncompress
 				newFileComp = gCompressionMethod;
 			}
 			else if (gCompress != ECompressionUnknown)
 			{
 			if(!gDriveImage)
 			{
 				// overide paging flags...
 				E32ImageHeaderV* h=f.iHdr;
 				if (iRomNode->iOverride & KOverrideCodePaged)
-					{
+				{
 					h->iFlags &= ~KImageCodeUnpaged;
 					h->iFlags |= KImageCodePaged;
-					}
+				}
 				if (iRomNode->iOverride & KOverrideCodeUnpaged)
-					{
+				{
 					h->iFlags |= KImageCodeUnpaged;
 					h->iFlags &= ~KImageCodePaged;
-					}
+				}
 				if (iRomNode->iOverride & KOverrideDataPaged)
-					{
+				{
 					h->iFlags &= ~KImageDataUnpaged;
 					h->iFlags |= KImageDataPaged;
-					}
+				}
 				if (iRomNode->iOverride & KOverrideDataUnpaged)
-					{
+				{
 					h->iFlags |= KImageDataUnpaged;
 					h->iFlags &= ~KImageDataPaged;
-					}
+				}
 				// apply global paging override...
 				switch(gCodePagingOverride)
-					{
+				{
 				case EKernelConfigPagingPolicyNoPaging:
 					h->iFlags |= KImageCodeUnpaged;
 					h->iFlags &= ~KImageCodePaged;
 					break;
 				case EKernelConfigPagingPolicyAlwaysPage:
 					break;
 				case EKernelConfigPagingPolicyDefaultPaged:
 					if(!(h->iFlags&(KImageCodeUnpaged|KImageCodePaged)))
 						h->iFlags |= KImageCodePaged;
 					break;
-					}
+				}
 				switch(gDataPagingOverride)
-					{
+				{
 				case EKernelConfigPagingPolicyNoPaging:
 					h->iFlags |= KImageDataUnpaged;
 					h->iFlags &= ~KImageDataPaged;
 					break;
 				case EKernelConfigPagingPolicyAlwaysPage:
 					break;
 				case EKernelConfigPagingPolicyDefaultPaged:
 					if(!(h->iFlags&(KImageDataUnpaged|KImageDataPaged)))
 						h->iFlags |= KImageDataPaged;
 					break;
-					}
+				}
 				f.UpdateHeaderCrc();
 				// make sure paged code has correct compression type...
 				if(h->iFlags&KImageCodePaged)
-					{
+				{
 					if(newFileComp!=0)
 						newFileComp = KUidCompressionBytePair;
-					}
+				}
 			}
 			if ( oldFileComp != newFileComp )
-				{
+			{
 				if( newFileComp == 0)
-					{
+				{
 					Print(ELog,"Decompressing executable '%s'\n", iFileName);
 					f.iHdr->iCompressionType = 0;
-					}
+				}
 				else
-					{
+				{
 					Print(ELog,"Compressing executable '%s' with method:%08x\n", iFileName, newFileComp);
 					f.iHdr->iCompressionType = newFileComp;
-					}
+				}
 				f.UpdateHeaderCrc();
 				if (overflow)
-					{
+				{
+					// need to check if the compressed file will fit in the image
+					//TODO the checking will slow down the build process, should do it later along with the writing on aDest.
+					TUint32 compressedSize;
 					char * buffer = new char [size];
-					// need to check if the compressed file will fit in the image
+#if defined(__LINUX__)
-					#if defined(__LINUX__)
+					ostrstream os((char*)aDest, aMaxSize, (ios_base::openmode)(ios_base::out+ios_base::binary));
-					ostrstream os((char*)aDest, aMaxSize, (ios::openmode)(ios::out+ios::binary));
+#elif defined(__TOOLS2__) && defined (_STLP_THREADS)
-					#elif defined(__TOOLS2__) && defined (_STLP_THREADS)
+					ostrstream os((char*)buffer, size,(ios_base::out+ios_base::binary));
-					ostrstream os((char*)buffer, size,(ios::out+ios::binary));
+#elif defined( __TOOLS2__)
-					#elif defined( __TOOLS2__)
+					ostrstream os((char*)buffer, size,(ios_base::out+ios_base::binary));
-					ostrstream os((char*)buffer, size,(ios::out+ios::binary));
+#else
-					#else
+					ostrstream os( (char*)buffer, size, (ios_base::out+ios_base::binary));
-					ostrstream os( (char*)buffer, size, (ios::out+ios::binary));
+#endif
-					#endif
 					os << f;
-					TUint compressedSize = os.pcount();
+					compressedSize = os.pcount();
+					delete[] buffer;
 					if (compressedSize <= aMaxSize)
 						overflow = EFalse;
-					delete[] buffer;
+				}
-					}
+			}
-				}
 			if (overflow)
-				{
+			{
 				Print(EError, "Can't fit '%s' in image\n", iFileName);
 				Print(EError, "Overflowed by approximately 0x%x bytes.\n", size - aMaxSize);
 				exit(667);
-				}
+			}
-			#if defined(__TOOLS2__) && defined (_STLP_THREADS)
-			ostrstream os((char*)aDest, aMaxSize,(ios::out+ios::binary));
+			//try to use cached version where possible.
-			#elif __TOOLS2__
+			if(gCache && !gDriveImage && !(iRomNode->iAlias) && (iRomNode->iEntry->iExecutable) && !(iRomNode->iOverride & KOverrideDllData))
-			ostrstream os((char*)aDest, aMaxSize, (std::_Ios_Openmode)(ios::out+ios::binary));
+			{
-			#else
+				//retrive cached version.
-			ostrstream os((char*)aDest, aMaxSize, (ios::out+ios::binary));
+				size_t len = strlen(iFileName) + 1;
-			#endif
+				char* temp = (char*)_alloca(len);
+				memcpy(temp,iFileName,len);
+				CacheEntry* entryref = CacheManager::GetInstance()->GetE32ImageFileRepresentation(temp , compression);
+				if(entryref)
+				{
+					size = entryref->GetCachedFileBufferLen();
+					memcpy(aDest, entryref->GetCachedFileBuffer(), size);
+					memcpy(aDest,f.iHdr,sizeof(E32ImageHeaderV));
+					compression = atoi(entryref->GetCachedFileCompressionID());
+					memcpy(&iUids[0], aDest, sizeof(iUids));
+					if (compression)
+						Print(ELog,"Compressed executable File '%s' size: %08x, mode:%08x\n", iFileName, size, compression);
+					else if (iExecutable)
+						Print(ELog,"Executable File '%s' size: %08x\n", iFileName, size);
+					else
+						Print(ELog,"File '%s' size: %08x\n", iFileName, size);
+					iRealFileSize = size;	// required later when directory is written
+					return size;
+				}
+			}
+#if defined(__TOOLS2__) && defined (_STLP_THREADS)
+			ostrstream os((char*)aDest, aMaxSize,(ios_base::out+ios_base::binary));
+#elif __TOOLS2__
+			ostrstream os((char*)aDest, aMaxSize, (_Ios_Openmode)(ios_base::out+ios_base::binary));
+#else
+			ostrstream os((char*)aDest, aMaxSize, (ios_base::out+ios_base::binary));
+#endif
 			os << f;
 			size = os.pcount();
+			//save the decompressed/recompressed executable into the cache if it's enabled.
+			if(gCache && !gDriveImage && !(iRomNode->iAlias) && (iRomNode->iEntry->iExecutable) && !(iRomNode->iOverride & KOverrideDllData))
+			{
+				CacheEntry* newentryref = new (nothrow) CacheEntry();
+				if(newentryref)
+				{
+					boost::filesystem::path originalfilepath(iFileName);
+					time_t originalcreationtime = last_write_time(originalfilepath);
+					newentryref->SetOriginalFileCreateTime(&originalcreationtime);
+					newentryref->SetOriginalFileCompression(f.iHdr->CompressionType());
+					size_t len = strlen(iFileName) + 1;
+					char* originalfilename = (char*)_alloca(len);
+					memcpy(originalfilename,iFileName,len);
+					CacheManager::GetInstance()->NormalizeFilename(originalfilename);
+					newentryref->SetOriginalFilename(originalfilename);
+					newentryref->SetCachedFileCompression(compression);
+					string cachedfilename(".rofs.");
+					cachedfilename += newentryref->GetCachedFileCompressionID();
+					cachedfilename += ".";
+					cachedfilename += iFileName;
+					size_t slashpos;
+					while(((slashpos=cachedfilename.find("/"))!=string::npos) || ((slashpos=cachedfilename.find("\\"))!=string::npos))
+						cachedfilename.replace(slashpos, 1, 1, '.');
+					cachedfilename.insert(0, "/");
+					cachedfilename.insert(0, CacheManager::GetInstance()->GetCacheRoot());
+					newentryref->SetCachedFilename(cachedfilename.c_str());
+					newentryref->SetCachedFileBuffer((char*)aDest, size);
+					try
+					{
+						size_t len = strlen(iFileName) + 1;
+						char* temp = (char*)_alloca(len);
+						memcpy(temp,iFileName,len);
+						CacheManager::GetInstance()->Invalidate(temp, newentryref);
+					}
+					catch (CacheException ce)
+					{
+						Print(EWarning, "Cache brings up an exception (%s) when processes %s\r\n", ce.GetErrorMessage(), iFileName);
+					}
+				}
+			}
 			compression = f.iHdr->CompressionType();
 			memcpy(&iUids[0], aDest, sizeof(iUids));
-			}
+		}
-		}
+	}
 	if (!executable)
-		{
+	{
 		if ( size > aMaxSize )
-			{
+		{
 			Print(EError, "Can't fit '%s' in image\n", iFileName);
 			Print(EError, "Overflowed by approximately 0x%x bytes.\n", size - aMaxSize);
 			exit(667);
-			}
+		}
-		size = HFile::Read((TText*)iFileName, (TAny *)aDest);
+		size = HFile::Read(iFileName, (TAny *)aDest);
-TUint32 Uidslen = (size > sizeof(iUids)) ? sizeof(iUids) : size;
+		TUint32 Uidslen = (size > sizeof(iUids)) ? sizeof(iUids) : size;
-memcpy(&iUids[0], aDest, Uidslen);
+		memcpy(&iUids[0], aDest, Uidslen);
-		}
+	}
 	if (compression)
 		Print(ELog,"Compressed executable File '%s' size: %08x, mode:%08x\n", iFileName, size, compression);
 	else if (iExecutable)
 		Print(ELog,"Executable File '%s' size: %08x\n", iFileName, size);
 	else
 		Print(ELog,"File '%s' size: %08x\n", iFileName, size);
+	iCompressEnabled = compression;
 	iRealFileSize = size;	// required later when directory is written
 	return size;
-	}
+}
 TRomNode* TRomNode::CopyDirectory(TRomNode*& aLastExecutable)
 	{
 void TRomNode::Alias(TRomNode* aNode)
 	{
 	  // sanity checking
 	if (aNode->iEntry == 0)
 	{
 		Print(EError, "Aliasing: TRomNode structure corrupted\n");
 		exit(666);
 	}
 	Clone(aNode);
 		}
 iAlias = true;
 	}
-void TRomNode::Rename(TRomNode *aOldParent, TRomNode* aNewParent, TText* aNewName)
+void TRomNode::Rename(TRomNode *aOldParent, TRomNode* aNewParent, const char* aNewName) {
-	{
 	aOldParent->Remove(this);
 	aNewParent->Add(this);
 	delete [] iName;
-	iName = new TText[strlen((const char *)aNewName)+1];
+	size_t len = strlen(aNewName)+1;
-	strcpy ((char *)iName, (const char *)aNewName);
+	iName = new char[len];
-	}
+	memcpy (iName, aNewName,len);
+}
 TInt TRomNode::FullNameLength(TBool aIgnoreHiddenAttrib) const
 	{
 	TInt l = 0;
 	// aIgnoreHiddenAttrib is used to find the complete file name length as
 	// in ROM of a hidden file.
 	if (iParent && ( !iHidden || aIgnoreHiddenAttrib))
 		l = iParent->FullNameLength() + 1;
 	l += strlen((const char*)iName);
 	return l;
 }
 // Fuction to set first node in the patchdata linked list
 void TRomBuilderEntry::SetFirstDllDataEntry(DllDataEntry *aDllDataEntry)
 {
 	iFirstDllDataEntry = aDllDataEntry;
 }
 void TRomBuilderEntry::DisplaySize(TPrintType aWhere)
 {
 	TBool aIgnoreHiddenAttrib = ETrue;
 	TInt aLen = iRomNode->FullNameLength(aIgnoreHiddenAttrib);

changeset 590	360bd6b35136
parent 0	044383f39525
child 626	ac03b93ca9c4