--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1/abld/makmake/makmake.pl Fri Jun 25 17:29:25 2010 +0800
@@ -0,0 +1,1901 @@
+# 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:
+# all variables called *Path* are set up to end with a backslash
+# all variables called *Path or *File are stored as absolute (file)paths within makmake
+# all variables called UpPath* are stored as relative paths within makmake
+#
+#
+
+
+use FindBin; # for FindBin::Bin
+use Getopt::Long;
+use Cwd;
+# modified start: makefile improvement
+use File::stat;
+use Time::localtime;
+# modified end: makefile improvement
+
+my $PerlLibPath; # fully qualified pathname of the directory containing our Perl modules
+
+# Prototype to remove warning.
+sub AddStringTables();
+
+BEGIN {
+# check user has a version of perl that will cope
+ require 5.005_03;
+# establish the path to the Perl libraries: currently the same directory as this script
+ $PerlLibPath = $FindBin::Bin; # X:/epoc32/tools
+ $PerlLibPath =~ s/\//\\/g; # X:\epoc32\tools
+ $PerlLibPath .= "\\";
+}
+
+use lib $PerlLibPath;
+use E32env;
+use E32Plat;
+use E32Variant;
+use Genutl;
+use Modload;
+use Pathutl;
+use Trgtype;
+use CheckSource;
+use featurevariantparser;
+use featurevariantmap;
+
+# THE MAIN PROGRAM SECTION
+##########################
+
+{
+ Load_SetModulePath($PerlLibPath);
+ Plat_Init($PerlLibPath);
+}
+
+my $MAKEFILE;
+my $MMPFILE;
+my %Options;
+my %Plat;
+my %TruePlat;
+my %BldMacros;
+my $PlatArg;
+my @PlatOverrideList=();
+my $EABIDef;
+my $DebugSwitch=undef;
+
+my $IsCompilerWrapperOption = 0;
+my $IsProxyWrapperOption = 0;
+my $FeatureVariantArg;
+my %FeatureVariantInfo;
+
+{
+ # process the command line
+ unless (GetOptions(\%Options, 'd', 'mmp', 'plat=s', 'v', 'arm', 'nd' , 'ithumb' , 'iarm' , 'debug', 'no_debug', 'logfc','wrap:s')) {
+ exit 1;
+ }
+ #Update the variable to set the information of -wrap option
+ if(exists($Options{wrap})) {
+ if ($Options{wrap} eq "") {
+ # Set the Compiler wrapper option information i.e. '1'
+ $IsCompilerWrapperOption = 1;
+ } elsif ($Options{wrap} eq "proxy") {
+ $IsProxyWrapperOption = 1;
+ } else {
+ print "WARNING: Invalid value for option -wrap: $Options{wrap}\n";
+ }
+ }
+
+ $Options{makemakefile}='1' unless ($Options{mmp} || $Options{plat});
+
+ if ($Options{mmp} or $Options{plat}) {
+ eval { &Load_ModuleL('MAKHELP'); };
+ die $@ if $@;
+ }
+
+ if ($Options{mmp}) {
+ &Help_Mmp;
+ exit;
+ }
+
+ if ($Options{plat}) {
+ eval { &Plat_GetL($Options{plat},\%Plat,\%BldMacros); };
+ die $@ if $@;
+ eval { &Load_ModuleL($Plat{MakeMod}); };
+ die $@ if $@;
+ &Help_Plat($Plat{Real},$Plat{CPU}, $Plat{DefFile}, \@{$Plat{MmpMacros}},\@{$Plat{Macros}});
+ exit;
+ }
+
+# show help & exit if necessary
+ if (@ARGV != 2) {
+ &Usage();
+ }
+ if ($Options{v}) {
+ print "perl -S makmake.pl @ARGV\n";
+ &Load_SetVerbose;
+ &Path_SetVerbose;
+ &Plat_SetVerbose;
+ }
+
+ $PlatArg=uc pop @ARGV;
+
+ # Process build platform arguments where they differ from the "norm"
+ if ($PlatArg=~/^(\S+)\.(\S+)$/)
+ {
+ # Explicit feature variant platforms take the form <base platform>.<variant name>
+ # e.g. armv5.variant1
+ $PlatArg=$1;
+ $FeatureVariantArg=$2;
+ }
+ elsif ($PlatArg=~/^(\S+):(\S+)$/)
+ {
+ # IDE platforms can take the form cw_ide:<platform-1>+<platform-2>+<platform-n>
+ # e.g. cw_ide:plat1+plat2+plat3
+ #
+ $PlatArg=$1;
+ @PlatOverrideList=split(/\+/,$2);
+ }
+
+ eval { &Plat_GetL($PlatArg,\%TruePlat,\%BldMacros); };
+ die $@ if $@;
+ if (scalar @PlatOverrideList) {
+ $PlatArg=$PlatOverrideList[0];
+ }
+
+
+ $MMPFILE=pop @ARGV;
+ die "ERROR: Can't specify MMP file on a different drive\n" if $MMPFILE=~/^\w:\\/o;
+ if ($MMPFILE!~/.MMP$/io) {
+ $MMPFILE.='.MMP';
+ }
+ $MMPFILE=&Path_AbsToWork($MMPFILE);
+
+ eval { &Load_ModuleL('Mmp'); };
+ die $@ if $@;
+ if ($Options{v}) {
+ &Mmp_SetVerbose;
+ }
+ if ($Options{d}) {
+ die "ERROR: $E32env::Data{EPOCPath} does not exist\n" if (!-d $E32env::Data{EPOCPath});
+ }
+
+ if ($Options{debug}) {
+ $DebugSwitch = 1;
+ }
+ elsif($Options{no_debug}){
+ $DebugSwitch = 0;
+ }
+}
+
+my %LinkerOptions;
+my %WarningLevel;
+my $ABI;
+my @AifStruct;
+my $AllowDllData;
+my $CompressTarget;
+my $CompressTargetMode; #NONE
+my $ASSPExports;
+my @ASSPLibList;
+my @BitMapStruct;
+my $BuildAsARM=$Options{arm};
+my $CallDllEntryPoints;
+my $Capability;
+my @CapabilityFlags;
+my $DataLinkAddress;
+my @DebugLibList;
+my %Def;
+my %DocHash;
+my $ExportUnfrozen;
+my $FirstLib;
+my $FixedProcess;
+my %HeapSize;
+my @LibList;
+my $LinkAs;
+my $LinkAsBase;
+my $ExportLibrary;
+my $NoExportLibrary;
+my %MmpFlag;
+my @PlatTxt2D;
+my $ProcessPriority;
+my @RamTargets;
+my @ResourceStruct;
+my @RomTargets;
+my $SmpSafe;
+my @SourceStruct;
+my $StackSize;
+my @StatLibList;
+my $StdCpp;
+my $NoStdCpp;
+my $NewLib;
+my @SysIncPaths;
+my @ResourceSysIncPaths;
+my $ResourceVariantMacroHRHFile;
+my $Trg;
+my %TrgType;
+my @UidList;
+my @UserIncPaths;
+my $SrcDbg;
+my %Path;
+my %Version;
+my $SecureId;
+my $VendorId;
+my $variantMacroHRHFile = Variant_GetMacroHRHFile(); # HRH file containing macros specific to a variant
+my %ReplaceOptions;
+my $ARMFPU;
+my @StringTable;
+my @StringTableUserIncPaths;
+my $CodePagingTargetMode; # 0-N/A, 1-UNPAGED, 2-PAGED
+my $DataPagingTargetMode; # 0-N/A, 1-UNPAGED, 2-PAGED
+my %CheckSourceUDEBIncludes;
+my %CheckSourceURELIncludes;
+my %CheckSourceMMPMetaData;
+my %CheckSourceMMPIncludes;
+my $IsWideCharMain=0;
+my $IsDebuggable; # 0-NONDEBUGGABLE, 1-DEBUGGABLE, 2-DEBUGGABLE_UDEBONLY
+
+
+use constant NOTPAGED => 0;
+use constant UNPAGED => 1;
+use constant PAGED => 2;
+
+use constant INFLATECOMPRESSIONMETHOD => 1;
+use constant BYTEPAIRCOMPRESSIONMETHOD => 2;
+
+use constant NOTDEBUGGABLE => 0;
+use constant DEBUGGABLE => 1;
+use constant DEBUGGABLE_UDEBONLY => 2;
+
+# If the platform does support feature variants but none are specified, then we assume the use of "DEFAULT" if it exists
+# If default doesn't exist feature variantion is basically disabled?
+$FeatureVariantArg = 'default' if (!$FeatureVariantArg && defined &PMSupportsFeatureVariants && featurevariantparser->DefaultExists());
+
+# Preload the details of the variant requested if any - we need the HRH file for MMP file processing
+if ($FeatureVariantArg)
+ {
+ # First check the feature variant is valid
+ my @buildableFeatureVariants = featurevariantparser->GetBuildableFeatureVariants();
+ die "ERROR: \"$PlatArg.$FeatureVariantArg\" feature variant is either invalid or virtual.\n" if !(grep /^$FeatureVariantArg$/i, @buildableFeatureVariants);
+
+ # Now load the variant
+ %FeatureVariantInfo = featurevariantparser->GetVariant($FeatureVariantArg);
+
+ # Change the HRH file to use
+ $variantMacroHRHFile = $FeatureVariantInfo{VARIANT_HRH} if $FeatureVariantInfo{VARIANT_HRH};
+ }
+
+&SetVarsFromMmp($PlatArg);
+die $@ if $@;
+
+{
+ # set up the makefile filepath - need to do this before loading the platform module
+ # because UID source file will be added and set up in the makefile path under WINS
+ if ($Options{d}) {
+ $MAKEFILE=join ('', $Path{Bld}, &Path_Split('Base',$MMPFILE), $TruePlat{Ext});
+ }
+ else {
+ $MAKEFILE=join "", &Path_WorkPath, &Path_Split('Base',$MMPFILE), $TruePlat{Ext};
+ }
+}
+
+{
+ # Generate an X86GCC def file from eabi def file in build dir if needed
+ if (($PlatArg eq "X86GCC" || $PlatArg eq "X86GMP") && $Def{Base} && not -e &DefFile)
+ {
+ # Find the equivalent eabi def file
+ my $eabiDefFile = File::Spec->canonpath("$Def{Path}../eabi/$Def{Base}$Def{Ext}");
+ if (-e $eabiDefFile)
+ {
+ # Need to create MAKEFILE directory early in this case
+ eval { &Path_MakePathL($MAKEFILE); };
+ die $@ if $@;
+ # Change def file path to build path
+ $Def{Path} = $Path{Bld};
+ &generateX86GCCDefFile($eabiDefFile, &DefFile);
+ }
+ else
+ {
+ print "WARNING: Unable to find EABI def file at $eabiDefFile to generate X86GCC def file with\n";
+ }
+ }
+}
+
+{
+
+
+# load the platform module
+ eval { &Load_ModuleL($TruePlat{MakeMod}); };
+ die $@ if $@;
+
+ unless (defined &PMHelp_Mmp) {
+# check this function is defined - all modules must have it - if not perhaps the
+# platform module has not loaded is compiler module successfully via "use"
+ die "ERROR: Module \"$Plat{MakeMod}\" not loaded successfully\n";
+ }
+}
+
+ # Allow the platform to bow out if feature variants have been specified but it doesn't support them
+ if ($FeatureVariantArg && !defined &PMSupportsFeatureVariants)
+ {
+ die "ERROR: The \"$PlatArg\" platform does not support feature variants.\n";
+ }
+
+{
+ # allow the platform to bow out if it can't support some .MMP file specifications
+ if (defined &PMCheckPlatformL) {
+ eval { &PMCheckPlatformL(); };
+ die $@ if $@;
+ }
+}
+
+my @StdIncPaths=();
+
+{
+ # get the platform module to do it's mmpfile processing - WINS modules may set up an extra source file
+ # for UIDs here depending upon the targettype
+ &PMPlatProcessMmp(@PlatTxt2D) if defined &PMPlatProcessMmp;
+}
+
+%CheckSourceMMPMetaData = &Mmp_CheckSourceMMPMetaData();
+%CheckSourceMMPIncludes = &Mmp_CheckSourceMMPIncludes();
+
+# merge checksource processing from platform specific .mmp sections, if applicable
+%CheckSourceMMPMetaData = (%CheckSourceMMPMetaData, &PMPlatCheckSource()) if defined &PMPlatCheckSource;
+
+@ResourceSysIncPaths = @SysIncPaths;
+$ResourceVariantMacroHRHFile = $variantMacroHRHFile;
+
+AddStringTables();
+
+# Process feature variants if applicable
+
+if ($FeatureVariantArg)
+ {
+ if ($Options{v})
+ {
+ $featurevariantmap::verbose = 1;
+ $featurevariantparser::verbose = 1;
+ }
+
+ # Get the default variant details
+ my %DefaultFeatureVariantInfo = $FeatureVariantInfo{NAME} =~ /^default$/i ? %FeatureVariantInfo : featurevariantparser->GetVariant("DEFAULT");
+ die "ERROR: Feature variant \"$PlatArg.default\" is invalid.\n" if !$DefaultFeatureVariantInfo{VALID};
+
+ # The following IF statement decides whether to use the default variant and not use the hash in the filename
+ # This prevents the generation of dll's/exe's for which variants are not needed (i.e they are invariant)
+ # It also avoids the time-consuming and redundant hash generation
+ # A component is considered invariant if it's not a DLL or EXE or FEATUREVARIANT isn't present in the .mmp file
+
+# modified start: makefile improvement
+ if ($TrgType{Basic} =~ /^(EXEDLL|EXE|DLL|LIB)$/ && &Mmp_IsFeatureVariant)
+# modified end: makefile improvement
+ {
+ # Load the requested variant if it hasn't already been preloaded
+ %FeatureVariantInfo = featurevariantparser->GetVariant($FeatureVariantArg) if !$FeatureVariantInfo{NAME} || $FeatureVariantInfo{NAME} ne $FeatureVariantArg;
+ }
+ else
+ {
+ # Use the default variant
+ %FeatureVariantInfo = %DefaultFeatureVariantInfo;
+ $FeatureVariantInfo{INVARIANT} = 1;
+ $FeatureVariantInfo{NAME} = uc $FeatureVariantArg;
+ }
+
+ die "ERROR: Feature variant \"$PlatArg.$FeatureVariantInfo{NAME}\" is invalid.\n" if !$FeatureVariantInfo{VALID};
+
+ my @featureVariantSysIncPaths = (@{$FeatureVariantInfo{BUILD_INCLUDES}},@SysIncPaths);
+
+ # Further process paths and filenames so that they include a drive letter.
+ # We store this in a hash specifically for passing on to featurevariantmap->Hash
+
+ my @processedIncludes = &Path_PrefixWithDrive(&Path_Chop(@UserIncPaths), &Path_Chop(@featureVariantSysIncPaths));
+ push @processedIncludes, &Path_Chop(&PMToolChainIncDir) if defined &PMToolChainIncDir && &PMToolChainIncDir;
+
+ my $processedPreInclude = "";
+ if (defined &PMPrefixFile)
+ {
+ $processedPreInclude = &PMPrefixFile;
+ $processedPreInclude =~ s/\"//g;
+ $processedPreInclude = &Path_PrefixWithDrive($processedPreInclude);
+ }
+
+ my %processedFeatureVariantInfo;
+ $processedFeatureVariantInfo{PREINCLUDE} = $processedPreInclude if $processedPreInclude;
+ $processedFeatureVariantInfo{BUILD_INCLUDES} = \@processedIncludes if @processedIncludes;
+ $processedFeatureVariantInfo{VALID} = 1;
+
+ # Pass in the details of the macros tested in the MMP
+ $processedFeatureVariantInfo{MMPTESTED} = &Mmp_TestedMacros();
+
+ my @pathedSrcList = ();
+ push @pathedSrcList, Path_PrefixWithDrive($$_{SrcPath}.$$_{CurFile}) foreach (@SourceStruct);
+
+ foreach my $bld (@{$Plat{Blds}})
+ {
+# modified start: makefile improvement
+ my @reusedHash;
+# modified end: makefile improvement
+ if ($FeatureVariantInfo{INVARIANT}) # Invariant override
+ {
+ $FeatureVariantInfo{$bld."_LABEL"} = "INVARIANT";
+ }
+ else
+ {
+# modified by SV start: makefile improvement
+ my $vmap = "$E32env::Data{RelPath}".lc($Plat{Real})."\\".lc($bld)."\\".Trg()."." . $FeatureVariantInfo{NAME}.".vmap";
+# modified by SV end: makefile improvement
+ $vmap = Path_PrefixWithDrive($vmap);
+ if(-e $vmap){
+ my @variantlist = featurevariantmap->GetVariantListFromVmap($vmap);
+ my @calls;
+ foreach(@variantlist)
+ {
+ my $target = "CHECKVMAP".uc($bld);
+ my $makefile = $MAKEFILE.".".$_;
+ if(-e $makefile){
+ push @calls, "make -r -f \"$makefile\" $target";
+ }
+ }
+ foreach my $call (@calls)
+ {
+ print "call: $call" if $Options{v};
+ open PIPE, "$call |";
+ while(<PIPE>) {
+ print $_;
+ }
+ close PIPE;
+ }
+ if(-e $vmap){
+ @reusedHash = featurevariantmap->CheckOldVmapFile($vmap, \%FeatureVariantInfo);
+ }
+ }
+ if(defined(@reusedHash))
+ {
+ $FeatureVariantInfo{$bld."_LABEL"} = $reusedHash[0];
+ $FeatureVariantInfo{$bld."_FEATURES"} = $reusedHash[1];
+ next;
+ }
+# modified end: makefile improvement
+ my @macros = (@{$Plat{Macros}}, @{$BldMacros{$bld}}, "__SUPPORT_CPP_EXCEPTIONS__");
+ push @macros, "__PRODUCT_INCLUDE__=\"".&Path_PrefixWithDrive($FeatureVariantInfo{VARIANT_HRH})."\"" if $FeatureVariantInfo{VARIANT_HRH};
+ $processedFeatureVariantInfo{MACROS} = \@macros;
+
+ print ("Feature variant hash processing: \"$FeatureVariantInfo{NAME} $bld\"\n") if $Options{v};
+
+ my @result = featurevariantmap->HashAndFeatures(\@pathedSrcList, \%processedFeatureVariantInfo);
+ $FeatureVariantInfo{$bld."_LABEL"} = $result[0];
+ $FeatureVariantInfo{$bld."_FEATURES"} = $result[1];
+
+ die "ERROR: Can't obtain hash for \"$PlatArg.$FeatureVariantInfo{NAME}\" feature variant.\n" if !$FeatureVariantInfo{$bld."_LABEL"};
+ }
+ }
+
+ # Customise standard content based on feature variant updates
+ @SysIncPaths = @featureVariantSysIncPaths;
+ $variantMacroHRHFile = $FeatureVariantInfo{VARIANT_HRH};
+ $MAKEFILE .= ".$FeatureVariantInfo{NAME}";
+
+ # Resources are always processed in the context of the default variant's system include and variant files when
+ # feature variants are in use
+ @ResourceSysIncPaths = (@{$DefaultFeatureVariantInfo{BUILD_INCLUDES}},@ResourceSysIncPaths);
+ $ResourceVariantMacroHRHFile = $DefaultFeatureVariantInfo{VARIANT_HRH};
+ }
+
+
+{
+ # if verbose mode set, output some info
+ #--------------------------------------
+ if ($Options{v}) {
+ print
+ "Target: \"$Trg\"\n",
+ "TargetType: \"$TrgType{Name}\"\n",
+ "Libraries: \"@LibList\"\n",
+ "Debug Libraries: \"@DebugLibList\"\n",
+ "Static Libraries: \"@StatLibList\"\n",
+ "Uids: \"@UidList\"\n",
+ "BuildVariants: \"@{$Plat{Blds}}\"\n",
+ "TargetMakeFile: \"$MAKEFILE\"\n",
+ "UserIncludes: \"<Source Dir> @UserIncPaths\"\n",
+ "SystemIncludes: \"@SysIncPaths\"\n"
+ ;
+
+ if (%FeatureVariantInfo)
+ {
+ print
+ "Feature Variant Name: \"$FeatureVariantInfo{NAME}\"\n",
+ "Feature Variant SystemIncludes: \"@{$FeatureVariantInfo{BUILD_INCLUDES}}\"\n",
+ "Feature Variant HRH file: \"$FeatureVariantInfo{VARIANT_HRH}\"\n";
+
+ foreach my $bld (@{$Plat{Blds}})
+ {
+ print "Feature Variant $bld Label: \"".$FeatureVariantInfo{$bld."_LABEL"}."\"\n";
+ }
+
+ }
+ }
+}
+
+# Special handling for non-default invariant makefiles without FEATUREVARIANT in the MMP file
+# In this situation the default variant makefle is just included into the variant makefile
+# modified start: makefile improvement
+if ($TrgType{Basic} =~ /^(EXEDLL|EXE|DLL|LIB)$/ && %FeatureVariantInfo && $FeatureVariantInfo{INVARIANT})
+ {
+ $MAKEFILE =~ s/([^.]*$)/DEFAULT/;
+# modified by SV start: makefile improvement
+ if( $FeatureVariantInfo{NAME} !~ /^default$/i)
+ {
+ print "not creating makefile for : $FeatureVariantInfo{NAME}\n" if ($Options{v});
+ }
+# modified by SV end: makefile improvement
+ if(-e $MAKEFILE )
+ {
+ my $mmp_time = -M $MMPFILE;
+ my $makefile_time = -M $MAKEFILE;
+ if( $makefile_time <= $mmp_time)
+ {
+ exit;
+ }
+ }
+ undef %FeatureVariantInfo;
+ %FeatureVariantInfo = featurevariantparser->GetVariant("default");
+ $FeatureVariantInfo{INVARIANT} = 1;
+ $FeatureVariantInfo{UREL_LABEL} = 'INVARIANT';
+ $FeatureVariantInfo{UDEB_LABEL} = 'INVARIANT';
+ }
+# modified by SV start: makefile improvement
+ elsif(%FeatureVariantInfo)
+ {
+ my $variant_info = &Path_Chop($E32env::Data{BldPath}).$Path{BldInfPath}."\\FeatureVariantInfo\\".$Plat{Real}."\\".$Plat{Real}.".".$FeatureVariantInfo{NAME}.".".&Path_Split('Base', $MMPFILE).".info";
+ #if mmp file does not exists
+ $variant_info = &Path_Chop($E32env::Data{BldPath}).$Path{BldInfPath}."\\FeatureVariantInfo\\".$Plat{Real}."\\".$Plat{Real}.".".$FeatureVariantInfo{NAME}.".info" if ! -e $MMPFILE;
+# modified by SV end: makefile improvement
+ my $variant_key = "VARIANT_PLAT_NAME_".&Path_Split('Base', $MMPFILE);
+ $variant_info_new = $variant_info.".tmp";
+ open VARIANTINFOR_NEW, ">$variant_info_new" or die "ERROR: Can't open or create file \"$variant_info_new\"\n";
+
+ # Open the variant infor file
+ open VARIANTINFOR, "<$variant_info" or die "ERROR: Can't open file \"$variant_info\"\n";
+ while(<VARIANTINFOR>)
+ {
+ if(/^$variant_key/)
+ {
+ print VARIANTINFOR_NEW $variant_key.":=".$FeatureVariantInfo{NAME}."\n";
+ }
+ else
+ {
+ print VARIANTINFOR_NEW $_;
+ }
+ }
+ # Close and cleanup
+ close VARIANTINFOR or die "ERROR: Can't close file \"$variant_info\"\n";
+ close VARIANTINFOR_NEW or die "ERROR: Can't close file \"$variant_info\"\n";
+ unlink $variant_info;
+ rename($variant_info_new, $variant_info);
+ if ($Options{v}) {
+ print "Successful Variant Infor File Creation\n";
+
+ }
+ }
+# modified end: makefile improvement
+
+my $CurAifRef;
+my $CurBaseObj;
+my $CurBld;
+my $CurBitMapRef;
+my @CurDepList;
+my $CurDoc;
+my $CurResrc;
+my $CurResourceRef;
+my $CurSrc;
+my $CurSrcPath;
+my $ResrcIsSys;
+# modified start: makefile improvement
+my %CurSrcSet;
+# modified end: makefile improvement
+
+# Set up library paths getting the backend module to help if it wants to
+{
+ &InitLinkPaths();
+}
+
+{
+
+ # LOOPING SECTION
+ #----------------
+ # Load the output module
+ eval { &Load_ModuleL('OUTPUT'); };
+ die $@ if $@;
+
+
+ # Believe include first on the system list.
+ my $VariantFile=&main::VariantFile();
+ if($VariantFile){
+ my $VariantFilePath = Path_Split('Path',$VariantFile);
+ chop($VariantFilePath);
+
+ push(@SysIncPaths, $VariantFilePath);
+ }
+
+ my $ResourceVariantFile=&main::ResourceVariantFile();
+ if($ResourceVariantFile){
+ my $ResourceVariantFilePath = Path_Split('Path',$ResourceVariantFile);
+ chop($ResourceVariantFilePath);
+
+ push(@ResourceSysIncPaths, $ResourceVariantFilePath);
+ }
+
+ ## Add default system include info for TOOLS2
+ if ($PlatArg eq 'TOOLS2') {
+ push @SysIncPaths , "$E32env::Data{EPOCPath}include\\tools\\stlport";
+ }
+
+ # If the stdcpp keyword is used, or if the target type is STD* ...
+ if ($StdCpp or $TrgType{Name} eq 'STDEXE' or $TrgType{Name} eq 'STDDLL' or $TrgType{Name} eq 'STDLIB') {
+ push @SysIncPaths, $E32env::Data{EPOCPath}."include\\stdapis";
+ }
+
+ &PMStartBldList($Plat{MakeCmd}) if defined &PMStartBldList;
+ my $LoopBld;
+ foreach $LoopBld (@{$Plat{Blds}}) {
+ $CurBld=$LoopBld;
+ &PMBld if defined &PMBld;
+ }
+ undef $CurBld;
+ undef $LoopBld;
+ &PMEndBldList if defined &PMEndBldList;
+
+
+ # Load the Dependency Generator
+ eval { &Load_ModuleL('MAKDEPS'); };
+ die $@ if $@;
+ eval { &Deps_InitL($E32env::Data{EPOCIncPath},@StdIncPaths); };
+ die $@ if $@;
+ if ($Options{v}) {
+ &Deps_SetVerbose;
+ }
+ if ($Plat{UsrHdrsOnly}) {
+ &Deps_SetUserHdrsOnly;
+ }
+
+ if ($Options{nd} || ($ENV{SYMBIANBUILD_DEPENDENCYOFF} && ($ENV{SYMBIANBUILD_DEPENDENCYOFF}==1))) {
+ &Deps_SetNoDependencies
+ }
+ &Deps_SetNoDependencies if(grep /boostlibrary/i, &Mmp_UserIncPaths);
+
+ &Deps_SetUserIncPaths(@UserIncPaths);
+ &Deps_SetSysIncPaths(@ResourceSysIncPaths);
+ &Deps_SetPlatMacros(@{$Plat{Macros}});
+
+ my $prefixFile;
+ $prefixFile = &PMPrefixFile if defined &PMPrefixFile;
+ &Deps_SetPrefixFile($prefixFile) if $prefixFile;
+
+# Start source list - bitmaps, resources, .AIF files, documents, sources.
+
+ # If feature variants are in use, dependency analysis may use a different overall variant file to that for "straight" source
+ my $curDepOSVariantFile = &Deps_GetOSVariantFile();
+ &Deps_SetOSVariantFile($ResourceVariantFile);
+
+ &PMStartSrcList if defined &PMStartSrcList;
+
+# start bitmaps
+
+ if ($Options{v}) {
+ print "Starting bitmaps\n";
+ }
+ my $LoopBitMapRef;
+ foreach $LoopBitMapRef (@BitMapStruct) {
+ $CurBitMapRef=$LoopBitMapRef;
+ if ($Options{v}) {
+ print "BitMap: \"$$CurBitMapRef{Trg}\"\n";
+ }
+ &PMBitMapBld if defined &PMBitMapBld;
+ }
+ undef $CurBitMapRef;
+ undef $LoopBitMapRef;
+
+# end bitmaps
+
+# start resources
+
+ if ($Options{v}) {
+ print "Starting resources\n";
+ }
+ my $LoopResourceRef;
+ foreach $LoopResourceRef (@ResourceStruct) {
+ $CurResourceRef=$LoopResourceRef;
+ if ($Options{v}) {
+ print "Resource: \"$$CurResourceRef{Trg}\"\n";
+ }
+ eval { @CurDepList=&Deps_GenDependsL($$CurResourceRef{Source}, ("LANGUAGE_$$CurResourceRef{Lang}")); };
+ die $@ if $@;
+ &PMResrcBld if defined &PMResrcBld;
+ undef @CurDepList;
+ }
+ undef $CurResourceRef;
+ undef $LoopResourceRef;
+
+# end resources
+
+# start aifs
+
+ if ($Options{v}) {
+ print "Starting aifs\n";
+ }
+
+# Add tools-relative include path to sys includes, to allow for shared include\aiftool.rh
+ use FindBin;
+ $FindBin::Bin =~ /:(.*)\//;
+ my $extraIncPath = $1;
+ $extraIncPath =~ s/\//\\/g;
+ my @SavedResourceSysIncPaths = @ResourceSysIncPaths;
+ push @ResourceSysIncPaths, "$extraIncPath\\INCLUDE";
+ &Deps_SetSysIncPaths(@ResourceSysIncPaths);
+
+ my $LoopAifRef;
+ foreach $LoopAifRef (@AifStruct) {
+ $CurAifRef=$LoopAifRef;
+ if ($Options{v}) {
+ print "Aif: \"$$CurAifRef{Trg}\"\n";
+ }
+ eval { @CurDepList=&Deps_GenDependsL("$$CurAifRef{Source}"); };
+ die $@ if $@;
+ &PMAifBld if defined &PMAifBld;
+ undef @CurDepList;
+ }
+ undef $CurAifRef;
+ undef $LoopAifRef;
+
+ @ResourceSysIncPaths = @SavedResourceSysIncPaths;
+
+# end aifs
+
+# start sources
+
+ if ($Options{v}) {
+ print "Starting sources\n";
+ }
+
+ my $SrcRef;
+ &Deps_SetOSVariantFile($curDepOSVariantFile);
+ &Deps_SetSysIncPaths(@SysIncPaths);
+
+ foreach $SrcRef (@SourceStruct){
+ $CurSrcPath=$$SrcRef{SrcPath};
+ $CurSrc=$$SrcRef{CurFile};
+
+ my @userIncludes = &Mmp_UserIncPaths;
+ @userIncludes = (@userIncludes, @StringTableUserIncPaths) if (@StringTableUserIncPaths);
+ unshift (@userIncludes, $CurSrcPath);
+
+ if ($TruePlat{Ext} !~ /\.DSP|\.xml/i)
+ {
+ foreach my $buildVariant (@{$Plat{Blds}})
+ {
+ my @macros = &MacroList;
+ @macros = (@macros, @{$BldMacros{$buildVariant}});
+
+ my $checkSourceCommandStore;
+
+ if ($buildVariant =~ /rel$/i)
+ {
+ $checkSourceCommandStore = \%CheckSourceURELIncludes
+ }
+ else
+ {
+ $checkSourceCommandStore = \%CheckSourceUDEBIncludes
+ }
+ CheckSource_Includes($CurSrcPath.$CurSrc, %$checkSourceCommandStore, $VariantFile, @macros, @userIncludes, @SysIncPaths);
+ }
+ }
+ if ($Options{v}) {
+ print "Sourcepath: \"$CurSrcPath\"\n";
+ }
+ &PMStartSrc if defined &PMStartSrc;
+
+# strict depend alt 1 start - call different module function if strict depend flag specified
+ if (((not $MmpFlag{StrictDepend}) || (not defined &PMSrcBldDepend)) && defined &PMSrcDepend) {
+ eval { @CurDepList=&Deps_GenDependsL($CurSrcPath.$CurSrc);};
+ die $@ if $@;
+# modified start: makefile improvement
+ foreach $srcFile (@CurDepList) {
+ if(not exists($CurSrcSet{$srcFile})){
+ my $srctmp = $srcFile;
+ $CurSrcSet{$srctmp} = 1;
+ }
+ }
+# modified end: makefile improvement
+ &PMSrcDepend if defined &PMSrcDepend;
+ undef @CurDepList;
+ }
+
+# strict depend alt 1 end
+
+ my $LoopBld;
+ foreach $LoopBld (@{$Plat{Blds}}) {
+ $CurBld=$LoopBld;
+ &PMStartSrcBld if defined &PMStartSrcBld;
+
+# strict depend alt 2 start - call the module function that deals with dependencies generated for each build variant
+ if ($MmpFlag{StrictDepend} && defined &PMSrcBldDepend) {
+ eval { @CurDepList=Deps_GenDependsL($CurSrcPath.$CurSrc,@{$BldMacros{$CurBld}}); };
+ die $@ if $@;
+ &PMSrcBldDepend if defined &PMSrcBldDepend;
+ undef @CurDepList;
+ }
+# strict depend alt 2 end
+
+ &PMEndSrcBld if defined &PMEndSrcBld;
+ }
+ undef $CurBld;
+ undef $LoopBld;
+ &PMEndSrc if defined &PMEndSrc;
+# modified start: makefile improvement
+ my $cursrcfile = $CurSrcPath.$CurSrc;
+ if(not exists($CurSrcSet{$cursrcfile})){
+ $CurSrcSet{$cursrcfile} = 1;
+ }
+# modified end: makefile improvement
+ }
+ undef $CurSrc;
+ undef $CurSrcPath;
+
+
+
+# end sources
+
+# start documents
+
+ if ($Options{v}) {
+ print "Starting documents\n";
+ }
+ my $LoopSrcPath;
+ foreach $LoopSrcPath (sort keys %DocHash) {
+ $CurSrcPath=$LoopSrcPath;
+ if ($Options{v}) {
+ print "Sourcepath: \"$CurSrcPath\"\n";
+ }
+ my $LoopDoc;
+ foreach $LoopDoc (sort @{$DocHash{$CurSrcPath}}) {
+ $CurDoc=$LoopDoc;
+ if ($Options{v}) {
+ print "Document: \"$CurDoc\"\n";
+ }
+ &PMDoc if defined &PMDoc;
+ }
+ undef $CurDoc;
+ undef $LoopDoc;
+ }
+ undef $CurSrcPath;
+ undef $LoopSrcPath;
+
+# end documents
+
+# rombuild
+
+ my %SpecialRomFileTypes=(
+ KEXT=>'extension[MAGIC]',
+ LDD=>'device[MAGIC]',
+ PDD=>'device[MAGIC]',
+ VAR=>'variant[MAGIC]'
+ );
+ my %KHash1 = (
+ kext=>1,
+ ldd=>1,
+ pdd=>1,
+ var=>1,
+ kdll=>1
+ );
+ my %KHash2 = (
+ primary=>1,
+ variant=>1,
+ extension=>1,
+ device=>1
+ );
+ unless ($TrgType{Basic} =~ /^IMPLIB$/io or $TruePlat{Ext} =~ /\.DSP|\.xml/i) { # change to avoid rombuild target for IDE makefiles
+ &Output("ROMFILE:\n");
+ unless ($Plat{OS} ne 'EPOC32' or $TrgType{Basic} eq 'LIB') {
+ my $ref;
+ foreach $ref (@RomTargets) {
+ my $ABIDir = '##MAIN##';
+ my $RomFileType='file';
+ if ($$ref{FileType}) { # handle EKERN.EXE and EFILE.EXE with new ROMFILETYPE keyword instead
+ $RomFileType=$$ref{FileType}; # or just do this bit as a custom build makefile
+ }
+ elsif ($CallDllEntryPoints) {
+ $RomFileType='dll';
+ }
+ elsif ($SpecialRomFileTypes{$TrgType{Name}}) {
+ $RomFileType=$SpecialRomFileTypes{$TrgType{Name}};
+ }
+ my $RomPath="sys\\bin\\";
+ if ($$ref{Path}) {
+ $RomPath=$$ref{Path};
+ }
+ elsif ($TrgType{Path}) {
+ $RomPath=$TrgType{Path};
+ $RomPath=~s-z\\(.*)-$1-o;
+ }
+ my $RomFile=$LinkAsBase;
+ if ($$ref{File}) {
+ $RomFile=$$ref{File};
+ }
+ my $RomDecorations='';
+ if ($DataLinkAddress) {
+ $RomDecorations="reloc=$DataLinkAddress";
+ }
+ elsif ($FixedProcess) {
+ $RomDecorations.='fixed';
+ }
+
+ $ABIDir = '##KMAIN##' if ($KHash1{lc $TrgType{Name}});
+ $ABIDir = '##KMAIN##' if ($KHash2{lc $RomFileType});
+ my $IbyTextFrom="$RomFileType=$E32env::Data{RelPath}$ABIDir\\##BUILD##\\$Trg";
+ my $IbyTextTo="$RomPath$RomFile";
+ my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1;
+ &Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, "$IbyTextTo $RomDecorations\n");
+ }
+ foreach $ref (@RamTargets) {
+ my $ABIDir = '##MAIN##';
+ $ABIDir = '##KMAIN##' if ($KHash1{lc $TrgType{Name}});
+ my $RomFileType='data';
+ my $RomPath="sys\\bin\\";
+ if ($$ref{Path}) {
+ $RomPath=$$ref{Path};
+ }
+ my $RomFile=$Trg;
+ if ($$ref{File}) {
+ $RomFile=$$ref{File};
+ }
+ my $RomDecorations='attrib=r';
+
+ my $IbyTextFrom="$RomFileType=$E32env::Data{RelPath}$ABIDir\\##BUILD##\\$Trg";
+ my $IbyTextTo="$RomPath$RomFile";
+ my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1;
+ &Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, "$IbyTextTo $RomDecorations\n");
+ }
+ }
+ }
+# end rombuild
+
+ &PMEndSrcList if defined &PMEndSrcList;
+}
+
+{
+
+ # open the makefile and write all the text it requires to it if makmake has so far been successful
+ #-------------------------------------------------------------------------------------------------
+ eval { &Path_MakePathL($MAKEFILE); };
+ die $@ if $@;
+ if ($Options{v}) {
+ print "Creating: \"$MAKEFILE\"\n";
+ }
+ open MAKEFILE,">$MAKEFILE" or die "ERROR: Can't open or create file \"$MAKEFILE\"\n";
+ print MAKEFILE &OutText or die "ERROR: Can't write output to file \"$MAKEFILE\"\n";
+ close MAKEFILE or die "ERROR: Can't close file \"$MAKEFILE\"\n";
+ if ($Options{v}) {
+ print "Successful MakeFile Creation\n";
+ }
+}
+
+
+################ END OF MAIN PROGRAM SECTION #################
+#------------------------------------------------------------#
+##############################################################
+
+
+
+
+
+# SUBROUTINE SECTION
+####################
+
+sub FatalError (@) {
+
+ print STDERR "MAKMAKE ERROR: @_\n";
+ exit 1;
+}
+
+sub Usage () {
+
+ eval { &Load_ModuleL('MAKHELP'); };
+ die $@ if $@;
+ eval { &Help_Invocation; };
+ die $@ if $@;
+ exit;
+}
+
+sub getEABIDef() {
+ # Preprocess the mmp with ARMv5 platform settings so we can pick up
+ # EABI specific def file entries etc.
+ my ($platname)="ARMV5";
+
+ # get platform info for armv5
+ eval { &Plat_GetL($platname,\%Plat,\%BldMacros); };
+ return $@ if $@;
+ &Mmp_Reset;
+ # process
+
+ # set package to ignore warnings about missing .def file.
+ &Mmp_SetIgnoreMissingDef;
+
+ eval { &Mmp_ProcessL($E32env::Data{EPOCPath}, $MMPFILE, \%Plat, $FeatureVariantInfo{BUILD_INCLUDES}); };
+ return $@ if $@;
+ my %EABIDef=%{&Mmp_Def};
+
+ # handle case that def file doesn't exist -> Simply set to ""
+ my $EABIDefFile = "$EABIDef{Path}$EABIDef{Base}$EABIDef{Ext}";;
+ unless (-e "$EABIDefFile") {
+ $EABIDefFile = "";
+ }
+
+ return $EABIDefFile;
+
+}
+
+sub SetVarsFromMmp ($) {
+
+ my ($platname)=@_;
+
+ if($platname eq "GCCXML") {
+ $EABIDef = getEABIDef();
+ }
+ else {
+ $EABIDef = "";
+ }
+
+ # MMP FILE PROCESSING - filter the mmp file content through the GCC preprecessor
+ #-------------------------------------------------------------------------------
+ eval { &Plat_GetL($platname,\%Plat,\%BldMacros); };
+ return $@ if $@;
+ &Mmp_Reset;
+
+ if($platname eq "GCCXML" || $platname eq "X86GCC" || $platname eq "X86GMP") {
+ # set package to ignore warnings about missing .def file, this is necessary,
+ # as either EABI .def or GCC .def may not exist, and this shouldn't be reported
+ # as a warning or error. Similarly for x86gcc def files - these are autogenerated.
+ &Mmp_SetIgnoreMissingDef;
+ }
+
+ eval { &Mmp_ProcessL($E32env::Data{EPOCPath}, $MMPFILE, \%Plat, $FeatureVariantInfo{BUILD_INCLUDES}); };
+ return $@ if $@;
+
+ %WarningLevel=&Mmp_WarningLevel;
+ %LinkerOptions=&Mmp_LinkerOptions;
+ $ABI=&Mmp_ABI;
+ @AifStruct=@{&Mmp_AifStruct};
+ $AllowDllData=&Mmp_AllowDllData;
+ $CompressTarget=&Mmp_CompressTarget;
+ $CompressTargetMode=&Mmp_CompressTargetMode;
+ $ASSPExports=&Mmp_ASSPExports;
+ @ASSPLibList=&Mmp_ASSPLibList;
+ @BitMapStruct=@{&Mmp_BitMapStruct};
+ $BuildAsARM=$BuildAsARM || &Mmp_BuildAsARM;
+ $CallDllEntryPoints=&Mmp_CallDllEntryPoints;
+ $Capability=&Mmp_Capability;
+ @CapabilityFlags=&Mmp_CapabilityFlags;
+ $DataLinkAddress=&Mmp_DataLinkAddress;
+ @DebugLibList=@{&Mmp_DebugLibList};
+ %Def=%{&Mmp_Def};
+ %DocHash=%{&Mmp_DocHash};
+ $ExportUnfrozen=&Mmp_ExportUnfrozen;
+ $FirstLib=&Mmp_FirstLib;
+ $FixedProcess=&Mmp_FixedProcess;
+ %HeapSize=%{&Mmp_HeapSize};
+ @LibList=@{&Mmp_LibList};
+ $LinkAs=&Mmp_LinkAs;
+ $LinkAsBase=&Mmp_LinkAsBase;
+ $ExportLibrary=&Mmp_ExportLibrary;
+ $NewLib = &Mmp_NewLib;
+ $NoExportLibrary=&Mmp_NoExportLibrary;
+ %MmpFlag=%{&Mmp_MmpFlag};
+ @PlatTxt2D=&Mmp_PlatTxt2D;
+ $ProcessPriority=&Mmp_ProcessPriority;
+ @RamTargets=&Mmp_RamTargets;
+ @ResourceStruct=@{&Mmp_ResourceStruct};
+ @RomTargets=&Mmp_RomTargets;
+ $SmpSafe=&Mmp_SmpSafe;
+ @SourceStruct=@{&Mmp_SourceStruct};
+ $StackSize=&Mmp_StackSize;
+ @StatLibList=&Mmp_StatLibList;
+ $StdCpp = &Mmp_StdCpp;
+ $NoStdCpp = &Mmp_NoStdCpp;
+ @SysIncPaths=&Mmp_SysIncPaths;
+ $Trg=&Mmp_Trg;
+ %TrgType=%{&Mmp_TrgType};
+ @UidList=&Mmp_UidList;
+ @UserIncPaths=&Mmp_UserIncPaths;
+ $SrcDbg=&Mmp_SrcDbg;
+ %Version=&Mmp_Version;
+ $SecureId=&Mmp_SecureId;
+ $VendorId=&Mmp_VendorId;
+ %ReplaceOptions=&Mmp_Replace;
+ $ARMFPU=&Mmp_ARMFPU;
+ @StringTable=@{&Mmp_StringTable};
+ $CodePagingTargetMode=&Mmp_CodePagingTargetMode;
+ $DataPagingTargetMode=&Mmp_DataPagingTargetMode;
+ $IsWideCharMain=&Mmp_IsWideCharMain;
+ $IsDebuggable=&Mmp_IsDebuggable;
+
+# finish defining any macros
+
+ if ($Plat{CPU} eq 'MARM') {
+# apply the ABI source define - note that it is difficult to define a corresponding
+# .MMP define since we can't be sure what the ABI is until we've processed the .MMP file,
+# though we could apply it for generic MARM builds only
+ push @{$Plat{Macros}}, "__MARM_${ABI}__";
+ }
+
+ if ($TrgType{Basic}=~/^(DLL|EXE)$/o) { # this macro may soon be removed
+ push @{$Plat{Macros}},'__'.$TrgType{Basic}.'__';
+ }
+
+# add the macros defined in the .mmp file
+ push @{$Plat{Macros}}, &Mmp_Macros;
+
+# set up a hash containing the start paths for various things
+ undef %Path;
+
+# set up ASSP link path - this is the path where the target looks for ASSP-specific import libraries
+ $Path{ASSPLink}="$E32env::Data{LinkPath}$Plat{ASSP}\\";
+
+# set up build path
+ my $BldInfPath=cwd;
+ $BldInfPath=~s-/-\\-go; # separator from Perl 5.005_02+ is forward slash
+ $BldInfPath=~s/^(.:)//o; # remove drive letter
+ $BldInfPath=~s-^(.*[^\\])$-$1\\-o; # ensure workpath ends with a backslash
+ $Path{BldInfPath} = $BldInfPath; # Remember the path to bldinf
+ $Path{Bld}=join('', &Path_Chop($E32env::Data{BldPath}), $BldInfPath, &Path_Split('Base',$MMPFILE), "\\$Plat{Real}\\");
+}
+
+sub generateX86GCCDefFile()
+{
+ my ($oldPath, $newPath) = @_;
+ print "Generating X86GCC deffile from $oldPath\n";
+ if (!open(OLDDEF, $oldPath))
+ {
+ print "Warning: Failed to open $oldPath for reading\n".
+ return;
+ }
+ # Force creation of new def file even if one already exists
+ if (!open(NEWDEF, ">$newPath"))
+ {
+ close OLDDEF;
+ print "Warning: Failed to open $newPath for writing\n".
+ return;
+ }
+ while (<OLDDEF>)
+ {
+ chomp;
+ if (/^\s*_ZT(I|V)/ && !/\sABSENT/i)
+ {
+ # Typeinfo that isn't already absent. Add the ABSENT keyword.
+ my @frags = split /;/, $_, 2; # 1 or 2 parts depending on the presence of a comment
+ $frags[0] =~ s/\s*$/ ABSENT /;
+ $_ = join ';', @frags;
+ }
+ else
+ {
+ # Try to substitute any va_list params with char* (Pc). Ignore if no match
+ s/St9__va_list/Pc/g;
+ }
+ print NEWDEF "$_\n";
+ }
+ close OLDDEF;
+ close NEWDEF;
+ print "Successfully generated $newPath\n";
+}
+
+sub InitLinkPaths() {
+# set up lib path - this is the path where the target puts it's import library
+
+ my $ABI=&Mmp_ABI;
+
+# let the build target determine where it puts its import libray and where its links against its imports
+ my $UnderlyingABI=$ABI;
+ $UnderlyingABI=&PMUnderlyingABI($ABI) if defined &PMUnderlyingABI;
+
+ $Path{Lib}="$E32env::Data{LinkPath}";
+ unless ($ASSPExports) {
+ $Path{Lib}.= lc($UnderlyingABI)."\\";
+ }
+ else {
+ $Path{Lib}.= lc($Plat{ASSP})."\\";
+ }
+
+
+# set up link path - this is the place where the target looks for ordinary libraries
+ $Path{Link}="$E32env::Data{LinkPath}"."$UnderlyingABI\\";
+
+# set up stat link path - this is where the target looks for static libraries
+ $Path{StatLink}="$E32env::Data{LinkPath}";
+ if ($Plat{StatLink}) {
+ $Path{StatLink}.=lc($Plat{StatLink})."\\";
+ } else {
+ unless ($Plat{OS} eq 'WINS') { # WINC and WINS versions of EEXE are different
+ $Path{StatLink}.=lc($ABI)."\\"; # ARM static libraries are currently always ASSP-independent
+ }
+ else {
+ $Path{StatLink}.=lc($Plat{ASSP})."\\"; # WINC static libraries are currently always ASSP-specific
+ }
+ }
+
+# set up release path
+ $Path{Rel}="$E32env::Data{RelPath}".lc($Plat{Real})."\\";
+
+}
+
+sub CreateExtraFile ($$) { # takes abs path for source and text
+# allows modules to create extrafiles
+ my ($FILE,$Text)=@_;
+ if ($Options{makemakefile}) { # only create if making the makefile
+ if ($Options{v}) {
+ print "Creating \"$FILE\"\n";
+ }
+ eval { &Path_MakePathL($FILE); };
+ die $@ if $@;
+ open FILE, ">$FILE" or die "WARNING: Can't open or create \"$FILE\"\n";
+ print FILE $Text or die "WARNING: Can't write text to \"$FILE\"\n";
+ close FILE or die "WARNING: Can't close \"$FILE\"\n";
+ }
+}
+
+sub ABI () {
+ $ABI;
+}
+sub AddSrc ($$) { # needs abs path for source
+# allows modules to add a source file to the project and have it created if necessary
+ my ($SRCFILE,$Text)=@_;
+ my $SrcPath=&Path_Split('Path',$SRCFILE);
+ my $CurFile=&Path_Split('File',$SRCFILE);
+ my $BaseName=&Path_Split('Base',$SRCFILE);
+
+ if ((not -e $SRCFILE) || (-M $SRCFILE > -M $MMPFILE)) {
+ # only create the file if it's older than the .MMP file
+ CreateExtraFile($SRCFILE,$Text);
+ }
+ my %CurSource;
+ $CurSource{SrcPath}=$SrcPath;
+ $CurSource{CurFile}=$CurFile;
+ $CurSource{BaseTrg}=$BaseName;
+ push @SourceStruct, \%CurSource;
+}
+sub AddPlatMacros (@) {
+# allows modules to add extra macros to the platform macro list
+ push @{$Plat{Macros}},@_;
+}
+sub AifRef () {
+ $CurAifRef;
+}
+sub AifStructRef () {
+ \@AifStruct;
+}
+sub AllowDllData () {
+ $AllowDllData;
+}
+sub CompressTarget () {
+ $CompressTarget;
+}
+sub CompressTargetMode () {
+ $CompressTargetMode;
+}
+sub BuildAsARM () {
+ return 0 if $Options{ithumb};
+ return 1 if $Options{iarm};
+ $BuildAsARM;
+}
+sub ASSPLibList () {
+ @ASSPLibList;
+}
+sub ASSPLinkPath () {
+# this is the path where the target looks for ASSP-specific import libraries
+ my $Path=$Path{ASSPLink};
+ if ($CurBld) {
+ if ($Plat{OS} eq 'EPOC32') {
+ $Path.="UREL\\";
+ }
+ else {
+ $Path.="UDEB\\";
+ }
+ }
+ $Path;
+}
+sub BaseMak () {
+ &Path_Split('Base',$MAKEFILE);
+}
+sub BaseResrc () {
+ &Path_Split('Base',$CurResrc);
+}
+sub BaseResrcList () {
+ my @ResrcList=&ResrcList;
+ my $Path;
+ foreach $Path (@ResrcList) {
+ $Path=&Path_Split('Base',$Path);
+ }
+ @ResrcList;
+}
+sub BaseSrc () {
+ &Path_Split('Base',$CurSrc);
+}
+sub ExtSrc () {
+ &Path_Split('Ext',$CurSrc);
+}
+sub BaseSrcList () {
+ my @SrcList=&SrcList;
+ my $Path;
+ foreach $Path (@SrcList) {
+ $Path=&Path_Split('Base',$Path);
+ }
+ @SrcList;
+}
+sub BaseSysResrcList () {
+ my @SysResrcList=&SysResrcList;
+ my $Path;
+ foreach $Path (@SysResrcList) {
+ $Path=&Path_Split('Base',$Path);
+ }
+ @SysResrcList;
+}
+sub BaseTrg () {
+ &Path_Split('Base',$Trg);
+}
+sub BitMapRef () {
+ $CurBitMapRef;
+}
+sub BitMapStructRef () {
+ \@BitMapStruct;
+}
+sub Bld () {
+ $CurBld;
+}
+sub BldList () {
+ @{$Plat{Blds}};
+}
+sub BldPath () {
+ my $Path=$Path{"Bld"};
+ if ($CurBld) {
+ $Path.=$FeatureVariantInfo{$CurBld."_LABEL"}."\\" if (%FeatureVariantInfo && !$FeatureVariantInfo{INVARIANT} && $FeatureVariantInfo{$CurBld."_LABEL"});
+ $Path.="$CurBld\\";
+ }
+ $Path;
+}
+sub CallDllEntryPoints () {
+ $CallDllEntryPoints;
+}
+sub Capability () {
+ $Capability;
+}
+sub CapabilityFlags () {
+ @CapabilityFlags;
+}
+sub DataLinkAddress () {
+ $DataLinkAddress;
+}
+sub DataPath () {
+ $E32env::Data{DataPath};
+}
+sub DebugLibList () {
+ @DebugLibList;
+}
+sub DefFile () {
+ "$Def{Path}$Def{Base}$Def{Ext}";
+}
+sub DefFileType () {
+ $Plat{DefFile};
+}
+sub DepList () {
+ sort @CurDepList;
+}
+sub Doc () {
+ $CurDoc;
+}
+sub DocList () {
+ if ($CurSrcPath) {
+ return sort @{$DocHash{$CurSrcPath}};
+ }
+ my @DocList;
+ my $Key;
+ foreach $Key (keys %DocHash) {
+ push @DocList,@{$DocHash{$Key}};
+ }
+ sort @DocList;
+}
+sub EPOCPath () {
+ $E32env::Data{EPOCPath};
+}
+sub EPOCDataPath () {
+ $E32env::Data{EPOCDataPath};
+}
+sub EPOCIncPath () {
+ $E32env::Data{EPOCIncPath};
+}
+sub EPOCRelPath () {
+ $E32env::Data{RelPath};
+}
+sub EPOCSecurePlatform () {
+ $E32env::Data{SecurePlatform};
+}
+sub EPOCToolsPath () {
+ $E32env::Data{EPOCToolsPath};
+}
+sub Exports () {
+ @{$TrgType{Exports}{$Plat{"DefFile"}}};
+}
+sub ExportUnfrozen () {
+ $ExportUnfrozen;
+}
+sub FirstLib () {
+ $FirstLib;
+}
+sub FixedProcess () {
+ $FixedProcess;
+}
+sub BasicTrgType () {
+ $TrgType{Basic};
+}
+sub HeapSize () {
+ %HeapSize;
+}
+sub LibList () {
+ @LibList;
+}
+sub LibPath () {
+# this is the path where the target puts it's import library
+ my $Path=$Path{Lib};
+ if ($CurBld) {
+ if (($Plat{DefFile} eq 'EABI') || ($Plat{DefFile} eq 'x86gcc') || ($Plat{OS} eq 'TOOLS2')) {
+ $Path.="lib\\";
+ }
+ elsif ($Plat{OS} eq 'EPOC32') {
+ $Path.="urel\\";
+ }
+ else {
+ $Path.="udeb\\";
+ }
+ }
+ $Path;
+}
+sub LinkAs () {
+ $LinkAs;
+}
+sub LinkAsBase () {
+ $LinkAsBase;
+}
+sub ExportLibrary () {
+ $ExportLibrary;
+}
+sub NoExportLibrary () {
+ $NoExportLibrary;
+}
+sub LinkPath () {
+# this is the place where the target looks for CPU-specific libraries
+ my $Path=$Path{Link};
+ if ($CurBld) {
+ if ($Plat{DefFile} eq 'EABI' || $Plat{DefFile} eq 'x86gcc') {
+ $Path.="LIB\\";
+ }
+ elsif ($Plat{OS} eq 'EPOC32') {
+ $Path.="UREL\\";
+ }
+ else {
+ $Path.="UDEB\\";
+ }
+ }
+ $Path;
+}
+
+sub MacroList ($) {
+ if ($_[0]) {
+ return @{$BldMacros{$_[0]}};
+ }
+ return @{$Plat{Macros}} unless $CurBld;
+ (@{$Plat{Macros}},@{$BldMacros{$CurBld}});
+}
+
+# returns the file containing Variant specific Macros
+sub VariantFile($)
+{
+ return $variantMacroHRHFile;
+}
+# returns the file containing Variant specific Macros, which may differ from the above if feature variants are used
+sub ResourceVariantFile($)
+{
+ return $ResourceVariantMacroHRHFile;
+}
+sub MakeFilePath () {
+ &Path_Split('Path',$MAKEFILE);
+}
+sub MmpFile () {
+ $MMPFILE;
+}
+sub PerlLibPath () {
+ $PerlLibPath;
+}
+sub Plat () {
+ $Plat{Real};
+}
+sub PlatABI () {
+ $Plat{"ABI"};
+}
+sub PlatCompiler () {
+ $Plat{"Compiler"};
+}
+sub PlatName () {
+ $Plat{Name};
+}
+sub PlatOS () {
+ $Plat{OS};
+}
+sub PlatOverrideList () {
+ @PlatOverrideList;
+}
+sub ProcessPriority () {
+ $ProcessPriority;
+}
+sub RelPath () {
+ my $Path=$Path{Rel};
+ if ($CurBld) {
+ $Path .= lc($CurBld)."\\";
+ }
+ $Path;
+}
+sub ResourceRef () {
+ $CurResourceRef;
+}
+sub ResourceStructRef () {
+ \@ResourceStruct;
+}
+sub SetCurBld($) {
+ $CurBld=$_[0]; # used by ide_cw.pm when handling additional platforms
+}
+sub SetStdIncPaths (@) {
+# allows module to set standard include paths
+ @StdIncPaths=();
+ my $Path;
+ foreach $Path (@_) {
+ $Path=~s-^(.*[^\\])$-$1\\-o if defined($Path);
+ push @StdIncPaths, $Path; # only place drive letters may appear, up to modules to handle
+ }
+}
+sub Src () {
+ $CurSrc;
+}
+sub SourceStructRef () {
+ \@SourceStruct; #array of references to hashes of SOURCEPATH => (filename1, filename2, ...)
+ }
+sub SrcList () {
+ my @SrcList;
+ my $KeyRef;
+ foreach $KeyRef (@SourceStruct) {
+ push @SrcList,$$KeyRef{CurFile};
+ }
+ @SrcList;
+}
+
+sub SmpSafe () {
+ $SmpSafe;
+}
+
+sub StackSize () {
+ $StackSize;
+}
+sub StatLibList () {
+ @StatLibList;
+}
+sub StatLinkPath () {
+ my $Path=$Path{StatLink};
+ if ($CurBld) {
+ $Path.="$CurBld\\";
+ }
+ $Path;
+}
+sub StdCpp () {
+ $StdCpp;
+}
+sub NoStdCpp () {
+ $NoStdCpp;
+}
+
+sub NewLib () {
+ $NewLib;
+}
+sub SetStatLinkPath($) {
+ ($Path{StatLink}) = @_;
+}
+sub SrcPath () {
+ $CurSrcPath;
+}
+sub SysIncPaths () {
+ @SysIncPaths;
+}
+sub ResourceSysIncPaths () {
+ return @ResourceSysIncPaths;
+}
+sub Trg (;$) {
+ # The optional $bld argument permits (U)DEB and (U)REL distinction in situations where $CurBld isn't set/relevant
+ my ($bld) = @_;
+ $bld = $CurBld if (!$bld);
+
+ return "" if !$Trg;
+
+ my $localTrg = $Trg;
+ my $vinfo = $FeatureVariantInfo{$bld."_LABEL"};
+ $localTrg =~ s/(\.[^\.]+)$/\.$vinfo$1/ if ($bld && %FeatureVariantInfo && !$FeatureVariantInfo{INVARIANT} && $vinfo);
+ return $localTrg;
+}
+sub TrgPath () {
+ $TrgType{Path};
+}
+sub TrgType () {
+ $TrgType{Name};
+}
+# this can probably go as its always 0 now
+sub KernelTrg () {
+ $TrgType{Kernel};
+}
+sub SystemTrg () {
+ $TrgType{System};
+}
+sub UidList () {
+ @UidList;
+}
+sub UserIncPaths () {
+ @UserIncPaths;
+}
+sub SrcDbg () {
+ $SrcDbg;
+}
+sub CompilerOption
+{
+ my $CompOption=$WarningLevel{$_[0]};
+ $CompOption="" if (!defined($CompOption));
+ $CompOption;
+}
+sub LinkerOption
+{
+ my $lnkOption = $LinkerOptions{$_[0]};
+ $lnkOption="" if (!defined($lnkOption));
+ $lnkOption;
+}
+
+sub PlatRec () {
+ %Plat;
+}
+
+sub Version() {
+ %Version;
+}
+
+sub SecureId() {
+ $SecureId;
+}
+
+sub VendorId () {
+ $VendorId;
+}
+
+sub EABIDef () {
+ $EABIDef;
+}
+
+sub ReplaceOptions () {
+ my @ReplacementOptions = ();
+ if (defined($ReplaceOptions{$_[0]}))
+ {
+ @ReplacementOptions=@{$ReplaceOptions{$_[0]}};
+ }
+ @ReplacementOptions;
+}
+
+sub ARMFPU () {
+ $ARMFPU;
+}
+
+sub IsDebuggable () {
+ $IsDebuggable;
+}
+
+sub PlatTxt2D () {
+ @PlatTxt2D;
+}
+
+sub ToolChain () {
+ my $ToolChain = $TruePlat{Toolchain};
+ $ToolChain ="" if(!defined ($TruePlat{Toolchain}) );
+ $ToolChain;
+}
+
+sub StringTables ()
+{
+ @StringTable;
+}
+
+
+#This generates and adds the generated source of the stringtable to the source list so it's included in the binary.
+sub AddStringTables ()
+{
+ if(@StringTable)
+ {
+ foreach my $stringtable (@StringTable)
+ {
+ my %genSrcHash;
+
+ $genSrcHash{SrcPath} = $Path{Bld};
+ $genSrcHash{CurFile} = $stringtable->{BaseTrg}.".cpp";
+ $genSrcHash{BaseTrg} = $stringtable->{BaseTrg};
+
+ push(@SourceStruct, \%genSrcHash) if !$stringtable->{Hdronly};
+
+ # Execute it now. This can probably be moved into the makefile by adding a suitable rule
+ # to ensure the resource file is generated before the source tries to #include it.
+ my $stPath = $Path{Bld};
+
+ my $stCpp = $stringtable->{BaseTrg}.".cpp";
+ my $stHeader = lc($stringtable->{BaseTrg}).".h";
+ my $stFile = $stringtable->{STFile};
+ my $stOrigin = $stringtable->{STPath};
+ system("perl -S ecopyfile.pl $stOrigin$stFile $stPath$stFile");
+ system("perl -S stringtable.pl $stPath$stFile");
+
+ #If it's an exported header we'll need to export it.
+ if(defined $stringtable->{ExportPath})
+ {
+ my $exportpath = $stringtable->{ExportPath};
+
+ system("perl -S ecopyfile.pl $stPath$stHeader $exportpath\\$stHeader");
+
+ push(@UserIncPaths, $exportpath);
+ push(@StringTableUserIncPaths, $exportpath);
+ }
+ #otherwise we just need the path of the generated header to be added 'userinclude'.
+ else
+ {
+ push(@UserIncPaths, $Path{Bld});
+ push(@StringTableUserIncPaths, $Path{Bld});
+ }
+ }
+ }
+}
+
+sub CheckSourceMMPMetaData () {
+ %CheckSourceMMPMetaData;
+}
+
+sub CheckSourceMMPIncludes () {
+ %CheckSourceMMPIncludes;
+}
+
+sub CheckSourceURELIncludes () {
+ %CheckSourceURELIncludes;
+}
+
+sub CheckSourceUDEBIncludes () {
+ %CheckSourceUDEBIncludes;
+}
+
+sub CodePagingTargetMode() {
+ $CodePagingTargetMode;
+}
+
+sub DataPagingTargetMode() {
+ $DataPagingTargetMode;
+}
+
+sub DebugSwitchUsed () {
+ return 1 if (defined $DebugSwitch);
+ return 0;
+}
+
+sub SymbolicDebugEnabled () {
+ return $DebugSwitch;
+}
+
+sub IsFunctionCallLogging() {
+ $Options{logfc};
+}
+
+sub IsWideCharMain() {
+ return $IsWideCharMain;
+}
+
+sub MmpMacros(){
+ my @mmpMacros=&Mmp_Macros;
+ return @mmpMacros;
+}
+
+sub FeatureVariantInfo()
+ {
+ return %FeatureVariantInfo;
+ }
+
+sub FeatureVariantVMapFile()
+ {
+ return "" if !%FeatureVariantInfo || defined $FeatureVariantInfo{INVARIANT};
+
+ my $target = RelPath().Trg();
+ $target =~ s/\.$FeatureVariantInfo{$CurBld."_LABEL"}//;
+# modified by SV start: makefile improvement
+ my $vmap = $target. "." . $FeatureVariantInfo{NAME}.".vmap";
+# modified by SV end: makefile improvement
+
+ eval { &Path_MakePathL($vmap); };
+
+ if (featurevariantmap->Save($target, $FeatureVariantInfo{$CurBld."_LABEL"}, $FeatureVariantInfo{NAME}, $FeatureVariantInfo{$CurBld."_FEATURES"}, &Mmp_IsFeatureVariant ? [ 'FEATUREVARIANT' ] : undef))
+ {
+ die "ERROR: Couldn't create feature variant map file \"$vmap\".\n";
+ }
+
+ return $vmap;
+ }
+
+sub FeatureVariantBaseTrg()
+ {
+ # In some situations, for example .sym files, we need a feature variant tagged name
+ # based on the normal BaseTrg i.e. root target name but minus extension.
+ my $localBaseTrg = BaseTrg();
+
+ if (%FeatureVariantInfo && !defined $FeatureVariantInfo{INVARIANT})
+ {
+ $localBaseTrg .= ".".$FeatureVariantInfo{$CurBld."_LABEL"};
+ }
+
+ return $localBaseTrg;
+ }
+
+sub CommandFile()
+ {
+ my $plat = Plat();
+ $plat .= ".$FeatureVariantInfo{NAME}" if %FeatureVariantInfo;
+ return MakeFilePath().BaseTrg().".$plat.".Bld().".objects.via";
+ }
+
+#Compiler wrapper option support
+sub CompilerWrapperOption()
+{
+ # Return 1 if compiler wrapper option option(-wrap) is specified else return 0
+ $IsCompilerWrapperOption;
+}
+
+#Proxy wrapper option support
+sub ProxyWrapperOption()
+{
+ # Return 1 if compiler wrapper option option(-wrap) is specified else return 0
+ $IsProxyWrapperOption;
+}
+# modified start: makefile improvement
+sub getSrcSet()
+{
+ return \%CurSrcSet;
+}
+# modified end: makefile improvement
+
+#1 = STDCPP support is available
+#others = STDCPP support is not available
+my $stdcppsupport;
+
+#STDCPP support check (SYMBIAN_OE_LIBSTDCPP)
+#return non-zero means STDCPP support is available,
+#otherwise it's not available
+sub StdCppSupport()
+{
+ return $stdcppsupport if (defined $stdcppsupport);
+
+ my @hrhMacros = &Variant_GetMacroList;
+ if (grep /^\s*SYMBIAN_OE_LIBSTDCPP\s*$/, @hrhMacros)
+ {
+ $stdcppsupport = 1;
+ }
+ else
+ {
+ $stdcppsupport = 0;
+ }
+
+ return $stdcppsupport;
+}