# 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;

 	}