#

# Copyright (c) 2008, 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:  End-user Interface for Core Tools execution

#

import sys

import os

import re

#while importing check if all modules are available, else raise error

try:

	import subprocess

	import platform

	import urllib

	import xml.dom.minidom

except ImportError:

	python_error()

#-------------------------Hardcoded values-----------------------------------------

#tool version denotes the version of the core tools package

TOOL_VERSION = "2.8.4"

TOOL_DATE = "16th February 2010"

#server to be used for downloading Core tools package and knownissues

SERVER_PATH = "http://"

#-------------------------Global values--------------------------------------------

CUR_DIR = os.getcwd()

#used to obtain the path in which checkbc and core tools are placed

tempStr = os.path.realpath(sys.argv[0]) 

[head,tail] = os.path.split(tempStr )

TOOL_DIR = head + os.sep

#create the \data and \bin paths which contain the necessary additional headers

DATA_PATH = TOOL_DIR + "data" + os.sep

EXEC_PATH = TOOL_DIR + "bin" + os.sep

REPORT_PATH = TOOL_DIR + "reports" + os.sep

DEFAULT_ISSUES_FILE = TOOL_DIR + "data" + os.sep + "knownissues.xml"

GLOBAL_DATA_FILE = TOOL_DIR + "global_data.xml"

tool_chain = ['gcc','gcce','rvct']

DATA_VERSION = ''

ALL_HEADER_SET = ''

sdk_version = []

s60_build_targets = []

sys_includes = {}

doc = xml.dom.minidom.parse(GLOBAL_DATA_FILE)

#data version denotes compatibility between the tool and carbide plugin

#Read dataversion from global_data.xml

DATA_VERSION = doc.getElementsByTagName("dataversion")[0].childNodes[0].data

#Read supported filetypes in header analyser from global_data.xml

for filetype in doc.getElementsByTagName("filetypes")[0].getElementsByTagName("type"):

   if ALL_HEADER_SET != '':

      ALL_HEADER_SET += ';'

   ALL_HEADER_SET += filetype.childNodes[0].data

#Read supported sdk versions from global_data.xml

for version in doc.getElementsByTagName("supportedversions")[0].getElementsByTagName("version"):

   sdk_version.append(version.childNodes[0].data)

#Read supported build targets from global_data.xml

for buildtarget in doc.getElementsByTagName("buildtargets")[0].getElementsByTagName("target"):

   s60_build_targets.append(buildtarget.childNodes[0].data)

#Read system include paths for supported sdk versions from global_data.xml

for node in doc.getElementsByTagName("sys_includes"):

   ver = node.getAttribute("version")

   includes = []

   for inc in node.getElementsByTagName("inc"):

       includes.append(inc.childNodes[0].data)

   sys_includes[ver] = includes     

#dictionary elements which hold the platform data(CDS) and forced header(symbian macros) information

#these are available only when the \data and \bin folders respectively are avaliable

if os.path.exists( DATA_PATH ):

	platformdata = {

	"3.0": DATA_PATH + "s60_platform_data_30.xml",

	"3.1": DATA_PATH + "s60_platform_data_31.xml",

	"3.2": DATA_PATH + "s60_platform_data_32.xml",

	"5.0": DATA_PATH + "s60_platform_data_50.xml",

	"5.1": DATA_PATH + "s60_platform_data_51.xml",

	"5.2": DATA_PATH + "s60_platform_data_52.xml",

	"SF1": DATA_PATH + "s60_platform_data_51.xml",

	"SF2": DATA_PATH + "s60_platform_data_52.xml"

	}

else:

	platformdata = {}

if os.path.exists( EXEC_PATH ):	

	forcedheadersdata = {

	"3.0": EXEC_PATH + "forced_9.1.h",

	"3.1": EXEC_PATH + "forced_9.2.h",

	"3.2": EXEC_PATH + "forced_9.3.h",

	"5.0": EXEC_PATH + "forced_9.4.h",

	"5.0v2": EXEC_PATH + "forced_9.4v2.h",

	"5.1": EXEC_PATH + "forced_9.4v2.h",

	"5.2": EXEC_PATH + "forced_9.4v2.h",

	"SF1": EXEC_PATH + "forced_9.4v2.h",

	"SF2": EXEC_PATH + "forced_9.4v2.h"

	}

else:

	forcedheadersdata = {}

if os.path.exists( DATA_PATH ):

	dllXMLdata = {

	"3.0": DATA_PATH + "s60_dll_data_30.xml",

	"3.1": DATA_PATH + "s60_dll_data_31.xml",

	"3.2": DATA_PATH + "s60_dll_data_32.xml",

	"5.0": DATA_PATH + "s60_dll_data_50.xml",

	"5.1": DATA_PATH + "s60_dll_data_51.xml",

	"5.2": DATA_PATH + "s60_dll_data_52.xml",

	"SF1": DATA_PATH + "s60_dll_data_51.xml",

	"SF2": DATA_PATH + "s60_dll_data_52.xml"

	}

else:

	dllXMLdata = {}

#set of binaries in the Core tools set, this is windows specific, to be added for linux support

if os.name == 'nt':

    HA_SET = [ EXEC_PATH+"ha.exe", EXEC_PATH+"ha_gccxml_cc1plus.exe", EXEC_PATH+"libxerces-c2_7_0.dll" ]

    LA_SET = [ EXEC_PATH+"la.exe", EXEC_PATH+"cfilt.exe"  ]

    BCFILTER_SET = [ EXEC_PATH+"bcfilter.exe", EXEC_PATH+"libxerces-c2_7_0.dll" ]

else:

    HA_SET = [ EXEC_PATH+"ha", EXEC_PATH+"ha_gccxml_cc1plus", EXEC_PATH+"libxerces-c2_7_0.dll" ]

    LA_SET = [ EXEC_PATH+"la", EXEC_PATH+"cfilt" ]

    BCFILTER_SET = [ EXEC_PATH+"bcfilter", EXEC_PATH+"libxerces-c2_7_0.dll" ]

#Default report paths

HEADER_REPORT = "Headers_CompatibilityReport"

LIBRARY_REPORT = "Libraries_CompatibilityReport"

#true if checkbc is called from carbide plugin,

#this make additional info available to STDOUT and STDEERR

CARBIDE_PLUGIN = False

#-------------------------Error Handling--------------------------------------------

#exhults with a environment error when the installed python version is unsupported

def python_error():

	sys.stdout.write("ERROR: Invalid python version")

	sys.stdout.write("\nPython versions from 2.4 to 3.0 are supported")

	sys.exit(1)

#this is the set of possible error values, stored as a dictionary, with the "value" represnting error message

ErrorCode = {

	"cmdlineIP": [ "\nERROR: Commandline input parameter invalid -- " , 1 ],

	"cmdlineIS": [ "\nERROR: Commandline parameter syntax invalid -- " , 2 ],

	"cmdlineMP": [ "\nERROR: Commandline parameter missing -- " , 3 ],

	"confIS": [ "\nERROR: Invalid syntax in config file -- " , 4 ],

	"confIP": [ "\nERROR: Invalid parameter in config file -- ", 5 ],

	"confMP": [ "\nERROR: Missing parameter in config file -- ", 6 ],

	"confMPath": [ "\nERROR: File/path in config file not found -- ", 7 ],

	"cmdhelp": [ "", 8],

	"other": [ "\nGENERAL ERROR: Please recheck the tool inputs.", 9 ]

	}

#an exception class, need to update this for better error representation

#value --> holds the error string, #text --> the info text to be displayed

class InputError(Exception):

	def __init__(self, list):

		self.error = ErrorCode["other"]

		if list[0] in ErrorCode:

			self.error = ErrorCode[ list[0] ]

		self.text = list[1]

		self.use = list[2]

#the exception handler class which prints out the error message and usage info when required

class ExHandler:

	def __init__(self, e):

		sys.stdout.write( e.error[0] )

		sys.stdout.write( e.text )

		if e.use:

			usage()

		sys.exit(e.error[1])	

#displays the usage characteristics for the interface when command is invoked without proper arguments

def usage():

	print ""

	print "Compatibility Analyser v" + TOOL_VERSION + " - " + TOOL_DATE

	print "Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved."

	print ""

	print "Usage: CheckBC <configfile> [-ha/-hm/-hs] [-la/-lm/-ls] [-f] [reportid]"

	print ""

	print "Where:"

	print "  configfile    Filename of a configuration file"

	print "  -ha           Check all headers"

	print "  -hm FILE      Check multiple headers (FILE = file with list of headers)"

	print "  -hs FILE      Check a single file (FILE = header)"

	print "  -la           Check all libraries"

	print "  -lm FILE      Check multiple libraries (FILE = file with list of libraries)"

	print "  -ls FILE      Check a single file (FILE = library)"

	print "  -f            Filter results after analysis"

	print "  reportid      ID to be used for report files"

	print ""

	print "Examples:"

	print "  To analyse all headers and libraries and filter results:"

	print "    CheckBC myconfig -ha -la -f MYID"

	print "  To analyse a single header file"

	print "    CheckBC myconfig -hs aknlists.h MYID"

#-------------------------Header Analysis--------------------------------------------

class HeaderAnalyser:

	# static dict to hold the arguments

	args = {}

	#initialization function for HA component	

	def __init__(self, ip_data, set_list, reportid):

		#'args' defines the parametrs required by HA

		self.args = {"BASELINE_NAME":[], "CURRENT_NAME":[], "BASELINE_DIR":[], "CURRENT_DIR":[], "REPORT_FILE":[],

				"BASELINE_SYSTEMINCLUDEDIR":[], "CURRENT_SYSTEMINCLUDEDIR":[], "FORCEBASEINCLUDE":[], "FORCECURRENTINCLUDE":[],

				"RECURSIVE":[], "REPLACE":[], "TEMP":[], "USE_THREAD":[], "USE_PLATFORM_DATA":[], "SET":[], "BUNDLESIZE":['-bundlesize', '50'] }

		base_sys_include = []

		curr_sys_include = []

		base_forced = []

		curr_forced = []

		#validate SDK versions

		validateSDKVersion(ip_data["BASELINE_SDK_S60_VERSION"],ip_data["CURRENT_SDK_S60_VERSION"])

		#validate USE_PLATFORM_DATA entry 'true' or 'false'

		if( getdata( ip_data, "USE_PLATFORM_DATA") ):

			if( not('true' == ip_data["USE_PLATFORM_DATA"].lower()) and not('false' == ip_data["USE_PLATFORM_DATA"].lower()) ):

				raise InputError(["confIP", "USE_PLATFORM_DATA\n", False])

		#validate USE_THREAD entry 'true' or 'false'

		if( getdata( ip_data, "USE_THREAD") ):

			if( not('true' == ip_data["USE_THREAD"].lower()) and not('false' == ip_data["USE_THREAD"].lower()) ):

				raise InputError(["confIP", "USE_THREAD\n", False])

		# specify the basline and current names

		if not getdata(ip_data, "BASELINE_NAME"):

			raise InputError(["confMP", "baseline name missing\n", False])

		self.args["BASELINE_NAME"] = ["-baselineversion", quote( ip_data["BASELINE_NAME"] )]			

		if not getdata( ip_data, "CURRENT_NAME"):

			raise InputError(["confMP", "current name missing\n", False])

		self.args["CURRENT_NAME"] = ["-currentversion", quote( ip_data["CURRENT_NAME"] )]

		# get the analysis directories

		tmp = []

		sdkBaseTmp = []

		if getdata( ip_data, "BASELINE_SDK_DIR"):

			if(ip_data["BASELINE_SDK_DIR"] == os.sep):

				sdkBaseTmp.append( validate(os.sep + "epoc32" + os.sep + "include"))

			else:

			  sdkBaseTmp.append( validate(ip_data["BASELINE_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include") )

		else:

			raise InputError(["confMP", "baseline header directory missing\n", False])

		if getdata( ip_data, "BASELINE_HEADERS"):

			if(ip_data["BASELINE_HEADERS"] == os.sep):

			  tmp = sdkBaseTmp

			else:

			  for i in ip_data["BASELINE_HEADERS"].split(';'):

			  	if not os.path.exists(i):

			  		if(ip_data["BASELINE_SDK_DIR"] == os.sep):

			  		  tmp.append(validate(os.sep + "epoc32" + os.sep + "include" + os.sep + i))

			  		else:

			  			tmp.append(validate(ip_data["BASELINE_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include" + os.sep + i))

			  	else:

				    tmp.append(validate(i))

		else:

			tmp = sdkBaseTmp

		self.args["BASELINE_DIR"] = ["-baselinedir", ';'.join(["%s" % quote(i) for i in tmp]) ]

		base_sys_include.extend(tmp)

		tmp = []	

		sdkCurrTmp = []	

		if getdata( ip_data, "CURRENT_SDK_DIR"):

		  if(ip_data["CURRENT_SDK_DIR"] == os.sep):

		    sdkCurrTmp.append( validate(os.sep+"epoc32" + os.sep + "include" ))

		  else:

			  sdkCurrTmp.append( validate(ip_data["CURRENT_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include") )

		else:

			raise InputError(["confMP", "current header directory missing\n", False])

		if getdata( ip_data, "CURRENT_HEADERS"):

		  if(ip_data["CURRENT_HEADERS"] == os.sep):

		    tmp = sdkCurrTmp

		  else:

			  for i in ip_data["CURRENT_HEADERS"].split(';'):

			  	if not os.path.exists(i):

			  		if(ip_data["CURRENT_SDK_DIR"] == os.sep):

			  		  tmp.append(validate(os.sep + "epoc32" + os.sep + "include" + os.sep + i))

			  		else:

			  			tmp.append(validate(ip_data["CURRENT_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include" + os.sep + i))

			  	else:

				    tmp.append(validate(i))

		else:

			tmp = sdkCurrTmp

		self.args["CURRENT_DIR"] = ["-currentdir", ';'.join(["%s" % quote(i) for i in tmp]) ]

		curr_sys_include.extend(tmp)

		# get the report file name		

		if not getdata( ip_data, "REPORT_FILE_HEADERS"):

			if not reportid:

				ip_data["REPORT_FILE_HEADERS"] = REPORT_PATH + HEADER_REPORT

			else:

				ip_data["REPORT_FILE_HEADERS"] = REPORT_PATH + HEADER_REPORT +'_'+ reportid

		else:

			[head, tail] = os.path.split(ip_data["REPORT_FILE_HEADERS"])

			if tail != '':

				if reportid:

					ip_data["REPORT_FILE_HEADERS"] = ip_data["REPORT_FILE_HEADERS"] +'_'+ reportid

			else:

				if reportid:

					ip_data["REPORT_FILE_HEADERS"] = ip_data["REPORT_FILE_HEADERS"] + HEADER_REPORT +'_'+ reportid

				else:

					ip_data["REPORT_FILE_HEADERS"] = ip_data["REPORT_FILE_HEADERS"] + HEADER_REPORT

		ip_data["REPORT_FILE_HEADERS"] = ip_data["REPORT_FILE_HEADERS"] + ".xml"		

		self.args["REPORT_FILE"] = ["-reportfile", quote( ip_data["REPORT_FILE_HEADERS"])]

		tmp = []

		# get the base system include directories		

		if getdata( ip_data, "BASELINE_SYSTEMINCLUDEDIR"):

			for term in ip_data["BASELINE_SYSTEMINCLUDEDIR"].split(';'):

			  if not os.path.exists(term):

			  	if(ip_data["BASELINE_SDK_DIR"] == os.sep):

			  	  tmp.append(os.sep + "epoc32" + os.sep + "include" + os.sep + term)

			  	else:

			  	  tmp.append(ip_data["BASELINE_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include" + os.sep + term)

			  else:

			  	tmp.append(term);			  	

		for i in sys_includes[ip_data["BASELINE_SDK_S60_VERSION"]]:

			if(ip_data["BASELINE_SDK_DIR"] == os.sep):

			  tmp.append( os.sep + i )

			else:

			  tmp.append( ip_data["BASELINE_SDK_DIR"] + os.sep + i )

		for i in tmp:	

			try:

				term = validate(i)

			except InputError, e:

				sys.stderr.write(os.linesep + "WARNING: Baseline system include path "+ i +" not found")

			else:

				if term not in base_sys_include:

					base_sys_include.append(term)

		self.args["BASELINE_SYSTEMINCLUDEDIR"] = ["-baseplatformheaders", quote( ';'.join(["%s" % quote(i) for i in base_sys_include]) ) ]

		tmp = []

		# get the current system include directories		

		if getdata( ip_data, "CURRENT_SYSTEMINCLUDEDIR"):

			for term in ip_data["CURRENT_SYSTEMINCLUDEDIR"].split(';'):

				if not os.path.exists(term):

					if(ip_data["CURRENT_SDK_DIR"] == os.sep):

						tmp.append(os.sep + "epoc32" + os.sep + "include" + os.sep + term)

					else:

						 tmp.append(ip_data["CURRENT_SDK_DIR"] + os.sep + "epoc32" + os.sep + "include" + os.sep + term)

				else:

					tmp.append(term);

		for i in sys_includes[ip_data["CURRENT_SDK_S60_VERSION"]]:

			if(ip_data["CURRENT_SDK_DIR"] == os.sep):

			  tmp.append( os.sep + i )

			else:

			  tmp.append( ip_data["CURRENT_SDK_DIR"] + os.sep + i )

		for i in tmp:			

			try:

				term = validate(i)

			except InputError, e:

				sys.stderr.write(os.linesep + "WARNING: Current system include path "+ i +" not found")

			else:

				if term not in curr_sys_include:

					curr_sys_include.append(term)

		self.args["CURRENT_SYSTEMINCLUDEDIR"] = ["-currentplatformheaders", quote( ';'.join(["%s" % quote(i) for i in curr_sys_include]) ) ]

		# get the forced headers 														 

		if not getdata( ip_data, "BASELINE_SDK_S60_VERSION"):

			raise InputError(["confMP", "Baseline SDK version undefined\n", False])

		for i in getdata( ip_data, "BASELINE_FORCED_HEADERS").split(';'):

			if i:

				base_forced.append(i)

		if forcedheadersdata.has_key(ip_data["BASELINE_SDK_S60_VERSION"]):

			base_forced.append( self.forcedheaders(ip_data["BASELINE_SDK_S60_VERSION"], self.args["BASELINE_SYSTEMINCLUDEDIR"][1]) )

		#Validate the existence of base forced header	

		for i in base_forced:

			if not os.path.exists(i):

				tmp = os.path.abspath(i)

				if not os.path.exists(tmp):

					raise InputError(["confIP", "BASELINE_SDK_S60_VERSION < Field "+ i +" is not valid >" + os.linesep,False])

		self.args["FORCEBASEINCLUDE"] = ["-forcebaseinclude", ';'.join(["%s" % quotep(i) for i in base_forced ]) ]

		if not getdata( ip_data, "CURRENT_SDK_S60_VERSION"):

			raise InputError(["confMP", "Current SDK version undefined\n", False])

		for i in getdata( ip_data, "CURRENT_FORCED_HEADERS").split(';'):

			if i:

				curr_forced.append(i)

		if forcedheadersdata.has_key(ip_data["CURRENT_SDK_S60_VERSION"]):

			curr_forced.append( self.forcedheaders(ip_data["CURRENT_SDK_S60_VERSION"], self.args["CURRENT_SYSTEMINCLUDEDIR"][1]) )

		#Validate the existence of current forced header	

		for i in curr_forced:

			if not os.path.exists(i):

				tmp = os.path.abspath(i)

				if not os.path.exists(tmp):

					raise InputError(["confIP", "CURRENT_SDK_S60_VERSION < Field "+ i +" is not valid >" + os.linesep,False])

		self.args["FORCECURRENTINCLUDE"] = ["-forcecurrentinclude", ';'.join(["%s" % quotep(i) for i in curr_forced ]) ]

		if getdata( ip_data, "USE_THREAD"):

			if 'true' == ip_data["USE_THREAD"].lower():

				self.args["USE_THREAD"] = [ "-usethread" ]

		# setup the replace and exclude directories

		self.args["RECURSIVE"] = [ "-recursive" ]

		if getdata( ip_data, "RECURSIVE_HEADERS"):

			if 'false' == ip_data["RECURSIVE_HEADERS"].lower():

				self.args["RECURSIVE"] = [ "" ]

			elif not 'true' == ip_data["RECURSIVE_HEADERS"].lower():

				raise InputError(["confIP", "RECURSIVE_HEADERS\n", False])

		tmp = []

		for i in getdata( ip_data, "EXCLUDE_DIR_HEADERS").split(';'):

			if i:

				tmp.append(i)

		if tmp:

			self.args["EXCLUDE_DIR_HEADERS"] = ["-excludedirs", ';'.join(["%s" % quote(i) for i in tmp]) ]

		self.args["TEMP"] = ["-temp", quotep( ip_data["TEMP"] )]

		if not getdata( ip_data, "USE_PLATFORM_DATA") or ('true' == ip_data["USE_PLATFORM_DATA"].lower()):

			if getdata(	platformdata, ip_data["BASELINE_SDK_S60_VERSION"] ) and getdata( platformdata, ip_data["CURRENT_SDK_S60_VERSION"] ):

				self.args["USE_PLATFORM_DATA"] = ["-baseplatformdata", quotep( platformdata[ip_data["BASELINE_SDK_S60_VERSION"]] ),

										 "-currentplatformdata", quotep( platformdata[ip_data["CURRENT_SDK_S60_VERSION"]] )]

			else:

				sys.stderr.write( os.linesep + "WARNING: Platform data not available in default paths, continuing without platform data information." )

		if getdata( ip_data, "REPLACE_HEADERS"):

			#separate the sets

			tlist_1 = ip_data["REPLACE_HEADERS"].split(';')

			str = ''

			#seperate the replacement pairs

			for entry in tlist_1:

				if entry != '':

					tlist_2 = (entry.split(':'))

					#create a single str, which is input param	

					str = ' '.join(["%s" % i for i in tlist_2])

			self.args["REPLACE"] = ["-replace", str ]

		else:

			del self.args["REPLACE"]

		# handling the files provide with 'm' or 's' options on commandline

		str = ''

		line = ''

		tmp = []

		if 's' == set_list[0]:

			str = set_list[1]

		elif 'm' == set_list[0]:

			fname = os.path.abspath(set_list[1])

			if not os.path.exists(fname):

				raise InputError(["confIP", "Input list file unavailable" + os.linesep, False])	

			filehandle = open(fname, 'r')

			for line in filehandle:

				tmp.append(clean(line))

			str = ';'.join(["%s" % i for i in tmp])

			filehandle.close()	

		elif 'a' == set_list[0]:

			str = ALL_HEADER_SET

		self.args["SET"] = ["-set", quote(str)]

	#'stringize' all params and invoke the tool

	def run(self):

		str = ''

		for i in HA_SET:

			if not os.path.exists(i):

				print os.linesep + i + " does not exist. Please reinstall."

				sys.exit(1)

		it_tmp = self.args.itervalues()

		for i in xrange(0, len(self.args), 1):

			for val in it_tmp.next():

				str = str + ' ' + val

		cmd_file= unquote(self.args["TEMP"][1]) + os.sep + 'ha.txt'

		file = open(cmd_file,'w')

		file.write(str)

		file.close()

		cmd_str = ' -commandfile ' + cmd_file

		invokeTool(quote(HA_SET[0]), cmd_str)

	#verify existence of system hrh files

	def forcedheaders(self, str, dirs):

		if "5.0" == str:

			dirs = unquote(dirs).split(';')

			for path in dirs:

				checkpath = os.path.normpath( unquote(path) + os.sep + "variant" + os.sep + "symbian_os_v9.4.hrh" )

				if os.path.exists( checkpath ):

					if forcedheadersdata.has_key(str):

						return forcedheadersdata[str]

			if forcedheadersdata.has_key("5.0v2"):

				return forcedheadersdata["5.0v2"]

		else:

			if forcedheadersdata.has_key(str):

				return forcedheadersdata[str]

		return ''	

#-------------------------Library Analysis-------------------------------------------

class LibraryAnalyser:

	args = {}

	def __init__(self, ip_data, set_list, reportid):

		#'args' defines the parametrs required by HA, 'optargs' defines optional ones

		self.args = { "TOOLCHAIN":[], "TOOLCHAIN_PATH":[], "BASELINE_NAME":[], "CURRENT_NAME":[], "BASELINE_DIR":[], "CURRENT_DIR":[],

				 "REPORT_FILE":[], "CFILT":[], "TEMP":[], "SET":[] }

		#validate SDK versions

		validateSDKVersion(ip_data["BASELINE_SDK_S60_VERSION"],ip_data["CURRENT_SDK_S60_VERSION"])