# Copyright (c) 2003-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:

#

use strict;

use Env qw(EPOCROOT);

# literals

my $icl_param  =  "-i";

my $misc_param =  "-c";

my $mmf_param  =  "-m";

my $all_param  =  "-f";

my $test_param =  "-t";

my $testBuild_param = "-b";

my $extra_param = "-x";

my $keep_param =  "-k";

my $gccxml_param = "-g";

my $skipMake_param = "-s";

my $setup_comm = "setup";

my $clean_comm = "clean";

my $build_comm = "build";

my @known_targets = ("wins", "winscw", "arm4", "armi","armv5", "gccxml", "thumb", "mcot", "misa", "mint");

my @Cedar_targets = ("winscw", "armv5");    # gccxml must be added explicitly with -g and even then only build gccxml on main code

my @Beech_targets = ("wins", "winscw", "thumb", "mcot");

my @default_targets = @Cedar_targets;

my @physical_targets = ("mcot", "misa", "mint"); # those we just re-build sound drivers for

my $gccxml_target = "gccxml";

my $x86gcc_target = "x86gcc";

my @stages = ("export", "makefile", "library", "resource", "target", "final");

my @tbstages = ("test export", "test makefile", "test library", "test resource", "test target", "test final");

my @stagesTakingTarget = ("makefile", "library", "resource", "target", "final",

                          "test makefile", "test library", "test resource", "test target", "test final");

my $eka2IdentifyFile  = "$ENV{EPOCROOT}epoc32\\release\\winscw\\udeb\\winsgui.dll"; # if file present, is EKA2 build

my $x86gccIdentifyFile  = "$ENV{EPOCROOT}epoc32\\release\\x86gcc\\udeb\\euser.dll"; # if dir present, x86 environment present

my @targets;

my $component = ""; # default added later

my $extras = "";

my $test = "";

my $testBuild = "";

my $command = "";

my $keep = "";

my $use_gccxml = "";

my $skipMake = "";

my $main_mbc = "__main.mbc";

my $test_mbc = "__test.mbc";

my $testBuild_mbc = "__testBuild.mbc";

my $phys_mbc = "__phys.mbc";

my $metabld = "metabld";

my $targetToolsDir = "..\\..\\..\\..\\..\\TargetTools\\Build";

my $TargetToolsExists = 0;

if (-d $targetToolsDir)

	{

	$TargetToolsExists = 1;

	print "TargetTools directory exists: $targetToolsDir\n"

	}

# main:

	{

	# Process command-line

	unless (@ARGV)

		{

		&Usage();

		}

	&ReadArgs();

	die "EPOCROOT is not set" unless ($EPOCROOT ne "");

	$| = 1; # autoflush stdout.

	if ($command eq $setup_comm)

		{

		&Setup();

		}

	elsif ($command eq $clean_comm)

		{

		&Clean();

		}

	elsif ($command eq $build_comm)

		{

		&Build();

		}

	else

		{

		die "Unknown command";

		}

	exit 0;

	}

#

# Subroutines

#

sub ReadArgs()

	{

	while (@ARGV)

		{

		my $param = @ARGV[0]; shift @ARGV; # grab first param and shift along

		if ($param eq "") # ignore blank parameters

			{

			next;

			}

		if ($param eq $icl_param || $param eq $misc_param ||

		    $param eq $mmf_param || $param eq $all_param)

			{

			$component = $param;

			}

		elsif ($param eq $test_param)

			{

			$test = $param;

			}

		elsif ($param eq $testBuild_param)

			{

			$testBuild = $param;

			}

		elsif ($param eq $extra_param)

			{

			$extras = $param;

			}

		elsif ($param eq $keep_param)

			{

			$keep = $param;

			}

		elsif ($param eq $gccxml_param)

			{

			$use_gccxml = $param;

			}

		elsif ($param eq $skipMake_param)

			{

			$skipMake = $param;

			}

		elsif ($param eq $setup_comm || $param eq $clean_comm ||

		       $param eq $build_comm)

			{

			if ($command ne "")

				{

				&Usage; # scream if we try to state more than one command

				}

			$command = $param;

			}

		elsif ($command eq $build_comm)

			{

			# see if the parameter is one of the list of arguments

			my $match = 0;

			foreach my $target (@known_targets)

				{

				if ($target eq $param)

					{

					$match = 1;

					last; # exit loop

					}

				}

			if ($match != 0)

				{

				$targets[++$#targets] = $param; # append

				}

			else

				{

				# was not a valid target

				Usage();

				}

			}

		else

			{

			# unknown setting

			&Usage();

			}

		}

	&CheckArgs();

	}

sub CheckArgs()

	{

	# check that the arguments make sense

	if ($command eq $clean_comm || $command eq $build_comm)

		{

		# for build and cleanup, can't set the required module

		if ($component ne "" || $extras ne "")

			{

			&Usage;

			}

		}

	# for setup, check -t has not been given

	if ($command eq $setup_comm)

		{

		if ($test ne "")

			{

			&Usage;

			}

		}

	if ($command eq "")

		{

		# need to state some command

		&Usage;

		}

	}

sub Setup

	{

	# default settings

	if ($component eq "")

		{

		$component = $all_param;

		}

	# some boolean values

	my $want_mmf = $component eq $mmf_param | $component eq $all_param;

	my $want_icl = $component eq $icl_param | $component eq $all_param;

	my $want_misc = $component eq $misc_param | $component eq $all_param;

	my $want_extra = $extras ne "";

	# generate .mbc files and then do bldmake

	open(OUTFILE, ">".$main_mbc) or die "Can't create file: $!";

	print OUTFILE "//\n//Auto-generated - do not edit!!\n//\n\n";

	print OUTFILE "#include \"mmf.mbc\"\n" if ($want_mmf);

	print OUTFILE "#include \"icl.mbc\"\n" if ($want_icl);

	print OUTFILE "#include \"Misc.mbc\"\n" if ($want_misc);

	print OUTFILE "#include \"mmfOpt.mbc\"\n" if ($want_mmf && $want_extra);

	print OUTFILE "#include \"iclOpt.mbc\"\n" if ($want_icl && $want_extra);

	print OUTFILE "#include \"MiscOpt.mbc\"\n" if ($want_misc && $want_extra);

	close OUTFILE;

	if ($want_mmf)

		{

		open(OUTFILE, ">".$phys_mbc) or die "Can't create file: $!";

		print OUTFILE "//\n//Auto-generated - do not edit!!\n//\n\n";

		print OUTFILE "#include \"mmfPhys.mbc\"\n";

		print OUTFILE "#include \"mmfOptPhys.mbc\"\n" if ($want_extra);

		close OUTFILE;

		}

	else

		{

		# only applicable for mmf - otherwise just delete the file

		if (-f $phys_mbc)

			{

			unlink $phys_mbc or die "Couldn't delete $phys_mbc";

			}

		}

	open(OUTFILE, ">".$test_mbc) or die "Can't create file: $!";

	print OUTFILE "//\n//Auto-generated - do not edit!!\n//\n\n";

	print OUTFILE "#include \"AllTests.mbc\"\n";

	print OUTFILE "#include \"TestFrameworkTest.mbc\"\n";

	print OUTFILE "#include \"mmfTest.mbc\"\n" if ($want_mmf);

	print OUTFILE "#include \"mmfNotOptTest.mbc\"\n" if ($want_mmf && !$want_extra);

	print OUTFILE "#include \"iclTest.mbc\"\n" if ($want_icl);

	print OUTFILE "#include \"MiscTest.mbc\"\n" if ($want_misc);

	print OUTFILE "#include \"mmfOptTest.mbc\"\n" if ($want_mmf && $want_extra);

	print OUTFILE "#include \"iclOptTest.mbc\"\n" if ($want_icl && $want_extra);

	print OUTFILE "#include \"MiscOptTest.mbc\"\n" if ($want_misc && $want_extra);

	if ($TargetToolsExists)

		{

		print OUTFILE "#include \"TargetTools.mbc\"\n";

		}

	close OUTFILE;

	open(OUTFILE, ">".$testBuild_mbc) or die "Can't create file: $!";

	print OUTFILE "//\n//Auto-generated - do not edit!!\n//\n\n";

	print OUTFILE "#include \"mmfTestBuild.mbc\"\n" if ($want_mmf);

	print OUTFILE "#include \"iclTestBuild.mbc\"\n" if ($want_icl);

	print OUTFILE "#include \"MiscTestBuild.mbc\"\n" if ($want_misc);

	print OUTFILE "#include \"mmfOptTestBuild.mbc\"\n" if ($want_mmf && $want_extra);

	print OUTFILE "#include \"iclOptTestBuild.mbc\"\n" if ($want_icl && $want_extra);

	print OUTFILE "#include \"MiscOptTestBuild.mbc\"\n" if ($want_misc && $want_extra);

	close OUTFILE;

	# first getmake does bldmake on the main entries

	my $sysComm = $metabld . " " . $main_mbc . " bldmake " . $keep . " bldfiles";

	my $result = system($sysComm);

	if ($result != 0 && $keep eq "")

		{

		print "Error '$sysComm' failed: $result\n";

		exit ($result);

		}

	my $error = $result;

	# second metabld goes through physical

	if (-f $phys_mbc)

		{

		$sysComm = $metabld . " " . $phys_mbc . " bldmake " . $keep . " bldfiles";

		$result = system($sysComm);

		if ($result != 0 && $keep eq "")

			{

			print "Error '$sysComm' failed: $result\n";

			exit ($result);

			}

		$error |= $result;

		}

	# third metabld goes through tests

	$sysComm = $metabld . " " . $test_mbc . " bldmake " . $keep . " bldfiles";

	$result = system($sysComm);

	if ($result != 0 && $keep eq "")

		{

		print "Error '$sysComm' failed: $result\n";

		exit ($result);

		}

	$error |= $result;

	# fourth metabld goes through test build tests - ignore any dups with the above. Does not make any difference

	$sysComm = $metabld . " " . $testBuild_mbc . " bldmake " . $keep . " bldfiles";

	$result = system($sysComm);

	if ($result != 0 && $keep eq "")

		{

		print "Error '$sysComm' failed: $result\n";

		exit ($result);

		}

	$error |= $result;

	if ($error)

		{

  		print "Errors found during run\n";

		exit ($error)

		}

	}

sub Clean

	{

	# first getmake does makefiles on the main entries

	# note we generally ignore any errors on this

	my $sysComm = $metabld . " " . $main_mbc . " abld " . $keep . " makefile";

	system($sysComm);

	if (-f $phys_mbc)

		{

		my $sysComm = $metabld . " " . $phys_mbc . " abld " . $keep . " makefile";

		system($sysComm);

		}

	if ($test eq $test_param)

		{

		# also do for test files

		$sysComm = $metabld . " " . $test_mbc . " abld " . $keep . " makefile";

		system($sysComm);

		$sysComm = $metabld . " " . $testBuild_mbc . " abld " . $keep . " test makefile";

		system($sysComm);

		}

	my $sysComm = $metabld . " " . $main_mbc . " abld " . $keep . " reallyclean";

	system($sysComm);

	if (-f $phys_mbc)

		{

		my $sysComm = $metabld . " " . $phys_mbc . " abld " . $keep . " reallyclean";

		system($sysComm);

		}

	if ($test eq $test_param)

		{

		# also do for test file

		$sysComm = $metabld . " " . $test_mbc . " abld " . $keep . " reallyclean";

		system($sysComm);

		$sysComm = $metabld . " " . $testBuild_mbc . " abld " . $keep . " test reallyclean";

		system($sysComm);

		}

	}

sub Build

	{

	# defaults

	if (!(-f $eka2IdentifyFile)) 

	    {

		@default_targets = @Beech_targets;

	    }

	if (@targets == 0)

		{

		@targets = @default_targets;

		}

	if ($use_gccxml ne "")

		{

		$targets[++$#targets] = $gccxml_target; # append		

		}

	if ((-f $x86gccIdentifyFile)) 

	        {

		$targets[++$#targets] = $x86gcc_target; # append x86gcc target since Build env present.

		}	

	# for each target we need to go through each stage

	# if -k was given, we make all calls and give error at the end

	my $error = 0;

	foreach my $target (@targets)

		{

		# work out which .mbc files to use. Key is as follows

		#    in physical targets and not test, __test.mbc

		#    in physical targets and test, skip - not currently supported

		#    not in physical targets and not test, __main.mbc

		#    not in physical targets and test, __test.mbc

		my $build_test = $test ne ""; # -t has been given

		my $build_testBuild = $test ne "" && $testBuild ne ""; # -t and -b has been given

		my $physical_target = 0;

		foreach my $phys (@physical_targets)

			{

			if ($phys eq $target)

				{

				$physical_target = 1;

				last; # exit loop

				}

			}

		my $mbc;

		if ($physical_target && !$test)

			{

			if (-f $phys_mbc)

				{

				$mbc = $phys_mbc;

				}

			else

				{

				# we don't want to do anything - skip to next target

				next; 

				}

			}

		elsif ($physical_target && $test)

			{

			next; # skip to next target

			}

		elsif (($target eq "gccxml") && $test) # Build GCCXML on the production code only

			{

			next; # skip to next target

			}

		elsif (!$physical_target && !$test)

			{

			$mbc = $main_mbc;

			}		

		elsif ($test ne "")

			{

			if (!$testBuild)

				{

				$mbc = $test_mbc;

				}

			else

				{

				$mbc = $testBuild_mbc;

				}

			}

		# if the target is "wins", then check to see if wins is installed and otherwise just do export

		# this is intended to get around Cedar builds not having wins. Really out to check for VC++ too,

		# but not clear how

		my @reqStages = @stages;

		@reqStages = @tbstages if $build_testBuild;

		if ($target eq "wins")

			{

			my $euser_lib = $EPOCROOT . "epoc32\\release\\wins\\udeb\\euser.lib";

			if (! -f $euser_lib)

				{

				print "no WINS installation found - just export\n";

				@reqStages = ( "export" );

				}

			}

		# now the main loop

		foreach my $stage (@reqStages)

			{

			# export does not take target as parameter, others do

			my $takesTarget = 0;

			foreach my $stage2 (@stagesTakingTarget)

				{

				if ($stage eq $stage2)

					{

					$takesTarget = 1;

					last; # exit loop

					}

				}

			if (($stage eq "makefile" || $stage eq "test makefile") && $skipMake ne "")

				{

				print "Skip makefile\n"; 

				next; # skip the makefile stage

				}

			# the command - metabld xxx.mbc command

			my $sysComm = $metabld . " " . $mbc .

			    " abld " . $keep . " " . $stage;

			if ($takesTarget)

				{

				$sysComm .= " " . $target;

				}

			my $result = system($sysComm);

			if ($result != 0)

				{

				if ($keep ne "")

					{

					# remember error and keep going

					$error |= $result;

					}

				else

					{

					print "Error '$sysComm' failed: $result\n";

					exit ($result);

					}

				}

			}

		}

	if ($error)

		{

  		print "Errors found during run\n";

		exit ($error)

		}

	}

sub Usage

	{

	# print usage statement and exit

	print <<ENDHERESTRING;

usage:

	mmbuild {-i|-e|-m|-f} [-x] [-k] setup

	mmbuild [-t] [-k] clean

	mmbuild [-t [-b]] [-k] [-g] [-s] build [targets]

mmbuild is intended to do a full build of the Multimedia source area, both for

use in test builds and by team engineers. The effect will be similar to that

achieved for overnight builds, although the mechanism is slight different.

In typical usage, the various forms of the command - as given above - are used

in turn. "setup" equates roughly to "bldmake bldfiles". It is called to setup

the various files prior to the build proper. The parameters are as follows:

-i) Build ICL only

-m) Build MMF only

-c) Build Misc only (other than ICL or MMF)

-f) Build all Multimedia components (default)

-x) Additionally build any optional components - default is non-optional only

"clean" effectively does a reallyclean operation.

-t) Clean test code, *as well as* main code - default is to clean main code only

"build" does a build operation. Optional parameters give the target list - the

default is "wins", "winscw", "arm4" and "mcot". For physical targets, like mcot,

only the SoundDev mmf folder is built.

-t) Build test code (including testframework), *instead of* main code - default

is to build main code only

-t) Build test code (including testframework), *instead of* main code 

    Note: without -b this is test code built via "abld build"

-b) When given with -t, build test code that is built via "abld test build"

-g) Build code additionally for gccxml. Null operation when used with -t. 

-s) Skip the make stage. Use with care - should not be used if any include, 

source list or library list have been changed, and never on the first time 

called. However, it can save time on a subsequent call.

A typical usage sequence would be:

	mmbuild setup

	mmbuild -t clean

	mmbuild build

	mmbuild -t build

	mmbuild -t -b build

which would do a reallyclean and rebuild of the whole Multimedia sub-system,

except the mcot sound drivers on EKA1.

For each command, the -k flag will try and keep going as much as possible -

setup and build, by default, will stop with the first error.

ENDHERESTRING

	exit 1;

	}