#
# Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "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:
#
use strict;
##################################################################################
# These variables can be customised as required
# define some global variables - customise as required
my $REPORTDIR;
my $MAINLINEZIPDIR;
my $RELSUBSYSROOT;
my $TECHVIEWROOT;
# set variables which can be set from the environment. If no environment
# equivalent is found, it will set to the default
SetVariable(\$REPORTDIR, "REPORTDIR", "L:\\AutoSecTests");
SetVariable(\$MAINLINEZIPDIR, "MAINLINEZIPDIR", "\\\\builds01\\Master");
SetVariable(\$RELSUBSYSROOT, "RELSUBSYSROOT", "security");
# To include Techview in build set environment variable:
# TECHVIEWROOT=Techview
SetVariable(\$TECHVIEWROOT, "TECHVIEWROOT", "");
# host platforms define which platforms are to be built and tests to run. Target
# platforms are those where roms are build
my @HOSTPLATFORMS = ("wins", "winscw");
my @TARGETPLATFORMS = ("arm4", "thumb");
my @ROMPLATFORMS = ("lubbock", "assabet");
my @BUILDTYPES = ("udeb", "urel");
#
# END of customisable variables
####################################################################################
my $P4CLIENTNAME = ConfigureDefaultClient();
my $TESTCONFIGFILE;
my $SUBSYSTEMROOT;
# beech or cedar
my $BUILDPLATFORM;
# first get the date
my @DATEARRAY = split(/[ \/]/, `date /t`);
# command line arguments
my %ARGS = ();
# Parse command line parameters
ProcessCommandLine();
# now, DATEARRAY[0] will be day, 1 will be date of month, 2 will be month, 3 is year
my $RESULTDIR = "$REPORTDIR\\$DATEARRAY[3]$DATEARRAY[2]$DATEARRAY[1]";
# define the file where the config.txt file is post-processed
my $POSTPROCESSED = "$RESULTDIR\\postprocessed.txt";
# create a new directory for today
system("mkdir \"$RESULTDIR\"");
# create a logfile and error file
open (LOGFILE, "> $RESULTDIR\\log.txt") || die "error opening for writing";
open (ERRFILE, "> $RESULTDIR\\error.txt") || die "error opening for writing";
# Derive rootdrive from perforce client. Set up variables
# which required the root drive to be configured. Note that
# the test config file is only overwritten if not configured by
# the command line. By default it looks for config.txt in the current
# directory
my $ROOTDRIVE = "L:";
GetRootDrive();
if (!$TESTCONFIGFILE)
{
use Cwd;
my $dir = cwd();
$TESTCONFIGFILE = "$dir\\config.txt";
}
if (!$SUBSYSTEMROOT)
{
$SUBSYSTEMROOT = "$ROOTDRIVE\\$RELSUBSYSROOT";
}
if ($TECHVIEWROOT)
{
$TECHVIEWROOT = "$ROOTDRIVE\\$TECHVIEWROOT";
}
# epoc root directory
my $EPOCROOT = "$ROOTDRIVE\\epoc32";
# add techview to build if requested
my @BUILDDIRS = "";
if ( $TECHVIEWROOT )
{
@BUILDDIRS = ( $SUBSYSTEMROOT, "$TECHVIEWROOT\\toolkit\\startup\\group", "$TECHVIEWROOT\\apps\\appinstui\\group", "$TECHVIEWROOT\\apps\\secui\\group");
}
else
{
@BUILDDIRS = ( $SUBSYSTEMROOT );
}
print "BUILDIRS = @BUILDDIRS\n";
# call main
main();
# main function
sub main()
{
print "REPORTDIR = $REPORTDIR\n";
print "MAINLINEZIPDIR = $MAINLINEZIPDIR\n";
print "SUBSYSTEMROOT = $SUBSYSTEMROOT\n";
print "TESTCONFIGFILE = $TESTCONFIGFILE\n";
print "TECHVIEWROOT = $TECHVIEWROOT\n";
print "BUILDPLATFORM = $BUILDPLATFORM\n";
# Figure out the second-latest release if none had been specified on the
# command line - we do not want the latest in case it has not yet been released.
my $releasedir = "";
my $platformsuffix = "";
if ($BUILDPLATFORM)
{
$platformsuffix = "_$BUILDPLATFORM";
}
if (!$ARGS{"mainline"})
{
my $filelist = `dir $MAINLINEZIPDIR\\0????$platformsuffix /ad /b | sort /r`;
my @filearray = split "\n", $filelist;
$releasedir = $filearray[1];
}
else
{
$releasedir = "$ARGS{\"mainline\"}$platformsuffix";
}
# Display what's to be done
ReportToFiles("------ Script run on $DATEARRAY[1]/$DATEARRAY[2]/$DATEARRAY[3] with the following options\n");
ReportToFiles("------ Report directory: $REPORTDIR\n");
ReportToFiles("------ Subsystem root: $SUBSYSTEMROOT\n");
ReportToFiles("------ Test config file: $TESTCONFIGFILE\n");
ReportToFiles("------ Built against MCL platform: $BUILDPLATFORM\n");
if ($ARGS{s}) { ReportToFiles("------ Perforce synchronisation using client spec \"$P4CLIENTNAME\" on drive \"$ROOTDRIVE\"\n"); }
if ($ARGS{u}) { ReportToFiles("------ Mainline unzip using build $releasedir\n"); }
if ($ARGS{b}) { ReportToFiles("------ Build of production and test code\n"); }
if ($ARGS{t}) { ReportToFiles("------ Running of test code on the host using $TESTCONFIGFILE\n"); }
if ($ARGS{f}) { ReportToFiles("------ Build rom first\n"); }
if ($ARGS{t}) { ReportToFiles("------ Running of test code on the host using $TESTCONFIGFILE\n"); }
if ($ARGS{r})
{
ReportToFiles("------ Building of target roms: ");
map { ReportToFiles("$_ "); } @ROMPLATFORMS;
ReportToFiles("\n");
}
ReportToFiles("------ Host builds used: ");
map { ReportToFiles("$_ "); } @HOSTPLATFORMS;
ReportToFiles("\n------ Target processor builds used: ");
map { ReportToFiles("$_ "); } @TARGETPLATFORMS;
ReportToFiles("\n------ Build types used: ");
map { ReportToFiles("$_ "); } @BUILDTYPES;
ReportToFiles("\n\n");
# Do a perforce sync
if ($ARGS{s})
{
DoPerforceSync();
}
# Now unzip the mainline
if ($ARGS{u})
{
DoMainlineUnzip($releasedir);
}
# Build the post-processed config file if the test flag is on
if ($ARGS{t})
{
ParseTestConfigFile();
}
# Build the tools
if ($ARGS{o})
{
foreach my $bt (@BUILDTYPES)
{
DoBuildTools($bt);
}
}
# Build rom first?
if ( $ARGS{f} )
{
# Now build the target platforms - no testing required
if ($ARGS{b})
{
foreach my $platform (@TARGETPLATFORMS)
{
foreach my $bt (@BUILDTYPES)
{
# Must build dummy midp2installerclient for cedar
if ( $BUILDPLATFORM eq "cedar" )
{
my @tempbuilddirs = @BUILDDIRS;
@BUILDDIRS = ("$SUBSYSTEMROOT\\appinst\\tsrc");
print "Building dummy midp2installerclient....on $platform/$bt\n";
DoBuild($platform, $bt);
# now build the rest
@BUILDDIRS = @tempbuilddirs;
}
DoBuild($platform, $bt);
}
}
}
# Now build the roms if required
if ($ARGS{r})
{
DoBuildRoms();
}
}
# Build and test host platforms. They get built and then tested in order.
# This is required as the EPOC C drive is shared between udeb and urel.
# If the build/test is run together as a set, then the state of the C
# drive will be restored
foreach my $platform (@HOSTPLATFORMS)
{
foreach my $bt (@BUILDTYPES)
{
if ($ARGS{b})
{
DoBuild($platform, $bt);
}
if ($ARGS{t})
{
DoRunTests($platform, $bt);
}
}
}
# Now build the target platforms (unless this has been done in advance) - no testing required
if ( !$ARGS{f} )
{
if ($ARGS{b})
{
foreach my $platform (@TARGETPLATFORMS)
{
foreach my $bt (@BUILDTYPES)
{
# Must build dummy midp2installerclient for cedar
if ( $BUILDPLATFORM eq "cedar" )
{
my @tempbuilddirs = @BUILDDIRS;
@BUILDDIRS = ("$SUBSYSTEMROOT\\appinst\\tsrc");
print "Building dummy midp2installerclient....on $platform/$bt\n";
DoBuild($platform, $bt);
# now build the rest
@BUILDDIRS = @tempbuilddirs;
}
DoBuild($platform, $bt);
}
}
}
# Now build the roms if required
if ($ARGS{r})
{
DoBuildRoms();
}
}
my $timeoutput = `time /t`;
ReportToFiles("\n------------------- Job finished at $timeoutput\n\n");
}
sub ConfigureDefaultClient
{
# this subroutine figures out what default perforce client to use
my $clientoutput = `p4 client -o`;
if ($clientoutput =~ /\nClient:\s*([^\s]*)/ )
{
return $1;
}
}
sub GetRootDrive
{
# this subroutine derives the rootdrive from the perforce client
my $clientoutput = `p4 client -o`;
if ($clientoutput =~ /\nRoot:\s*(.):/ )
{
$ROOTDRIVE = "$1:"
}
}
sub ProcessCommandLine
{
use Getopt::Long;
&GetOptions (\%ARGS, "a", "h", "s", "u", "b", "t", "r", "o", "f", "client=s", "configfile=s", "workdir=s", "mainline=s", "subsystemroot=s", "nohost", "notgt", "platform=s", @HOSTPLATFORMS, @TARGETPLATFORMS, @ROMPLATFORMS, @BUILDTYPES);
# if the -a option is specified, this means that sync, unzip, build, run
# tests, and rom options should be set
if ($ARGS{a})
{
$ARGS{o} = $ARGS{s} = $ARGS{u} = $ARGS{b} = $ARGS{t} = $ARGS{r} = $ARGS{a};
}
# if the help option is specified, or none of the other arguments are specified,
# or both beech and cedar requested, then display the help
if ($ARGS{h} || (!$ARGS{s} && !$ARGS{u} && !$ARGS{b} && !$ARGS{t} && !$ARGS{r} && !$ARGS{o}))
{
print "Command line switches: \n";
print " -s Do perforce synchronisation\n";
print " -u Do unzipping from the mainline\n";
print " -b Build the appropriate targets\n";
print " -t Run the test suite\n";
print " -r Build the roms\n";
print " -o Build the tools\n";
print " -a Do all of the above\n";
print " -f Build rom First (before wins winscw)\n";
print " -h Display this screen\n";
print "\nOther options:\n";
print " --wins Use the wins platform for building and running of host tests\n";
print " --winscw Use the winscw platform for building and running of host tests\n";
print " --nohost Do not use any host platform\n";
print " --arm4 Use the arm4 processor for rom building\n";
print " --thumb Use the thumb processor for rom building\n";
print " --notgt Do not use any target platform\n";
print " --assabet Build roms for assabet platform\n";
print " --lubbock Build roms for lubbock platform\n";
print " --udeb Build udeb version only\n";
print " --urel Build urel version only\n";
print "\nParameters:\n";
print " --client=<client> Specifies the perforce client to use (default: $P4CLIENTNAME)\n";
print " --workdir=<dir> Specifies the working directory (default: $REPORTDIR)\n";
print " --subsystemroot=<dir> Specifies the root directory to build\n";
print " --configfile=<file> Specifies the test config file\n";
print " --mainline=<release number> Specifies the release number to use\n";
print " --platform=<platform name> Specifies MCL platform. Default is beech. Set to none for pre MCL builds\n";
print "\nExamples:\n";
print " perl -w RunTests.pl -b -t -r --wins --lubbock --thumb --platform=cedar --client=lon-julianl\n\n";
print " Uses drive m, client lon-julianl, build against cedar and builds and runs tests on the wins\n";
print " platform and builds roms for lubbock\n\n";
print " perl -w RunTests.pl -u -b --winscw --urel --notgt --mainline=01038\n\n";
print " Unzips mainline 01038_beech and builds only winscw/urel. Uses default client\n";
print " perl -w RunTests.pl -u -b --winscw --urel --notgt --platform=none --mainline=01038\n\n";
print " Unzips mainline 01038 and builds only winscw/urel. Uses default client\n";
exit(0);
}
# Now parse the client, drive, and working directory parameters
if ($ARGS{"client"})
{
$P4CLIENTNAME = $ARGS{"client"};
$ENV{"P4CLIENT"} = $P4CLIENTNAME;
}
if ($ARGS{"configfile"})
{
$TESTCONFIGFILE = $ARGS{"configfile"};
}
if ($ARGS{"workdir"})
{
$REPORTDIR = $ARGS{"workdir"};
}
if ($ARGS{"subsystemroot"})
{
$SUBSYSTEMROOT = $ARGS{"subsystemroot"};
}
use Getopt::Long;
# now parse the host options
if ($ARGS{"nohost"})
{
@HOSTPLATFORMS = ();
}
else
{
ParseArguments(\@HOSTPLATFORMS);
}
# now parse the target platforms
if ($ARGS{"notgt"})
{
@TARGETPLATFORMS = ();
}
else
{
ParseArguments(\@TARGETPLATFORMS);
}
# now parse the rom platforms and the build types
ParseArguments(\@ROMPLATFORMS);
ParseArguments(\@BUILDTYPES);
if ($ARGS{"platform"})
{
$BUILDPLATFORM=$ARGS{"platform"};
if ($BUILDPLATFORM eq "none")
{
# set compatibity for pre MCL builds
$BUILDPLATFORM="";
}
}
else
{
# default
$BUILDPLATFORM="beech";
}
}
sub ParseArguments
{
# common parsing of arguments in an array - returns another array
# which have the options specified.
# If none specified, it returns ALL the options.
#
# eg. If -wins specified, and options = ("wins", "winscw"), then
# return array is just ("wins"). If neither wins or winscw specified,
# then returns both
(my $options) = @_;
my @retoptions = ();
foreach my $opt (@$options)
{
if ($ARGS{$opt})
{
push(@retoptions, $opt);
}
}
# change if we have at least one option specified
if (scalar(@retoptions) > 0)
{
@$options = @retoptions;
}
}
# subroutine to do a perforce sync
sub DoPerforceSync
{
print "Doing a Perforce synchronisation....\n";
ExecAndOutputToLog("p4 sync -f $SUBSYSTEMROOT\\...");
if ( $TECHVIEWROOT )
{
ExecAndOutputToLog("p4 sync -f $TECHVIEWROOT\\...");
}
}
# subroutine to do the unzipping
sub DoMainlineUnzip
{
my ($dir) = @_;
print "Doing an unzip of mainline $MAINLINEZIPDIR\\$dir...\n";
my @zipfiles = ("techview");
# firstly, delete anything already there
ExecAndOutputToLog("del \/F \/S \/Q $EPOCROOT");
# unzip all the zipfiles
map { ExecAndOutputToLog("t:\\tools\\unzip -o $MAINLINEZIPDIR\\$dir\\zips\\$_.zip -d $ROOTDRIVE\\"); } @zipfiles;
}
# subrountine to build or clean release or test build
# call RunAbld("<Directory>", "<Command>", "<Target>", "test" or "")
sub RunAbld
{
my ($dir, $cmd, $target, $test, $bldtype) = @_;
chdir ($dir);
my $bldcommand = "abld $test $cmd -k $target $bldtype";
my $bldoutput = ExecAndOutputToLog($bldcommand);
if ($cmd eq "build")
{
# match "error:" or "error(s)" or fatal error
my @errout = grep(/(error(\(s\)|\:))|fatal error/i, split("\n", $bldoutput));
if (scalar(@errout) > 0)
{
print ERRFILE "-------- Errors found when running $bldcommand\n";
map { print ERRFILE "$_\n"; } @errout;
print ERRFILE "-------- End of errors for $bldcommand\n\n";
}
}
}
# builds the release and test code for a specified platform and mode
# eg WINS/UDEB
sub DoBuild
{
my ($platform, $bt) = @_;
RemoveWatchers($platform, $bt);
foreach my $bd (@BUILDDIRS)
{
chdir ($bd);
system("bldmake bldfiles");
print "Building build targets.... $bd on $platform/$bt\n";
ReportToFiles("\n------------------- Now building $bd on $platform/$bt\n\n");
RunAbld($bd, "clean", $platform, "", $bt);
RunAbld($bd, "clean", $platform, "test", $bt);
RunAbld($bd, "build", $platform, "", $bt);
RunAbld($bd, "build", $platform, "test", $bt);
}
}
# builds the tools for deb or rel
sub DoBuildTools
{
my ($bt) = @_;
#adjust for unicode
if ($bt eq "udeb")
{
$bt = "deb";
}
if ($bt eq "urel")
{
$bt = "rel";
}
foreach my $bd (@BUILDDIRS)
{
chdir ($bd);
system("bldmake bldfiles");
print "Building tools.... $bd on $bt\n";
ReportToFiles("\n------------------- Now building $bd for tools on $bt\n\n");
RunAbld($bd, "clean", "tools", "", $bt);
RunAbld($bd, "build", "tools", "", $bt);
}
}
# this subroutine executes the given command and outputs to the log file
sub ExecAndOutputToLog
{
my ($cmd) = @_;
my $timeoutput = `time /t`;
my $cmdoutput = `$cmd 2>&1`;
# capture output to log file
print LOGFILE "-------- Output of $cmd run at $timeoutput";
if ($cmdoutput)
{
print LOGFILE "$cmdoutput\n";
}
else
{
print LOGFILE "(NO OUTPUT)\n";
}
if ($? != 0)
{
print ERRFILE "\n-------- Error code $? returned when executing:\n";
print ERRFILE "-------- \"$cmd\".\n";
if ($cmdoutput)
{
print ERRFILE "-------- Output:\n";
print ERRFILE "$cmdoutput";
}
}
return $cmdoutput;
}
# this subroutine executes all the tests as specified in the configuration file.
# It will run the tests for the specified platform/built type
#
# The configuration file has the following valid commands:
#
# #include <filename> - includes another config file
# SYSTEMCMD <command and parameters> - executes a DOS command eg SYSTEMCMD copy a.txt b.txt
# DOTEST <testname> <scriptname> <logname> ... - executes a test
# COMP <filea> <fileb> - compares two files and logs result
#
# For SYSTEMCMD and COMP, the following variables get substituted
# - $C - the current EPOC C drive (eg o:\epoc32\wins\c)
# - $Z - the current EPOC Z drive (eg o:\epoc32\release\wins\udeb\z)
# - $RELEASE - the epoc release directory for this build (eg o:\epoc32\release\wins\udeb)
# - $EPOC - the epoc root (eg o:\epoc32)
# - $ROOT - the root drive (eg o:)
sub DoRunTests
{
# platform and build type
my ($p, $bt) = @_;
print "Running tests on platform $p/$bt\n";
ReportToFiles("\n------------------- Now running tests on platform $p/$bt\n\n");
# set the default directory to be the subsystem root
chdir($SUBSYSTEMROOT);
# Make the results directory
my $testlogs = "$RESULTDIR\\testlogs";
system("mkdir $testlogs");
system("mkdir $testlogs\\$p");
system("mkdir $testlogs\\$p\\$bt");
# open the post processed file
open (POSTFILE, "< $POSTPROCESSED") || die "error opening $POSTPROCESSED for reading";
# open a separate report file for test results
open (TESTREPFILE, "> $RESULTDIR\\testresults.$p.$bt.txt") || die "error opening for writing";
my $timeoutput = `time /t`;
print TESTREPFILE "-------- Test log file when running on platform $p/$bt at $timeoutput";
my $cdrive = "$EPOCROOT\\$p\\c";
while (<POSTFILE>)
{
my $line = $_;
# check for a line with SYSTEMCMD <command>
if ( $line =~ /^SYSTEMCMD[ ]+(.*)/ )
{
# Substitute $C for the cdrive, $Z for the zdrive, and $RELEASE
# for the release path, etc
my $cmd = $1;
SubstitutePaths($p, $bt, \$cmd);
print " - executing system command: $cmd\n";
ExecAndOutputToLog($cmd);
}
elsif ( $line =~ /^\s*$/ )
{
# if we have an empty line then do nothing
}
elsif ( $line =~ /^DOTEST\s+([^\s]+)[\s]+([^\s]+)[\s]+([^\s]+)/ )
{
# if this pattern matches DOTEST <cmd> <scriptfile> <logfile>,
# then we execute this test - extra parameters can be supplied after the logfile
print " - running test: $1 $2 $3\n";
ExecAndOutputToLog("$EPOCROOT\\release\\$p\\$bt\\$1 $2 $3 $'");
# log files are assumed to be stored in \epoc32\wins\c
my $outfile = "$cdrive\\$3";
print TESTREPFILE "\n---- Result of test \"$1 $2 $3\"\n";
if (-e $outfile)
{
# also, copy the log file into the results dir
copy ($outfile, "$testlogs\\$p\\$bt\\$3");
# check to see if there is a failure
my $output = `type $outfile`;
if ($output =~ /(\d+) tests failed out of (\d+)/)
{
print TESTREPFILE " $1 tests failed out of $2\n";
if ($1 ne "0")
{
# if there is a fail, then print it in the test log
print ERRFILE "-------- Logfile $outfile produced a failure result!\n";
print ERRFILE "$output\n";
print TESTREPFILE " There was a test FAILURE\n";
}
else
{
print TESTREPFILE " All tests SUCCEEDED\n";
}
}
else
{
# if it doesn't conform to standard format, then need to notify
print TESTREPFILE " WARNING: non-standard log file format - check log\n";
}
}
else
{
# if we get here, the output file didn't exist
print ERRFILE "-------- Logfile $outfile does not exist - did $1 fail to build?\n";
print TESTREPFILE " ERROR! Log file $outfile does not exist\n";
}
}
elsif ( $line =~ /^COMP\s+([^\s]+)[\s]+([^\s]+)/ )
{
# Parse our paths
my $file1 = $1;
my $file2 = $2;
# substitute variables
SubstitutePaths($p, $bt, \$file1);
SubstitutePaths($p, $bt, \$file2);
print " - doing comparison on $file1 and $file2\n";
print TESTREPFILE "\n---- Comparing $file1 and $file2\n";
my $output = ExecAndOutputToLog("diff -q $file1 $file2");
if ( $output =~ /differ/ )
{
print TESTREPFILE " Comparison FAILED\n";
}
else
{
print TESTREPFILE " Comparison SUCCESSFUL\n";
}
}
else
{
ReportToFiles("**** Error test config line: $line");
}
}
close (POSTFILE);
close (TESTREPFILE);
}
# - $C - the current EPOC C drive (eg o:\epoc32\wins\c)
# - $Z - the current EPOC Z drive (eg o:\epoc32\release\wins\udeb\z)
# - $RELEASE - the epoc release directory for this build (eg o:\epoc32\release\wins\udeb)
# - $EPOC - the epoc root (eg o:\epoc32)
# - $ROOT - the root drive (eg o:)
# - $SUBSYSROOT - subsystem root e.g. security
sub SubstitutePaths
{
my ($platform, $buildtype, $cmdref) = @_;
my $cdrive = "$EPOCROOT\\$platform\\c";
my $releasedir = "$EPOCROOT\\release\\$platform\\$buildtype";
my $zdrive = "$releasedir\\z";
${$cmdref} =~ s/\$C/$cdrive/g;
${$cmdref} =~ s/\$Z/$zdrive/g;
${$cmdref} =~ s/\$RELEASE/$releasedir/g;
${$cmdref} =~ s/\$EPOC/$EPOCROOT/g;
${$cmdref} =~ s/\$ROOT/$ROOTDRIVE/g;
${$cmdref} =~ s/\$SUBSYSROOT/$RELSUBSYSROOT/g;
}
# This subroutine acts as a preprocessor for a config file. It
# expands the test config file and produced a file in POSTPROCESSED
sub ParseTestConfigFile
{
use File::Copy;
# Firstly, copy the configuration file into the postprocessed file
copy($TESTCONFIGFILE, $POSTPROCESSED);
# set up boolean to indicate if preprocessing of #include is done
my $keepgoing = "1";
while ($keepgoing)
{
# reset the keepgoing flag
$keepgoing = "";
# if we have to keep going, copy the postprocessed file into a temp
my $tempfile = "$RESULTDIR\\temp.txt";
move ($POSTPROCESSED, $tempfile);
open (TEMPFILE, "< $tempfile") || die "error opening $tempfile for reading";
open (POSTFILE, "> $POSTPROCESSED") || die "error opening $POSTPROCESSED for writing";
# Now search the temp file for instances of #include
while (<TEMPFILE>)
{
my $line = $_;
# check for comments - use C++ style //
if ( $line =~ /(.*)\/\/.*/ )
{
# set the keepgoing flag
$keepgoing = "1";
print POSTFILE "$1\n";
}
elsif ( $line =~ /\#include[ ]+\"([^\"]*)\"/ )
{
# set the keepgoing flag because a #include has been found
$keepgoing = "1";
# now write the entire contents of this file into the
# the postprocessed file
my $contents = `type $SUBSYSTEMROOT\\$1`;
print POSTFILE "$contents\n";
}
elsif ( $line =~ /^\s*$/ )
{
# remove if we have only whitespaces
}
else
{
print POSTFILE $line;
}
}
close (TEMPFILE);
close (POSTFILE);
# delete the temp file
unlink($tempfile);
}
}
sub ReportToFiles
{
# this function just prints a string to both the log file and the error file
my ($str) = @_;
print LOGFILE $str;
print ERRFILE $str;
}
sub DoBuildRoms
{
ReportToFiles("\n------------------- Now building roms\n\n");
chdir ("$EPOCROOT\\rom");
# create a new directory for the roms
my $romdir = "$RESULTDIR\\roms";
system("mkdir \"$romdir\"");
# define the oby file to use
my $oby_file = "techview.oby";
# firstly, make sure the SecurityTests.iby file has been included from the techview.oby
if (open(OBY, ">> include\\$oby_file"))
{
print OBY "\n#include <SecurityTests.iby>\n";
close(OBY);
}
# Now go through the list of rom targets and build
foreach my $rom (@ROMPLATFORMS)
{
ExecAndOutputToLog("tools\\buildrom -D__NOWATCHER__ -o$romdir\\$rom.img $rom $oby_file");
}
}
sub SetVariable
{
# Sets a variable from an environment variable or a default value if the
# environment variable has not been set
my ($variable, $env_name, $default) = @_;
${$variable} = $ENV{$env_name};
if (!${$variable})
{
${$variable} = $default;
}
}
# remove the watchers (prevents connection intermittently to NTRas)
sub RemoveWatchers
{
my ($platform, $bt) = @_;
ReportToFiles("------------------- Removing watchers\n");
if ( ($platform eq "wins") or ($platform eq "winscw") )
{
# emulator build, delete the dlls for beech and exes for cedar
system("del $EPOCROOT\\release\\$platform\\$bt\\watcher.dll");
system("del $EPOCROOT\\release\\$platform\\$bt\\z\\system\\libs\\watcher.dll");
system("del $EPOCROOT\\release\\$platform\\$bt\\watcher.exe");
system("del $EPOCROOT\\release\\$platform\\$bt\\z\\system\\libs\\watcher.exe");
}
else
{
# hardware. remove the watchers from startup script
if ( $TECHVIEWROOT )
{
system("attrib -r $TECHVIEWROOT\\toolkit\\startup\\group\\start.rss");
system("copy $SUBSYSTEMROOT\\testframework\\test\\autotesting\\startnowatchers.rss $TECHVIEWROOT\\toolkit\\startup\\group\\start.rss");
}
}
}