diff -r 000000000000 -r 83f4b4db085c toolsandutils/e32tools/rommask/rommask.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/rommask/rommask.cpp	Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,395 @@
+// Copyright (c) 1996-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:
+//
+
+#include <string.h>
+#include <io.h>
+
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+#include <iomanip>
+#else //!__MSVCDOTNET__
+#include <iomanip.h>
+#endif //__MSVCDOTNET__
+
+#include "h_utl.h"
+#include "h_ver.h"
+
+// ROMMASK.EXE cl parameters
+char *gRomImage=NULL;
+char *gOutputRom=NULL;
+int	gRomSize=0;
+char gFormat='P';
+const int KMaxSections=8;
+int gNumberOfSections=0;
+int gSectionSize[KMaxSections];
+int gHeader=ETrue;
+int gVerbose=EFalse;
+
+
+TInt MaskPlain(TInt aRomSize,ifstream& aPsionImageFile,ofstream& aMaskRomImageFile)
+//
+// Create a plain mask rom image file
+//
+	{
+
+	const char KMaskRomFillCharacter='\377';
+	const TInt KBufferSize=1024;
+	char empty[KBufferSize];
+	for (TInt y=0;y<KBufferSize;y++)
+		empty[y]=KMaskRomFillCharacter;
+	char buffer[KBufferSize];
+	TUint checksum32=0;
+	TUint checksum8=0;
+	for (TInt x=0;x<aRomSize;x+=KBufferSize)
+		{
+		memcpy(buffer,empty,KBufferSize);
+		aPsionImageFile.read(buffer,KBufferSize);
+		aMaskRomImageFile.write(buffer,KBufferSize);
+		TInt z;
+		for (z=0;z<KBufferSize;z+=4)
+			checksum32+=*(TUint32*)&buffer[z];
+		for (z=0;z<KBufferSize;z++)
+			checksum8+=(TUint8)buffer[z];
+		}
+
+	if (gVerbose)
+		{
+		cout << dec;
+		cout << aRomSize << " byte PLAIN\r\n";
+		cout << "32 bit checksum 0x";
+		cout << setw(8);
+		cout << hex;
+		cout << setfill('0');
+		cout << checksum32 << "\r\n";
+		cout << " 8 bit checksum 0x";
+		cout << setw(8);
+		cout << hex;
+		cout << setfill('0');
+		cout << checksum8 << "\r\n";
+		}
+	return(KErrNone);
+	}
+
+TInt MaskMotorola(TInt /*aRomSize*/,ifstream& /*aPsionImageFile*/,ofstream& /*aMaskRomImageFile*/)
+//
+// Create a motorola s-record mask rom image file
+//
+	{
+	return(KErrNone);
+	}
+
+TInt MaskRom(TInt aRomSize,ifstream& aPsionImageFile,const char* aMaskRomImageFileName,const char* aMaskRomFormat)
+	{
+	ofstream MaskRomImageFile;
+
+	TInt r;
+	if (!MaskRomImageFile)
+		{
+		cout << "Error:  Cannot create mask rom image file (" << aMaskRomImageFileName << ")\r\n";
+		r=KErrArgument;
+		}
+	else
+		{
+		if (gVerbose)
+			{
+			cout << "\r\nMask ROM image file: ";
+			cout << aMaskRomImageFileName << "\r\n"; 
+			}
+		switch (aMaskRomFormat[0])
+			{
+		case 'P':
+			MaskRomImageFile.open(aMaskRomImageFileName, ios::in | ios::binary);
+			r=MaskPlain(aRomSize,aPsionImageFile,MaskRomImageFile);
+			break;
+		case 'M':
+			MaskRomImageFile.open(aMaskRomImageFileName, ios::in);
+			r=MaskMotorola(aRomSize,aPsionImageFile,MaskRomImageFile);
+			break;
+		default:
+			cerr << "Error:  Rom format not recognised\r\n";
+			r=KErrGeneral;
+			break;
+			}
+		MaskRomImageFile.close();
+		}
+	return r;
+	}
+
+
+TInt getIntegerArg(int argc, char *argv[], int param)
+	{
+
+	int error=KErrNone;
+	if (param>=argc)
+		error=KErrArgument;
+	if (error==KErrNone)
+		{
+		int val;
+//		if (!isNumber(argv[param]))
+//			return KErrArgument;
+
+#ifdef __TOOLS2__
+istringstream s(argv[param]);
+#else
+istrstream s(argv[param], strlen(argv[param]));
+#endif
+
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+		s >> setbase(0);
+#endif //__MSVCDOTNET__
+
+		s>>val;
+		if (!s.fail())
+			return val;
+		}
+	cerr << "Error:  Integer argument required for ";
+	cerr << argv[param-1];
+	cerr << "\r\n";
+	return -1;
+	}
+
+char *getStringArg(int argc, char *argv[], int param)
+	{
+
+	if (param>=argc)
+		{
+		cerr << "Error:  String argument required for ";
+		cerr << argv[param-1];
+		cerr << "\r\n";
+		return NULL;
+		}
+	return argv[param];
+	}
+
+char getCharArg(int argc, char *argv[], int param)
+	{
+	
+	char *p=getStringArg(argc,argv,param);
+	if (p!=NULL)
+		return p[0];
+	return '\000';
+	}
+
+TInt processCommandLine(int argc, char *argv[])
+	{
+
+	if (argc==1)
+		return KErrArgument;
+	int param=1;
+	while (param<argc)
+		{
+		switch (argv[param][1])
+			{
+		case 'r':
+		case 'R':
+			// rom name
+			param++;
+			gRomImage=getStringArg(argc, argv, param);
+			break;
+		case 's':
+		case 'S':
+			if (argv[param][2]=='i')
+				{
+				// rom size
+				param++;
+				gRomSize=getIntegerArg(argc, argv, param);
+				if (gRomSize==-1)
+					return KErrGeneral;
+				}
+			else
+				{
+				// section
+				if (gNumberOfSections>=KMaxSections)
+					{
+					cerr << "Error:  Too many sections\r\n";
+					return KErrGeneral;
+					}
+				param++;
+				gSectionSize[gNumberOfSections]=getIntegerArg(argc, argv, param);
+				if (gSectionSize[gNumberOfSections]==-1)
+					return KErrGeneral;
+				if (gSectionSize[gNumberOfSections]==0)
+					{
+					cerr << "Error:  Section is zero bytes long\r\n";
+					return KErrGeneral;
+					}
+				if (gSectionSize[gNumberOfSections]>64)
+					{
+					cerr << "Error: Section too big\r\n";
+					return KErrGeneral;
+					}
+				gNumberOfSections++;
+				}
+				break;
+			case 'f':
+			case 'F':
+				param++;
+				gRomSize=getCharArg(argc, argv, param);
+				break;
+			case 'l':
+			case 'L':
+				cerr << "Error:  Use -verbose instead of -log";
+				break;
+			case 'v':
+			case 'V':
+				gVerbose=ETrue;
+				break;
+			case 'o':
+			case 'O':
+				param++;
+				gOutputRom=getStringArg(argc, argv, param);
+				break;
+			case 'n':
+			case 'N':
+				// -no-header
+				gHeader=EFalse;
+				break;
+			default:
+				cout << "Error:  Unrecognised switch '"<<argv[param]<<"'\r\n";
+				return KErrArgument;
+			}
+		param++;
+		}
+	if (gRomImage==NULL)
+		{
+		cerr << "Error:  No rom image specified\r\n";
+		return KErrArgument;
+		}
+	if (gOutputRom==NULL)
+		{
+		cerr << "Error:  No output rom file specified\r\n";
+		return KErrArgument;
+		}
+	if (gRomSize>64)
+		{
+		cerr << "Error:  Rom too big\r\n";
+		return KErrGeneral;
+		}
+	if (gRomSize==0)
+		{
+		cerr << "Error: No rom size specified\r\n";
+		return KErrArgument;
+		}
+	if (gFormat!='P' && gFormat!='M')
+		{
+		cerr << "Error:  Invalid mask rom format specified\r\n";
+		return KErrArgument;
+		}
+
+	return KErrNone;
+	}
+
+TInt Align1M(TInt aVal)
+	{
+	return (aVal+0xfffff) & 0x7ff00000;
+	}
+
+TInt main(int argc, char *argv[])
+	{
+
+	const TInt KPsionImageFileHeaderSize=0x100;
+
+	cout << "\r\nROMMASK - Rom masker V" << MajorVersion << "." << MinorVersion << "(Build " << Build << ")\r\n";
+	cout << Copyright;
+
+	char HelpText[] = 
+		"Syntax: ROMMASK -romimage <psion img file> -output <rom img name>\r\n"
+		"                [-verbose] [-size <total rom size>]\r\n"
+		"                [-no-header] [-format <format>] [-section <size>]*\r\n"
+		"Format: MOTOROLA (ascii s-record format)\r\n"
+		"        PLAIN (plain binary format) default\r\n";
+	int r=processCommandLine(argc, argv);
+	if (r==KErrArgument)
+		{
+		cout << HelpText;
+		return(KErrArgument);
+		}
+
+// Open the psion image file
+
+	ifstream PsionImageFile;
+	char*& PsionImageFileName=gRomImage;
+
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+	PsionImageFile.open(PsionImageFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	PsionImageFile.open(PsionImageFileName, ios::nocreate | ios::binary);
+#endif //__MSVCDOTNET__
+
+	if (!PsionImageFile)
+		{
+		cerr << "Error:  Cannot open psion image file (" << PsionImageFileName << ")\r\n";
+		return(KErrArgument);
+		}
+	
+	gRomSize*=1024*1024; // in Mb
+	// resolve sections to cover whole rom
+	int size=0;
+	int i;
+	for (i=0; i<gNumberOfSections; i++)
+		{
+		gSectionSize[i]*=1024*1024; // in Mb
+		size+=gSectionSize[i];
+		}
+	if (size<gRomSize)
+		gSectionSize[gNumberOfSections++]=gRomSize-size;
+	if (size>gRomSize)
+		{
+		cerr << "Error:  Sections too big for rom";
+		return KErrGeneral;
+		}
+
+// Create the mask rom image file
+
+	ofstream MaskRomImageFile;
+	char*& MaskRomImageFileName=gOutputRom;
+
+ 	MaskRomImageFile.open(MaskRomImageFileName);
+	if (!MaskRomImageFile)
+		{
+		cerr << "Error:  Cannot create mask rom image file (" << MaskRomImageFileName << ")\r\n";
+		PsionImageFile.close();
+		return(KErrArgument);
+		}
+
+	if (gHeader)
+		{
+		PsionImageFile.ignore(KPsionImageFileHeaderSize);
+		int count=PsionImageFile.gcount();
+		if (count!=KPsionImageFileHeaderSize)
+			{
+			cerr << "Error:  Corrupt Psion image file\r\n";
+			return(KErrGeneral);
+			}
+		}
+
+	r=KErrNone;
+	for (i=0; i<gNumberOfSections; i++)
+		{
+		r=MaskRom(gSectionSize[i],PsionImageFile,MaskRomImageFileName,&gFormat);
+		if (r!=KErrNone)
+			{
+			cerr << "Error:  An error occured while processing Rom image\r\n";
+			return r;
+			}
+		// next section
+		char* ptr=MaskRomImageFileName;
+		while (*++ptr!=0)
+			;
+		*--ptr=(char)(i+'2');
+		}
+
+	PsionImageFile.close();
+	return(r);
+	}