--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1_os/e32toolp/platform/cl_generic.pm Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,1138 @@
+# Copyright (c) 2001-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:
+# this package contains generic routines to handle bits of makefiles which are
+# common to all of the platforms. Currently it deals with AIF, MBM amd RSC files.
+#
+#
+
+package cl_generic;
+
+require Exporter;
+@ISA=qw(Exporter);
+@EXPORT=qw(
+ Generic_Define
+ Generic_Definition
+ Generic_MakeWorkDir
+ Generic_MakeWorkFile
+ Generic_Quote
+ Generic_Header
+ Generic_Releaseables
+ Generic_BitMapBld
+ Generic_ResrcBld
+ Generic_AifBld
+ Generic_End
+ Generic_CopyAction
+ Generic_WhatCleanTargets
+ Generic_WhatTargets
+ Generic_CleanTargets
+);
+
+use strict;
+use File::Basename;
+use lockit_info;
+use CheckSource;
+use E32Variant;
+
+my $SavedBldPath;
+my $MakefileType=0; # 0=NMAKE, 1=MAKE
+my %CheckSourceResourceIncludes;
+
+sub Generic_Header ($$;$) {
+ my ($UseRltPaths, $makefileType, $supportAbsPathConversion) = @_;
+
+ $MakefileType=($makefileType eq "nmake")? 0:1;
+
+ my $LibSubDir="UDEB";
+ if (&main::PlatOS eq 'EPOC32') {
+ $LibSubDir="UREL";
+ }
+ elsif (&main::PlatOS eq 'TOOLS2') {
+ $LibSubDir="LIB";
+ }
+
+ my $BldPath=&main::BldPath;
+
+ if ( LocalBuildPathExists() ) {
+ $BldPath = ConvertToLocalBuild($BldPath);
+ }
+
+ # Get the information regarding supporting Compiler Wrapper option
+ my $IsCompilerWrapperOption=&main::CompilerWrapperOption();
+ my $RelPath=&main::RelPath;
+ my $LibPath=&main::LibPath;
+ my $LinkPath=&main::LinkPath;
+ my $StatLinkPath=&main::StatLinkPath;
+ my $ASSPLinkPath=&main::ASSPLinkPath;
+
+ $SavedBldPath=&main::Path_Chop($BldPath);
+
+ if ($UseRltPaths) {
+
+ if ( ! LocalBuildPathExists() ) {
+ # Local build does not exists so keep relative path.
+ $BldPath =&main::Path_RltToWork($BldPath);
+ }
+
+ $RelPath =&main::Path_RltToWork($RelPath);
+ $LibPath =&main::Path_RltToWork($LibPath);
+ $LinkPath =&main::Path_RltToWork($LinkPath);
+ $StatLinkPath=&main::Path_RltToWork($StatLinkPath);
+ $ASSPLinkPath=&main::Path_RltToWork($ASSPLinkPath);
+ }
+
+ $BldPath=&main::Path_Chop($BldPath);
+ $RelPath=&main::Path_Chop($RelPath);
+ $LibPath=&main::Path_Chop($LibPath);
+ $LinkPath=&main::Path_Chop($LinkPath);
+ $StatLinkPath=&main::Path_Chop($StatLinkPath);
+ $ASSPLinkPath=&main::Path_Chop($ASSPLinkPath);
+
+ my $EPOCDataPath=&main::Path_Chop(&main::EPOCDataPath);
+ my $EPOCIncPath=&main::Path_Chop(&main::EPOCIncPath);
+ my $DataPath=&main::Path_Chop(&main::DataPath);
+ my $TrgPath=&main::Path_Chop(&main::TrgPath);
+
+ my $erasedefn = "\@erase";
+ $erasedefn = "\@erase 2>>nul" if ($ENV{OS} eq "Windows_NT");
+
+ &main::Output(
+ "\n",
+ '# CWD ', &main::Path_WorkPath, "\n",
+ '# MMPFile ', &main::MmpFile, "\n",
+ '# Target ', &main::Trg, "\n",
+ '# TargetType ', &main::TrgType, "\n",
+ '# BasicTargetType ', &main::BasicTrgType, "\n",
+ '# MakefileType ', ($MakefileType==1)? "GNU":"NMAKE", "\n"
+ );
+
+ my @BldList=&main::BldList;
+ my %featureVariantInfo = &main::FeatureVariantInfo;
+
+ if (%featureVariantInfo)
+ {
+ &main::Output("# FeatureVariantName ", $featureVariantInfo{NAME}, "\n");
+
+ foreach (@BldList)
+ {
+ &main::Output("# FeatureVariant".$_."Label ", $featureVariantInfo{$_."_LABEL"}, "\n");
+ }
+ }
+
+ &main::Output(
+ "\n",
+ "ERASE = $erasedefn\n",
+ "\n"
+ );
+
+ # Include function to perform optional DOS to Unix slash conversion
+ # on absolute paths if requested from backend.
+ if ($supportAbsPathConversion) {
+ &main::Output(
+ "ifeq \"\$(UNIX_SLASH_FOR_CC_ABS_PATHS)\" \"1\"\n",
+ "define absolutePaths\n",
+ "\$(subst \\,\/,\$1)\n",
+ "endef\n",
+ "else\n",
+ "define absolutePaths\n",
+ "\$1\n",
+ "endef\n",
+ "endif\n",
+ "\n"
+ );
+ }
+
+ &main::Output(
+ "# EPOC DEFINITIONS\n",
+ "\n"
+ );
+
+ Generic_Define("EPOCBLD", $BldPath);
+ if (defined $ENV{PBUILDPID}) {
+ my $BldPathP = $BldPath . '$(PBUILDPID)';
+ Generic_Define("EPOCBLDP", $BldPathP);
+ } else {
+ Generic_Define("EPOCBLDP", $BldPath);
+ }
+ Generic_Define("EPOCTRG", $RelPath);
+ Generic_Define("EPOCLIB", $LibPath);
+ Generic_Define("EPOCLINK", $LinkPath);
+ Generic_Define("EPOCSTATLINK", $StatLinkPath);
+ Generic_Define("EPOCBSFSTATLINK", $RelPath);
+ Generic_Define("EPOCASSPLINK", $ASSPLinkPath);
+
+ Generic_Define("EPOCDATA", $EPOCDataPath);
+ Generic_Define("EPOCINC", $EPOCIncPath);
+ Generic_Define("TRGDIR", $TrgPath);
+ Generic_Define("DATADIR", $DataPath);
+
+
+ foreach (@BldList) {
+ &main::Output("\n");
+
+ my $bldOffset = "";
+ $bldOffset .= $featureVariantInfo{$_."_LABEL"}."\\" if (%featureVariantInfo && !$featureVariantInfo{INVARIANT});
+
+ Generic_Define("EPOCBLD$_", "\$(EPOCBLD)\\".$bldOffset.lc($_));
+ if (defined $ENV{PBUILDPID}) {
+ Generic_Define("EPOCBLDP$_", "\$(EPOCBLDP)\\".$bldOffset.lc($_));
+ } else {
+ Generic_Define("EPOCBLDP$_", "\$(EPOCBLD)\\".$bldOffset.lc($_));
+ }
+ Generic_Define("EPOCTRG$_", "\$(EPOCTRG)\\".lc($_));
+ Generic_Define("EPOCLIB$_", "\$(EPOCLIB)\\".lc($LibSubDir));
+ Generic_Define("EPOCLINK$_", "\$(EPOCLINK)\\".lc($LibSubDir));
+ Generic_Define("EPOCSTATLINK$_", "\$(EPOCSTATLINK)\\".lc($_));
+ Generic_Define("EPOCBSFSTATLINK$_","\$(EPOCBSFSTATLINK)\\".lc($_));
+ Generic_Define("EPOCASSPLINK$_", "\$(EPOCASSPLINK)\\".lc($LibSubDir));
+ }
+
+ # Compiler Wrapper option support
+ # Generate the information Compiler Wrapper options in second level make file.
+ if($IsCompilerWrapperOption)
+ {
+ &main::Output(
+ "\n\n",
+ "#COMPILER WRAPPER OPTION DEFINITIONS\n",
+ "COMPWRAP = ",
+ "$ENV{ABLD_COMPWRAP}", # Extract the tool name from environment variable
+ "\n\n"
+ );
+ }
+ # Compiler Wrapper option
+
+ my $gccxml;
+ if (&main::Plat =~ /gccxml/i){
+ $gccxml = &main::Plat;
+ }
+
+ my $edg;
+ if (&main::Plat =~ /edg/i){
+ $edg = &main::Plat;
+ }
+
+ &main::Output(
+ "\n",
+ "# EPOC PSEUDOTARGETS\n",
+ "\n"
+ );
+
+ foreach (@BldList) {
+ if(!$edg){
+ &main::Output(
+ "$_ : MAKEWORK$_ RESOURCE$_\n\n"
+ );
+ }
+ else {
+ &main::Output(
+ "$_ : MAKEWORK$_ \n\n"
+ );
+ }
+ }
+
+ &main::Output( # ALL comes after DEB: because first target in makefile is the default
+ "ALL :"
+ );
+ foreach (@BldList) {
+ &main::Output(
+ " $_"
+ );
+ }
+ # # Compiler Wrapper option support
+ if($IsCompilerWrapperOption)
+ {
+ &main::Output( # ALL comes after DEB: because first target in makefile is the default
+ "\n\nCOMPWRAPALL : COMPWRAPUREL COMPWRAPUDEB"
+ );
+
+ }
+
+ &main::Output(
+ "\n",
+ "\n",
+ "CLEAN CLEANALL : CLEANBUILD CLEANRELEASE CLEANLIBRARY\n",
+ "\n"
+ );
+ my $pseudoTarget;
+ foreach $pseudoTarget ("WHAT", "RESOURCE", "CLEANBUILD", "CLEANRELEASE",
+ "MAKEWORK", "LISTING")
+ {
+ if(($gccxml && $pseudoTarget eq "RESOURCE") ||
+ !($gccxml || $edg)){
+
+ &main::Output(
+ "\n",
+ "\n",
+ "$pseudoTarget $pseudoTarget","ALL :"
+ );
+ foreach (@BldList) {
+ &main::Output(
+ " $pseudoTarget$_"
+ );
+ }
+ }
+ }
+ if($gccxml){
+ &main::Output(
+ "\n",
+ "\n",
+ );
+ }
+
+ if(!($gccxml || $edg)){
+ &main::Output(
+ "\n",
+ "\n",
+ "MAKEWORK : MAKEWORKLIBRARY\n",
+ "\n"
+ );
+ }
+ if(!$edg){
+ foreach (@BldList) {
+ &main::Output(
+ "RESOURCE$_ "
+ );
+ }
+ &main::Output(
+ ": GENERIC_RESOURCE\n",
+ "\n"
+ );
+ }
+}
+
+# Quote name if necessary, according to the type of Makefile
+
+sub Generic_Quote ($) {
+ my ($name)=@_;
+ if ($MakefileType==1) {
+ # GNU make wants backslash before each space
+ $name =~ s/ /\\ /go;
+ } else {
+ # NMAKE prefers quotes around all filenames
+ $name = "\"$name\"";
+ }
+ return $name;
+}
+
+# Generic file copying action, which uses built-in variables quoted appropriately
+#
+# GNU make variables may contain spaces, but perl.exe will be executed directly
+# and so doesn't need any quotes.
+
+sub Generic_CopyAction($) {
+ my ($target) = @_;
+ my $source = '$?';
+ $target = '$@' if (!defined $target);
+ return "perl -w -S ecopyfile.pl $source $target\n";
+}
+
+# Record necessary directories, for eventual emkdir.pl rules
+# Also need to record related defines, to eliminate duplicates
+
+my %DirDefines;
+sub expandDefines ($) {
+ my ($value)=@_;
+ while ($value =~ /^(.*?)\$\((\w+)\)(.*)$/) {
+ last if ($2 eq 'PBUILDPID');
+ $value="$1$DirDefines{$2}$3";
+ }
+ return $value;
+}
+sub Generic_Define ($$;$) {
+ my ($name, $value, $trailer)=@_;
+ $trailer="" if (! defined $trailer);
+ &main::Output(
+ "$name = $value$trailer\n"
+ );
+ $DirDefines{$name}=expandDefines($value);
+}
+sub Generic_Definition ($) {
+ return $DirDefines{$_[0]};
+}
+
+my %MkDirs;
+sub Generic_MkDir ($) {
+ my $dir=&main::Path_Chop(&expandDefines($_[0]));
+ $dir = lc $dir;
+ $dir =~ s/\$\(pbuildpid\)/\$\(PBUILDPID\)/g;
+ $MkDirs{$dir}=1;
+ return $dir;
+}
+
+# Accumulate MAKEWORK targets and lists of directories,
+# automatically filling in the rest of the details.
+#
+my %MakeWork;
+sub Generic_MakeWorkDir($$) {
+ my ($work, $dir) = @_;
+
+ if ( LocalBuildPathExists() ) {
+ $dir = ConvertToLocalBuild($dir);
+ }
+
+ my $workhash;
+ if (defined $MakeWork{$work}) {
+ $workhash=$MakeWork{$work};
+ } else {
+ my %newhash;
+ $workhash=\%newhash;
+ $MakeWork{$work}=$workhash;
+ }
+ my $normdir=lc &main::Path_Chop(&expandDefines($dir));
+ $normdir =~ s/\$\(pbuildpid\)/\$\(PBUILDPID\)/g;
+ $$workhash{$normdir} ||= &Generic_MkDir($dir);
+}
+
+sub Generic_MakeWorkFile($$) {
+ my ($work, $file) = @_;
+ my $dir=&main::Path_Split('Path',&expandDefines($file));
+ &Generic_MakeWorkDir($work,$dir);
+}
+
+
+sub Generic_WhatTargets($$@)
+{
+ my ($prefix, $whattarget, @files)=@_;
+
+ if ((scalar @files) == 0) {
+ &main::Output(
+ "\n",
+ "\n$whattarget :\n",
+ "\t\@rem none\n"
+ );
+ } else {
+# emit list of releasables in batches to avoid overflowing the 2048 character
+# batch file line limit doing echo or erase...
+
+ my $count=1;
+ my $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_RELEASEABLES$count="
+ );
+
+ my $File;
+
+ foreach $File (sort @files) {
+ my $name = &Generic_Quote($File);
+ my $namelen = length($name)+3; # for space, newline and tab
+ if ($length+$namelen > 1700) { # very conservative limit
+ $count++;
+ $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_RELEASEABLES$count="
+ );
+ }
+ &main::Output(
+ " \\\n\t", $name
+ );
+ $length += $namelen;
+ }
+ &main::Output(
+ "\n",
+ "\n",
+ "$whattarget:\n"
+ );
+ my $filecount=1;
+ while ($filecount<=$count) {
+ &main::Output(
+ "\t\@echo \$(${prefix}_RELEASEABLES$filecount)\n"
+ );
+ $filecount++;
+ }
+ }
+
+ &main::Output(
+ "\n",
+ );
+}
+
+sub Generic_CleanTargets($$@) {
+ my ($prefix, $cleantarget, @files)=@_;
+
+ if ((scalar @files) == 0) {
+ &main::Output(
+ "\n",
+ "\n$cleantarget :\n",
+ "\t\@rem none\n"
+ );
+ } else {
+# emit list of releasables in batches to avoid overflowing the 2048 character
+# batch file line limit doing echo or erase...
+
+ my $count=1;
+ my $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_CLEANTARGETS$count="
+ );
+
+ my $File;
+
+ foreach $File (sort @files) {
+ my $name = &Generic_Quote($File);
+ my $namelen = length($name)+3; # for space, newline and tab
+ if ($length+$namelen > 1700) { # very conservative limit
+ $count++;
+ $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_CLEANTARGETS$count="
+ );
+ }
+ if (!main::NoExportLibrary || ($name !~ /.dso$/i && $name !~ /.lib$/i))
+ {
+ &main::Output(
+ " \\\n\t", $name
+ );
+ $length += $namelen;
+ }
+ }
+ &main::Output(
+ "\n",
+ "\n",
+ "$cleantarget:\n",
+ );
+ my $filecount=1;
+ while ($filecount<=$count) {
+ &main::Output(
+ "\t-\$(ERASE) \$(${prefix}_CLEANTARGETS$filecount)\n"
+ );
+ $filecount++;
+ }
+ }
+
+ &main::Output(
+ "\n",
+ );
+}
+
+sub Generic_WhatCleanTargets($$$@) {
+ my ($prefix, $whattarget, $cleantarget, @files)=@_;
+
+ if ((scalar @files) == 0) {
+ &main::Output(
+ "\n",
+ "\n$whattarget $cleantarget :\n",
+ "\t\@rem none\n"
+ );
+ } else {
+# emit list of releasables in batches to avoid overflowing the 2048 character
+# batch file line limit doing echo or erase...
+
+ my $count=1;
+ my $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_RELEASEABLES$count="
+ );
+
+ my $File;
+
+ foreach $File (sort @files) {
+ my $name = &Generic_Quote($File);
+ my $namelen = length($name)+3; # for space, newline and tab
+ if ($length+$namelen > 1700) { # very conservative limit
+ $count++;
+ $length=0;
+ &main::Output(
+ "\n",
+ "${prefix}_RELEASEABLES$count="
+ );
+ }
+ &main::Output(
+ " \\\n\t", $name
+ );
+ $length += $namelen;
+ }
+ &main::Output(
+ "\n",
+ "\n",
+ "$whattarget:\n"
+ );
+ my $filecount=1;
+ while ($filecount<=$count) {
+ &main::Output(
+ "\t\@echo \$(${prefix}_RELEASEABLES$filecount)\n"
+ );
+ $filecount++;
+ }
+ &main::Output(
+ "\n",
+ "$cleantarget:\n",
+ );
+ $filecount=1;
+ while ($filecount<=$count) {
+ &main::Output(
+ "\t-\$(ERASE) \$(${prefix}_RELEASEABLES$filecount)\n"
+ );
+ $filecount++;
+ }
+ }
+
+ &main::Output(
+ "\n",
+ );
+}
+
+# accumulated list of generic releasables
+my %Files;
+sub Generic_End {
+ &Generic_WhatCleanTargets("GENERIC","WHATGENERIC","CLEANGENERIC", keys %Files);
+
+ &main::Output(
+ "# Rules to create all necessary directories\n",
+ );
+
+ foreach (sort keys %MakeWork) {
+ my $workhash = $MakeWork{$_};
+ &main::Output(
+ "\n$_ :",
+ );
+ foreach (sort keys %$workhash) {
+ my $withcase=$$workhash{$_};
+ if ($withcase =~ /\$\(PBUILDPID\)\\/) {
+ &main::Output(
+ " \\\n",
+ "\t\$(if \$(PBUILDPID),", &Generic_Quote($withcase), ")"
+ );
+ } else {
+ &main::Output(
+ " \\\n",
+ "\t", &Generic_Quote($withcase)
+ );
+ }
+ }
+ &main::Output(
+ "\n"
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ my $dir;
+ foreach $dir (sort keys %MkDirs) {
+ if ($dir =~ /\$\(PBUILDPID\)\\/) {
+ &main::Output(
+ "\$(if \$(PBUILDPID),", &Generic_Quote($dir),") \\\n",
+ );
+ } else {
+ &main::Output(
+ &Generic_Quote($dir)," \\\n",
+ );
+ }
+ }
+ &main::Output(
+ ":\n",
+ "\tperl -w -S emkdir.pl \$\@\n",
+ "\n"
+ );
+
+ &main::Output(
+ "CHECKSOURCE :\n",
+ );
+
+ &main::Output (CheckSource_MakefileOutput(&main::CheckSourceMMPIncludes));
+ &main::Output (CheckSource_MakefileOutput(%CheckSourceResourceIncludes));
+ &main::Output (CheckSource_MakefileOutput(&main::CheckSourceMMPMetaData));
+
+ my $cs_targetprefix = "";
+ $cs_targetprefix = "U" unless (&main::Plat =~ /tools/i);
+
+ &main::Output(
+ "\nCHECKSOURCE".$cs_targetprefix."REL :\n",
+ );
+
+ &main::Output (CheckSource_MakefileOutput(&main::CheckSourceURELIncludes));
+
+ &main::Output(
+ "\nCHECKSOURCE".$cs_targetprefix."DEB :\n",
+ );
+
+ &main::Output (CheckSource_MakefileOutput(&main::CheckSourceUDEBIncludes));
+
+}
+
+sub Generic_Releaseables {
+
+ my $ResrcPath=&main::TrgPath;
+ my $dir;
+ my $EPOCIncPath=&main::EPOCIncPath;
+
+ &Generic_MakeWorkDir('GENERIC_MAKEWORK',$SavedBldPath); # used for temp directory in epocrc.pl
+
+ my $AifStructRef=&main::AifStructRef;
+ my $AifRef;
+ foreach $AifRef (@$AifStructRef) {
+# regression change - workaround lack of AIF directory
+ $$AifRef{TrgFile}=&main::Path_Split('File',$$AifRef{Trg}); # record for later
+ my $path=&main::Path_Split('Path',"$ResrcPath$$AifRef{Trg}");
+ my $file="\$(EPOCDATA)\\$ResrcPath$$AifRef{Trg}";
+ my $xip="_xip";
+ my $base=&main::Path_Split('Base',"$file");
+ my $root=&main::Path_Split('Path',"$file");
+ my $ext=&main::Path_Split('Ext',"$file");
+ my $file_xip="$root"."$base$xip$ext"; # since XIP AIF format is generated
+ if ($path eq "") {
+ # no target path for the AIF file, so not a releasable
+ $file="$SavedBldPath\\$$AifRef{Trg}";
+ } else {
+ $Files{$file}=1;
+ $Files{$file_xip}=1;
+ }
+ $$AifRef{GenericTrg}=$file; # record for later
+ &Generic_MakeWorkFile('GENERIC_MAKEWORK',$file);
+ }
+
+ my $BitMapStructRef=&main::BitMapStructRef;
+ my $BitMapRef;
+ foreach $BitMapRef (@$BitMapStructRef) {
+ my $path=$$BitMapRef{TrgPath};
+ my $file="\$(EPOCDATA)\\$path$$BitMapRef{Trg}";
+ $$BitMapRef{GenericTrg}=$file; # record for later
+ $Files{$file}=1;
+ &Generic_MakeWorkFile('GENERIC_MAKEWORK',$file);
+ if ($$BitMapRef{Hdr}) {
+ my $mbg=&main::Path_Split('Base', $$BitMapRef{Trg});
+ $mbg="\$(EPOCINC)\\$mbg.mbg";
+ &Generic_MakeWorkDir('GENERIC_MAKEWORK',$EPOCIncPath);
+ $Files{$mbg}=1;
+ }
+ }
+
+ my $ResourceStructRef=&main::ResourceStructRef;
+ my $ResourceRef;
+ foreach $ResourceRef (@$ResourceStructRef) {
+ if(defined $$ResourceRef{Hdronly})
+ {
+ my $rsg="\$(EPOCINC)\\$$ResourceRef{BaseTrg}.rsg";
+ $$ResourceRef{GenericTrg}=$rsg; # record for later
+
+ &Generic_MakeWorkDir('GENERIC_MAKEWORK',$EPOCIncPath);
+ $Files{$rsg}=1;
+ }
+ else
+ {
+ my $file="\$(EPOCDATA)\\$$ResourceRef{Trg}";
+ $$ResourceRef{GenericTrg}=$file; # record for later
+ $Files{$file}=1;
+ &Generic_MakeWorkFile('GENERIC_MAKEWORK',$file);
+ if ($$ResourceRef{Hdr}) {
+ my $rsg="\$(EPOCINC)\\$$ResourceRef{BaseTrg}.rsg";
+ &Generic_MakeWorkDir('GENERIC_MAKEWORK',$EPOCIncPath);
+ $Files{$rsg}=1;
+ }
+ }
+ }
+
+# Do StringTable 'export'
+ my @stringTables = &main::StringTables();
+ foreach my $stringtable (@stringTables)
+ {
+ if(defined $stringtable->{ExportPath})
+ {
+ $Files{$stringtable->{ExportPath}."\\".$stringtable->{BaseTrg}.".h"} = 1;
+ }
+ }
+
+
+ &main::Output(
+ "GENERIC_RESOURCE : GENERIC_MAKEWORK\n",
+ "\n"
+ );
+
+}
+
+sub Generic_BitMapBld {
+
+ my $BitMapRef=&main::BitMapRef;
+ my $quotedTrg=&Generic_Quote($$BitMapRef{GenericTrg});
+ my $WorkPath = &main::Path_Chop(&main::Path_WorkPath); ## required for Lockit
+
+ &main::Output(
+ "# BitMap $$BitMapRef{Trg}\n",
+ "\n",
+ "GENERIC_RESOURCE : $quotedTrg\n",
+ "\n",
+ "$quotedTrg :"
+ );
+
+# must lower-case header here since bmconv generates a header with case-sensitive enums accordingly
+ my $BitMapHdr=join('', &main::EPOCIncPath, &main::Path_Split('Base', $$BitMapRef{Trg}), '.mbg');
+ my $TmpBitMapHdr=join('', &main::BldPath, &main::Path_Split('Base', $$BitMapRef{Trg}), '.mbg');
+
+ my $SrcRef;
+ foreach $SrcRef (@{$$BitMapRef{Source}}) {
+
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ %Files = &Lockit_Releasables($WorkPath, $$BitMapRef{Trg}, \%Files, basename($$SrcRef{Src}),"","");
+ }
+ else {
+ %Files = &Lockit_Releasables($WorkPath, $$BitMapRef{Trg}, \%Files, basename($$SrcRef{Src}));
+ }
+ &main::Output(
+ " \\\n ", &Generic_Quote($$SrcRef{Src})
+ );
+ }
+ &main::Output(
+ "\n",
+ "\tperl -w -S epocmbm.pl -h\"$TmpBitMapHdr\"",
+ "\t-o\"$$BitMapRef{GenericTrg}\"",
+ "\t-l\"\\$$BitMapRef{TrgPath}:$WorkPath\"",
+ "\\\n\t\t"
+ );
+ &main::Output(
+ " -b\""
+ );
+ foreach $SrcRef (@{$$BitMapRef{Source}}) {
+ &main::Output(
+ "\\\n\t\t/$$SrcRef{ClDepth}$$SrcRef{Src}"
+ );
+ }
+
+
+ &main::Output(
+ "\" \\\n\t\t"
+ );
+
+ &main::Output(
+ " -l\"\\$$BitMapRef{TrgPath}:$WorkPath\"\n"
+ );
+
+ if ($$BitMapRef{Hdr}) {
+ &main::Output(
+ "\tperl -w -S ecopyfile.pl \"$TmpBitMapHdr\" \"$BitMapHdr\"\n",
+ );
+ }
+ &main::Output(
+ "\n"
+ );
+}
+
+sub Generic_ResrcBld {
+ my $ResourceRef=&main::ResourceRef;
+ my $WorkPath = &main::Path_Chop(&main::Path_WorkPath); # required for Lockit
+ my @RcompMacro=&main::MmpMacros;
+
+ &main::Output(
+ "# Resource $$ResourceRef{Trg}\n",
+ "\n"
+ );
+ my @DepList=&main::DepList;
+
+ &main::Output(
+ "DEPEND="
+ );
+ foreach (@DepList) {
+ &main::Output(
+ " \\\n",
+ "\t", &Generic_Quote($_)
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ my $BaseResrc= $$ResourceRef{BaseTrg};
+ my $SrcPath=&main::Path_Split('Path', $$ResourceRef{Source});
+
+ my $AbsSrc;
+ my $AbsSrcPath;
+
+ my $ResrcHdr=join '', &main::EPOCIncPath(), $BaseResrc, '.rsg';
+ my $AbsResrcHdr;
+ my $PlatName=&main::PlatName;
+
+ my @ChopAbsSysIncPaths;
+ my @ChopAbsUserIncPaths;
+
+ @ChopAbsSysIncPaths=&main::Path_Chop(&main::Path_AbsToWork(&main::ResourceSysIncPaths));
+ @ChopAbsUserIncPaths=&main::Path_Chop(&main::Path_AbsToWork(&main::UserIncPaths));
+
+ $AbsSrc=&main::Path_AbsToWork($$ResourceRef{Source});
+ $AbsSrcPath=&main::Path_AbsToWork($SrcPath);
+ $AbsResrcHdr=&main::Path_AbsToWork($ResrcHdr);
+
+ my $ChopAbsSrcPath=&main::Path_Chop($AbsSrcPath);
+
+ my $EPOCDataDir = &main::Path_Chop($$ResourceRef{TrgPath});
+
+ my $RscOption= "";
+ my $HeaderOption = "";
+ my $HeaderCopyCmd = "";
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ if ($$ResourceRef{Hdr} || $$ResourceRef{Hdronly}) {
+ $HeaderOption = " -h\"$SavedBldPath\\$BaseResrc$$ResourceRef{Lang}.rsg\"";
+ $HeaderCopyCmd = "\tperl -w -S ecopyfile.pl \"$SavedBldPath\\$BaseResrc$$ResourceRef{Lang}.rsg\" \"$ResrcHdr\"\n";
+ }
+
+ }
+ else {
+ if ($$ResourceRef{Hdr} || $$ResourceRef{Hdronly}) {
+ $HeaderOption = " -h\"$SavedBldPath\\$BaseResrc.rsg\"";
+ $HeaderCopyCmd = "\tperl -w -S ecopyfile.pl \"$SavedBldPath\\$BaseResrc.rsg\" \"$ResrcHdr\"\n";
+ }
+ }
+ if (! $$ResourceRef{Hdronly}) {
+ $RscOption = " -o\$\@ ";
+ }
+
+ my $Uidsref=$$ResourceRef{Uids};
+ my @Uids=();
+ @Uids = @{$Uidsref} if (defined($Uidsref));
+ my $Uidsarg="";
+ if ($#Uids>0) {
+ $Uidsarg="-uid2 $Uids[0] -uid3 $Uids[1]";
+ }
+ elsif ($#Uids==0) {
+ $Uidsarg="-uid2 $Uids[0] ";
+ }
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ %Files = &Lockit_Releasables($WorkPath, $$ResourceRef{Source}, \%Files, "", $$ResourceRef{Lang}) unless $$ResourceRef{Hdronly};
+ }
+ else {
+ %Files = &Lockit_Releasables($WorkPath,$$ResourceRef{Source}, \%Files, "") unless $$ResourceRef{Hdronly};
+ }
+ my $quotedTrg=&Generic_Quote($$ResourceRef{GenericTrg});
+ &main::Output(
+ "GENERIC_RESOURCE : $quotedTrg\n",
+ "\n",
+ "$quotedTrg : ", &Generic_Quote($AbsSrc), " \$(DEPEND)\n",
+ "\tperl -w -S epocrc.pl -m045,046,047 -I \"$ChopAbsSrcPath\""
+ );
+ foreach (@ChopAbsUserIncPaths) {
+ &main::Output(
+ " -I \"$_\""
+ );
+ }
+ &main::Output(
+ " -I-"
+ );
+ foreach (@ChopAbsSysIncPaths) {
+ &main::Output(
+ " -I \"$_\""
+ );
+ }
+ foreach(@RcompMacro) {
+ &main::Output(
+ " -D$_ "
+ );
+ }
+ &main::Output(
+ " -DLANGUAGE_$$ResourceRef{Lang} -u \"$AbsSrc\" ",
+ " $Uidsarg ",
+ "$RscOption $HeaderOption -t\"$SavedBldPath\""
+ );
+
+ if (!$$ResourceRef{Hdronly}) {
+ &main::Output(
+ " -l\"$EPOCDataDir:$WorkPath\""
+ );
+ }
+
+ if (&main::ResourceVariantFile()) {
+ &main::Output(
+ " -preinclude\"".&main::ResourceVariantFile()."\""
+ );
+ }
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ if ((lc $$ResourceRef{Lang}) eq "sc") {
+
+ &main::Output(
+ "\n",
+ $HeaderCopyCmd,
+ );
+ }
+ &main::Output(
+ "\n"
+ );
+
+ }
+ else {
+ &main::Output(
+ "\n",
+ $HeaderCopyCmd,
+ "\n"
+ );
+ }
+
+ my @macros;
+ push @macros, "LANGUAGE_$$ResourceRef{Lang}", "_UNICODE";
+ my @userIncludes = &main::Path_Chop(&main::Path_AbsToWork(&main::UserIncPaths));
+ unshift (@userIncludes, $AbsSrcPath);
+ my @systemIncludes = &main::Path_Chop(&main::Path_AbsToWork(&main::ResourceSysIncPaths));
+
+ CheckSource_Includes($AbsSrc, %CheckSourceResourceIncludes, &Variant_GetMacroHRHFile(), @macros, @userIncludes, @systemIncludes);
+}
+
+sub Generic_AifBld {
+
+ my $AifRef=&main::AifRef;
+ my $ResrcPath=&main::TrgPath;
+
+ &main::Output(
+ "# Aif $$AifRef{Trg}\n",
+ "\n"
+ );
+ my @DepList=&main::DepList;
+
+ &main::Output(
+ "DEPEND="
+ );
+ foreach (@DepList) {
+ &main::Output(
+ " \\\n",
+ "\t", &Generic_Quote($_)
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ my @ChopRTWSysIncPaths=&main::Path_Chop(&main::Path_RltToWork(&main::ResourceSysIncPaths));
+ my @ChopRTWUserIncPaths=&main::Path_Chop(&main::Path_RltToWork(&main::UserIncPaths));
+ my $BaseResrc=&main::Path_Split('Base',$$AifRef{Source});
+
+ my $WorkPath = &main::Path_Chop(&main::Path_WorkPath); # required for Lockit
+ my $quotedTrg=&Generic_Quote($$AifRef{GenericTrg});
+ &main::Output(
+ "GENERIC_RESOURCE : $quotedTrg\n",
+ "\n",
+ "$quotedTrg : ", &Generic_Quote("$$AifRef{Source}"), " \$(DEPEND)"
+ );
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ %Files = &Lockit_Releasables($WorkPath, $$AifRef{TrgFile}, \%Files, "", "");
+ }
+ else
+ {
+ %Files = &Lockit_Releasables($WorkPath, $$AifRef{TrgFile}, \%Files, "");
+ }
+ my $bitmapArg = "";
+ if ($$AifRef{BitMaps}) { # bitmaps aren't essential
+ $bitmapArg = "\\\n\t\t-b\"";
+ foreach my $BitMapRef (@{$$AifRef{BitMaps}}) {
+ my $BitMap = &main::Path_Split('File', $$BitMapRef{Src});
+ if (defined $ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} && ($ENV{ABLD_TOOLSMOD_COMPATIBILITY_MODE} eq 'alpha')) {
+ %Files = &Lockit_Releasables($WorkPath, $$AifRef{TrgFile}, \%Files, $BitMap, "");
+ }
+ else
+ {
+ %Files = &Lockit_Releasables($WorkPath, $$AifRef{TrgFile}, \%Files, $BitMap);
+ }
+ &main::Output(
+ " ", &Generic_Quote("$$BitMapRef{Src}")
+ );
+ $bitmapArg .= "\\\n\t\t/$$BitMapRef{ClDepth}$$BitMapRef{Src}";
+ }
+ $bitmapArg .= "\" ";
+ }
+ &main::Output(
+ "\n",
+ "\tperl -w -S epocaif.pl -o\$\@ ",
+ "\"$$AifRef{Source}\" ",
+ "\\\n\t\t",
+ "-t\"$SavedBldPath\" ",
+ " -l\"\$(TRGDIR):$WorkPath\"",
+ $bitmapArg,
+ "\\\n\t\t"
+ );
+ foreach (@ChopRTWUserIncPaths) {
+ &main::Output(
+ " -I \"$_\""
+ );
+ }
+ &main::Output(
+ " -I-"
+ );
+ foreach (@ChopRTWSysIncPaths) {
+ &main::Output(
+ " -I \"$_\""
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+}
+
+
+
+#
+# Check to see that LOCAL_BUILD_PATH exists.
+#
+
+sub LocalBuildPathExists()
+{
+ if ( defined( $ENV{LOCAL_BUILD_PATH} ) ) {
+ return 1;
+ }
+ else {
+ return 0;
+ }
+}
+
+
+#
+# Take the build path and ensure that it is now local.
+#
+
+
+sub ConvertToLocalBuild($)
+{
+ my ($BldPath)=@_;
+
+ my $sub_replacement = $ENV{"LOCAL_BUILD_PATH"};
+ if ( !ValidBuildPath($sub_replacement) ) {
+ &FatalError(" Invalid Local Build Path : LOCAL_BUILD_PATH = \"$BldPath\" must be in format drive:dir_name1 " );
+ }
+ else
+ {
+ # Replace the \epoc32\build with local setting
+ my $epocroot=$ENV{"EPOCROOT"};
+
+ my $sub_match = "\Q${epocroot}\EEPOC32\\\\BUILD";
+ $BldPath =~ s/${sub_match}/${sub_replacement}/;
+ }
+
+ return $BldPath
+}
+
+
+
+#
+# Checks that the path is at least of the form drive:path_name
+# If no drive: then the makefiles will be produced but not work.
+#
+
+
+sub ValidBuildPath($)
+{
+ my ($BldPath)=@_;
+
+ if ( $BldPath =~/^[a-zA-z]{1}:{1}.*$/) {
+ # Must have at least d:
+ return 1;
+ }
+ else {
+ return 0;
+ }
+
+}
+
+1;
+