// 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 <cstdlib>

#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),

{

	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;