#!perl -w

# baserom

# 

# Copyright (c) 2009 - 2010 Accenture. All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the "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:

# Accenture - Initial contribution

#

use strict;

use Cwd;

use Getopt::Long;

use File::Path;

#fwd decls for functions.

sub CreateNewObeyFile();

sub ProcessCommandLine();

sub Usage();

sub ConvertIbyLine($);

sub FindMissingDeps($);

sub ResolveMissingDeps($);

sub FindIby($);

sub CheckIbyContains($$);

sub headerInfo($);

sub trim($);

sub Query($$);

sub makeFullFileName($);

# globals

my $verbose = 0;

my $help;

my $epocroot = $ENV{"epocroot"};

my $tempDir = $ENV{"temp"};

my $romIncludeDir;

my $obyName;

my $obyPath;

my $baseObeyFile = "tshell.oby";

my $main = "armv5";

my $build = "udeb";

my $variant = "h4hrp";

my $extraInclude = undef;

my %ignoreDeps = ('scppnwdl.dll' => 1, 'drtaeabi.dll' => 1, 'drtrvct2_2.dll' => 1, 'dfpaeabi.dll' => 1, 'dfprvct2_2.dll' => 1);

ProcessCommandLine();

my $newObyFile;

my $missingCount;

my $continue;

do {

  $continue = 0;

  $newObyFile = CreateNewObeyFile();

  my $missingFiles = FindMissingDeps($newObyFile);

  $missingCount = scalar(@$missingFiles);

  if ($missingCount) {

    #print "$missingCount missing dependancies:\n";

    #foreach my $dep (@$missingFiles) {

    #	if (defined $dep->[1]) {

    #		print "$dep->[0] UID3: $dep->[1]\n";

    #	} else {

    #		print "$dep->[0]\n";

    #	}

    #}

    if (Query("\nThere are $missingCount missing dependancies; resolve them now?", "yn")==0) {

    	ResolveMissingDeps($missingFiles);

    	$continue = 1;

    } else {

    	$newObyFile = CreateNewObeyFile();

    }

  }

} while ($missingCount && $continue);

print "New OBY file: $newObyFile\n\n";

print "To build a ROM:\n";

print "rom --type tshell_$obyName --inst $main --build $build --variant $variant\n";

exit(0);

sub ProcessCommandLine() {

	Getopt::Long::Configure ("bundling");

	GetOptions( 'h' => \$help, 

	            'v+' => \$verbose, 

	            'e=s' => \$epocroot, 

	            'i=s' => \$romIncludeDir, 

				'x=s' => \$extraInclude,

	            'o=s' => \$baseObeyFile, 

	            'V=s' => \$variant,

	            't=s' => \$main,

	            'b=s' => \$build);

	Usage() if ($help);

	$epocroot = "$epocroot\\" unless $epocroot =~ m/\\$/;

	my ($drive) = (getcwd =~ m/^(\w)\:/);

	die "Can't get current drive\n" unless $drive;

	$epocroot = "$drive:$epocroot";

	print "Using epocroot $epocroot\n" if ($verbose);

	($romIncludeDir = "epoc32\\rom\\include") unless ($romIncludeDir);

	$romIncludeDir =~ s/\\$//; # remove trailing \ if it exists

	$romIncludeDir = "$epocroot$romIncludeDir";

	print "Using include directory $romIncludeDir\n" if ($verbose);

	unless (scalar (@ARGV) == 1) {

		print "Inavlid arguments\n";

		Usage();

		}

	$obyPath = $ARGV[0];

	if ($obyPath =~ m/.*[\\\/]([^.]+)\..*/i) {

		$obyName = $1;

	} else {

		$obyName = $obyPath;

	}

	die "ERROR: Build must be either 'udeb' or 'urel'\n" unless ($build =~ m/(udeb)|(urel)/i);

	print "Using variant $variant, build $main $build\n";

}

sub CreateNewObeyFile() {

	unless (-d $obyName) {

		mkdir $obyName or die "Can't create dir $obyName: $!\n";

	}

	open OBEY, "<$obyPath" or die "Can't open $obyPath: $!\n";

	my %ibysProcessed;

	my @ibyStack;

	my $obyBaseName;

	if ($baseObeyFile =~ m/(.*)\.oby/i) {

		$obyBaseName = $1;

	} else {

		$obyBaseName = "tshell";

	}

	my $newObyName = "${obyBaseName}_$obyName.oby";

	open TSHELL_OBY, "<$baseObeyFile" or die "Can't open $baseObeyFile: $!\n";

	open TSHELL_NEW, ">$newObyName" or die "Can't write to $newObyName: $!\n";

	print "Creating tshell_$obyName.oby\n";

	if ($extraInclude) {

		print TSHELL_NEW "#include \"$obyName/$extraInclude\"\n";

	}

	while (my $line = <TSHELL_OBY>) {

		print TSHELL_NEW "$line";

	}

	close (TSHELL_OBY);

	while (my $line = <OBEY>) {

		chomp $line;

		if ($line =~ m/^#include\s+[<"](.*)[>"]/ ) {

			my $iby = $1;

			if (!$ibysProcessed{lc($iby)}) {

				print "Adding $iby to stack\n" if ($verbose);

				push @ibyStack, $iby;

				$ibysProcessed{lc($iby)} = 1;

				}

			print TSHELL_NEW "#include \"$obyName\\$iby\"\n";

			next;

		} else {

			print TSHELL_NEW ConvertIbyLine("$line");

			print TSHELL_NEW "\n";

		}

	}

	close TSHELL_NEW;

	while (my $iby = pop(@ibyStack)) {

		print "Processing $iby\n" if ($verbose);

		my $fullIby = "$romIncludeDir\\$iby";

		unless (-f $fullIby) {

			warn "$fullIby does not exist\n" ;

			next;

		}

		my $fixedIby = $iby;

		$fixedIby =~ s|^(\.\.[\\/])*||; # get rid of ..\ at path start

		$fixedIby =~ s|^[\\/]||; # remove \ at start too

		my ($ibyPath, $ibyFile) = ($fixedIby =~ m|^((?:.*[\\/])?)(.*)$|);

		if (($ibyPath) && (!-d "$obyName\\$ibyPath")) {

			$ibyPath =~ s|[\\/]$||;

			mkpath("$obyName\\$ibyPath") or die "Can't create path $obyName\\$ibyPath: $!\n";

			$ibyPath .= "/";

		}

		my $newIby = "$obyName\\$ibyPath$ibyFile";

		#BEGIN TOMSCI

		# For the purposes of finding #includes, we run $fulliby through CPP first so that we don't pick up includes that are #ifdef'd out

		# To prevent the #includes being expanded, we have to change them in the file we run cpp over.

		open IBY, "<$fullIby" or die "Can't open $fullIby: $!\n";		

		open NOINCLUDEIBY, ">$newIby.noinclude" or die "Can't open $newIby.noinclude: $!\n";

		while (my $line = <IBY>) {

			$line =~ s/#include/BASEROMHASHINCLUDE/;

			print NOINCLUDEIBY $line;

		}

		close IBY;

		close NOINCLUDEIBY;

		my $cppOpts = "-undef -traditional -lang-c++ -nostdinc -I . -I $romIncludeDir";

		if ($extraInclude) {

			if (!($newIby =~ /$extraInclude$/)) { # Make sure we don't include the extraInclude in itself

				$cppOpts .= " -include $romIncludeDir\\$extraInclude";

			}

		}

		my $cmd .= "cpp $cppOpts $newIby.noinclude";

		print "running: $cmd\n" if ($verbose);

		open IBYCPP, "$cmd |" or die "Can't run '$cmd': $!\n";

		while (my $line = <IBYCPP>) {

			chomp $line;

			if ($line =~ m/^BASEROMHASHINCLUDE\s+[<"](.*)[>"]/ ) {

				my $iby = $1;

				if (!$ibysProcessed{lc($iby)}) {

					print "Adding $iby to stack\n" if ($verbose);

					push @ibyStack, $iby;

					$ibysProcessed{lc($iby)} = 1;

				}

			}

		}

		close IBYCPP;

		#END TOMSCI

		open IBY, "<$fullIby" or die "Can't open $fullIby: $!\n";		

		open NEWIBY, ">$newIby" or die "Can't open $newIby: $!\n";

		print "Creating $newIby\n" if ($verbose);

		while (my $line = <IBY>) {

			chomp $line;

			if ($line =~ m/^#include\s+[<"](.*)[>"]/ ) {

				my $iby = $1;

				#if (!$ibysProcessed{lc($iby)}) {

				#	print "Adding $iby to stack\n" if ($verbose);

				#	push @ibyStack, $iby;

				#	$ibysProcessed{lc($iby)} = 1;

				#	}

				print NEWIBY "#include \"$iby\"\n";

				next;

			} else {

				print NEWIBY ConvertIbyLine("$line");

				print NEWIBY "\n";

			}

		}

		close IBY;

		close NEWIBY;

	}

	return $newObyName;

}

sub ConvertIbyLine($) {

	my $line = shift;

	if ($line =~ m/^\s*\w*ECOM_PLUGIN(?:_UDEB)?\s*\(\s*(.*?)\s*,\s*(.*?)\s*\)\s*$/ ) {

		my $dll = $1;

		my $rsc = $2;

		my ($dllName) = $dll =~ m/^(.*?)\./;

		$rsc =~ s/[A-Fa-f0-9]{8}\.rs[cs]/$dllName.rsc/; # Some broken IBYs specify .rss instead of .rsc

		return "file=\\epoc32\\release\\##MAIN\\##BUILD##\\$dll\t\"sys\\bin\\$dll\"\n".

				"data=\\epoc32\\data\\Z\\resource\\Plugins\\$rsc\t\"resource\\plugins\\$rsc\"";

	}

	if ($line =~ m|\\ABI_DIR\\|) {

		$line =~ s|\\ABI_DIR\\|\\epoc32\\release\\##MAIN##\\|;

	} else {

		$line =~ s|ABI_DIR\\|\\epoc32\\release\\##MAIN##\\|;

	}

	$line =~ s|\\BUILD_DIR\\|\\##BUILD##\\|;

	$line =~ s|\\DEBUG_DIR\\|\\##BUILD##\\|;

	$line =~ s|\\USB_DIR\\|\\##BUILD##\\|;

	$line =~ s|ZRESOURCE\\|\\epoc32\\data\\Z\\resource\\|;

	$line =~ s|ZPRIVATE\\|\\epoc32\\data\\Z\\private\\|;

	$line =~ s|ZSYSTEM\\|\\epoc32\\data\\Z\\system\\|;

	$line =~ s|DATAZ_\\|\\epoc32\\data\\Z\\|;

	if ($line =~ m|MULTI_LINGUIFY\s*\(\s*RSC\s+(.*?)\s+(.*?)\s*\)|) {

		my $localRsc = $1;

		my $romRsc = $2;

		my @resources = <$epocroot$localRsc.R*>;

		if (scalar(@resources)) {

			$localRsc = $resources[0];

			my $er = $epocroot;

			$er =~ s/\\/\\\\/g;

			$localRsc =~ s|$er|\\|;

			#print "FOUND: $localRsc\n";

		} else {

			print "WARNING: resource for $romRsc could not be found\n";

			$localRsc .= ".RSC";

		}

		$line = "data=$localRsc\t\"$romRsc.RSC\"";

	}

	if ($line =~ m|^#\s*include (["^])(.*?)([">])(.*)$|) {

		my ($firstQuote, $include, $lastQuote, $extra) = ($1, $2, $3, $4);

		$include =~ s|^(\.\.[\\/])*||;

		$include =~ s|^[\\/]||;

		$line = "#include $firstQuote$include$lastQuote$extra\n";

	}

	return $line;

}

sub Usage() {

	require Pod::Text;

	print "\n";

	my $parser = Pod::Text->new();

	$parser->parse_from_file($0);

	exit;

}

sub FindMissingDeps($) {

	my $obyFile = shift;

	print "Checking dependancies...\n";

	my $ibys = {};

	my $filesByName = {};

	my $filesByUid = {};

	# since cpp doesn't deal with macros inside #include's, do it manually here:

	print "Manually processing $obyFile\n" if ($verbose);

	open IBY, "<$obyFile" or die "Can't open $obyFile: $!\n";

	my $ibyFile = "$tempDir\\baserom.tmp";

	open TEMPIBY, ">$ibyFile" or die "Can't open $ibyFile: $!\n";

	while (my $line = <IBY>) {

		$line =~ s/\#\#VARIANT\#\#/$variant/;

		$line =~ s/^\s*#/#/;

		print TEMPIBY $line;

	}

	close IBY;

	close TEMPIBY;

	my $cppOpts = "-undef -traditional -lang-c++ -nostdinc -I . -I ${epocroot}epoc32 -DVARIANT=$variant -DBUILD=$build -DMAIN=$main -DEUSERDIR=$main -DKMAIN=$main";

	my $cmd .= "cpp $cppOpts $ibyFile";

	print "running: $cmd\n" if ($verbose);

	open CPP, "$cmd |" or die "Can't run '$cmd': $!\n";

	while (my $line = <CPP>) {

		chomp $line;

		#print "\tCPP:$.:$line\n";

		$line =~ s/EPOCROOT##/\\/;

		$line =~ s/##//g;

		my $executableSrc = undef;

		my $executableTrg = undef;

		if ($line =~ m/^# 1 "(.*)" 1/) {

			my $includedIby = $1;

			print "iby included by cpp: $includedIby\n" if ($verbose);

			$ibys->{lc($includedIby)} = 1;

		} elsif ($line =~ m/^#/) {

			# ignore - line inserted by c preprocessor

			$line = "";

		} elsif ($line =~ m/^\s*file\s*=\s*(.*?)\s+(.*)$/) {

			$executableSrc = $1;

			$executableTrg = trim $2;

		} elsif ($line =~ m/^\s*(device|extension|primary|variant|file)\[0x[0-9A-Fa-f]{8}\]\s*=\s*(.*?)\s+(.*)$/) {

			$executableSrc = $2;

			$executableTrg = trim $3;

		} elsif ($line =~ m|^\s*ECOM_PLUGIN\(\s*(.*?)\s*,| ) {

			$executableSrc = $1;

			$executableTrg = $executableSrc;

		} elsif ($line =~ m|^\s*secondary\s*=(.*?)\s+(.*)$| ) {

			$executableSrc = $1;

			$executableTrg = trim $2;

		} elsif ($line =~ m|^\s*data\s*=(.*?)\s|) {

			my $data = $1;

			print "WARNING: file $data not found\n" unless (-f "$epocroot$data");

		} elsif (length(trim($line))==0) {

			# ignore empty line

		} elsif ($line =~ m|^\s*REM\s.*$|i) {

			# comment, ignore.

		} elsif ($line =~ m|^\s*patchdata\s.*$| ) {

			# patchdata - ignore

		} elsif ($line =~ m|^files=$|) {

			# tshell.oby contains this line, not sure why.

		} elsif ($line =~ m/^\s*PlatSec(Diagnostics|Enforcement|ProcessIsolation|EnforceSysBin)\s*(ON|OFF)\s*$/) {

			# ignore platsec stuff

		} elsif ($line =~ m/^\s*(debugport|kerneltrace|memmodel|trace|collapse|multikernel|version|bootbinary|romsize|romlinearbase|romalign|(kernel)?dataaddress|kernelheap(max|min)|defaultstackreserve|romchecksum|nowrapper|pagingpolicy)/) {

			# rom config stuff, ignore

		} elsif ($line =~ m/^\s*#/) {

			# We ignore any other preprocessor directive

		} else {

			print "OBY line not recognised: $line\n";

		}

		if ((defined $executableSrc) && (! ($executableSrc =~ m|eka1_entry_stub\.dll$|)) ) {

			#die "Cannot find file ${epocroot}$executableSrc\n" unless (-f "${epocroot}$executableSrc");

			# Assume anything like BTDEBUG_DIR should equate to urel

			$executableSrc =~ s/\\[A-Z]+_DIR\\/\\urel\\/;

			if (!(-f "${epocroot}$executableSrc")) {

				print "WARNING: Can't find ${epocroot}$executableSrc, skipping dependancy check\n";

				next;

			}

			my $exeOnly = lc $executableSrc;

			$exeOnly =~ s/.*\\//;

			my $exeOnlyTrg = lc $executableTrg;

			$exeOnlyTrg =~ s/.*\\//;

			my $uid3 = (headerInfo("${epocroot}$executableSrc"))[3];

			if (defined $uid3) {

				if ($filesByName->{$exeOnlyTrg}) {

				  print "WARNING: 2 files with name $exeOnlyTrg in rom\n";

			  }	

				$filesByName->{$exeOnlyTrg} = $executableSrc;

				if (!($uid3 eq "00000000")) {

					$filesByUid->{$uid3} = $executableSrc;

					print "UID3 for $executableSrc: $uid3\n" if ($verbose>1);

				}

			} else {

				print "WARNING: could not find UID3 for $executableSrc\n"

			}

		}

	}

	close CPP;

	# now check for missing dependancies

	my @missingFiles;

	foreach my $dependancy (keys %$filesByName) {

		my $executable = $filesByName->{$dependancy};

		$cmd = "elftran -dump i ${epocroot}$executable";

		print "running: $cmd\n" if ($verbose);

		open ELFTRAN, "$cmd|" or die "Couldn't run $cmd: $!\n";

		while (my $line = <ELFTRAN>) {

			if ($line =~ m/^\d+ imports from (.*)$/) {

				my $dep = lc($1);

				my $depName = undef;

				my $depUid = undef;

				if ($dep =~ m/^(.*?)\{[a-f0-9]{8}\}\[([a-f0-9]{8})\]\.(.*)$/ ) {

					unless ($ignoreDeps{lc("$1.$3")}) {

						$depName = "$1.$3";

						$depUid = $2;

					}

				} elsif ($dep =~ m/^(.*?)\{[a-f0-9]{8}\}\.(.*)$/ ) {

					unless ($ignoreDeps{lc("$1.$2")}) {

						$depName = "$1.$2";

					}

				} else {

					print "WARNING: dependancy name '$dep' could not be parsed\n";

				}

				if (defined $depName) {

					print "$executable links to $depName\n" if ($verbose>1);

					if ((defined $depUid) && ($filesByUid->{$depUid})) {

						print "Found match by UID3: $filesByUid->{$depUid} ($depUid)\n" if ($verbose>1);

					} elsif ($filesByName->{lc($depName)}) {

						my $uid3 = $filesByName->{lc($depName)};

						#print "WARNING: Found match by name but not UID: $depName UID3: $uid3 expected $depUid\n";

					} else {

						my $fullDepName = makeFullFileName($depName);

						if (defined $depUid) {

							print "Missing dependancy: $depName (UID3 $depUid) required by $executable\n";

							$filesByUid->{$depUid} = $fullDepName;

						} else {

							print "Missing dependancy: $depName required by $executable\n";

						}

						push @missingFiles, [$depName, $depUid];

						#print "WARNING: can't find dependancy $depName at $fullDepName\n" unless (-f $fullDepName);

						$filesByName->{lc($depName)} = $fullDepName;

					}

				}

			}

		}

		close (ELFTRAN);

	}

	return \@missingFiles;

}

sub ResolveMissingDeps($) {

  my $missingFiles = shift;

	my %addedIbys;

	foreach my $depInfo (@$missingFiles) {

	  my $expectedDepPath = makeFullFileName $depInfo->[0];