diff -r 9f25be3da657 -r fa7a3cc6effd sbsv1/abld/platform/e32plat.pm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1/abld/platform/e32plat.pm	Fri Jun 25 17:29:25 2010 +0800
@@ -0,0 +1,880 @@
+# Copyright (c) 1997-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:
+# Module providing platform details for platforms supported
+# by Symbian OS
+# all data is uppercase
+# 
+#
+
+package E32Plat;
+
+require Exporter;
+@ISA=qw(Exporter);
+
+@EXPORT=qw(
+	Plat_SetVerbose
+	Plat_Init
+	Plat_GetL
+	Plat_List
+	Plat_AssocIDE
+	Plat_Customizations
+	Plat_Customizes
+	Plat_Root
+	Plat_SupportsFeatureVariants
+);
+
+use Winutl;
+use RVCT_plat2set;
+use BPABIutl;
+use E32Variant;
+
+my $variantABIV2Keyword = &Variant_GetMacro();
+
+my %Mode=(
+	Verbose=>0
+);
+my $ModulePath;
+
+sub Plat_SetVerbose () {
+	$Mode{Verbose}=1;
+}
+
+my %BldLists=(
+	EPOC32=>['UREL','UDEB'],
+	WINS=>['UDEB','UREL'],
+	TOOLS=>['DEB','REL'],
+	TOOLS2=>['DEB','REL'],
+);
+
+my %BldMacros=(
+	DEB=>['_DEBUG'],
+	REL=>['NDEBUG'],
+	UDEB=>['_DEBUG','_UNICODE'],
+	UREL=>['NDEBUG','_UNICODE']
+);
+
+
+my @EpocMacros=('__SYMBIAN32__');
+
+my @BPABIPlats = &BPABIutl_Plat_List;
+
+my %Plat=(
+	ARM4=>{
+		ABI=>'ARM4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+	},
+	ARM4SMP=>{
+		ABI=>'ARM4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		SMP=>1,
+		StatLink=>'ARM4SMP',
+	},
+	ARM4T=>{
+		ABI=>'ARM4T',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+	},
+	ARMI=>{
+		ASSP=>'MARM',
+		Generic=>1,
+		ASSPABI=>'',
+	},
+	SARM4=>{
+		ABI=>'ARM4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		Single=>1,
+	},
+	SARMI=>{
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		Single=>1,
+	},
+	STHUMB=>{
+		ABI=>'THUMB',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		Single=>1,
+	},
+	THUMB=>{
+		ABI=>'THUMB',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+	},
+	TOOLS=>{
+		ABI=>'TOOLS',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'TOOLS',
+		OS=>'TOOLS',
+		MakeMod=>'Cl_win',
+		MakeCmd=>'nmake',
+	},
+	TOOLS2=>{
+		ABI=>'TOOLS2',
+		ASSPABI=>'',
+		Compiler=>'GCC32',
+		CPU=>'TOOLS2',
+		OS=>'TOOLS2',
+		MakeMod=>'Cl_mingw',
+		MakeCmd=>'make',
+	},
+	CWTOOLS=>{
+		ABI=>'TOOLS',
+		ASSPABI=>'',
+		Compiler=>'CW32',
+		CPU=>'TOOLS',
+		OS=>'TOOLS',
+		MakeMod=>'Cl_tools',
+		MakeCmd=>'make',
+	},
+	VC6TOOLS=>{
+		ABI=>'TOOLS',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'TOOLS',
+		Ext=>'.DSP',
+		MakeMod=>'Ide_vc6',
+		MakeCmd=>'nmake',
+		OS=>'TOOLS',
+		Real=>'TOOLS',
+		UsrHdrsOnly=>1,
+	},
+	WINS=>{
+		ABI=>'WINS',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'WINS',
+		MakeMod=>'Cl_win',
+		MakeCmd=>'nmake',
+		OS=>'WINS',
+	},
+	VC6=>{
+		ABI=>'WINS',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'WINS',
+		Ext=>'.DSP',
+		MakeMod=>'Ide_vc6',
+		MakeCmd=>'nmake',
+		OS=>'WINS',
+		Real=>'WINS',
+		UsrHdrsOnly=>1,
+	},
+	WINSCW=>{
+		ABI=>'WINSCW',
+		ASSPABI=>'',
+		Compiler=>'CW32',
+		CPU=>'WINS',
+		MakeMod=>'Cl_codewarrior',
+		OS=>'WINS',
+		DefFile=>'WINS',	# use the MSVC def files
+	},
+	CW_IDE=>{
+		ABI=>'WINSCW',
+		ASSPABI=>'',
+		Compiler=>'CW32',
+		CPU=>'WINS',
+		Ext=>'.xml',
+		MakeMod=>'Ide_cw',
+		MakeCmd=>'make',
+		OS=>'WINS',
+		Real=>'WINSCW',
+		DefFile=>'WINS',	# use the MSVC def files
+		UsrHdrsOnly=>1,
+		SupportsMultiplePlatforms=>1,	# supports more than one real platform
+	},
+	X86=>{
+		ABI=>'X86',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'X86',
+		MakeMod=>'Cl_x86',
+		MakeCmd=>'nmake',
+		OS=>'EPOC32',
+		DefFile=>'X86',
+		Generic=>1,
+	},
+	X86SMP=>{
+		ABI=>'X86',
+		ASSPABI=>'',
+		Compiler=>'VC32',
+		CPU=>'X86',
+		MakeMod=>'Cl_x86',
+		MakeCmd=>'nmake',
+		OS=>'EPOC32',
+		DefFile=>'X86',
+		Generic=>1,
+		SMP=>1,
+		StatLink=>'X86SMP',
+	},
+	X86GCC=>{
+		ABI=>'X86gcc',
+		ASSPABI=>'',
+		Compiler=>'X86GCC',
+		CPU=>'X86',
+		MakeMod=>'Cl_x86gcc',
+		OS=>'EPOC32',
+		DefFile=>'x86gcc',
+		Generic=>1,
+	},	
+	X86GMP=>{
+		ABI=>'X86gcc',
+		ASSPABI=>'',
+		Compiler=>'X86GCC',
+		CPU=>'X86',
+		MakeMod=>'Cl_x86gcc',
+		OS=>'EPOC32',
+		DefFile=>'x86gcc',
+		Generic=>1,
+		SMP=>1,
+		StatLink=>'X86GMP',
+	},	
+	ARMV4=>{
+		ABI=>'ARMV4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'Cl_arm',
+		Compiler=>'ARMCC',
+		DefFile=>'EABI',
+		EABI=>1,
+	},
+	ARMV4SMP=>{
+		ABI=>'ARMV4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'Cl_arm',
+		Compiler=>'ARMCC',
+		DefFile=>'EABI',
+		EABI=>1,
+		SMP=>1,
+		StatLink=>'ARMV4SMP',
+	},
+	ARMV5_ABIV1=>{
+		ABI=>'ARMV5',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'Cl_arm',
+		Compiler=>'ARMCC',
+		DefFile=>'EABI',
+		EABI=>1,
+		SupportsFeatureVariants=>1,
+	},
+	ABIV2=>{
+		ABI=>'ARMV5',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'Cl_bpabi',
+		DefFile=>'EABI',
+		EABI=>1,
+		SupportsFeatureVariants=>1,
+	},
+	GCCXML=>{
+		ABI=>'ARM4',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'cl_gccxml',
+	},
+	VS6=>{
+		ABI=>'WINSCW',
+		ASSPABI=>'',
+		Compiler=>'CW32',
+		CPU=>'WINS',
+		MakeMod=>'Cl_vscw',
+		OS=>'WINS',
+		Real=>'WINSCW',
+		DefFile=>'WINS',	# use the MSVC def files
+		Ext=>'.mak'		
+	},
+	VS2003=>{
+		ABI=>'WINSCW',
+		ASSPABI=>'',
+		Compiler=>'CW32',
+		CPU=>'WINS',
+		MakeMod=>'Cl_vscw',
+		OS=>'WINS',
+		Real=>'WINSCW',
+		DefFile=>'WINS',	# use the MSVC def files
+		Ext=>'.mak'
+	},
+	EDG=>{
+		ABI=>'ARMV5',
+		ASSP=>'MARM',
+		ASSPABI=>'',
+		Generic=>1,
+		MakeMod=>'cl_edg',
+	},
+
+	# ASSP platforms should be described using .ASSP files
+	# Do not add additional ASSP platforms to this file.
+);
+
+sub Set_Plat() 
+{
+	@BPABIPlats = &BPABIutl_Plat_List;
+	foreach my $Candidate (@BPABIPlats)
+	{
+# All BPABI platforms inherit from ABIV2 properties as listed in the platlist
+# and Platlist is updated to include the BPABI platforms.
+		my ( $key, $value);
+		while (($key, $value) = each %{$Plat{ABIV2}}) {
+			$Plat{$Candidate}{$key}=$value;
+		}
+	}
+}
+
+sub Plat_SupportsFeatureVariants($)
+	{
+	my ($plat) = @_;
+
+	# In a non-ABIV2 world, ARMV5 means ARMV5_ABIV1 within e32plat content
+	if (!$variantABIV2Keyword && $plat =~ /^ARMV5$/i)
+		{
+		$plat .= "_ABIV1";
+		}
+		
+	return ($plat && defined $Plat{$plat}{SupportsFeatureVariants}) ? $Plat{$plat}{SupportsFeatureVariants} : 0;
+	}
+
+sub Plat_Customizations($) {
+        my ($plat) = @_;
+	my @empty = ();
+	return @{$Plat{$plat}{'CUSTOMIZATIONS'}} if $Plat{$plat}{'CUSTOMIZATIONS'};
+	return @empty;
+      }
+
+sub Plat_Customizes($) {
+	my ($plat) = @_;
+	return $Plat{$plat}{'CUSTOMIZES'} ? $Plat{$plat}{'CUSTOMIZES'} : "";
+}
+
+sub Plat_Root($) {
+	my ($plat) = @_;
+
+	my $RootName = $Plat{$plat}{'ROOTPLATNAME'};
+
+	if ($RootName) {
+		return $RootName;
+	}
+	else {
+		# A non-BSF platform is its own root.
+		return $plat;
+	}
+}
+
+sub Init_BSFs($) {
+	my ($Path)=@_;  
+#	get a list of modules
+	opendir DIR, $Path;
+	my @BSFs=grep s/^([^\.].*)\.BSF$/$1/, map { uc $_ } sort readdir DIR;
+	closedir DIR;
+
+	my $BSF;
+	foreach $BSF (@BSFs) {
+		my $File=$Path.$BSF.'.bsf';
+#		check whether the assp is already defined
+		if (defined %{$Plat{$BSF}}) {
+			warn(
+				"$File : warning: Platform \"$BSF\" already defined\n",
+				" ... skipping this spec\n"
+			);
+			delete $Plat{$BSF};
+			next;
+		}
+#		open the module
+		unless (open FILE, $File) {
+			delete $Plat{$BSF};
+			warn "warning: Can't open BSF specification \"$File\"\n";
+			next;
+		}
+		my $line1 = <FILE>;
+		$line1 = uc($line1);
+		unless ($line1 =~ /^\#\<BSF\>\#/) {
+			warn "warning: \"$File\" Invalid BSF specification - missing #<bsf>#\n";
+			delete $Plat{$BSF};
+			close FILE;
+                  next;
+            }
+            my $custom;
+            while ($custom = <FILE>) {
+					#skip blank lines and comments
+			delete $Plat{$BSF};
+					last unless ($custom =~ /^$|^\#/);
+            }
+            $custom = uc $custom;
+            unless ($custom =~ /^\s*CUSTOMIZES\s+(\S+)/) {
+				warn "warning: \"$File\" Invalid BSF specification - 'customizes' missing\n";
+				delete $Plat{$BSF};
+				close FILE;
+			next;
+            }
+		my $root = $1;
+		my $platname = '';
+		my $CustomizedPlatName = '';		
+
+		# In v1 mode, ARMV5 platform implies ARMV5_ABIV1 platform listed in the platlist		
+		my $Armv5Flag = 0;
+		if (!$variantABIV2Keyword && $root =~ /^ARMV5$/i) {
+			$Armv5Flag = 1;
+		}
+
+		# Support for Hierarchy of Customizations (BSF file customization of another BSF file)
+		# 1. Check whether the BSF file customizes another BSF file.
+		# 2. If so, check whether the root BSF file has already been read.
+		# 3. If not read, then defer the current BSF file reading until the root file is read.
+		my $rootPlatFound = 0;
+		if (defined %{$Plat{$root}} || $Armv5Flag) 
+		{
+			# BSF platform customizes another valid BSF platform
+			if (defined $Plat{$root}{'CUSTOMIZES'}) 
+			{
+				$rootPlatFound = 1;
+				$platname = $root;
+				$CustomizedPlatName = $root;
+
+				# Set the root platform name which is same as of customizes platform
+				$Plat{$BSF}{'ROOTPLATNAME'} = $Plat{$root}{'ROOTPLATNAME'};
+			}
+			# BSF platform customizes to one of the existing ABI platforms
+			else
+			{
+				# All BPABI platforms inherits from ABIV2 platform listed in the platlist
+				if (grep /^$root$/i, @BPABIPlats) {
+					$platname = "ABIV2";
+				}
+				elsif ($Armv5Flag) {
+				# In v1 mode, ARMV5 platform implies ARMV5_ABIV1 platform listed in the platlist
+					$platname = "ARMV5_ABIV1";	
+				}
+				else {
+					$platname = $root;
+				}
+				
+				$CustomizedPlatName=$root;
+
+				# BSF File check Begins 
+				# The following check is included to handle the existing BSF files which has to behave in different manner
+				# in default v1 mode and v2 mode. The following code changes the BSF name and the custmoized platform name
+				# to the implied names. This is done to support switching between v1 and v2 modes by enabling the keyword in
+				# the variant configuration file.
+				# In v1 mode, the ARMV6_ABIV1 => ARMV6 platform and ARMV6 => ARMV6_ABIV2 platform.
+				if (!$variantABIV2Keyword) {
+					if ($BSF =~ /^ARMV6_ABIV1$/i) {
+						$BSF = "ARMV6";	
+						$CustomizedPlatName = "ARMV5";	
+					}
+					elsif ($BSF =~ /^ARMV6$/i) {
+						$BSF = "ARMV6_ABIV2";	
+						$CustomizedPlatName = "ARMV5_ABIV2";
+						$platname = "ABIV2";
+					}
+				}
+				# BSF File check Ends
+
+				# Set the root platform name
+				$Plat{$BSF}{'ROOTPLATNAME'} = $CustomizedPlatName;
+			}			
+		}
+		else
+		{
+			my $rootbsf = $Path.$root.".bsf";			
+			if ( -e $rootbsf ) {
+				# BSF file customizes another BSF file which has not been read yet.
+				# So defer current BSF file reading until the root BSF file is read.				
+				delete $Plat{$BSF};
+				push(@BSFs, $BSF);
+				next;		
+			}
+		}
+		# If the customizes platform is not a valid BSF platform or BPABI platorm or ARMV5 or ARMV5_ABIV1,
+		# then throw warning.
+		unless ($rootPlatFound || $root =~ /^ARMV5(_ABIV1)?$/ || (grep /^$root$/i, @BPABIPlats)) {
+			warn "warning: \"$File\" Invalid BSF specification - customization restricted to ARMV5, ABIv2 and valid BSF platforms\n";
+			close FILE;
+			delete $Plat{$BSF};
+			next;
+		}
+			
+		my ( $key, $value);
+		while (($key, $value) = each %{$Plat{$platname}}) {
+			$Plat{$BSF}{$key}=$value;
+		}
+		
+		push @{$Plat{$CustomizedPlatName}{'CUSTOMIZATIONS'}}, $BSF;
+		$Plat{$BSF}{'CUSTOMIZES'} = $CustomizedPlatName;
+		while (<FILE>) {
+			next if (/^$|^\#/);
+			if (/^\s*SMP\s*$/i) {
+				$Plat{$BSF}{'SMP'} = 1;
+				$Plat{$BSF}{'StatLink'} = lc $BSF;
+				next;
+			}
+			$Plat{$BSF}{'CUSTOMIZATION_DATA'} .= $_;
+		}
+		# BSF file statements will have newline character("\n") at the end, except for the last statement.
+		# So append "\n" for the last BSF file statement.
+		# "\n" will be used to split BSF statements to support hierarchy of customizations.
+		$Plat{$BSF}{'CUSTOMIZATION_DATA'} .= "\n";
+		close FILE;
+	}
+	1;
+}
+
+sub Plat_Init ($) { # takes path to ASSP modules
+	my ($Path)=@_;
+
+	my %PlatHashKeys=(
+		ABI=>1,
+		ASSPABI=>1,
+		SINGLE=>1,
+		Compiler=>1,
+		CPU=>1,
+		MakeMod=>1,
+		MakeCmd=>1,
+		OS=>1,
+		DefFile=>1,
+		ASSP=>1,
+	);
+
+#	Include the list of BPABI platforms
+	&Set_Plat;
+
+	Init_BSFs($Path);
+
+#	get a list of modules
+	opendir DIR, $Path;
+	my @_ASSPs=grep s/^([^\.].*)\.ASSP$/$1/, map { uc $_ } readdir DIR;
+	closedir DIR;
+
+	my @ASSPs;
+	foreach (@_ASSPs) {
+		if (!$ENV{USEARMCC} and /EDG$/i) {
+#			warn(
+#				"Note: ASSP \"$_\" disabled\n"
+#			);
+
+			next;
+		}
+		push @ASSPs, $_;
+	}
+
+#	open each module in turn, and add it to the array
+	my $ASSP;
+	foreach $ASSP (@ASSPs) {
+		my $File=$Path.$ASSP.'.assp';
+#		check whether the assp is already defined
+		if (defined %{$Plat{$ASSP}}) {
+			warn(
+				"$File : warning: ASSP \"$ASSP\" already defined\n",
+				" ... skipping this module\n"
+			);
+
+			next;
+		}
+#		open the module
+		unless (open FILE, $File) {
+			warn "warning: Can't open assp module \"$File\"\n";
+			next;
+		}
+		my %Data=();
+		my %SingleData=();
+		my $MatchingSingle="";
+		my @Errors=();
+		while (<FILE>) {
+#			strip comments
+			s/^([^#]*)#.*$/$1/o;
+#			skip blank lines
+			if (/^\s*$/o) {
+				next;
+			}
+#			get the key-value pair
+			unless (/^\s*(\w+)\s+(\w+)\s*$/o) {
+				push @Errors, "$File($.) : warning: syntax error - only key-value pairs allowed\n";
+				next;
+			}
+			my ($Key, $Val)=($1, $2);
+			if ($PlatHashKeys{$Key}!=1) {
+				push @Errors, "$File($.) : warning: unrecognized keyword - $Key\n";
+				next;
+			}
+			if ($Key eq "SINGLE") {
+				$SingleData{Single} = 1;
+				$SingleData{ASSP} = $ASSP;
+				$MatchingSingle = uc $2;
+			} else {
+				$Data{$Key}=$Val;
+				$SingleData{$Key}=$Val;
+			}
+		}
+		close FILE;
+		if (@Errors) {
+			warn(
+				@Errors,
+				" ... skipping this module\n"
+			);
+			next;
+		}
+# change -  Allow ASSPs to pick up all the options of the ABI they specify, 
+# in particular the compiler they need.
+			$Data{'ASSP'} = $ASSP unless $Data{'ASSP'};
+			if ($Plat{$Data{'ABI'}}) {
+			foreach (keys %{$Plat{$Data{'ABI'}}}) {
+			$Data{$_} = $Plat{$Data{'ABI'}}{$_} unless ($_ =~ /^GENERIC$/i) or $Data{$_};
+			}
+		}
+
+		%{$Plat{$ASSP}}=%Data;
+		if ($MatchingSingle ne "") {
+			foreach (keys %Data) {
+			$SingleData{$_} = $Data{$_} unless ($_ =~ /^GENERIC$/i) or $SingleData{$_};
+			}
+			%{$Plat{$MatchingSingle}}=%SingleData;
+		}			
+	}
+}
+
+sub Plat_GetL ($$$$) { # takes Platform name, ref to plat hash, ref to bldmacrohash, bldmake plat command notifier
+	my ($Candidate,$PlatHash_ref,$BldMacrosHash_ref,$platcommand)=@_;
+	$Candidate=uc $Candidate;
+
+# is platform in our list?
+	unless (defined $Plat{$Candidate}) {
+
+		# is platform BPABI compliant one?
+		if (!$variantABIV2Keyword && $Candidate eq 'ARMV5') {
+		}
+		elsif (not(grep /^$Candidate$/i, @BPABIPlats))
+		{
+			die "ERROR: Platform \"$Candidate\" not supported\n";
+		}
+	}
+
+	my $BPABIPlat;
+	my %PlatHash=();
+
+# check the data
+# All BPABI platforms inherit ABIV2 properties 
+	if (grep /^$Candidate$/i, @BPABIPlats) 
+	{
+		$BPABIPlat='ABIV2';
+		%PlatHash=%{$Plat{$BPABIPlat}};
+	}
+# In v1 mode, ARMV5 platform implies ARMV5_ABIV1 platform listed in the platlist
+	elsif (!$variantABIV2Keyword && $Candidate eq 'ARMV5') {
+		%PlatHash=%{$Plat{ARMV5_ABIV1}};
+	}
+	else {
+		%PlatHash=%{$Plat{$Candidate}};
+	}
+
+# set the defaults
+	$PlatHash{Name}=$Candidate;
+	$PlatHash{Real}=$PlatHash{Name} unless $PlatHash{Real};
+	$PlatHash{Ext}=".$PlatHash{Real}" unless $PlatHash{Ext};
+	$PlatHash{ASSP}=$PlatHash{Real} unless $PlatHash{ASSP};
+
+# Get the root platform name to support hierarchy of customizations
+	my $CustomizedPlat=$PlatHash{'ROOTPLATNAME'};
+
+	if ((defined($Candidate)  && ($Candidate =~ /^ARMV5/i)) || (defined($CustomizedPlat) && ($CustomizedPlat =~ /^ARMV5/i))) {
+# Compiler name should be set as ARMCC for all ARMV5 platforms
+		$PlatHash{Compiler}='ARMCC';
+		$PlatHash{Toolchain}='rvct22';
+	}
+	elsif ($BPABIPlat) {
+# Compiler name should be set as that of platform name for all BPABI platforms
+		$PlatHash{Compiler}=$Candidate;
+		$PlatHash{Toolchain}=$Candidate;
+	}
+	elsif ($CustomizedPlat) {
+# Compiler name should be set as that of the customized platform name incase of customization
+		$PlatHash{Compiler}=$CustomizedPlat;
+		$PlatHash{Toolchain}=$CustomizedPlat;
+	}
+
+	$PlatHash{Compiler}='GCC32' unless $PlatHash{Compiler};
+	$PlatHash{OS}='EPOC32' unless $PlatHash{OS};
+	$PlatHash{MakeMod}='Cl_gcc' unless $PlatHash{MakeMod};
+	$PlatHash{MakeCmd}='make' unless $PlatHash{MakeCmd};
+	$PlatHash{CPU}='MARM' unless $PlatHash{CPU};
+	$PlatHash{Single}=0 unless $PlatHash{Single};
+	$PlatHash{UsrHdrsOnly}=0 unless $PlatHash{UsrHdrsOnly};
+	$PlatHash{Generic}=0 unless $PlatHash{Generic}; # generic means "for a target device but no particular ASSP"
+	$PlatHash{SupportsMultiplePlatforms}=0 unless $PlatHash{SupportsMultiplePlatforms};
+
+	$PlatHash{ABI}='ARMI' unless $PlatHash{ABI};
+	$PlatHash{ASSPABI}='ARM4' unless defined $PlatHash{ASSPABI};
+
+	unless (defined $PlatHash{DefFile}) {
+		if ($PlatHash{Compiler} eq 'VC32') {
+			$PlatHash{DefFile}='WINS';
+		} else {
+			$PlatHash{DefFile}='MARM';
+		}
+	}
+	
+# .MMP macros - keeping the order is useful
+	@{$PlatHash{MmpMacros}}=$PlatHash{Compiler};
+	push @{$PlatHash{MmpMacros}}, $PlatHash{OS};
+	push @{$PlatHash{MmpMacros}}, $PlatHash{CPU} unless $PlatHash{CPU} eq $PlatHash{OS};
+	push @{$PlatHash{MmpMacros}}, $PlatHash{ASSP} unless $PlatHash{ASSP}=~/^($PlatHash{CPU}|$PlatHash{OS})$/;
+
+	if ($PlatHash{Single}) {
+		push @{$PlatHash{MmpMacros}}, 'SINGLE';
+	}
+	if ($PlatHash{SMP}) {
+		push @{$PlatHash{MmpMacros}}, 'SMP';
+	}
+	if ($PlatHash{EABI}) {
+		push @{$PlatHash{MmpMacros}}, 'EABI';
+	}
+	if ($PlatHash{Compiler} eq 'VC32') {
+		my $MSVCVer = &Winutl_MSVCVer($platcommand);
+		my $MSVCSubVer = &Winutl_MSVCSubVer($platcommand);
+		push @{$PlatHash{MmpMacros}}, 'MSVC'.$MSVCVer;
+		push @{$PlatHash{MmpMacros}}, 'MSVC'.$MSVCVer.$MSVCSubVer;
+		if ($MSVCVer > 6) {
+			push @{$PlatHash{MmpMacros}}, 'MSVCDOTNET';
+		}
+	}
+	if ($PlatHash{Compiler} eq 'ARMCC') {
+		my ($MajVer, $MinVer) = RVCT_plat2set::get_version_list($Candidate);
+		push @{$PlatHash{MmpMacros}}, 'ARMCC_'.$MajVer;
+		push @{$PlatHash{MmpMacros}}, 'ARMCC_'.$MajVer.'_'.$MinVer;
+	}
+	
+	if ($PlatHash{Compiler} eq 'X86GCC') {	
+			push @{$PlatHash{MmpMacros}}, 'GCC32';
+	}
+
+	## TOOLS2 Specific Macros ##
+	
+	if ($PlatHash{Compiler} eq 'GCC32') {
+		push @{$PlatHash{MmpMacros}}, 'MINGW32';
+		push @{$PlatHash{MmpMacros}}, '_STLP_LITTLE_ENDIAN';
+		
+	}
+
+    # add GCCXML to the mmp macro list, so we can filter out stuff in bld.inf files and mmps.
+    # note that this mean that __GCCXML__ is automacally routed to makefile, so we can take out explicit call. 
+    if( $PlatHash{Name} eq "GCCXML") {
+        push @{$PlatHash{MmpMacros}}, 'GCCXML';
+    }
+	
+# add specific platform macros for platforms customising others.
+	if (Plat_Customizes($PlatHash{Name})) {
+		push @{$PlatHash{MmpMacros}}, $PlatHash{Name} unless grep /$PlatHash{Name}/, @{$PlatHash{MmpMacros}};
+	}
+
+# compilation macros
+	@{$PlatHash{Macros}}=@EpocMacros;
+	foreach (@{$PlatHash{MmpMacros}}) {
+		## If STLP_LTTLE_ENDIAN is used, then dont append __ to the macro name ##
+		if ($_ =~ m/STLP_LITTLE_ENDIAN/) {
+			push @{$PlatHash{Macros}}, $_;
+		} else {
+		push @{$PlatHash{Macros}}, '__'.$_.'__';
+		}
+	}
+
+#	extra special .MMP macros which aren't applied for compilation
+	if ($PlatHash{Generic}) {
+		push @{$PlatHash{MmpMacros}}, "GENERIC_$PlatHash{CPU}";
+		if ($PlatHash{CPU} eq 'MARM') {
+#			we can't define this for ASSP platforms because we won't be sure what
+#			the ABI is until we've processed the .MMP file
+			push @{$PlatHash{MmpMacros}}, "MARM_$PlatHash{ABI}";
+		}
+	}
+
+# builds
+	@{$PlatHash{Blds}}=@{$BldLists{$PlatHash{OS}}};
+
+# output some information
+	if ($Mode{Verbose}) {
+		print
+			"Platform         $PlatHash{Name}\n",
+			"Real Name        $PlatHash{Real}\n",
+			"Compiler         $PlatHash{Compiler}\n",
+			"OS               $PlatHash{OS}\n",
+			"CPU              $PlatHash{CPU}\n",
+			"ASSP             $PlatHash{ASSP}\n",
+			"ABI              $PlatHash{ABI}\n",
+			"ASSPABI          $PlatHash{ASSPABI}\n",
+			"Makefile Module  $PlatHash{MakeMod}\n",
+			"Makefile Type    $PlatHash{MakeCmd}\n",
+			"MMP Macros       @{$PlatHash{MmpMacros}}\n",
+			"Macros           @{$PlatHash{Macros}}\n",
+			"Blds             @{$PlatHash{Blds}}\n"
+		;
+	}
+
+	%{$PlatHash_ref}=%PlatHash;
+	%{$BldMacrosHash_ref}=%BldMacros;
+}
+
+sub Plat_List () {
+
+#	Include the list of BPABI platforms
+	&Set_Plat;
+
+#	return list of supported platforms
+
+	#sort keys %Plat;
+	my @PlatList;
+	my $Key;
+	foreach $Key (keys %Plat) {
+		if (!$variantABIV2Keyword && $Key =~ /^armv5_abiv1$/i) {
+			$Key = 'ARMV5';
+		}
+		unless (grep /^$Key$/i, @PlatList) {
+			push @PlatList, $Key;
+		}
+	}
+	return @PlatList
+}
+
+sub Plat_AssocIDE ($$) {
+#	return the IDE associated with a "Real" platform if there is one
+	my ($Candidate, $AssocIDEs)=@_;
+
+	unless (defined $Plat{$Candidate}) {
+		die "ERROR: Platform \"$Candidate\" not supported\n";
+	}
+
+	my $Key;
+	foreach $Key (keys %Plat) {
+		if (${Plat{$Key}}{Real}) {
+			if (${Plat{$Key}}{Real} eq $Candidate) {
+				push @$AssocIDEs, $Key;
+			}
+		}
+	}
+}
+
+1;