diff -r 000000000000 -r 83f4b4db085c toolsandutils/e32tools/elf2e32/source/parametermanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolsandutils/e32tools/elf2e32/source/parametermanager.cpp	Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,3730 @@
+// Copyright (c) 2004-2009 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:
+// Implementation of the Class ParameterManager for the elf2e32 tool
+// @internalComponent
+// @released
+// 
+//
+
+// This must go before ParameterManager.h
+#define __INCLUDE_CAPABILITY_NAMES__
+#include <e32capability.h>
+
+#include "pl_common.h"
+#include "parametermanager.h"
+#include "errorhandler.h"
+#include <iostream>
+
+#include "h_utl.h"
+#include "h_ver.h"
+/**
+Constructor for the ParameterManager.
+
+@internalComponent
+@released
+
+@param aArgc
+ The number of command line arguments passed into the program
+@param aArgv
+ The listing of all the arguments
+*/
+ParameterManager::ParameterManager(int aArgc, char** aArgv) :
+	iArgc(aArgc),
+	iArgv(aArgv),
+	iImageLocation(0), 
+	iImageName(0),
+	iTargetTypeOption(false), 
+	iDefFileInOption(false),
+	iDefFileOutOption(false), 
+	iFileDumpOption(false),		
+	iDSOFileOutOption(false), 
+	iOutFileOption(false),
+	iElfFileInOption(false),
+	iE32ImageInOption(false),			
+	iLinkAsOption(false),
+	iUid1Option(false), 	
+	iSecureIDOption(false), 
+	iVendorIDOption(false),
+	iUID1(0), 
+	iUID2(0), 
+	iUID3(0),
+	iSecureID(0),
+	iVendorID(0),
+	iCompress(true),
+	iCompressionMethod(KUidCompressionDeflate),
+	iFixedAddress(false),
+	iHeapCommittedSize(0x1000),
+	iHeapReservedSize(0x100000),	
+	iStackCommittedSize(0x2000),
+	iUnfrozen(false),
+	iIgnoreNonCallable(false),
+	iTargetTypeName(ETargetTypeNotSet),	
+	iDefOutput(0),
+	iDSOOutput(0),	
+	iOutFileName(0),
+	iDefInput(0),		
+	iElfInput(0),
+	iE32Input(0),
+	iLinkDLLName(0),
+	iDumpOptions(EDumpDefaults),
+	iFileDumpSubOptions(0),	
+	iSysDefOption(false),
+	iLogFileName(0),
+	iLogFileOption(false),
+	iMessageFileName(0),
+	iMessageFileOption(false),		
+	iDumpMessageFileName(0),	
+	iDumpMessageFileOption(false),
+	iDllDataP(false),	
+	iLibPathList (0),	
+	iSysDefCount (0),	
+	iPriorityOption(false),
+	iPriorityVal((TProcessPriority)0),
+	iVersion(0x000a0000u),
+	iVersionOption(false),
+	iCallEntryPoint(true),
+	iFPU(0),
+	iFPUOption(false),
+	iArgumentCount(0),
+
+	iCodePaged(false),
+	iCodeUnpaged(false),
+	iCodeDefaultPaged(false),
+
+	iDataPaged(false),
+	iDataUnpaged(false),
+	iDataDefaultPaged(false),
+	
+	iExcludeUnwantedExports(false),
+	iCustomDllTarget(false),
+	iSymNamedLookup(false),
+	iDebuggable(false),
+	iSmpSafe(false)
+{
+	iArgumentCount = aArgc;
+	ParamList temp(aArgv, aArgv+aArgc);
+	iParamList = temp;
+	iCapability.iCaps[0] = 0;	
+	iCapability.iCaps[1] = 0;
+}
+
+/**
+Destructor for the ParameterManager.
+
+@internalComponent
+@released
+*/
+ParameterManager::~ParameterManager()
+{
+	DELETE_PTR_ARRAY(iImageLocation);
+}
+
+/**
+Function to check if the given value is a valid number (decimal value)
+
+@internalComponent
+@released
+
+@param aArg
+Value to be checked
+@return True if the provided value is a decimal value.
+*/
+static bool IsAllDigits(const char * aArg)
+{
+	const char * p = aArg;
+	while (*p)
+	{
+		if (!isdigit(*p++)) return false;
+	}
+	return true;	
+}
+
+/**
+Function to check if the given value is a valid number (Hexadecimal value)
+
+@internalComponent
+@released
+
+@param aArg
+Value to be checked
+@return True if the provided value is a hexadecimal value.
+*/
+static bool IsAllXDigits(const char * aArg)
+{
+	const char * p = aArg;
+	while (*p)
+	{
+		if (!isxdigit(*p++)) return false;
+	}
+	return true;	
+}
+
+/**
+Function to check if the given value is a valid number (Decimal or Hexadecimal value)
+
+@internalComponent
+@released
+
+@param aVal
+Holds the validated number.
+@param aArg
+Value to be checked
+@return True if the provided value is a valid number.
+*/
+static bool GetUInt(UINT & aVal, const char * aArg)
+{
+	char * final = (char *)aArg;
+	// try base 10 first
+	if (IsAllDigits(aArg))
+	{
+		aVal = strtoul(aArg, &final, 10);
+		if (aArg != final) return true;
+		// now try as hex
+	}
+	if (aArg[0] == '0' && (aArg[1] == 'x' || aArg[1] == 'X'))
+	{
+		aArg += 2;
+		if (IsAllXDigits(aArg))
+		{
+			final = (char *)aArg ;
+			aVal = strtoul(aArg, &final, 16);
+			if (aArg != final) return true;
+		}
+	}
+
+	return false;
+}
+
+const char * ParameterManager::iParamPrefix = "--";
+const char * ParameterManager::iParamShortPrefix = "-";
+const char ParameterManager::iParamEquals = '=';
+
+// Option Map
+const ParameterManager::OptionDesc ParameterManager::iOptions[] = 
+{
+	{ 
+		"definput", 
+		(void *)ParameterManager::ParseDefInput,
+		"Input DEF File",
+	},
+	{ 
+		"defoutput", 
+		(void *)ParameterManager::ParseDefOutput,
+		"Output DEF File",
+	},
+	{ 
+		"elfinput", 
+		(void *)ParameterManager::ParseElfInput,
+		"Input ELF File",
+	},
+	{ 
+		"output", 
+		(void *)ParameterManager::ParseOutput,
+		"Output E32 Image",
+	},
+	{ 
+		"dso", 
+		(void *)ParameterManager::ParseDSOOutput,
+		"Output import DSO File",
+	},
+	{ 
+		"targettype", 
+		(void *)ParameterManager::ParseTargetTypeName,
+		"Target Type",
+	},
+	{ 
+		"linkas", 
+		(void *)ParameterManager::ParseLinkAs,
+		"name",
+	},
+	{ 
+		"uid1", 
+		(void *)ParameterManager::ParseUID1,
+		"UID 1",
+	},
+	{ 
+		"uid2", 
+		(void *)ParameterManager::ParseUID2,
+		"UID 2",
+	},
+	{ 
+		"uid3", 
+		(void *)ParameterManager::ParseUID3,
+		"UID 3",
+	},
+	{ 
+		"sid", 
+		(void *)ParameterManager::ParseSecureId,
+		"Secure ID",
+	},
+	{ 
+		"vid", 
+		(void *)ParameterManager::ParseVendorId,
+		"Vendor ID",
+	},
+	{ 
+		"fixedaddress", 
+		(void *)ParameterManager::ParseFixedAddress,
+		"Has fixed address",
+		},
+	{ 
+		"uncompressed", 
+		(void *)ParameterManager::ParseUncompressed,
+		"Don't compress output e32image",
+		},
+	{
+		"compressionmethod",
+		(void*)ParameterManager::ParseCompressionMethod,
+		"Input compression method [none|inflate|bytepair]\n\t\tnone     no compress the image.\
+		\n\t\tinflate  compress image with Inflate algorithm.\
+		\n\t\tbytepair tcompress image with BytePair Pak algorithm."
+	},
+	{ 
+		"heap", 
+		(void *)ParameterManager::ParseHeap,
+		"Heap committed and reserved size in bytes(.EXEs only)",
+	},
+	{ 
+		"stack", 
+		(void *)ParameterManager::ParseStackCommitted,
+		"Stack size in bytes(.EXEs only)",
+	},
+	{ 
+		"unfrozen", 
+		(void *)ParameterManager::ParseUnfrozen,
+		"Don't treat input dot-def file as frozen",
+	},
+	{ 
+		"ignorenoncallable", 
+		(void *)ParameterManager::ParseIgnoreNonCallable,
+		"Suppress implicit exports",
+	},
+	{
+		"capability",
+		(void *)ParameterManager::ParseCapability,
+		"capability option",
+	},
+	{ 
+		"libpath", 
+		(void *)ParameterManager::ParseLibPaths,
+		"A semi-colon separated search path list to locate import DSOs",
+	},
+	{
+		"sysdef",
+		(void *)ParameterManager::ParseSysDefs,
+		"A semi-colon separated Pre Defined Symbols to be exported and the ordinal number",
+	},
+	{
+		"log",
+		(void *)ParameterManager::ParseLogFile,
+		"Output Log Message",
+	},
+	{
+		"messagefile",
+		(void *)ParameterManager::ParseMessageFile,
+		"Input Message File",
+	},
+	{
+		"dumpmessagefile",
+		(void *)ParameterManager::ParseDumpMessageFile,
+		"Output Message File",
+	},
+	{
+		"dlldata", 
+		(void *)ParameterManager::ParseAllowDllData,
+		"Allow writable static data in DLL",
+	},
+	{
+		"dump",
+		(void *)ParameterManager::ParseFileDump,
+		"Input dump options [hscdeit] --e32input <filename>\n\tFlags for dump:\n\t\th Header \
+		 \n\t\ts Security info\n\t\tc Code section\n\t\td Data section \
+		 \n\t\te Export info\n\t\ti Import table\n\t\tt Symbol Info",
+	},
+	{
+		"e32input",
+		(void *)ParameterManager::ParseE32ImageInput,
+		"Input E32 Image File Name",
+	},
+	{
+		"priority",
+		(void *)ParameterManager::ParsePriority,
+		"Input Priority",
+	},
+	{
+		"version",
+		(void *)ParameterManager::ParseVersion,
+		"Module Version",
+	},
+	{
+		"callentry",
+		(void *)ParameterManager::ParseCallEntryPoint,
+		"Call Entry Point",
+	},
+	{
+		"fpu",
+		(void *)ParameterManager::ParseFPU,
+		"FPU type [softvfp|vfpv2]",
+	},
+	{
+        "codepaging",
+		(void *)ParameterManager::ParseCodePaging,
+		"Code Paging Strategy [paged|unpaged|default]",
+	},
+	{
+        "datapaging",
+		(void *)ParameterManager::ParseDataPaging,
+		"Data Paging Strategy [paged|unpaged|default]",
+	},
+
+	{
+		"paged",
+		(void *)ParameterManager::ParsePaged,
+		"This option is deprecated. Use --codepaging=paged instead.",
+	},
+	{
+		"unpaged",
+		(void *)ParameterManager::ParseUnpaged,
+		"This option is deprecated. Use --codepaging=unpaged instead.",
+	},
+	{
+		"defaultpaged",
+		(void *)ParameterManager::ParseDefaultPaged,
+		"This option is deprecated. Use --codepaging=default instead.",
+	},
+
+	{
+		"excludeunwantedexports",
+		(void *)ParameterManager::ParseExcludeUnwantedExports,
+		"Exclude Unwanted Exports",
+	},
+	{
+		"customdlltarget",
+		(void *)ParameterManager::ParseIsCustomDllTarget,
+		"Custom Dll Target",
+	},
+	{
+		"namedlookup",
+		(void*)ParameterManager::ParseSymNamedLookup,
+		"Enable named lookup of symbols",
+	},
+	{
+		"debuggable",
+		(void*)ParameterManager::ParseDebuggable,
+		"Debuggable by run-mode debug subsystem",
+	},
+	{
+		"smpsafe",
+		(void*)ParameterManager::ParseSmpSafe,
+		"SMP Safe",
+	},
+	{ 
+		"help", 
+		(void *)ParameterManager::ParamHelp,
+		0,
+	},
+};
+
+// Map for the short options (abbreviation)
+const ParameterManager::OptionDesc ParameterManager::iShortOptions[] =
+{
+	{ 
+		"h", 
+		(void *)ParameterManager::ParamHelp,
+		0,
+	},
+};
+
+/**
+This function finds the total number of options with normal prefix ('--')
+
+@internalComponent
+@released
+
+@return the total number of options with normal prefix '--' in the option list.
+*/
+int ParameterManager::NumOptions()
+{
+	return (sizeof(iOptions) / sizeof(OptionDesc));
+}
+
+/**
+This function finds the total number of options with short prefix ('-')
+
+@internalComponent
+@released
+
+@return the total number of options with short prefix '-' in the option list.
+*/
+int ParameterManager::NumShortOptions()
+{
+	return (sizeof(iShortOptions) / sizeof(OptionDesc));
+}
+
+/**
+This function initializes the option list, options preceeded by '--' and '-'
+
+@internalComponent
+@released
+*/
+void ParameterManager::InitParamParser()
+{
+	int lim = NumOptions();
+	int shortoptionlim = NumShortOptions();
+	int i;
+
+ 	for (i = 0; i < lim; i++)
+	{
+		string aOption = iOptions[i].iName;
+		iOptionMap[aOption] = &iOptions[i];
+	}
+
+	for (i = 0; i < shortoptionlim; i++)
+	{
+		string aShortOption = iShortOptions[i].iName;
+		iShortOptionMap[aShortOption] = &iShortOptions[i];
+	}
+}
+
+/**
+This function parses the command line options and identifies the input parameters.
+If no options or if --log is the only option passed in, then usage information will 
+be displayed.
+
+@internalComponent
+@released
+*/
+void ParameterManager::ParameterAnalyser()
+{
+	InitParamParser();
+	const OptionDesc * aHelpDesc = iOptionMap["help"];
+	int prefixLen = strlen(iParamPrefix);
+	int prefixShortLen = strlen(iParamShortPrefix);
+	int ArgCount = iArgumentCount-1;
+	RecordImageLocation();
+	ParamList::iterator p = iParamList.begin()+1;
+
+	int OnlyLoggingOption = 0;
+	
+	// Have to have some arguments. Otherwise, assume this is a request for --help and display the usage information
+	if (p == iParamList.end())
+	{
+		ParserFn parser = (ParserFn)aHelpDesc->iParser ;
+		parser(this, "help", 0, aHelpDesc);
+	}
+
+	if ( (ArgCount ==1) && (!strncmp(*p,"--log",5)) )
+		OnlyLoggingOption = 1;
+
+	for (; p != iParamList.end(); p++)
+	{
+		int Prefix=0, ShortPrefix=0;
+		ArgCount--;
+		
+
+		// Check if the option provided is correct and display help on getting incorrect options
+		try 
+		{
+			if (!strncmp(*p, iParamPrefix, prefixLen))
+				Prefix = 1;
+			else if (!strncmp(*p, iParamShortPrefix, prefixShortLen))
+				ShortPrefix = 1;
+			else // Option is neither preceeded by '-' or by '--'
+				throw ParameterParserError(OPTIONNAMEERROR,*p);
+		}
+		catch (ErrorHandler& error) 
+		{ 
+			error.Report();
+			ParserFn parser = (ParserFn)aHelpDesc->iParser ;
+			parser(this, *p, 0, 0);
+		}
+		
+		char *option;
+		const OptionDesc * aDesc;
+		char * optval=NULL;
+
+		// Get the option name excluding the prefix, '-' or '--'if (Prefix)
+		if (Prefix)
+			{
+ 			option = *p + prefixLen;
+			}
+ 		else
+			{
+			option = *p + prefixShortLen;
+			}
+
+		char * pos = strchr(*p, iParamEquals);
+
+		char *end = pos ? pos : *p + strlen(*p);
+
+		string aName(option, end);
+		string optionval;
+
+		if (pos)
+		{
+			if (*end != 0 && (*(end+1) != NULL) )
+			{
+			// Check to ensure that optval points to the correct option value
+				optval=end+1;
+			}
+			if ( ((p+1) != iParamList.end()) && (**(p+1) != '-') )
+			{
+				pos = 0;
+			}
+		}
+		if ( !pos)
+		{
+			// The option is not immediately preceeded by '='
+			// Space may be used to separate the input option and the paramters
+			// '=' may be enclosed within space
+			//if ((p+1) != iParamList.end())
+			if (ArgCount != 0) //To find if we have consumed all the arguments
+			{
+				while ( ((p+1) != iParamList.end()) && (**(p+1) != '-') )
+				{
+					end = *(p+1);
+					if (*end == '=') 
+					{
+						if ( (*(end+1) != ' ') && (*(end+1) != NULL) )
+							// This is the case where '=' is preceeded by space.
+							optionval += end+1;
+					}
+					else
+					{
+						optionval += end;
+					}
+					p++;
+					ArgCount-- ;
+				}
+				if (optionval.length())
+				{
+					if (optval)
+  						strcat(optval, optionval.c_str());
+  					else
+  					{
+  						optval = new char[optionval.length()+1];
+  						strcpy(optval, optionval.c_str());
+  					}
+				}				
+			}
+		}
+	
+		if (Prefix)
+			aDesc = iOptionMap[aName];
+		else
+			aDesc = iShortOptionMap[aName];
+
+		ParserFn parser = aDesc ?(ParserFn)aDesc->iParser : (ParserFn)aHelpDesc->iParser ;
+		// NB aDesc might be NULL which tells help to exit with error.
+		try
+		{
+			if (!aDesc)
+				throw ParameterParserError(OPTIONNAMEERROR,*p);
+		}
+		catch (ErrorHandler& error) 
+		{ 
+			error.Report();
+			ParserFn parser = (ParserFn)aHelpDesc->iParser ;
+			parser(this, "help", 0, 0);
+		}
+
+		// If --log is the only option provided, then display the usage information
+		if (OnlyLoggingOption)
+		{
+			parser(this, (char *)aName.c_str(), optval, aDesc);
+			parser = (ParserFn)aHelpDesc->iParser ;
+			parser(this, "help", 0, 0);
+		}
+
+		parser(this, const_cast<char*>(aName.c_str()), optval, aDesc);
+	}
+}
+
+/**
+This function extracts the path
+
+@internalComponent
+@released
+
+@param aPathName
+The file path name
+
+@return the Path in case of valid path name, else 0.
+
+*/
+char * ParameterManager::Path(char * aPathName)
+{
+	string str(aPathName);
+	size_t pos = str.find_last_of(DirectorySeparator());
+
+	if (pos < str.size())
+	{
+		char * aPath = new char[pos+2];
+		memcpy(aPath, aPathName, pos+1);
+		aPath[pos+1] = 0;
+		return aPath;
+	}
+	else
+		return (char *)0;
+}
+
+
+/**
+This function extracts the location where the image is to be dumped and the image name.
+
+@internalComponent
+@released
+*/
+void ParameterManager::RecordImageLocation()
+{
+	iImageLocation = Path(iArgv[0]);
+	iImageName = FileName(iArgv[0]);
+}
+
+/**
+This function finds out if the --definput option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --definput option is passed in or False.
+*/
+bool ParameterManager::DefFileInOption()
+{
+	return iDefFileInOption;
+}
+
+/**
+This function finds out if the --e32input option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --e32input option is passed in or False.
+*/
+bool ParameterManager::E32ImageInOption()
+{
+	return iE32ImageInOption;
+}
+
+/**
+This function finds out if the --elfinput option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --elfinput option is passed in or False.
+*/
+bool ParameterManager::ElfFileInOption()
+{
+	return iElfFileInOption;
+}
+
+/**
+This function finds out if the --dso option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --dso option is passed in or False.
+*/
+bool ParameterManager::DSOFileOutOption()
+{
+	return iDSOFileOutOption;
+}
+
+/**
+This function finds out if the --defoutput option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --defoutput option is passed in or False.
+*/
+bool ParameterManager::DefFileOutOption()
+{
+	return iDefFileOutOption;
+}
+
+/**
+This function finds out if the --output option is passed to the program.
+
+
+@internalComponent
+@released
+
+@return true if --output option is passed else return False.
+*/
+bool ParameterManager::E32OutOption()
+{
+	return iOutFileOption;
+}
+
+/**
+This function finds out if the --linkas option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --linkas option is passed in or False.
+*/
+bool ParameterManager::LinkAsOption()
+{
+	return iLinkAsOption;
+}
+
+
+/**
+This function finds out if the --UID1 option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --UID1 option is passed in or False.
+*/
+bool ParameterManager::Uid1Option()
+{
+	return iUid1Option;
+}
+
+/**
+This function finds out if the --sid option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --sid option is passed in or False.
+*/
+bool ParameterManager::SecureIdOption()
+{
+	return iSecureIDOption;
+}
+
+/**
+This function finds out if the --vid option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --vid option is passed in or False.
+*/
+bool ParameterManager::VendorIdOption()
+{
+	return iVendorIDOption;
+}
+
+/**
+This function finds out if the --log option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --log option is passed in or False.
+*/
+bool ParameterManager::LogFileOption()
+{
+	return iLogFileOption;
+}
+
+/**
+This function finds out if the --messagefile option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --messagefile option is passed in or False.
+*/
+bool ParameterManager::MessageFileOption()
+{
+	return iMessageFileOption;
+}
+
+/**
+This function finds out if the --dumpmessagefile option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --dumpmessagefile option is passed in or False.
+*/
+bool ParameterManager::DumpMessageFileOption()
+{
+	return iDumpMessageFileOption;
+}
+
+/**
+This function finds out if the --fixedaddress option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --fixedaddress option is passed in or False.
+*/
+bool ParameterManager::FixedAddress()
+{
+	return iFixedAddress;
+}
+
+/**
+This function finds out if the --uncompressed option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --uncompressed option is passed in or False.
+*/
+bool ParameterManager::Compress()
+{
+	return iCompress;
+}
+
+
+/**
+This function finds out if the --compressionmethod option is passed to the program.
+
+@internalComponent
+@released
+
+@return UId if --compressionmethod option is passed in or UId of deflate compressor (compatibility).
+*/
+UINT ParameterManager::CompressionMethod()
+{
+	return iCompressionMethod;
+}
+
+
+/**
+This function finds out if the --unfrozen option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --unfrozen option is passed in or False.
+*/
+bool ParameterManager::Unfrozen()
+{
+	return iUnfrozen;
+}
+
+/**
+This function finds out if the --ignorenoncallable option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --ignorenoncallable option is passed in or False.
+*/
+bool ParameterManager::IgnoreNonCallable()
+{
+	return iIgnoreNonCallable;
+}
+
+/**
+This function finds out if the --dlldata option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --dlldata option is passed in or False.
+*/
+bool ParameterManager::DllDataP()
+{
+ 	return iDllDataP;
+}
+
+/**
+This function finds out if the --version option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --version option is passed in or False.
+*/
+bool ParameterManager::VersionOption()
+{
+	return iVersionOption;
+}
+
+/**
+This function finds out if the --callentry option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --callentry option is passed in or False.
+*/
+bool ParameterManager::CallEntryPoint()
+{
+	return iCallEntryPoint;
+}
+
+/**
+This function finds out if the --priority option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --priority option is passed in or False.
+*/
+bool ParameterManager::PriorityOption()
+{
+	return iPriorityOption;
+}
+
+/**
+This function finds out if the --sysdef option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --sysdef option is passed in or False.
+*/
+bool ParameterManager::SysDefOption()
+{
+	return iSysDefOption;
+}
+
+/**
+This function finds out if the --dump option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --dump option is passed in or False
+*/
+bool ParameterManager::FileDumpOption()
+{
+	return iFileDumpOption;
+}
+
+/**
+This function finds out if the --fpu option is passed to the program.
+
+@internalComponent
+@released
+
+@return True if --fup option is passed in or False.
+*/
+bool ParameterManager::FPUOption()
+{
+	return iFPUOption;
+}
+
+
+/**
+This function extracts the DEF file name that is passed as input through the --definput option.
+
+@internalComponent
+@released
+
+@return the name of the input DEF file if provided as input through --definput or 0.
+*/
+char * ParameterManager::DefInput()
+{
+	return iDefInput;
+}
+
+/**
+This function extracts the Elf file name that is passed as input through the --elfinput option.
+
+@internalComponent
+@released
+
+@return the name of the input Elf file if provided as input through --elfinput or 0.
+*/
+char * ParameterManager::ElfInput()
+{
+	return iElfInput;
+}
+
+/**
+This function extracts the E32 image name that is passed as input through the --e32input option.
+
+@internalComponent
+@released
+
+@return the name of the input E32 image if provided as input through --e32input or 0.
+*/
+char * ParameterManager::E32Input()
+{
+	return iE32Input;
+}
+
+/**
+This function extracts the output DEF file name that is passed as input through the --defoutput option.
+
+@internalComponent
+@released
+
+@return the name of the output DEF file if provided as input through --defoutput or 0.
+*/
+char * ParameterManager::DefOutput()
+{
+	return iDefOutput;
+}
+
+/**
+This function extracts the DSO file name that is passed as input through the --dso option.
+
+@internalComponent
+@released
+
+@return the name of the output DSO file if provided as input through --dso or 0.
+*/
+char * ParameterManager::DSOOutput()
+{
+	return iDSOOutput;
+}
+
+/**
+This function extracts the E32 image output that is passed as input through the --output option.
+
+@internalComponent
+@released
+
+@return the name of the output E32 image output if provided as input through --output or 0.
+*/
+char * ParameterManager::E32ImageOutput()
+{
+	return iOutFileName;
+}
+
+/**
+This function extracts the target type that is passed as input through the --targettype option.
+
+@internalComponent
+@released
+
+@return the name of the input target type if provided as input through --targettype or 0.
+*/
+ETargetType ParameterManager::TargetTypeName()
+{
+	return iTargetTypeName;
+}
+
+/**
+This function extracts the name of the DLL (that the DSO is to be linked with) 
+that is passed as input through the --linkas option.
+
+@internalComponent
+@released
+
+@return the name of the DLL name to be linked with if provided as input through --linkas or 0.
+*/
+char * ParameterManager::LinkAsDLLName()
+{
+	return iLinkDLLName;
+}
+
+/**
+This function extracts the path (where the intermediate libraries should be put)
+that is passed as input through the --libpath option.
+
+@internalComponent
+@released
+
+@return the path if provided as input through --libpath or 0.
+*/
+ParameterListInterface::LibSearchPaths& ParameterManager::LibPath()
+{
+	return iLibPathList;
+}
+
+/**
+This function extracts the total number of predefined symbols passed to --sysdef option.
+
+@internalComponent
+@released
+
+@return the total number of predefined symbols passed through --elfinput or 0.
+*/
+int ParameterManager::SysDefCount()
+{
+	return iSysDefCount;
+}
+
+/**
+This function extracts the E32 image dump options passed as input through the --dump option.
+
+/@internalComponent
+@released
+
+@return the name of the dump options if provided as input through --dump or 0.
+*/
+char * ParameterManager::FileDumpSubOptions()
+{
+	return iFileDumpSubOptions;
+}
+
+/**
+This function extracts the E32 image dump options in integer value passed as character input
+through the --dump option.
+
+@internalComponent
+@released
+
+@return the name of the dump options in integer.
+*/
+int ParameterManager::DumpOptions()
+{
+      return iDumpOptions;
+}
+
+/**
+This function gets the first UID in a compound identifier (UID type) that is passed as 
+input through the --uid1 option.UID1 differentiates the executables, DLLs and file stores.
+
+@internalComponent
+@released
+
+@return the System level identifier if provided as input through --uid1 or 0.
+*/
+UINT ParameterManager::Uid1()
+{
+	return iUID1;
+}
+
+/**
+This function gets the UID2 that is passed as input through the --uid2 option.
+UID2 differentiates the static interface (shared library) and polymorphic interface 
+(application or plug-in framework) DLLs.
+	
+@internalComponent
+@released
+
+@return the Interface identifier if provided as input through --uid2 or 0.
+*/
+UINT ParameterManager::Uid2()
+{
+	return iUID2;
+}
+
+/**
+This function gets the UID3 that is passed as input through the --uid3 option. UID3 
+is shared by all objects belonging to a given program, including library DLLs if any, 
+framework DLLs, and all documents.
+	
+@internalComponent
+@released
+
+@return the Project identifier if provided as input through --uid3 or 0.
+*/
+UINT ParameterManager::Uid3()
+{
+	return iUID3;
+}
+
+/**
+This function gets the Secure Id that is passed as input through the --sid option.
+
+@internalComponent
+@released
+
+@return the Secure Id if provided as input through --sid or 0.
+*/
+UINT ParameterManager::SecureId()
+{
+	return iSecureID;
+}
+
+/**
+This function gets the Vendor Id that is passed as input through the --vid option.
+
+@internalComponent
+@released
+
+@return the Vendor Id if provided as input through --vid or 0.
+*/
+UINT ParameterManager::VendorId()
+{
+	return iVendorID;
+}
+
+/**
+This function gets the capability value passed to '--capability' option.
+
+@internalComponent
+@released
+
+@return the capability value passed to '--capability' option.
+*/
+SCapabilitySet ParameterManager::Capability()
+{
+	return iCapability;
+}
+
+/**
+This function extracts the Log file name that is passed as input through the --log option.
+
+@internalComponent
+@released
+
+@return the name of the Log file if provided as input through --log or 0.
+*/
+char * ParameterManager::LogFile()
+{
+	return iLogFileName;
+}
+
+/**
+This function extracts the Message file name that is passed as input through the --messagefile option.
+
+@internalComponent
+@released
+
+@return the name of the Message file if provided as input through --messagefile or 0.
+*/
+char * ParameterManager::MessageFile()
+{
+	return iMessageFileName;
+}
+
+/**
+This function extracts the Message file name that is passed as input through the --dumpmessagefile option.
+
+@internalComponent
+@released
+
+@return the name of the Message file to be dumped if provided as input through --dumpmessagefile or 0.
+*/
+char * ParameterManager::DumpMessageFile()
+{
+	return iDumpMessageFileName;
+}
+
+/**
+This function extracts the list of predefined symbols that is passed as input through
+the --sysdef option.
+
+@internalComponent
+@released
+
+@return the list of predefined symbols that is passed as input through the --sysdef option.
+*/
+ParameterManager::Sys ParameterManager::SysDefSymbols(int sysdefcount)
+{
+	return iSysDefSymbols[sysdefcount];
+}
+
+/**
+This function extracts the heap commited size passed as input to --heap option.
+
+@internalComponent
+@released
+
+@return the heap commited size passed as input to --heap option.
+*/
+size_t ParameterManager::HeapCommittedSize()
+{
+ 	return iHeapCommittedSize;
+}
+
+/**
+This function extracts the heap reserved size passed as input to --heap option.
+
+@internalComponent
+@released
+
+@return the heap reserved size passed as input to --heap option.
+*/
+size_t ParameterManager::HeapReservedSize()
+{
+ 	return iHeapReservedSize;
+}
+
+/**
+This function extracts the stack commited size passed as input to --stack option.
+
+@internalComponent
+@released
+
+@return the stack commited size passed as input to --stack option.
+*/
+size_t ParameterManager::StackCommittedSize()
+{
+ 	return iStackCommittedSize;
+}
+
+/**
+This function extracts the priority value passed as input to --priority option.
+
+@internalComponent
+@released
+
+@return the priority value passed as input to --priority option
+*/
+TProcessPriority ParameterManager::Priority()
+{
+	return iPriorityVal;
+}
+
+/**
+This function extracts the version information passed as input to --version option.
+
+@internalComponent
+@released
+
+@return the version information passed as input to --version option.
+*/
+UINT ParameterManager::Version()
+{
+	return iVersion;
+}
+
+/**
+This function extracts the fpu information passed as input to the --fpu option.
+
+@internalComponent
+@released
+
+@return the fpu information passed as input to the --fpu option.
+*/
+UINT ParameterManager::FPU()
+{
+	return iFPU;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsCodePaged()
+{
+	return iCodePaged;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsCodeUnpaged()
+{
+	return iCodeUnpaged;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsCodeDefaultPaged()
+{
+	return iCodeDefaultPaged;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsDataPaged()
+{
+	return iDataPaged;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsDataUnpaged()
+{
+	return iDataUnpaged;
+}
+
+/**
+@internalComponent
+@released
+*/
+bool ParameterManager::IsDataDefaultPaged()
+{
+	return iDataDefaultPaged;
+}
+
+/**
+This function finds out if the --excludeunwantedexports option is passed to the program.
+
+@internalComponent
+@released
+
+@return true if --excludeunwantedexports option is passed in or False.
+*/
+bool ParameterManager::ExcludeUnwantedExports()
+{
+	return iExcludeUnwantedExports;
+}
+
+/**
+This function finds out if the --customdlltarget option is passed to the program.
+
+@internalComponent
+@released
+
+@return true if --customdlltarget option is passed in or False.
+*/
+bool ParameterManager::IsCustomDllTarget()
+{
+	return iCustomDllTarget;
+}
+
+/**
+This function extracts the SymNamedLookup information passed as input to the --namedlookup option.
+
+@internalComponent
+@released
+
+@return the namedlookup information passed as input to the --namedlookup option.
+*/
+bool ParameterManager::SymNamedLookup()
+{
+	return iSymNamedLookup;
+}
+
+/**
+This function determines if the -debuggable option is passed to the program.
+
+@internalComponent
+@released
+
+@return true if --debuggable is passed in or False.
+*/
+bool ParameterManager::IsDebuggable()
+{
+	return iDebuggable;
+}
+
+
+bool ParameterManager::IsSmpSafe()
+{
+	return iSmpSafe;
+}
+
+/**
+This function extracts the filename from the absolute path that is given as input.
+
+@internalComponent
+@released
+
+@param aFileName
+The filename alongwith the absolute path.
+
+@return the filename (without the absolute path) for valid input else the filename itself.
+*/
+char * ParameterManager::FileName(char * aFileName)
+{
+	string str(aFileName);
+	
+	size_t pos = str.find_last_of(DirectorySeparator());	
+#ifndef __LINUX__ 	
+	// Support Unix slashes on Windows when stripping filenames from paths
+	if (pos > str.size())
+		{
+		pos = str.find_last_of('/');
+		}
+#endif
+
+	if (pos < str.size())
+		return aFileName + pos + 1;
+	else
+		return aFileName;
+}
+
+/**
+This function finds out the directory separator '\' in the path
+
+@internalComponent
+@released
+
+@return the directory spearator '\'
+*/
+char ParameterManager::DirectorySeparator()
+{
+#ifdef __LINUX__ 
+	return '/';
+#else 
+	return '\\';
+#endif 
+}
+
+/**
+This function set the input Def file name that is passed through --definput option.
+
+void ParameterManager::ParseDefInput(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --definput
+@param aValue
+The DEF file name passed to --definput option
+@param aDesc
+Pointer to function ParameterManager::ParseDefInput returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDefInput)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetDefInput(aValue);
+}
+
+/**
+This function set the input Elf file name that is passed through --elfinput option.
+
+void ParameterManager::ParseElfInput(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --elfinput
+@param aValue
+The ELF file name passed to --elfinput option
+@param aDesc
+Pointer to function ParameterManager::ParseElfInput returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseElfInput)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetElfInput(aValue);
+}
+
+/**
+This function set the output Def file name that is passed through --defoutput option.
+
+void ParameterManager::ParseDefOutput(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --defoutput
+@param aValue
+The DEF file name passed to --defoutput option
+@param aDesc
+Pointer to function ParameterManager::ParseDefOutput returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDefOutput)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetDefOutput(aValue);
+}
+
+/**
+This function set the input E32 file name that is passed through --e32input option.
+
+void ParameterManager::ParseE32Input(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --e32input
+@param aValue
+The E32 file name passed to --e32input option
+@param aDesc
+Pointer to function ParameterManager::ParseE32Input returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseE32ImageInput)
+{
+      INITIALISE_PARAM_PARSER;
+      aPM->SetE32Input(aValue);
+}
+
+/**
+This function set the output E32 image name that is passed through --output option.
+
+void ParameterManager::ParseOutput(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --output
+@param aValue
+The E32 file name passed to --output option
+@param aDesc
+Pointer to function ParameterManager::ParseOutput returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseOutput)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetE32Output(aValue);
+}
+
+/**
+This function set the output Log file name that is passed through --log option.
+
+void ParameterManager::ParseLogFile(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --log
+@param aValue
+The Log file name passed to --log option
+@param aDesc
+Pointer to function ParameterManager::ParseLogFile returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseLogFile)
+{
+	INITIALISE_PARAM_PARSER;
+	if(aValue)
+	{
+		aPM->SetLogFile(aValue);
+		MessageHandler::StartLogging(aValue);
+	}
+	else
+	{
+		throw ParameterParserError(NOARGUMENTERROR, "--log");
+	}
+}
+
+/**
+This function set the input Message file name that is passed through --messagefile option.
+
+void ParameterManager::ParseMessageFile(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --messagefile
+@param aValue
+The Message file name passed to --messagefile option
+@param aDesc
+Pointer to function ParameterManager::ParseMessageFile returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseMessageFile)
+{
+	INITIALISE_PARAM_PARSER;
+	if(aValue)
+	{
+		aPM->SetMessageFile(aValue);
+		MessageHandler::InitializeMessages(aValue);
+	}
+	else
+	{
+		throw ParameterParserError(NOARGUMENTERROR, "--messagefile");
+	}
+}
+
+/**
+This function set the Message file name to be dumped that is passed through --dumpmessagefile option.
+
+void ParameterManager::ParseDumpMessageFile(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --dumpmessagefile
+@param aValue
+The output Message file name passed to --dumpmessagefile option
+@param aDesc
+Pointer to function ParameterManager::ParseDumpMessageFile returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDumpMessageFile)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetDumpMessageFile(aValue);
+}
+
+/**
+This function checks the arguments passed to the options. If an incorrect argument
+is passed or if no arguments are passed then appropriate error message is displayed.
+
+@internalComponent
+@released
+
+@param aValue
+Input to the option
+@param aOption
+Option that is passed as input
+@return the validated value
+*/
+UINT ValidateInputVal(char * aValue, char * aOption)
+{
+	UINT uid;
+	if (!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, aOption);
+	else if (!GetUInt(uid, aValue))
+		throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, aOption);
+	return uid;
+}
+
+/**
+There are some boolean options which does not expect any inputs. This function checks
+if there are any the arguments passed to the option. In case of getting an input argument,
+the warning message "Value is ignored" is displayed.
+
+@internalComponent
+@released
+
+@param aValue
+Input to the option
+@param aOption
+Option that is passed as input
+*/
+void CheckInput(char * aValue, char * aOption)
+{
+	if (aValue)
+		MessageHandler::GetInstance()->ReportMessage(WARNING, VALUEIGNOREDWARNING, aOption);
+}
+
+/**
+This function set the version information that is passed through --version option.
+
+void ParameterManager::ParseVersion(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --version
+@param aValue
+The version information passed to --version option
+@param aDesc
+Pointer to function ParameterManager::ParseVersion returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseVersion)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT version = 0;
+	UINT majorVal = 0;
+	UINT minorVal = 0;
+
+	if(!aValue)
+  	throw ParameterParserError(NOARGUMENTERROR, "--version");
+
+	char * tokens = strdup(aValue);
+	char * major, * minor;
+
+	major = strtok(tokens, ".");
+	majorVal = ValidateInputVal(major, "--version");
+	minor = strtok(NULL, ".");
+	if (minor && !GetUInt(minorVal, minor))
+		throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, "--version");
+
+	version = ((majorVal & 0xFFFF) << 16) | (minorVal & 0xFFFF);
+	aPM->SetVersion(version);
+}
+
+/**
+This function set the UID1 value that is passed through --uid1 option.
+
+void ParameterManager::ParseUID1(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --uid1
+@param aValue
+The UID1 value passed to --uid1 option
+@param aDesc
+Pointer to function ParameterManager::ParseUID1 returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUID1)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aUid = ValidateInputVal(aValue, "--uid1");
+	aPM->SetUID1(aUid);
+}
+
+/**
+This function set the UID2 value that is passed through --uid2 option.
+
+void ParameterManager::ParseUID2(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --uid2
+@param aValue
+The UID2 value passed to --uid2 option
+@param aDesc
+Pointer to function ParameterManager::ParseUID2 returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUID2)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aUid = ValidateInputVal(aValue, "--uid2");
+	aPM->SetUID2(aUid);
+}
+
+/**
+This function set the UID3 value that is passed through --uid3 option.
+
+void ParameterManager::ParseUID3(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --uid3
+@param aValue
+The UID3 value passed to --uid3 option
+@param aDesc
+Pointer to function ParameterManager::ParseUID3 returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUID3)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aUid = ValidateInputVal(aValue, "--uid3");
+	aPM->SetUID3(aUid);
+}
+
+/**
+This function set the Secure ID value that is passed through --sid option.
+
+void ParameterManager::ParseSecureId(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --sid
+@param aValue
+The Secure ID value passed to --sid option
+@param aDesc
+Pointer to function ParameterManager::ParseSecureId returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseSecureId)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aUid = ValidateInputVal(aValue, "--sid");
+	aPM->SetSecureId(aUid);
+}
+
+/**
+This function set the Vendor ID value that is passed through --vid option.
+
+void ParameterManager::ParseVendorId(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --vid
+@param aValue
+The Vendor ID value passed to --vid option
+@param aDesc
+Pointer to function ParameterManager::ParseVendorId returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseVendorId)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aUid = ValidateInputVal(aValue, "--vid");
+	aPM->SetVendorId(aUid);
+}
+
+/**
+This function set the FixedAddress flag if --fixedaddress option is passed to the program.
+
+void ParameterManager::ParseFixedAddress(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --fixedaddress
+@param aValue
+The value passed to --fixedaddress option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseFixedAddress returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseFixedAddress)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--fixedaddress");
+	aPM->SetFixedAddress(true);
+}
+
+/**
+This function set the CallEntryPoint flag if --callentry option is passed to the program.
+
+void ParameterManager::ParseCallEntryPoint(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --callentry
+@param aValue
+The value passed to --callentry option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseCallEntryPoint returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseCallEntryPoint)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetCallEntryPoint(true);
+}
+
+/**
+This function set the Uncompressed flag if --uncompressed option is passed to the program.
+
+void ParameterManager::ParseUncompressed(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --uncompressed
+@param aValue
+The value passed to --uncompressed option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseUncompressed returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUncompressed)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--uncompressed");
+	aPM->SetCompress(false);
+}
+
+
+static const ParameterManager::CompressionMethodDesc MethodNames[] =
+{
+	{ "none", 0},
+	{ "inflate", KUidCompressionDeflate},
+	{ "bytepair", KUidCompressionBytePair},
+	{ 0, 0}
+};
+
+/**
+This function parses the compression method value passed in and finds the corresponding match
+from the list of existing method values.
+
+@internalComponent
+@released
+
+@param aMethod
+Holds the method value mapped from list.
+@param aText
+The priority value passed to --compressionmethod option
+@return True if the method value passed in is a valid one present in the list.
+*/
+static bool ParseCompressionMethodArg(UINT & aMethod, const char *aText)
+{
+	
+	int i = 0;
+	aMethod = 0;
+	for (;; i++)
+	{
+		if (!MethodNames[i].iMethodName)
+			return false;
+		if (!stricmp(aText, MethodNames[i].iMethodName))
+		{
+			aMethod = MethodNames[i].iMethodUid;
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+This function set the CompressionMethod variable if --compressionmethod option is passed to the program.
+
+void ParameterManager::ParseUncompressed(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --compressionmethod
+@param aValue
+The value passed to --compressionmethod option, in this case none|inflate|bytepair
+@param aDesc
+Pointer to function ParameterManager::ParseCompressionMethod returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseCompressionMethod)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT method;
+	if(!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, "--compressionmethod");
+	
+	if(ParseCompressionMethodArg(method, aValue) )
+		aPM->SetCompressionMethod(method);
+	else
+		throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, "compression method");
+}
+
+/**
+This function parses the compression method value passed in and finds the corresponding match
+from the list of existing method values.
+
+@internalComponent
+@released
+
+
+
+/**
+This function set the AllowDllData flag if --dlldata option is passed to the program.
+
+void ParameterManager::ParseAllowDllData(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --dlldata
+@param aValue
+The value passed to --dlldata option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseAllowDllData returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseAllowDllData)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--dlldata");
+	aPM->SetDllDataP(true);
+}
+
+static const ParameterManager::PriorityValueDesc PriorityNames[] =
+{
+	{ "Low", EPriorityLow},
+	{ "Background", EPriorityBackground},
+	{ "Foreground", EPriorityForeground},
+	{ "High", EPriorityHigh},
+	{ "WindowServer", EPriorityWindowServer},
+	{ "FileServer", EPriorityFileServer},
+	{ "RealTimeServer", EPriorityRealTimeServer},
+	{ "Supervisor", EPrioritySupervisor},
+	{ 0, (TProcessPriority)0}
+};
+
+/**
+This function parses the priority value passed in and finds the corresponding match
+from the list of existing priority values.
+
+@internalComponent
+@released
+
+@param aPriority
+Holds the priority value mapped from list.
+@param aText
+The priority value passed to --priority option
+@return True if the priority value passed in is a valid one present in the list.
+*/
+static bool ParsePriorityArg(unsigned int & aPriority, const char *aText)
+{
+	int i = 0;
+	aPriority = 0;
+	for (;; i++)
+	{
+		if (!PriorityNames[i].iName)
+			return false;
+		if (!stricmp(aText, PriorityNames[i].iName))
+		{
+			aPriority = PriorityNames[i].iPriority;
+			return true;
+		}
+	}
+	return false;
+}
+
+
+/**
+This function set the priority value that is passed through --priority option.
+
+void ParameterManager::ParsePriority(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --priority
+@param aValue
+The priority value passed to --priority option
+@param aDesc
+Pointer to function ParameterManager::ParsePriority returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParsePriority)
+{
+	INITIALISE_PARAM_PARSER;
+	unsigned int priority;
+	if (!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, "--priority");
+	if (GetUInt(priority, aValue) || ParsePriorityArg(priority, aValue))
+		aPM->SetPriority((TProcessPriority)priority);
+	else
+		throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, "priority");
+}
+
+/**
+This function sets the predefined symbols, at the specified ordinal numbers, that are passed through 
+--sysdef option.
+
+void ParameterManager::ParseSysDefs(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --sysdef
+@param aValue
+The predefined symbols alongwith the ordinal numbers passed to --sysdef option
+@param aDesc
+Pointer to function ParameterManager::ParseSysDefs returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseSysDefs)
+{
+	INITIALISE_PARAM_PARSER;
+	if (!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, "--sysdef");
+	string aSysDefValues(aValue);
+	string::iterator p = aSysDefValues.begin();
+
+	int sysdeflength = aSysDefValues.size();
+	
+	int parsesysdef = 1; 
+
+	int sysdefcount=0;
+
+	while (parsesysdef && sysdeflength)
+	{
+
+		int q = 0;
+		unsigned int ordinalnum = 0;
+		char *symbol = 0;
+
+		int nq = aSysDefValues.find_first_of(",", q,sizeof(*p));
+		if (nq && (nq != string::npos))
+		{
+			int len = nq;
+			symbol = new char[len+1];
+			memcpy(symbol, p, len);
+			symbol[len] = 0;
+			q = nq+1;
+
+			char val = *(p+q);
+			if (!val || !isdigit(val))
+				throw ParameterParserError(SYSDEFERROR, "--sysdef");
+			ordinalnum = *(p+q) - '0';
+			aPM->SetSysDefs(ordinalnum, symbol, sysdefcount);
+
+			unsigned int separator = aSysDefValues.find(";", 0);
+
+			if (separator && (separator != string::npos))
+			{
+				if (separator != (unsigned int)(q+1))
+					throw ParameterParserError(MULTIPLESYSDEFERROR, "--sysdef");
+				else 
+				{
+					sysdeflength -= separator + 1;
+					aSysDefValues = aSysDefValues.substr(separator+1);
+					sysdefcount++;
+				}	
+			}
+			else
+			{
+				sysdeflength -= q+1;
+				if (sysdeflength)
+					throw ParameterParserError(MULTIPLESYSDEFERROR, "--sysdef");
+				else
+					parsesysdef = 0;
+			}
+		}
+		else
+		{
+			if (!nq && sysdeflength)
+				throw ParameterParserError(SYSDEFNOSYMBOLERROR, "--sysdef");
+			else
+				throw ParameterParserError(SYSDEFERROR, "--sysdef");
+		}
+	}
+}
+
+/**
+This function parses the capability value passed to --capability option.
+
+@internalComponent
+@released
+
+@param aName
+The pointer marking the beginning value passed to the --capability option
+@param aEnd
+The pointer marking the end value passed to the --capability option
+@param aCapabilities
+List of Capability Values allowed
+@param aInvert
+Flag to denote if value can be inverted.
+*/
+void ParameterManager::ParseCapability1(const char * aName, const char * aEnd, SCapabilitySet& aCapabilities, bool aInvert)
+{
+	int n = aEnd - aName;
+	int i = 0;
+	if(n==3 && strnicmp("all",aName,n)==0)
+	{
+		if(aInvert)
+			throw CapabilityError(CAPABILITYALLINVERSIONERROR);
+
+		for(i=0; i<ECapability_Limit; i++)
+		{
+			if(CapabilityNames[i])
+				aCapabilities[i>>5] |= (1<<(i&31));
+		}
+		return;
+	}
+
+	if(n==4 && strnicmp("none",aName,n)==0)
+	{
+		if(aInvert)
+			throw CapabilityError(CAPABILITYNONEINVERSIONERROR);
+
+		memset(&aCapabilities,0,sizeof(aCapabilities));
+		return;
+	}
+
+	for(i=0; i<ECapability_Limit; i++)
+	{
+		const char* cap = CapabilityNames[i];
+		if(!cap)
+			continue;
+		if((int)strlen(cap)!=n)
+			continue;
+		if(strnicmp(cap,aName,n)!=0)
+			continue;
+		break;
+	}
+	if(i>=ECapability_Limit)
+	{
+		string aBadCap(aName, aEnd);
+		throw UnrecognisedCapabilityError(UNRECOGNISEDCAPABILITYERROR,"BAD CAP");
+	}
+	if(aInvert)
+		aCapabilities[i>>5] &= ~(1<<(i&31));
+	else
+		aCapabilities[i>>5] |= (1<<(i&31));
+}
+
+/**
+This function parses the capability value passed to --capability option.
+
+@internalComponent
+@released
+
+@param aCapabilities
+List of Capability Values allowed
+@param aText
+Value passed to --capability option.
+*/
+void ParameterManager::ParseCapabilitiesArg(SCapabilitySet& aCapabilities, const char *aText)
+{
+	string aCapList(aText);
+	string::iterator b = aCapList.begin();
+	string::iterator e = b;
+	bool invert = false;
+
+	while(e != aCapList.end())
+	{
+		invert = false;
+		if (*b == '-')
+		{
+			invert = true;
+			b++;
+		}
+		else if (*b == '+')
+			b++;
+
+		e = b;
+		for (; e != aCapList.end(); e++)
+		{
+			if (*e == '-' || *e == '+') break;
+		}
+		if (e != b)
+			ParseCapability1(b, e, aCapabilities, invert);
+
+		b = e;
+		
+	}
+}
+
+/**
+This function parses the capability value passed to --capability option.
+
+void ParameterManager::ParseCapability(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --capability
+@param aValue
+The predefined symbols alongwith the ordinal numbers passed to --capability option
+@param aDesc
+Pointer to function ParameterManager::ParseCapability returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseCapability)
+{
+	INITIALISE_PARAM_PARSER;
+	unsigned int cap;
+	SCapabilitySet capSet = {0, 0};
+	if (!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, "--capability");
+	if (GetUInt(cap, aValue))
+	{
+		aPM->SetCapability(cap);
+	}
+	else
+	{
+		aPM->ParseCapabilitiesArg(capSet, aValue);
+		aPM->SetCapability(capSet);
+	}
+}
+
+/**
+This function set the Heap Reserved and Committed Size value that is passed through --heap option.
+
+void ParameterManager::ParseHeap(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --heap
+@param aValue
+The Heap Reserved and Committed Size value passed to --heap option separated by ','.
+@param aDesc
+Pointer to function ParameterManager::ParseHeap returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseHeap)
+{
+	INITIALISE_PARAM_PARSER;
+	string aArg(aValue);
+	UINT committed = aPM->HeapCommittedSize();
+	UINT reserved = aPM->HeapReservedSize();
+	int p = aArg.find_first_of(",");
+	if (p  < 0)
+	{
+		if ( !GetUInt(committed, aValue)) 
+			throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, "heap");
+	}
+	else
+	{
+		aArg[p] = 0;
+		const char * committedval = aArg.c_str();
+		const char * reservedval = committedval + p + 1;
+		if (!(GetUInt(committed, committedval) && GetUInt(reserved, reservedval)))
+			throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, "heap");
+	}
+	aPM->SetHeapCommittedSize(committed);
+	aPM->SetHeapReservedSize(reserved);
+}
+
+/**
+This function set the stack Committed Size that is passed through --stack option.
+
+void ParameterManager::ParseStackCommitted(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --stack
+@param aValue
+The Stack Committed Size value passed to --stack option.
+@param aDesc
+Pointer to function ParameterManager::ParseStackCommitted returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseStackCommitted)
+{
+	INITIALISE_PARAM_PARSER;
+	UINT aSize = ValidateInputVal(aValue, "--stack");
+	aPM->SetStackCommittedSize(aSize);
+}
+
+/**
+This function set the Unfrozen flag if --unfrozen option is passed to the program.
+
+void ParameterManager::ParseUnfrozen(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --unfrozen
+@param aValue
+The value passed to --unfrozen option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseUnfrozen returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUnfrozen)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--unfrozen");
+	aPM->SetUnfrozen(true);
+}
+
+/**
+This function set the ignorenoncallable flag if --ignorenoncallable option is passed to the program.
+
+void ParameterManager::ParseIgnoreNonCallable(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --ignorenoncallable
+@param aValue
+The value passed to --ignorenoncallable option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::Parseignorenoncallable returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseIgnoreNonCallable)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--ignorenoncallable");
+	aPM->SetIgnoreNonCallable(true);
+}
+
+/**
+This function sets the FPU type that is passed using the --fpu option.
+
+void ParameterManager::ParseFPU(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --fpu
+@param aValue
+The fpu information passed to the --fpu option
+@param aDesc
+Pointer to function ParameterManager::ParseFPU returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseFPU)
+{
+	INITIALISE_PARAM_PARSER;
+
+	if (strnicmp(aValue, "softvfp", 7)==0)
+		aPM->SetFPU(0);
+	else if (strnicmp(aValue, "vfpv2", 5)==0)
+		aPM->SetFPU(1);
+	else
+		throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, aOption);
+}
+
+/**
+This function set the Paged flag if --paged option is passed to the program.
+
+void ParameterManager::ParsePaged(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --paged
+@param aValue
+The value passed to --paged option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParsePaged returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParsePaged)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--paged");
+
+	if (aPM->IsCodeUnpaged() || aPM->IsCodeDefaultPaged())
+	{
+		throw InvalidInvocationError(INVALIDINVOCATIONERROR);
+	}
+
+	aPM->SetCodePaged(true);
+}
+
+/**
+This function set the Unpaged flag if --unpaged option is passed to the program.
+
+void ParameterManager::ParseUnpaged(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --unpaged
+@param aValue
+The value passed to --unpaged option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseUnpaged returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseUnpaged)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--unpaged");
+
+	if (aPM->IsCodePaged() || aPM->IsCodeDefaultPaged())
+	{
+		throw InvalidInvocationError(INVALIDINVOCATIONERROR);
+	}
+	
+	aPM->SetCodeUnpaged(true);
+}
+
+/**
+This function set the Defaultpaged flag if --defaultpaged option is passed to the program.
+
+void ParameterManager::ParseDefaultpaged(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --defaultpaged
+@param aValue
+The value passed to --defaultpaged option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseDefaultpaged returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDefaultPaged)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--defaultpaged");
+
+	if (aPM->IsCodePaged() || aPM->IsCodeUnpaged())
+	{
+		throw InvalidInvocationError(INVALIDINVOCATIONERROR);
+	}
+	
+	aPM->SetCodeDefaultPaged(true);
+}
+
+
+/**
+@internalComponent
+@released
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseCodePaging)
+{
+	INITIALISE_PARAM_PARSER;
+
+	if (strnicmp(aValue, "paged", 5)==0)
+    {
+        aPM->SetCodePaged(true);
+    }
+	else if (strnicmp(aValue, "unpaged", 7)==0)
+    {
+        aPM->SetCodeUnpaged(true);
+    }
+	else if (strnicmp(aValue, "default", 7)==0)
+    {
+        aPM->SetCodeDefaultPaged(true);
+    }
+	else
+    {
+        throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, aOption);
+    }
+
+	// Check that we haven't been given conflicting options.
+
+    unsigned check = 0;
+
+    if ( aPM->IsCodePaged() )
+    {
+        check++;
+    }
+    if ( aPM->IsCodeUnpaged() )
+    {
+        check++;
+    }
+    if ( aPM->IsCodeDefaultPaged() )
+    {
+        check++;
+    }
+
+    if (check > 1)
+    {
+		throw InvalidInvocationError(INVALIDINVOCATIONERROR);
+    }
+}
+
+/**
+@internalComponent
+@released
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDataPaging)
+{
+	INITIALISE_PARAM_PARSER;
+
+	if (strnicmp(aValue, "paged", 5)==0)
+    {
+        aPM->SetDataPaged(true);
+    }
+	else if (strnicmp(aValue, "unpaged", 7)==0)
+    {
+        aPM->SetDataUnpaged(true);
+    }
+	else if (strnicmp(aValue, "default", 7)==0)
+    {
+        aPM->SetDataDefaultPaged(true);
+    }
+	else
+    {
+        throw InvalidArgumentError(INVALIDARGUMENTERROR, aValue, aOption);
+    }
+
+	// Check that we haven't been given conflicting options.
+
+    unsigned check = 0;
+
+    if ( aPM->IsDataPaged() )
+    {
+        check++;
+    }
+    if ( aPM->IsDataUnpaged() )
+    {
+        check++;
+    }
+    if ( aPM->IsDataDefaultPaged() )
+    {
+        check++;
+    }
+
+    if (check > 1)
+    {
+		throw InvalidInvocationError(INVALIDINVOCATIONERROR);
+    }
+}
+
+
+/**
+This function sets the iExcludeUnwantedExports flag if --excludeunwantedexports option is passed to the program.
+
+void ParameterManager::ParseExcludeUnwantedExports(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --excludeunwantedexports
+@param aValue
+The value passed to --excludeunwantedexports, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseExcludeUnwantedExports returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseExcludeUnwantedExports)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--excludeunwantedexports");
+	aPM->SetExcludeUnwantedExports(true);
+}
+
+/**
+This function sets the customdlltarget flag if --customdlltarget option is passed to the program.
+
+void ParameterManager::ParseIsCustomDllTarget(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --customdlltarget
+@param aValue
+The value passed to --customdlltarget option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseIsCustomDllTarget returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseIsCustomDllTarget)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--customdlltarget");
+	aPM->SetCustomDllTarget(true);
+}
+
+DEFINE_PARAM_PARSER(ParameterManager::ParseSymNamedLookup)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--namedlookup");
+	aPM->SetSymNamedLookup(true);
+}
+
+/**
+This function set the iDebuggable flag if --debuggable option is passed to the program.
+
+void ParameterManager::ParseDebuggable(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --debuggable
+@param aValue
+The value passed to --debuggable option, in this case NULL
+@param aDesc
+Pointer to function ParameterManager::ParseDebuggable returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDebuggable)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--debuggable");
+	aPM->SetDebuggable(true); 
+}
+
+
+DEFINE_PARAM_PARSER(ParameterManager::ParseSmpSafe)
+{
+	INITIALISE_PARAM_PARSER;
+	CheckInput(aValue, "--smpsafe");
+	aPM->SetSmpSafe(true); 
+}
+
+static const ParameterManager::TargetTypeDesc DefaultTargetTypes[] =
+{
+	{ "DLL", EDll },
+	{ "LIB", ELib },
+	// allow full name
+	{ "LIBRARY", ELib},
+	{ "IMPLIB", ELib},
+	{ "EXE", EExe},
+	{ "ANI", EPolyDll},
+	{ "APP", EPolyDll},
+	{ "CTL", EPolyDll},
+	{ "CTPKG", EPolyDll},
+	{ "FSY", EPolyDll},
+	{ "LDD", EPolyDll},
+	{ "ECOMIIC", EPolyDll},
+	{ "PLUGIN", EPolyDll},
+	{ "PLUGIN3", EPolyDll},
+	{ "KDLL", EPolyDll},
+	{ "KEXT", EPolyDll},
+	{ "MDA", EPolyDll},
+	{ "MDl", EPolyDll},
+	{ "RDL", EPolyDll},
+	{ "NOTIFIER", EPolyDll},
+	{ "NOTIFIER2", EPolyDll},
+	{ "TEXTNOTIFIER2", EPolyDll},
+	{ "PDD", EPolyDll},
+	{ "PDL", EPolyDll},
+	{ "VAR", EPolyDll},
+	{ "VAR2", EPolyDll},
+	{ "EXEXP", EExexp},
+	{ "STDEXE", EStdExe},
+	{ "STDDLL", EDll},
+	{ 0, EInvalidTargetType }
+};
+
+/**
+Function to check if the given target type is a valid one from the list.
+
+@internalComponent
+@released
+
+@param aArg
+Value to be checked, the one that is passed to '--targettype'.
+@return True if the provided value is a valid targettype.
+*/
+static ETargetType IsDefaultTargetType(const char * aArg)
+{
+	for (int i = 0; DefaultTargetTypes[i].iName; i++)
+	{
+		if (aArg && !stricmp(aArg, DefaultTargetTypes[i].iName)) 
+			return DefaultTargetTypes[i].iTargetType;
+	}
+	return EInvalidTargetType;
+}
+
+/**
+Function to check if the given target type is a valid one from the list. If no value is
+passed or if unsupported targettypes are passed, then the appropriate warnings are displayed.
+
+@internalComponent
+@released
+
+@param aArg
+Value to be checked, the one that is passed to '--targettype'.
+@return the appropriate matching value from the list.
+*/
+ETargetType ParameterManager::ValidateTargetType(const char * aArg)
+{
+	ETargetType res = IsDefaultTargetType(aArg);
+	if (res == EInvalidTargetType)
+	{
+		if (aArg)
+			MessageHandler::GetInstance()->ReportMessage(WARNING, UNSUPPORTEDTARGETTYPEERROR,aArg);
+		else
+			MessageHandler::GetInstance()->ReportMessage(WARNING, TARGETTYPENOTSPECIFIEDERROR);
+	}
+	return res;
+}
+
+/**
+This function set the target type that is passed through --targettype option.
+
+void ParameterManager::ParseTargetTypeName(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --targettype
+@param aValue
+The target type passed to --targettype option
+@param aDesc
+Pointer to function ParameterManager::ParseTargetTypeName returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseTargetTypeName)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetTargetTypeName(aPM->ValidateTargetType(aValue));
+}
+
+/**
+This function set the output DSO file name that is passed through --dso option.
+
+void ParameterManager::ParseDSOOutput(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --dso
+@param aValue
+The DSO file name passed to --dso option
+@param aDesc
+Pointer to function ParameterManager::ParseDSOOutput returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseDSOOutput)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetDSOOutput(aValue);
+}
+
+/**
+This function displays the usage information if --help option is passed in.
+For invalid option, this function displays the usage information and throws the
+appropriate error message.
+
+void ParameterManager::ParamHelp(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --help or -h
+@param aValue
+The value passed to --help option, in this case, no value, hence 0.
+@param aDesc
+Pointer to function ParameterManager::ParamHelp returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParamHelp)
+{
+	INITIALISE_PARAM_PARSER;
+	using std::cerr;
+	using std::endl;
+
+	cerr << "\nSymbian Post Linker, " << "Elf2E32"
+         << " V" << MajorVersion << "." << MinorVersion << " (Build "<<Build <<")"
+         << endl;
+
+	cerr << "Usage:\t" << "elf2e32" << " [options] [filename]\n" << endl;
+    
+    cerr << "Options:\n" ;
+
+	const OptionDesc * aHelpDesc = aPM->iOptionMap["help"];
+	int lim = aPM->NumOptions();
+	for (int i = 0; i < lim; i++)
+	{
+		if (aPM->iOptions[i].iName == aHelpDesc->iName)
+		{
+			cerr << '\t' << aPM->iParamPrefix << aPM->iOptions[i].iName 
+				<< " : This command." << endl;
+		}
+		else
+		{
+			cerr << '\t' << aPM->iParamPrefix << aPM->iOptions[i].iName;
+			if (aPM->iOptions[i].iDoc) cerr << aPM->iParamEquals << aPM->iOptions[i].iDoc;
+			cerr << endl;
+		}
+	}
+	
+	if (!aDesc)
+		exit(EXIT_FAILURE);
+	else
+		exit(EXIT_SUCCESS);
+}
+
+/**
+This function set the LibPath that is passed through --libpath option.
+
+void ParameterManager::ParseLibPath(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --libpath
+@param aValue
+The LibPath value passed to --libpath option.
+@param aDesc
+Pointer to function ParameterManager::ParseLibPath returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseLibPaths)
+{
+	INITIALISE_PARAM_PARSER;
+	if (!aValue)
+		throw ParameterParserError(NOARGUMENTERROR, "--libpath");
+	string aPathList(aValue);
+	const char* p = aPathList.c_str(); 
+	int n =  strlen(p); 
+	int q = 0;
+	while (n)
+	{
+		int nq = aPathList.find_first_of(";", q, sizeof(*p));
+		if (nq > 0)
+		{
+			// handle case where there are multiple paths which are ; separated
+			int len = nq - q;
+			if (p[len-1] == aPM->DirectorySeparator()) len--;
+			char * path = new char[len+1];
+			memcpy(path, p+q, len);
+			path[len] = 0;
+			aPM->iLibPathList.push_back(path);
+			n -= nq - q + 1;
+			q = nq+1;
+		}
+		else
+		{
+			p += q;
+			int len = strlen(p);
+			if (p[len-1] == aPM->DirectorySeparator()) len--;
+			char * path = new char[len+1];
+			memcpy(path, p, len);
+			path[len] = 0;
+			aPM->iLibPathList.push_back(path);
+			break;
+		}
+	}
+}
+
+/**
+This function sets the linkas dll name when --linkas option is passed in.
+
+void ParameterManager::ParseLinkAs(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --linkas
+@param aValue
+The DLL name to be linked with passed through --linkas option
+@param aDesc
+Pointer to function ParameterManager::ParseLinkAs returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseLinkAs)
+{
+	INITIALISE_PARAM_PARSER;
+	aPM->SetLinkDLLName(aValue);
+}
+
+/**
+This function set the sub options that are passed through --dump option.
+
+void ParameterManager::ParseFileDump(ParameterManager * aPM, char * aOption, char * aValue, void * aDesc)
+
+@internalComponent
+@released
+
+@param aPM
+Pointer to the ParameterManager
+@param aOption
+Option that is passed as input, in this case --dump
+@param aValue
+The FileDump suboptions passed to --dump option.
+@param aDesc
+Pointer to function ParameterManager::ParseFileDump returning void.
+*/
+DEFINE_PARAM_PARSER(ParameterManager::ParseFileDump)
+{
+      INITIALISE_PARAM_PARSER;
+      aPM->SetFileDumpOptions(aValue);
+}
+
+/**
+This function sets the target type that is passed as input through the --targettype option
+and sets the flag if --targettype option is passed in.
+
+@internalComponent
+@released
+
+@param aTargetTypeVal
+Name of the input target type if provided as input through --targettype or 0.
+*/
+void ParameterManager::SetTargetTypeName(ETargetType aTargetTypeVal)
+{
+	iTargetTypeOption = true;
+	iTargetTypeName = aTargetTypeVal;
+}
+
+/**
+This function sets the DEF file name that is passed as input through the --definput option and
+sets the flag if --definput option is passed in.
+
+@internalComponent
+@released
+
+@param aDefInputVal
+Name of the input DEF file if provided as input through --definput or 0.
+*/
+void ParameterManager::SetDefInput(char * aDefInputVal)
+{
+	iDefFileInOption = true;
+	iDefInput = aDefInputVal;
+}
+
+/**
+This function sets the DSO file name that is passed as input through the --dso option
+and sets the flag if the --dso option is passed in.
+
+@internalComponent
+@released
+
+@param aDSOOutputVal
+Name of the output DSO file if provided as input through --dso or 0.
+*/
+void ParameterManager::SetDSOOutput(char * aDSOOutputVal)
+{
+	iDSOFileOutOption = true;
+	iDSOOutput = aDSOOutputVal;
+}
+
+/**
+This function sets the Elf file name that is passed as input through the --dsoin option.
+
+@internalComponent
+@released
+
+@param aSetElfInput
+Name of the input Elf file if provided as input through --dsoin or 0.
+*/
+void ParameterManager::SetElfInput(char * aElfInputVal)
+{
+	iElfFileInOption = true;
+	iElfInput = aElfInputVal;
+}
+
+/**
+This function sets the E32 name that is passed as input through the --e32dump option.
+
+@internalComponent
+@released
+
+@param aSetE32Input
+Name of the input E32 image if provided as input through --e32dump or 0.
+*/
+void ParameterManager::SetE32Input(char * aSetE32Input)
+{
+	iE32ImageInOption = true;
+	iE32Input = aSetE32Input;
+}
+
+/**
+This function sets the E32 dump options that is passed as input through the --dump option.
+
+@internalComponent
+@released
+
+@param aSetFileDumpOptions
+Dump sub options passed to --dump option
+*/
+void ParameterManager::SetFileDumpOptions(char * aSetFileDumpOptions)
+{
+	iFileDumpOption = true;
+	iFileDumpSubOptions = aSetFileDumpOptions;
+
+	if (aSetFileDumpOptions)
+	{
+		iDumpOptions=0;
+		while (char c = *(aSetFileDumpOptions++))
+		{
+			if (c < 'a')
+				c += 'a'-'A';
+			switch(c)
+			{
+			case 'h': iDumpOptions |= EDumpHeader; break;
+			case 's': iDumpOptions |= EDumpSecurityInfo; break;
+			case 'c': iDumpOptions |= EDumpCode; break;
+			case 'd': iDumpOptions |= EDumpData; break;
+			case 'e': iDumpOptions |= EDumpExports; break;
+			case 'i': iDumpOptions |= EDumpImports; break;
+			case 'a': iDumpOptions |= EDumpAsm; break; //Dump the Assembler code
+			case 't': iDumpOptions |= EDumpSymbols;break;
+			default: 
+				iDumpOptions=0;
+				return;
+			}
+		}
+	}
+}
+
+/**
+This function extracts the E32 image output that is passed as input through the --output option.
+
+@internalComponent
+@released
+
+@param aSetE32Output
+Name of the output E32 image output if provided as input through --output or 0.
+*/
+void ParameterManager::SetE32Output(char * aSetE32Output)
+{
+	iOutFileOption = true;
+	iOutFileName = aSetE32Output;
+}
+
+/**
+This function sets the output DEF file name that is passed as input through the --defoutput option.
+
+@internalComponent
+@released
+
+@param aSetDefOutput
+Name of the output DEF file if provided as input through --defoutput or 0.
+*/
+void ParameterManager::SetDefOutput(char * aSetDefOutput)
+{
+	iDefFileOutOption = true;
+	iDefOutput = aSetDefOutput;
+}
+
+/**
+This function sets the name of the DLL (that the DSO is to be linked with) that is passed 
+as input through the --linkas option and sets the flag if the --linkas option is passed in.
+
+@internalComponent
+@released
+
+@param aSetLinkDLLName
+The DLL name with which the DSO is to be linked with
+*/
+void ParameterManager::SetLinkDLLName(char * aSetLinkDLLName)
+{
+	iLinkAsOption = true;
+	iLinkDLLName = aSetLinkDLLName;
+}
+
+/**
+This function sets the priority value.
+
+@internalComponent
+@released
+
+@param anewVal
+priority value passed in to --priority option.
+*/
+void ParameterManager::SetPriority(TProcessPriority anewVal)
+{
+	iPriorityOption = true;
+	iPriorityVal = anewVal;
+}
+
+/**
+This function sets the capability value.
+
+@internalComponent
+@released
+
+@param anewVal
+Capability value passed in to --capability option.
+*/
+void ParameterManager::SetCapability(unsigned int anewVal)
+{
+	iCapability[0] = anewVal;
+}
+
+/**
+This function sets the capability value.
+
+@internalComponent
+@released
+
+@param anewVal
+Capability value passed in to --capability option.
+*/
+void ParameterManager::SetCapability(SCapabilitySet & anewVal)
+{
+	iCapability = anewVal;
+}
+
+/**
+This function sets the list of predefined symbols passed to --sysdef option.
+
+@internalComponent
+@released
+
+@param aOrdinalnum
+Ordinal number of the predefined symbols
+@param aSymbol
+Symbol Name
+@param aCount
+Position of the predefined symbol
+*/
+void ParameterManager::SetSysDefs(unsigned int aOrdinalnum, char* aSymbol, int aCount)
+{
+	iSysDefOption = 1;
+	iSysDefSymbols[aCount].iSysDefOrdinalNum = aOrdinalnum;
+	iSysDefSymbols[aCount].iSysDefSymbolName = aSymbol;
+	iSysDefCount = (aCount+1);
+}
+
+/**
+This function sets the output LOG file name that is passed as input through the --log option.
+
+@internalComponent
+@released
+
+@param aSetLogFile
+Name of the output LOG file if provided as input through --log or 0.
+*/
+void ParameterManager::SetLogFile(char * aSetLogFile)
+{
+	iLogFileOption = true;
+	iLogFileName = aSetLogFile;
+}
+
+/**
+This function sets the Message file name that is passed as input through the --messagefile option.
+
+@internalComponent
+@released
+
+@param aMessageFile
+Name of the Message file if provided as input through --messagefile or 0.
+*/
+void ParameterManager::SetMessageFile(char * aMessageFile)
+{
+	iMessageFileOption = true;
+	iMessageFileName = aMessageFile;
+}
+
+/**
+This function sets the Message file name that is passed as input through the --dumpmessagefile option.
+
+@internalComponent
+@released
+
+@param aDumpMessageFile
+Name of the Message file to be dumped if provided as input through --dumpmessagefile or 0.
+*/
+void ParameterManager::SetDumpMessageFile(char * aDumpMessageFile)
+{
+	iDumpMessageFileOption = true;
+	iDumpMessageFileName = aDumpMessageFile;
+}
+
+/**
+This function sets iFixedAddress if --fixedaddress is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --fixedaddress is passed in.
+*/
+void ParameterManager::SetFixedAddress(bool aSetFixedAddress)
+{
+	iFixedAddress = aSetFixedAddress;
+}
+
+/**
+This function sets iCompress if --uncompressed is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --uncompressed is passed in.
+*/
+void ParameterManager::SetCompress(bool aSetCompress)
+{
+	iCompress = aSetCompress;
+}
+
+/**
+This function sets iCompress if --uncompressed is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --uncompressed is passed in.
+*/
+void ParameterManager::SetCompressionMethod(UINT aCompressionMethod)
+{
+	
+	iCompressionMethod = aCompressionMethod;
+}
+
+
+/**
+This function sets iCallEntryPoint if --callentry is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --callentry is passed in.
+*/
+void ParameterManager::SetCallEntryPoint(bool aSetCallEntryPoint)
+{
+	iCallEntryPoint = aSetCallEntryPoint;
+}
+
+/**
+This function sets the Version information passed to '--version' option.
+
+@internalComponent
+@released
+
+@param aVersion information
+Version information passed to '--version' option.
+*/
+void  ParameterManager::SetVersion(UINT aSetVersion)
+{
+	iVersionOption = true;
+	iVersion = aSetVersion;
+}
+
+/**
+This function sets the UID1 passed to '--uid1' option.
+
+@internalComponent
+@released
+
+@param aUID1
+UID1 passed to '--uid1' option.
+*/
+void  ParameterManager::SetUID1(UINT aUID1)
+{
+	iUid1Option = true;
+	iUID1 = aUID1;
+}
+
+/**
+This function sets the UID2 passed to '--uid2' option.
+
+@internalComponent
+@released
+
+@param aUID2
+UID2passed to '--uid2' option.
+*/
+void  ParameterManager::SetUID2(UINT aUID2)
+{
+	iUID2 = aUID2;
+}
+
+/**
+This function sets the UID3 passed to '--uid3' option.
+
+@internalComponent
+@released
+
+@param aUID3
+UID3 passed to '--uid3' option.
+*/
+void  ParameterManager::SetUID3(UINT aUID3)
+{
+	iUID3 = aUID3;
+}
+
+/**
+This function sets the Secure ID passed to '--sid' option.
+
+@internalComponent
+@released
+
+@param aSetSecureID
+Secure ID passed to '--sid' option.
+*/
+void  ParameterManager::SetSecureId(UINT aSetSecureID)
+{
+	iSecureIDOption = true;
+	iSecureID = aSetSecureID;
+}
+
+/**
+This function sets the Vendor ID passed to '--vid' option.
+
+@internalComponent
+@released
+
+@param aSetVendorID
+Vendor ID passed to '--vid' option.
+*/
+void  ParameterManager::SetVendorId(UINT aSetVendorID)
+{
+	iVendorIDOption = true;
+	iVendorID = aSetVendorID;
+}
+
+/**
+This function sets the heap committed size passed to '--heap' option.
+
+@internalComponent
+@released
+
+@param aSetHeapCommittedSize
+stack committed size passed to '--heap' option.
+*/
+void  ParameterManager::SetHeapCommittedSize(UINT aSetHeapCommittedSize)
+{
+	iHeapCommittedSize = aSetHeapCommittedSize;
+}
+
+/**
+This function sets the heap reserver size passed to '--heap' option.
+
+@internalComponent
+@released
+
+@param aSetStackReservedSize
+stack reserved size passed to '--heap' option.
+*/
+void  ParameterManager::SetHeapReservedSize(UINT aSetHeapReservedSize)
+{
+	iHeapReservedSize = aSetHeapReservedSize;
+}
+
+/**
+This function sets the stack committed size passed to '--stack' option.
+
+@internalComponent
+@released
+
+@param aSetStackCommittedSize
+stack committed size passed to '--stack' option.
+*/
+void  ParameterManager::SetStackCommittedSize(UINT aSetStackCommittedSize)
+{
+	iStackCommittedSize = aSetStackCommittedSize;
+}
+
+/**
+This function sets iUnfrozen if --unfrozen is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --unfrozen is passed in.
+*/
+void ParameterManager::SetUnfrozen(bool aVal)
+{
+	iUnfrozen = aVal;
+}
+
+/**
+This function sets iIgnoreNonCallable if --ignorenoncallable is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --ignorenoncallable is passed in.
+*/
+void ParameterManager::SetIgnoreNonCallable(bool aVal)
+{
+	iIgnoreNonCallable = aVal;
+}
+
+/**
+This function sets iDllDataP if --dlldata is passed in.
+
+@internalComponent
+@released
+
+@param anewVal
+True if --dlldata is passed in.
+*/
+void ParameterManager::SetDllDataP(bool anewVal)
+{
+	iDllDataP = anewVal;
+}
+
+/**
+This function sets the FPU type based on the parsed '--fpu' option.
+
+@internalComponent
+@released
+
+@param aSetVendorID
+FPU type passed to the '--fpu' option.
+*/
+void  ParameterManager::SetFPU(UINT aFPU)
+{
+	iFPUOption = true;
+	iFPU = aFPU;
+}
+
+
+void ParameterManager::SetCodePaged(bool anewVal)
+{
+	iCodePaged = anewVal;
+}
+
+void ParameterManager::SetCodeUnpaged(bool anewVal)
+{
+	iCodeUnpaged = anewVal;
+}
+
+void ParameterManager::SetCodeDefaultPaged(bool anewVal)
+{
+	iCodeDefaultPaged = anewVal;
+}
+
+void ParameterManager::SetDataPaged(bool anewVal)
+{
+	iDataPaged = anewVal;
+}
+
+void ParameterManager::SetDataUnpaged(bool anewVal)
+{
+	iDataUnpaged = anewVal;
+}
+
+void ParameterManager::SetDataDefaultPaged(bool anewVal)
+{
+	iDataDefaultPaged = anewVal;
+}
+
+void ParameterManager::SetSymNamedLookup(bool aVal)
+{
+	iSymNamedLookup = aVal;
+}
+
+/**
+This function sets iExcludeUnwantedExports if --excludeunwantedexports is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --excludeunwantedexports is passed in.
+*/
+void ParameterManager::SetExcludeUnwantedExports(bool aVal)
+{
+	iExcludeUnwantedExports = aVal;
+}
+
+/**
+This function sets iIsCustomDllTarget if --customdlltarget is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --customdlltarget is passed in.
+*/
+void ParameterManager::SetCustomDllTarget(bool aVal)
+{
+	iCustomDllTarget = aVal;
+}
+
+/**
+This function sets iDebuggable if --debuggable is passed in.
+
+@internalComponent
+@released
+
+@param aVal
+True if --debuggable is passed in.
+*/
+void ParameterManager::SetDebuggable(bool aVal)
+{
+	iDebuggable = aVal;
+}
+
+
+void ParameterManager::SetSmpSafe(bool aVal)
+{
+	iSmpSafe = aVal;
+}