1 # Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 # All rights reserved.

     3 # This component and the accompanying materials are made available

     4 # under the terms of "Eclipse Public License v1.0"

     5 # which accompanies this distribution, and is available

     6 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 #

     8 # Initial Contributors:

     9 # Nokia Corporation - initial contribution.

    10 #

    11 # Contributors:

    12 #

    13 # Description:

    14 # all variables called *Path* are set up to end with a backslash

    15 # all variables called *Path or *File are stored as absolute (file)paths within makmake

    16 # all variables called UpPath* are stored as relative paths within makmake

    17 # 

    18 #

    19 

    20 

    21 use FindBin;		# for FindBin::Bin

    22 use Getopt::Long;

    23 use Cwd;

    24 # modified start: makefile improvement 

    25 use File::stat;

    26 use Time::localtime;

    27 # modified end: makefile improvement 

    28 

    29 my $PerlLibPath;    # fully qualified pathname of the directory containing our Perl modules

    30 

    31 # Prototype to remove warning.

    32 sub AddStringTables();

    33 

    34 BEGIN {

    35 # check user has a version of perl that will cope

    36 	require 5.005_03;

    37 # establish the path to the Perl libraries: currently the same directory as this script

    38 	$PerlLibPath = $FindBin::Bin;	# X:/epoc32/tools

    39 	$PerlLibPath =~ s/\//\\/g;	# X:\epoc32\tools

    40 	$PerlLibPath .= "\\";

    41 }

    42 

    43 use lib $PerlLibPath;

    44 use E32env;

    45 use E32Plat;

    46 use E32Variant;

    47 use Genutl;

    48 use Modload;

    49 use Pathutl;

    50 use Trgtype;

    51 use CheckSource;

    52 use featurevariantparser;

    53 use featurevariantmap;

    54 

    55 # THE MAIN PROGRAM SECTION

    56 ##########################

    57 

    58 {

    59 	Load_SetModulePath($PerlLibPath);

    60 	Plat_Init($PerlLibPath);

    61 }

    62 

    63 my $MAKEFILE;

    64 my $MMPFILE;

    65 my %Options;

    66 my %Plat;

    67 my %TruePlat;

    68 my %BldMacros;

    69 my $PlatArg;

    70 my @PlatOverrideList=();

    71 my $EABIDef;

    72 my $DebugSwitch=undef;

    73 

    74 my $IsCompilerWrapperOption = 0;

    75 my $IsProxyWrapperOption = 0;

    76 my $FeatureVariantArg;

    77 my %FeatureVariantInfo;

    78 

    79 {

    80 	# process the command line

    81 	unless (GetOptions(\%Options, 'd', 'mmp', 'plat=s', 'v', 'arm', 'nd' , 'ithumb' , 'iarm' , 'debug', 'no_debug', 'logfc','wrap:s')) {

    82 		exit 1;

    83 	}

    84 	#Update the variable to set the information of -wrap option

    85 	if(exists($Options{wrap})) {

    86 		if ($Options{wrap} eq "") {

    87 			# Set the Compiler wrapper option information i.e. '1'

    88 			$IsCompilerWrapperOption = 1;

    89 		} elsif ($Options{wrap} eq "proxy") {

    90 			$IsProxyWrapperOption = 1;

    91 		} else {

    92 			print "WARNING: Invalid value for option -wrap: $Options{wrap}\n";

    93 		}

    94 	}

    95 	

    96 	$Options{makemakefile}='1' unless ($Options{mmp} || $Options{plat});

    97 

    98 	if ($Options{mmp} or $Options{plat}) {

    99 		eval { &Load_ModuleL('MAKHELP'); };

   100 		die $@ if $@;

   101 	}

   102 

   103 	if ($Options{mmp}) {

   104 		&Help_Mmp;

   105 		exit;

   106 	}

   107 

   108 	if ($Options{plat}) {

   109 		eval { &Plat_GetL($Options{plat},\%Plat,\%BldMacros); };

   110 		die $@ if $@;

   111 		eval { &Load_ModuleL($Plat{MakeMod}); };

   112 		die $@ if $@;

   113 		&Help_Plat($Plat{Real},$Plat{CPU}, $Plat{DefFile}, \@{$Plat{MmpMacros}},\@{$Plat{Macros}});

   114 		exit;

   115 	}

   116 

   117 #	show help & exit if necessary

   118 	if (@ARGV != 2) {

   119 		&Usage();

   120 	}

   121 	if ($Options{v}) {

   122 		print "perl -S makmake.pl @ARGV\n";

   123 		&Load_SetVerbose;

   124 		&Path_SetVerbose;

   125 		&Plat_SetVerbose;

   126 	}

   127 

   128 	$PlatArg=uc pop @ARGV;

   129 

   130 	# Process build platform arguments where they differ from the "norm"

   131 	if ($PlatArg=~/^(\S+)\.(\S+)$/)

   132 		{

   133 		# Explicit feature variant platforms take the form <base platform>.<variant name>

   134 		# e.g. armv5.variant1

   135 		$PlatArg=$1;

   136 		$FeatureVariantArg=$2;

   137 		}

   138 	elsif ($PlatArg=~/^(\S+):(\S+)$/)

   139 		{

   140 		# IDE platforms can take the form cw_ide:<platform-1>+<platform-2>+<platform-n>

   141 		# e.g. cw_ide:plat1+plat2+plat3

   142 		# 			

   143 		$PlatArg=$1;

   144 		@PlatOverrideList=split(/\+/,$2);

   145 		}

   146 

   147 	eval { &Plat_GetL($PlatArg,\%TruePlat,\%BldMacros); };

   148 	die $@ if $@;

   149 	if (scalar @PlatOverrideList) {

   150 		$PlatArg=$PlatOverrideList[0];

   151 	}

   152 

   153 	

   154 	$MMPFILE=pop @ARGV;

   155 	die "ERROR: Can't specify MMP file on a different drive\n" if $MMPFILE=~/^\w:\\/o;

   156 	if ($MMPFILE!~/.MMP$/io) {

   157 		$MMPFILE.='.MMP';

   158 	}

   159 	$MMPFILE=&Path_AbsToWork($MMPFILE);

   160 

   161 	eval { &Load_ModuleL('Mmp'); };

   162 	die $@ if $@;

   163 	if ($Options{v}) {

   164 		&Mmp_SetVerbose;

   165 	}

   166 	if ($Options{d}) {

   167 		die "ERROR: $E32env::Data{EPOCPath} does not exist\n" if (!-d $E32env::Data{EPOCPath});

   168 	}

   169 	

   170 	if ($Options{debug}) {

   171 		$DebugSwitch = 1;

   172 	}

   173 	elsif($Options{no_debug}){

   174 		$DebugSwitch = 0;

   175 	}

   176 }

   177 

   178 my %LinkerOptions;

   179 my %WarningLevel;

   180 my $ABI;

   181 my @AifStruct;

   182 my $AllowDllData;

   183 my $CompressTarget;

   184 my $CompressTargetMode;   #NONE

   185 my $ASSPExports;

   186 my @ASSPLibList;

   187 my @BitMapStruct;

   188 my $BuildAsARM=$Options{arm};

   189 my $CallDllEntryPoints;

   190 my $Capability;

   191 my @CapabilityFlags;

   192 my $DataLinkAddress;

   193 my @DebugLibList;

   194 my %Def;

   195 my %DocHash;

   196 my $ExportUnfrozen;

   197 my $FirstLib;

   198 my $FixedProcess;

   199 my %HeapSize;

   200 my @LibList;

   201 my $LinkAs;

   202 my $LinkAsBase;

   203 my $ExportLibrary;

   204 my $NoExportLibrary;

   205 my %MmpFlag;

   206 my @PlatTxt2D;

   207 my $ProcessPriority;

   208 my @RamTargets;

   209 my @ResourceStruct;

   210 my @RomTargets;

   211 my $SmpSafe;

   212 my @SourceStruct;

   213 my $StackSize;

   214 my @StatLibList;    

   215 my $StdCpp;

   216 my $NoStdCpp;

   217 my $NewLib;

   218 my @SysIncPaths;

   219 my @ResourceSysIncPaths;

   220 my $ResourceVariantMacroHRHFile;

   221 my $Trg;

   222 my %TrgType;

   223 my @UidList;

   224 my @UserIncPaths;

   225 my $SrcDbg;

   226 my %Path;

   227 my %Version;

   228 my $SecureId;

   229 my $VendorId;

   230 my $variantMacroHRHFile = Variant_GetMacroHRHFile();  # HRH file containing macros specific to a variant

   231 my %ReplaceOptions;

   232 my $ARMFPU;

   233 my @StringTable;

   234 my @StringTableUserIncPaths;

   235 my $CodePagingTargetMode;	# 0-N/A, 1-UNPAGED, 2-PAGED

   236 my $DataPagingTargetMode;	# 0-N/A, 1-UNPAGED, 2-PAGED

   237 my %CheckSourceUDEBIncludes;

   238 my %CheckSourceURELIncludes;

   239 my %CheckSourceMMPMetaData;

   240 my %CheckSourceMMPIncludes;

   241 my $IsWideCharMain=0;

   242 my $IsDebuggable; # 0-NONDEBUGGABLE, 1-DEBUGGABLE, 2-DEBUGGABLE_UDEBONLY

   243 

   244 

   245 use constant NOTPAGED => 0;

   246 use constant UNPAGED => 1;

   247 use constant PAGED => 2;

   248 

   249 use constant INFLATECOMPRESSIONMETHOD => 1;

   250 use constant BYTEPAIRCOMPRESSIONMETHOD => 2;

   251 

   252 use constant NOTDEBUGGABLE => 0;

   253 use constant DEBUGGABLE =>  1;

   254 use constant DEBUGGABLE_UDEBONLY => 2;

   255 

   256 # If the platform does support feature variants but none are specified, then we assume the use of "DEFAULT" if it exists

   257 # If default doesn't exist feature variantion is basically disabled?

   258 $FeatureVariantArg = 'default' if (!$FeatureVariantArg && defined &PMSupportsFeatureVariants && featurevariantparser->DefaultExists());

   259 

   260 # Preload the details of the variant requested if any - we need the HRH file for MMP file processing

   261 if ($FeatureVariantArg)

   262 	{

   263 	# First check the feature variant is valid

   264 	my @buildableFeatureVariants = featurevariantparser->GetBuildableFeatureVariants();

   265 	die "ERROR: \"$PlatArg.$FeatureVariantArg\" feature variant is either invalid or virtual.\n" if !(grep /^$FeatureVariantArg$/i, @buildableFeatureVariants);

   266 

   267 	# Now load the variant

   268 	%FeatureVariantInfo = featurevariantparser->GetVariant($FeatureVariantArg);

   269 	

   270 	# Change the HRH file to use

   271 	$variantMacroHRHFile = $FeatureVariantInfo{VARIANT_HRH} if $FeatureVariantInfo{VARIANT_HRH};

   272 	}

   273 	

   274 &SetVarsFromMmp($PlatArg);

   275 die $@ if $@;

   276 

   277 {

   278 	# set up the makefile filepath - need to do this before loading the platform module

   279 	# because UID source file will be added and set up in the makefile path under WINS

   280 	if ($Options{d}) {

   281 		$MAKEFILE=join ('', $Path{Bld}, &Path_Split('Base',$MMPFILE), $TruePlat{Ext});

   282 	}

   283 	else {

   284 		$MAKEFILE=join "", &Path_WorkPath, &Path_Split('Base',$MMPFILE), $TruePlat{Ext};

   285 	}

   286 }

   287 

   288 {

   289 	# Generate an X86GCC def file from eabi def file in build dir if needed

   290 	if (($PlatArg eq "X86GCC" || $PlatArg eq "X86GMP") && $Def{Base} && not -e &DefFile)

   291 	{

   292 		# Find the equivalent eabi def file

   293 		my $eabiDefFile = File::Spec->canonpath("$Def{Path}../eabi/$Def{Base}$Def{Ext}");

   294 		if (-e $eabiDefFile)

   295 		{

   296 			# Need to create MAKEFILE directory early in this case

   297 			eval { &Path_MakePathL($MAKEFILE); };

   298 			die $@ if $@;

   299 			# Change def file path to build path 

   300 			$Def{Path} = $Path{Bld};

   301 			&generateX86GCCDefFile($eabiDefFile, &DefFile);

   302 		}

   303 		else

   304 		{

   305 			print "WARNING: Unable to find EABI def file at $eabiDefFile to generate X86GCC def file with\n";

   306 		}

   307 	}

   308 }

   309 

   310 {

   311 

   312 

   313 #	load the platform module

   314 	eval { &Load_ModuleL($TruePlat{MakeMod}); };

   315 	die $@ if $@;

   316 

   317 	unless (defined &PMHelp_Mmp) {

   318 #		check this function is defined - all modules must have it - if not perhaps the

   319 #		platform module has not loaded is compiler module successfully via "use"

   320 		die "ERROR: Module \"$Plat{MakeMod}\" not loaded successfully\n";

   321 	}

   322 }

   323 

   324 	# Allow the platform to bow out if feature variants have been specified but it doesn't support them

   325 	if ($FeatureVariantArg && !defined &PMSupportsFeatureVariants)

   326 		{

   327 		die "ERROR: The \"$PlatArg\" platform does not support feature variants.\n";

   328 		}

   329 

   330 {

   331 	# allow the platform to bow out if it can't support some .MMP file specifications

   332 	if (defined &PMCheckPlatformL) {

   333 		eval { &PMCheckPlatformL(); };

   334 		die $@ if $@;

   335 	}

   336 }

   337 

   338 my @StdIncPaths=();

   339 

   340 {

   341 	# get the platform module to do it's mmpfile processing - WINS modules may set up an extra source file

   342 	# for UIDs here depending upon the targettype

   343 	&PMPlatProcessMmp(@PlatTxt2D) if defined &PMPlatProcessMmp;

   344 }

   345 

   346 %CheckSourceMMPMetaData = &Mmp_CheckSourceMMPMetaData();

   347 %CheckSourceMMPIncludes = &Mmp_CheckSourceMMPIncludes();

   348 

   349 # merge checksource processing from platform specific .mmp sections, if applicable

   350 %CheckSourceMMPMetaData = (%CheckSourceMMPMetaData, &PMPlatCheckSource()) if defined &PMPlatCheckSource;

   351 

   352 @ResourceSysIncPaths = @SysIncPaths;

   353 $ResourceVariantMacroHRHFile = $variantMacroHRHFile;

   354 

   355 AddStringTables();

   356 

   357 # Process feature variants if applicable

   358 

   359 if ($FeatureVariantArg)

   360 	{

   361 	if ($Options{v})

   362 		{

   363 		$featurevariantmap::verbose = 1;

   364 		$featurevariantparser::verbose = 1;

   365 		}

   366 

   367 	# Get the default variant details

   368 	my %DefaultFeatureVariantInfo = $FeatureVariantInfo{NAME} =~ /^default$/i ? %FeatureVariantInfo : featurevariantparser->GetVariant("DEFAULT");	

   369 	die "ERROR: Feature variant \"$PlatArg.default\" is invalid.\n" if !$DefaultFeatureVariantInfo{VALID};

   370 

   371 	# The following IF statement decides whether to use the default variant and not use the hash in the filename 

   372 	# This prevents the generation of dll's/exe's for which variants are not needed (i.e they are invariant)

   373 	# It also avoids the time-consuming and redundant hash generation

   374 	# A component is considered invariant if it's not a DLL or EXE or FEATUREVARIANT isn't present in the .mmp file

   375 	

   376 # modified start: makefile improvement 

   377 	if ($TrgType{Basic} =~ /^(EXEDLL|EXE|DLL|LIB)$/ && &Mmp_IsFeatureVariant)

   378 # modified end: makefile improvement 

   379 		{

   380 		# Load the requested variant if it hasn't already been preloaded		

   381 		%FeatureVariantInfo = featurevariantparser->GetVariant($FeatureVariantArg) if !$FeatureVariantInfo{NAME} || $FeatureVariantInfo{NAME} ne $FeatureVariantArg;

   382 		}

   383 	else

   384 		{

   385 		# Use the default variant

   386 		%FeatureVariantInfo = %DefaultFeatureVariantInfo;

   387 		$FeatureVariantInfo{INVARIANT} = 1;

   388 		$FeatureVariantInfo{NAME} = uc $FeatureVariantArg;

   389 		}

   390 

   391 	die "ERROR: Feature variant \"$PlatArg.$FeatureVariantInfo{NAME}\" is invalid.\n" if !$FeatureVariantInfo{VALID};

   392 	

   393 	my @featureVariantSysIncPaths = (@{$FeatureVariantInfo{BUILD_INCLUDES}},@SysIncPaths);

   394 	

   395 	# Further process paths and filenames so that they include a drive letter.

   396 	# We store this in a hash specifically for passing on to featurevariantmap->Hash

   397 	

   398 	my @processedIncludes = &Path_PrefixWithDrive(&Path_Chop(@UserIncPaths), &Path_Chop(@featureVariantSysIncPaths));

   399 	push @processedIncludes, &Path_Chop(&PMToolChainIncDir) if defined &PMToolChainIncDir && &PMToolChainIncDir;

   400 	

   401 	my $processedPreInclude = "";

   402 	if (defined &PMPrefixFile)

   403 		{

   404 		$processedPreInclude = &PMPrefixFile;

   405 		$processedPreInclude =~ s/\"//g;

   406 		$processedPreInclude = &Path_PrefixWithDrive($processedPreInclude);		

   407 		}

   408 

   409 	my %processedFeatureVariantInfo;

   410 	$processedFeatureVariantInfo{PREINCLUDE} = $processedPreInclude if $processedPreInclude;

   411 	$processedFeatureVariantInfo{BUILD_INCLUDES} = \@processedIncludes if @processedIncludes;

   412 	$processedFeatureVariantInfo{VALID} = 1;

   413 	

   414 	# Pass in the details of the macros tested in the MMP

   415 	$processedFeatureVariantInfo{MMPTESTED} = &Mmp_TestedMacros();

   416 

   417 	my @pathedSrcList = ();

   418 	push @pathedSrcList, Path_PrefixWithDrive($$_{SrcPath}.$$_{CurFile}) foreach (@SourceStruct);

   419 

   420 	foreach my $bld (@{$Plat{Blds}})

   421 		{

   422 # modified start: makefile improvement 

   423 		my @reusedHash;

   424 # modified end: makefile improvement 

   425 		if ($FeatureVariantInfo{INVARIANT})															# Invariant override

   426 			{

   427 			$FeatureVariantInfo{$bld."_LABEL"} = "INVARIANT";

   428 			}

   429 		else

   430 			{

   431 # modified by SV start: makefile improvement 

   432 			my $vmap = "$E32env::Data{RelPath}".lc($Plat{Real})."\\".lc($bld)."\\".Trg()."." . $FeatureVariantInfo{NAME}.".vmap";

   433 # modified by SV end: makefile improvement 

   434 			$vmap = Path_PrefixWithDrive($vmap);

   435 			if(-e $vmap){

   436 				my @variantlist = featurevariantmap->GetVariantListFromVmap($vmap);

   437 				my @calls;

   438 				foreach(@variantlist)

   439 				{

   440 					my $target = "CHECKVMAP".uc($bld);

   441 					my $makefile = $MAKEFILE.".".$_;

   442 					if(-e $makefile){

   443 						push @calls, "make -r -f \"$makefile\"  $target";

   444 					}

   445 				}

   446 				foreach my $call (@calls)

   447 				{

   448 					print "call: $call" if $Options{v};

   449 					open PIPE, "$call |";

   450 					while(<PIPE>) {

   451 						print $_;

   452 					}

   453 					close PIPE;

   454 				}

   455 				if(-e $vmap){

   456 					@reusedHash = featurevariantmap->CheckOldVmapFile($vmap, \%FeatureVariantInfo);

   457 				}

   458 			}

   459 			if(defined(@reusedHash))

   460 			{

   461 				$FeatureVariantInfo{$bld."_LABEL"} = $reusedHash[0];

   462 				$FeatureVariantInfo{$bld."_FEATURES"} = $reusedHash[1];

   463 				next;

   464 			}

   465 # modified end: makefile improvement 

   466 			my @macros = (@{$Plat{Macros}}, @{$BldMacros{$bld}}, "__SUPPORT_CPP_EXCEPTIONS__");

   467 			push @macros, "__PRODUCT_INCLUDE__=\"".&Path_PrefixWithDrive($FeatureVariantInfo{VARIANT_HRH})."\"" if $FeatureVariantInfo{VARIANT_HRH};

   468 			$processedFeatureVariantInfo{MACROS} = \@macros;

   469 

   470 			print ("Feature variant hash processing: \"$FeatureVariantInfo{NAME} $bld\"\n") if $Options{v};

   471 			

   472 			my @result = featurevariantmap->HashAndFeatures(\@pathedSrcList, \%processedFeatureVariantInfo);

   473 			$FeatureVariantInfo{$bld."_LABEL"} = $result[0];

   474 			$FeatureVariantInfo{$bld."_FEATURES"} = $result[1];

   475 			

   476 			die "ERROR: Can't obtain hash for \"$PlatArg.$FeatureVariantInfo{NAME}\" feature variant.\n" if !$FeatureVariantInfo{$bld."_LABEL"};

   477 			}

   478 		}

   479 

   480 	# Customise standard content based on feature variant updates

   481 	@SysIncPaths = @featureVariantSysIncPaths;

   482 	$variantMacroHRHFile = $FeatureVariantInfo{VARIANT_HRH};

   483 	$MAKEFILE .= ".$FeatureVariantInfo{NAME}";

   484 

   485 	# Resources are always processed in the context of the default variant's system include and variant files when

   486 	# feature variants are in use

   487 	@ResourceSysIncPaths = (@{$DefaultFeatureVariantInfo{BUILD_INCLUDES}},@ResourceSysIncPaths);

   488 	$ResourceVariantMacroHRHFile = $DefaultFeatureVariantInfo{VARIANT_HRH};

   489 	}

   490 

   491 

   492 {

   493 	# if verbose mode set, output some info

   494 	#--------------------------------------

   495 	if ($Options{v}) {

   496 		print  

   497 			"Target: \"$Trg\"\n",

   498 			"TargetType: \"$TrgType{Name}\"\n",

   499 			"Libraries: \"@LibList\"\n",

   500 			"Debug Libraries: \"@DebugLibList\"\n",

   501 			"Static Libraries: \"@StatLibList\"\n",

   502 			"Uids: \"@UidList\"\n",

   503 			"BuildVariants: \"@{$Plat{Blds}}\"\n",

   504 			"TargetMakeFile: \"$MAKEFILE\"\n",

   505 			"UserIncludes: \"<Source Dir> @UserIncPaths\"\n",

   506 			"SystemIncludes: \"@SysIncPaths\"\n"

   507 		;

   508 

   509 	if (%FeatureVariantInfo)

   510 		{

   511 		print 

   512 			"Feature Variant Name: \"$FeatureVariantInfo{NAME}\"\n",

   513 			"Feature Variant SystemIncludes: \"@{$FeatureVariantInfo{BUILD_INCLUDES}}\"\n",

   514 			"Feature Variant HRH file: \"$FeatureVariantInfo{VARIANT_HRH}\"\n";

   515 

   516 		foreach my $bld (@{$Plat{Blds}})

   517 			{

   518 			print "Feature Variant $bld Label: \"".$FeatureVariantInfo{$bld."_LABEL"}."\"\n";			

   519 			}

   520 		

   521 		}

   522 	}

   523 }

   524 

   525 # Special handling for non-default invariant makefiles without FEATUREVARIANT in the MMP file

   526 # In this situation the default variant makefle is just included into the variant makefile

   527 # modified start: makefile improvement 

   528 if ($TrgType{Basic} =~ /^(EXEDLL|EXE|DLL|LIB)$/ && %FeatureVariantInfo && $FeatureVariantInfo{INVARIANT})

   529 	{

   530 	$MAKEFILE =~ s/([^.]*$)/DEFAULT/;

   531 # modified by SV start: makefile improvement 

   532 		if( $FeatureVariantInfo{NAME} !~ /^default$/i)

   533 			{

   534 				print "not creating makefile for  : $FeatureVariantInfo{NAME}\n" if ($Options{v});

   535 			}

   536 # modified by SV end: makefile improvement 

   537 	if(-e $MAKEFILE )

   538 		{

   539 		my $mmp_time = -M $MMPFILE;

   540 		my $makefile_time = -M $MAKEFILE;

   541 		if( $makefile_time <= $mmp_time)

   542 			{

   543 			exit;

   544 			}

   545 		}

   546 	undef %FeatureVariantInfo;

   547 	%FeatureVariantInfo = featurevariantparser->GetVariant("default");

   548 	$FeatureVariantInfo{INVARIANT} = 1;

   549 	$FeatureVariantInfo{UREL_LABEL} = 'INVARIANT';

   550 	$FeatureVariantInfo{UDEB_LABEL} = 'INVARIANT';

   551 	}

   552 # modified by SV start: makefile improvement 

   553 	elsif(%FeatureVariantInfo)

   554 	{

   555 	my $variant_info = &Path_Chop($E32env::Data{BldPath}).$Path{BldInfPath}."\\FeatureVariantInfo\\".$Plat{Real}."\\".$Plat{Real}.".".$FeatureVariantInfo{NAME}.".".&Path_Split('Base', $MMPFILE).".info";

   556 	#if mmp file does not exists

   557 	$variant_info = &Path_Chop($E32env::Data{BldPath}).$Path{BldInfPath}."\\FeatureVariantInfo\\".$Plat{Real}."\\".$Plat{Real}.".".$FeatureVariantInfo{NAME}.".info" if ! -e $MMPFILE;

   558 # modified by SV end: makefile improvement 

   559 	my $variant_key = "VARIANT_PLAT_NAME_".&Path_Split('Base', $MMPFILE);

   560 	$variant_info_new = $variant_info.".tmp";

   561 	open VARIANTINFOR_NEW, ">$variant_info_new" or die "ERROR: Can't open or create file \"$variant_info_new\"\n";

   562 

   563 	# Open the variant infor file

   564 	open VARIANTINFOR, "<$variant_info" or die "ERROR: Can't open file \"$variant_info\"\n";

   565 	while(<VARIANTINFOR>)

   566 		{

   567 		if(/^$variant_key/)

   568 			{

   569 			print VARIANTINFOR_NEW $variant_key.":=".$FeatureVariantInfo{NAME}."\n";

   570 			}

   571 			else

   572 			{

   573 			print VARIANTINFOR_NEW $_;

   574 			}

   575 		}

   576 	# Close and cleanup

   577 	close VARIANTINFOR or die "ERROR: Can't close file \"$variant_info\"\n";

   578 	close VARIANTINFOR_NEW or die "ERROR: Can't close file \"$variant_info\"\n";

   579 	unlink $variant_info;

   580 	rename($variant_info_new, $variant_info);

   581 	if ($Options{v}) {

   582 		print "Successful Variant Infor File Creation\n";

   583 

   584 		}

   585 	}

   586 # modified end: makefile improvement 

   587 

   588 my $CurAifRef;

   589 my $CurBaseObj;

   590 my $CurBld;

   591 my $CurBitMapRef;

   592 my @CurDepList;

   593 my $CurDoc;

   594 my $CurResrc;

   595 my $CurResourceRef;

   596 my $CurSrc;

   597 my $CurSrcPath;

   598 my $ResrcIsSys;

   599 # modified start: makefile improvement 

   600 my %CurSrcSet;

   601 # modified end: makefile improvement 

   602 

   603 # Set up library paths getting the backend module to help if it wants to

   604 {

   605 	&InitLinkPaths();

   606 }

   607 

   608 {

   609 

   610 	# LOOPING SECTION

   611 	#----------------

   612 	# Load the output module

   613 	eval { &Load_ModuleL('OUTPUT'); };

   614 	die $@ if $@;

   615 

   616  

   617 	# Believe include first on the system list. 

   618     my $VariantFile=&main::VariantFile();

   619     if($VariantFile){

   620         my $VariantFilePath = Path_Split('Path',$VariantFile);

   621         chop($VariantFilePath);

   622 

   623         push(@SysIncPaths, $VariantFilePath);

   624     }

   625 

   626 	my $ResourceVariantFile=&main::ResourceVariantFile();

   627     if($ResourceVariantFile){

   628         my $ResourceVariantFilePath = Path_Split('Path',$ResourceVariantFile);

   629         chop($ResourceVariantFilePath);

   630 

   631         push(@ResourceSysIncPaths, $ResourceVariantFilePath);

   632     }

   633     

   634     ## Add default system include info for TOOLS2

   635     if ($PlatArg eq 'TOOLS2') {    	

   636     	push @SysIncPaths , "$E32env::Data{EPOCPath}include\\tools\\stlport";

   637     }

   638 

   639 	# If the stdcpp keyword is used, or if the target type is STD* ...

   640 	if ($StdCpp or $TrgType{Name} eq 'STDEXE' or $TrgType{Name} eq 'STDDLL' or $TrgType{Name} eq 'STDLIB') {

   641 		push @SysIncPaths, $E32env::Data{EPOCPath}."include\\stdapis";

   642 	}

   643 

   644 	&PMStartBldList($Plat{MakeCmd}) if defined &PMStartBldList;

   645 	my $LoopBld;

   646 	foreach $LoopBld (@{$Plat{Blds}}) {

   647 		$CurBld=$LoopBld;

   648 		&PMBld if defined &PMBld;

   649 	}

   650 	undef $CurBld;

   651 	undef $LoopBld;

   652 	&PMEndBldList if defined &PMEndBldList;

   653 

   654 

   655 	# Load the Dependency Generator

   656 	eval { &Load_ModuleL('MAKDEPS'); };

   657 	die $@ if $@;

   658 	eval { &Deps_InitL($E32env::Data{EPOCIncPath},@StdIncPaths); };

   659 	die $@ if $@;

   660 	if ($Options{v}) {

   661 		&Deps_SetVerbose;

   662 	}

   663 	if ($Plat{UsrHdrsOnly}) {

   664 		&Deps_SetUserHdrsOnly;

   665 	}

   666 

   667 	if ($Options{nd} || ($ENV{SYMBIANBUILD_DEPENDENCYOFF} && ($ENV{SYMBIANBUILD_DEPENDENCYOFF}==1))) {

   668 		&Deps_SetNoDependencies

   669 	}

   670 	&Deps_SetNoDependencies if(grep /boostlibrary/i, &Mmp_UserIncPaths);

   671 

   672 	&Deps_SetUserIncPaths(@UserIncPaths);

   673 	&Deps_SetSysIncPaths(@ResourceSysIncPaths);

   674 	&Deps_SetPlatMacros(@{$Plat{Macros}});

   675 

   676 	my $prefixFile;

   677 	$prefixFile = &PMPrefixFile if defined &PMPrefixFile;

   678 	&Deps_SetPrefixFile($prefixFile) if $prefixFile;

   679 

   680 #	Start source list - bitmaps, resources, .AIF files, documents, sources.

   681 

   682 	# If feature variants are in use, dependency analysis may use a different overall variant file to that for "straight" source

   683 	my $curDepOSVariantFile = &Deps_GetOSVariantFile();

   684 	&Deps_SetOSVariantFile($ResourceVariantFile);

   685 

   686 	&PMStartSrcList if defined &PMStartSrcList;

   687 

   688 #	start bitmaps

   689 

   690 	if ($Options{v}) {

   691 		print "Starting bitmaps\n";

   692 	}

   693 	my $LoopBitMapRef;

   694 	foreach $LoopBitMapRef (@BitMapStruct) {

   695 		$CurBitMapRef=$LoopBitMapRef;

   696 		if ($Options{v}) {

   697 			print "BitMap: \"$$CurBitMapRef{Trg}\"\n";

   698 		}

   699 		&PMBitMapBld if defined &PMBitMapBld;

   700 	}

   701 	undef $CurBitMapRef;

   702 	undef $LoopBitMapRef;

   703 

   704 #	end bitmaps

   705 

   706 #	start resources

   707 

   708 	if ($Options{v}) {

   709 		print "Starting resources\n";

   710 	}

   711 	my $LoopResourceRef;

   712 	foreach $LoopResourceRef (@ResourceStruct) {

   713 		$CurResourceRef=$LoopResourceRef;

   714 		if ($Options{v}) {

   715 			print "Resource: \"$$CurResourceRef{Trg}\"\n";

   716 		}

   717 		eval { @CurDepList=&Deps_GenDependsL($$CurResourceRef{Source}, ("LANGUAGE_$$CurResourceRef{Lang}")); };

   718 		die $@ if $@;

   719 		&PMResrcBld if defined &PMResrcBld;

   720 		undef @CurDepList;

   721 	}

   722 	undef $CurResourceRef;

   723 	undef $LoopResourceRef;

   724 

   725 #	end resources

   726 

   727 #	start aifs

   728 

   729 	if ($Options{v}) {

   730 		print "Starting aifs\n";

   731 	}

   732 

   733 # Add tools-relative include path to sys includes, to allow for shared include\aiftool.rh

   734 	use FindBin;

   735 	$FindBin::Bin =~ /:(.*)\//;

   736 	my $extraIncPath = $1;

   737 	$extraIncPath =~ s/\//\\/g;

   738 	my @SavedResourceSysIncPaths = @ResourceSysIncPaths;

   739 	push @ResourceSysIncPaths, "$extraIncPath\\INCLUDE";

   740 	&Deps_SetSysIncPaths(@ResourceSysIncPaths);

   741 

   742 	my $LoopAifRef;

   743 	foreach $LoopAifRef (@AifStruct) {

   744 		$CurAifRef=$LoopAifRef;

   745 		if ($Options{v}) {

   746 			print "Aif: \"$$CurAifRef{Trg}\"\n";

   747 		}

   748 		eval { @CurDepList=&Deps_GenDependsL("$$CurAifRef{Source}"); };

   749 		die $@ if $@;

   750 		&PMAifBld if defined &PMAifBld;

   751 		undef @CurDepList;

   752 	}

   753 	undef $CurAifRef;

   754 	undef $LoopAifRef;

   755 

   756 	@ResourceSysIncPaths = @SavedResourceSysIncPaths;

   757 

   758 #	end aifs

   759 

   760 #	start sources

   761 

   762 	if ($Options{v}) {

   763 		print "Starting sources\n";

   764 	}

   765 	

   766 	my $SrcRef;

   767 	&Deps_SetOSVariantFile($curDepOSVariantFile);

   768 	&Deps_SetSysIncPaths(@SysIncPaths);

   769 

   770 	foreach $SrcRef (@SourceStruct){

   771 		 $CurSrcPath=$$SrcRef{SrcPath};

   772 		 $CurSrc=$$SrcRef{CurFile};

   773 

   774 		 my @userIncludes = &Mmp_UserIncPaths;

   775 		 @userIncludes = (@userIncludes, @StringTableUserIncPaths) if (@StringTableUserIncPaths);

   776 		 unshift (@userIncludes, $CurSrcPath);		 

   777 

   778 		 if ($TruePlat{Ext} !~ /\.DSP|\.xml/i)

   779 		 	{

   780 			foreach my $buildVariant (@{$Plat{Blds}})

   781 				{		 		

   782 				my @macros = &MacroList;

   783 				@macros = (@macros, @{$BldMacros{$buildVariant}});

   784 

   785 				my $checkSourceCommandStore;

   786 			

   787 				if ($buildVariant =~ /rel$/i)

   788 					{

   789 					$checkSourceCommandStore = \%CheckSourceURELIncludes

   790 					}

   791 				else

   792 					{

   793 					$checkSourceCommandStore = \%CheckSourceUDEBIncludes

   794 					}

   795 				CheckSource_Includes($CurSrcPath.$CurSrc, %$checkSourceCommandStore, $VariantFile, @macros, @userIncludes, @SysIncPaths);

   796 			}

   797 		 }

   798 		 if ($Options{v}) {

   799 			print "Sourcepath: \"$CurSrcPath\"\n";

   800 		 }

   801 		 &PMStartSrc if defined &PMStartSrc;

   802 

   803 #			strict depend alt 1 start - call different module function if strict depend flag specified

   804 			if (((not $MmpFlag{StrictDepend}) || (not defined &PMSrcBldDepend)) && defined &PMSrcDepend) {

   805 				eval { @CurDepList=&Deps_GenDependsL($CurSrcPath.$CurSrc);};

   806 				die $@ if $@;

   807 # modified start: makefile improvement 

   808 				foreach $srcFile (@CurDepList) {

   809 					if(not exists($CurSrcSet{$srcFile})){

   810 						my $srctmp = $srcFile;

   811 						$CurSrcSet{$srctmp} = 1;

   812 					}

   813 				}

   814 # modified end: makefile improvement 

   815 				&PMSrcDepend if defined &PMSrcDepend;

   816 				undef @CurDepList;

   817 			}

   818 							

   819 #			strict depend alt 1 end

   820 

   821 			my $LoopBld;

   822 			foreach $LoopBld (@{$Plat{Blds}}) {

   823 				$CurBld=$LoopBld;

   824 				&PMStartSrcBld if defined &PMStartSrcBld;

   825 

   826 #				strict depend alt 2 start - call the module function that deals with dependencies generated for each build variant

   827 				if ($MmpFlag{StrictDepend} && defined &PMSrcBldDepend) {

   828 					eval { @CurDepList=Deps_GenDependsL($CurSrcPath.$CurSrc,@{$BldMacros{$CurBld}}); };

   829 					die $@ if $@;

   830 					&PMSrcBldDepend if defined &PMSrcBldDepend;

   831 					undef @CurDepList;

   832 				}

   833 #				strict depend alt 2 end

   834 

   835 				&PMEndSrcBld if defined &PMEndSrcBld;

   836 			}

   837 			undef $CurBld;

   838 			undef $LoopBld;

   839 			&PMEndSrc if defined &PMEndSrc;

   840 # modified start: makefile improvement 

   841 			my $cursrcfile = $CurSrcPath.$CurSrc;

   842 			if(not exists($CurSrcSet{$cursrcfile})){

   843 				$CurSrcSet{$cursrcfile} = 1;

   844 			}

   845 # modified end: makefile improvement 

   846 		}

   847 		undef $CurSrc;

   848 		undef $CurSrcPath;  

   849 	

   850 	

   851 

   852 #	end sources

   853 

   854 #	start documents

   855 

   856 	if ($Options{v}) {

   857 		print "Starting documents\n";

   858 	}

   859 	my $LoopSrcPath;

   860 	foreach $LoopSrcPath (sort keys %DocHash) {

   861 		$CurSrcPath=$LoopSrcPath;

   862 		if ($Options{v}) {

   863 			print "Sourcepath: \"$CurSrcPath\"\n";

   864 		}

   865 		my $LoopDoc;

   866 		foreach $LoopDoc (sort @{$DocHash{$CurSrcPath}}) {

   867 			$CurDoc=$LoopDoc;

   868 			if ($Options{v}) {

   869 				print "Document: \"$CurDoc\"\n";

   870 			}

   871 			&PMDoc if defined &PMDoc;

   872 		}

   873 		undef $CurDoc;

   874 		undef $LoopDoc;

   875 	}

   876 	undef $CurSrcPath;

   877 	undef $LoopSrcPath;

   878 

   879 #	end documents

   880 

   881 #	rombuild

   882 

   883 	my %SpecialRomFileTypes=(

   884 		KEXT=>'extension[MAGIC]',

   885 		LDD=>'device[MAGIC]',

   886 		PDD=>'device[MAGIC]',

   887 		VAR=>'variant[MAGIC]'

   888 	);

   889 	my %KHash1 = (

   890 		kext=>1,

   891 		ldd=>1,

   892 		pdd=>1,

   893 		var=>1,

   894 		kdll=>1

   895 	);

   896 	my %KHash2 = (

   897 		primary=>1,

   898 		variant=>1,

   899 		extension=>1,

   900 		device=>1

   901 	);

   902 	unless ($TrgType{Basic} =~ /^IMPLIB$/io or $TruePlat{Ext} =~ /\.DSP|\.xml/i) { # change to avoid rombuild target for IDE makefiles

   903 		&Output("ROMFILE:\n");

   904 		unless ($Plat{OS} ne 'EPOC32' or $TrgType{Basic} eq 'LIB') {

   905 			my $ref;

   906 			foreach $ref (@RomTargets) {

   907 				my $ABIDir = '##MAIN##';

   908 				my $RomFileType='file';

   909 				if ($$ref{FileType}) {	# handle EKERN.EXE and EFILE.EXE with new ROMFILETYPE keyword instead

   910 					$RomFileType=$$ref{FileType}; # or just do this bit as a custom build makefile

   911 				}

   912 				elsif ($CallDllEntryPoints) {

   913 					$RomFileType='dll';

   914 				}

   915 				elsif ($SpecialRomFileTypes{$TrgType{Name}}) {

   916 					$RomFileType=$SpecialRomFileTypes{$TrgType{Name}};

   917 				}

   918 				my $RomPath="sys\\bin\\";

   919 				if ($$ref{Path}) {

   920 					$RomPath=$$ref{Path};

   921 				}

   922 				elsif ($TrgType{Path}) {

   923 					$RomPath=$TrgType{Path};

   924 					$RomPath=~s-z\\(.*)-$1-o;

   925 				}

   926 				my $RomFile=$LinkAsBase;

   927 				if ($$ref{File}) {

   928 					$RomFile=$$ref{File};

   929 				}

   930 				my $RomDecorations='';

   931 				if ($DataLinkAddress) {

   932 					$RomDecorations="reloc=$DataLinkAddress";

   933 				}

   934 				elsif ($FixedProcess) {

   935 					$RomDecorations.='fixed';

   936 				}

   937 				

   938 				$ABIDir = '##KMAIN##' if ($KHash1{lc $TrgType{Name}});

   939 				$ABIDir = '##KMAIN##' if ($KHash2{lc $RomFileType});

   940 				my $IbyTextFrom="$RomFileType=$E32env::Data{RelPath}$ABIDir\\##BUILD##\\$Trg";

   941 				my $IbyTextTo="$RomPath$RomFile";

   942 				my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1; 

   943 				&Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, "$IbyTextTo $RomDecorations\n");

   944 			}

   945 			foreach $ref (@RamTargets) {

   946 				my $ABIDir = '##MAIN##';

   947 				$ABIDir = '##KMAIN##' if ($KHash1{lc $TrgType{Name}});

   948 				my $RomFileType='data';

   949 				my $RomPath="sys\\bin\\";

   950 				if ($$ref{Path}) {

   951 					$RomPath=$$ref{Path};

   952 				}

   953 				my $RomFile=$Trg;

   954 				if ($$ref{File}) {

   955 					$RomFile=$$ref{File};

   956 				}

   957 				my $RomDecorations='attrib=r';

   958 

   959 				my $IbyTextFrom="$RomFileType=$E32env::Data{RelPath}$ABIDir\\##BUILD##\\$Trg";

   960 				my $IbyTextTo="$RomPath$RomFile";

   961 				my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1; 

   962 				&Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, "$IbyTextTo $RomDecorations\n");

   963 			}

   964 		}

   965 	}

   966 #	end rombuild

   967 

   968 	&PMEndSrcList if defined &PMEndSrcList;

   969 }

   970 

   971 {

   972 

   973 	# open the makefile and write all the text it requires to it if makmake has so far been successful

   974 	#-------------------------------------------------------------------------------------------------

   975 	eval { &Path_MakePathL($MAKEFILE); };

   976 	die $@ if $@;

   977 	if ($Options{v}) {

   978 		print "Creating: \"$MAKEFILE\"\n";

   979 	}

   980 	open MAKEFILE,">$MAKEFILE" or die "ERROR: Can't open or create file \"$MAKEFILE\"\n";

   981 	print MAKEFILE &OutText or die "ERROR: Can't write output to file \"$MAKEFILE\"\n";

   982 	close MAKEFILE or die "ERROR: Can't close file \"$MAKEFILE\"\n";

   983 	if ($Options{v}) {

   984 		print "Successful MakeFile Creation\n";

   985 	}

   986 }

   987 

   988 	

   989 ################ END OF MAIN PROGRAM SECTION #################

   990 #------------------------------------------------------------#

   991 ##############################################################

   992 

   993 

   994 

   995 

   996 

   997 # SUBROUTINE SECTION

   998 ####################

   999 

  1000 sub FatalError (@) {

  1001 

  1002 	print STDERR "MAKMAKE ERROR: @_\n";

  1003 	exit 1;

  1004 }

  1005 

  1006 sub Usage () {

  1007 

  1008 		eval { &Load_ModuleL('MAKHELP'); };

  1009 		die $@ if $@; 

  1010 		eval { &Help_Invocation; };

  1011 		die $@ if $@;

  1012 		exit;

  1013 }

  1014 

  1015 sub getEABIDef() {

  1016 	# Preprocess the mmp with ARMv5 platform settings so we can pick up 

  1017     # EABI specific def file entries etc. 

  1018     my ($platname)="ARMV5";

  1019     

  1020     # get platform info for armv5

  1021     eval { &Plat_GetL($platname,\%Plat,\%BldMacros); };

  1022 	return $@ if $@;

  1023 	&Mmp_Reset;

  1024 	# process 

  1025     

  1026     # set package to ignore warnings about missing .def file. 

  1027     &Mmp_SetIgnoreMissingDef;

  1028     

  1029     eval { &Mmp_ProcessL($E32env::Data{EPOCPath}, $MMPFILE, \%Plat, $FeatureVariantInfo{BUILD_INCLUDES}); };

  1030 	return $@ if $@;

  1031 	my %EABIDef=%{&Mmp_Def};

  1032 	

  1033     # handle case that def file doesn't exist -> Simply set to ""

  1034     my $EABIDefFile = "$EABIDef{Path}$EABIDef{Base}$EABIDef{Ext}";;

  1035    	unless (-e "$EABIDefFile") {

  1036         $EABIDefFile = "";

  1037 	}

  1038     

  1039     return $EABIDefFile;

  1040 	

  1041 }

  1042 

  1043 sub SetVarsFromMmp ($) {

  1044 

  1045 	my ($platname)=@_;

  1046     

  1047 	if($platname eq "GCCXML") {

  1048         $EABIDef = getEABIDef();

  1049     } 

  1050     else {

  1051         $EABIDef = "";

  1052     }

  1053 

  1054 	# MMP FILE PROCESSING - filter the mmp file content through the GCC preprecessor

  1055 	#-------------------------------------------------------------------------------

  1056 	eval { &Plat_GetL($platname,\%Plat,\%BldMacros); };

  1057 	return $@ if $@;

  1058 	&Mmp_Reset;

  1059 

  1060 	if($platname eq "GCCXML" || $platname eq "X86GCC" || $platname eq "X86GMP") {

  1061 	# set package to ignore warnings about missing .def file, this is necessary,

  1062 	# as either EABI .def or GCC .def may not exist, and this shouldn't be reported

  1063 	# as a warning or error. Similarly for x86gcc def files - these are autogenerated.

  1064 	&Mmp_SetIgnoreMissingDef;

  1065 	}

  1066 

  1067 	eval { &Mmp_ProcessL($E32env::Data{EPOCPath}, $MMPFILE, \%Plat, $FeatureVariantInfo{BUILD_INCLUDES}); };

  1068 	return $@ if $@;

  1069 

  1070 	%WarningLevel=&Mmp_WarningLevel;

  1071 	%LinkerOptions=&Mmp_LinkerOptions;

  1072 	$ABI=&Mmp_ABI;

  1073 	@AifStruct=@{&Mmp_AifStruct};

  1074 	$AllowDllData=&Mmp_AllowDllData;

  1075 	$CompressTarget=&Mmp_CompressTarget;

  1076 	$CompressTargetMode=&Mmp_CompressTargetMode;

  1077 	$ASSPExports=&Mmp_ASSPExports;

  1078 	@ASSPLibList=&Mmp_ASSPLibList;

  1079 	@BitMapStruct=@{&Mmp_BitMapStruct};

  1080 	$BuildAsARM=$BuildAsARM || &Mmp_BuildAsARM;

  1081 	$CallDllEntryPoints=&Mmp_CallDllEntryPoints;

  1082 	$Capability=&Mmp_Capability;

  1083 	@CapabilityFlags=&Mmp_CapabilityFlags;

  1084 	$DataLinkAddress=&Mmp_DataLinkAddress;

  1085 	@DebugLibList=@{&Mmp_DebugLibList};

  1086 	%Def=%{&Mmp_Def};

  1087 	%DocHash=%{&Mmp_DocHash};

  1088 	$ExportUnfrozen=&Mmp_ExportUnfrozen;

  1089 	$FirstLib=&Mmp_FirstLib;

  1090 	$FixedProcess=&Mmp_FixedProcess;

  1091 	%HeapSize=%{&Mmp_HeapSize};

  1092 	@LibList=@{&Mmp_LibList};

  1093 	$LinkAs=&Mmp_LinkAs;

  1094 	$LinkAsBase=&Mmp_LinkAsBase;

  1095 	$ExportLibrary=&Mmp_ExportLibrary;

  1096 	$NewLib = &Mmp_NewLib;

  1097     $NoExportLibrary=&Mmp_NoExportLibrary;

  1098 	%MmpFlag=%{&Mmp_MmpFlag};

  1099 	@PlatTxt2D=&Mmp_PlatTxt2D;

  1100 	$ProcessPriority=&Mmp_ProcessPriority;

  1101 	@RamTargets=&Mmp_RamTargets;

  1102 	@ResourceStruct=@{&Mmp_ResourceStruct};

  1103 	@RomTargets=&Mmp_RomTargets;

  1104 	$SmpSafe=&Mmp_SmpSafe;

  1105 	@SourceStruct=@{&Mmp_SourceStruct};

  1106 	$StackSize=&Mmp_StackSize;

  1107 	@StatLibList=&Mmp_StatLibList;    

  1108 	$StdCpp = &Mmp_StdCpp;

  1109 	$NoStdCpp = &Mmp_NoStdCpp;

  1110 	@SysIncPaths=&Mmp_SysIncPaths;

  1111 	$Trg=&Mmp_Trg;

  1112 	%TrgType=%{&Mmp_TrgType};

  1113 	@UidList=&Mmp_UidList;

  1114 	@UserIncPaths=&Mmp_UserIncPaths;

  1115 	$SrcDbg=&Mmp_SrcDbg;

  1116 	%Version=&Mmp_Version;

  1117 	$SecureId=&Mmp_SecureId;

  1118 	$VendorId=&Mmp_VendorId;

  1119 	%ReplaceOptions=&Mmp_Replace;

  1120 	$ARMFPU=&Mmp_ARMFPU;

  1121 	@StringTable=@{&Mmp_StringTable};

  1122 	$CodePagingTargetMode=&Mmp_CodePagingTargetMode;

  1123 	$DataPagingTargetMode=&Mmp_DataPagingTargetMode;

  1124 	$IsWideCharMain=&Mmp_IsWideCharMain;

  1125 	$IsDebuggable=&Mmp_IsDebuggable;

  1126 

  1127 #	finish defining any macros

  1128 

  1129 	if ($Plat{CPU} eq 'MARM') {

  1130 #		apply the ABI source define - note that it is difficult to define a corresponding

  1131 #		.MMP define since we can't be sure what the ABI is until we've processed the .MMP file,

  1132 #		though we could apply it for generic MARM builds only

  1133 		push @{$Plat{Macros}}, "__MARM_${ABI}__";

  1134 	}