Remove the PrintingServices component from TB10.1 on wards(on behalf of dane.waby@nokia.com)
# 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 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 -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 -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 -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 -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 -S ecopyfile.pl \"$SavedBldPath\\$BaseResrc$$ResourceRef{Lang}.rsg\" \"$ResrcHdr\"\n";
}
}
else {
if ($$ResourceRef{Hdr} || $$ResourceRef{Hdronly}) {
$HeaderOption = " -h\"$SavedBldPath\\$BaseResrc.rsg\"";
$HeaderCopyCmd = "\tperl -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 -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 -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;