#!/usr/bin/perl

#

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

# Mike Kinghan, mikek@symbian.org, for Symbian Foundation

#

# Description:

#

# romnibus.pl - Build a rom like rom_sbs.pl but without Windows dependencies.

#

# Pre-processes the .oby/iby files then invokes rombuild.exe

# (or other specified builder)

# First, read our config file

use strict;

use Getopt::Long;

use Cwd;

use Cwd 'abs_path';

use File::Spec;

my $on_windows;

my $epocroot_vol;

my $epocroot_dir;

my $epocroot_file;

my %dir_listings = ();	

my %opts=();

my $param_count = scalar(@ARGV);

my (@assps, @builds, %variants, @templates, %flags, %insts, %zip, %builder);

my $main;

my $kmain;

my $toroot;

my $e32path;

my $rombuildpath;

my $euserdir;

my $elocldir;

my $kbdir;

my $romname;

my $single;

my $smain;

my $pagedCode;

my $debug;

my $quiet;

my $drive;

my $toolpath;

my $epoc32path;

my $epocroot;

my $drive = "";

my $base_path;

my $line;

sub Variant_GetMacroHRHFile;

sub is_RVCT_build($);

sub parse_cfg;

sub ASSPS;

sub BUILDS;

sub TEMPLATES;

sub usage;

sub rectify($$$);

sub match_abbrev($$);

sub check_opts;

sub lookup_file_info($$);

sub lookupSymbolInfo($$);

sub parse_patch_data($$);

sub gen_file;

sub nix_fixes {

#	Fix case-sensitivity offenders for unix/linux environment.

	my $e32plat_pm = File::Spec->catfile($toolpath,"e32plat.pm");

	my $armutl_pm = File::Spec->catfile($toolpath,"armutl.pm");

	my $bpabiutl_pm = File::Spec->catfile($toolpath,"bpabiutl.pm");

	my $e32variant_pm = File::Spec->catfile($toolpath,"e32variant.pm");

	my $E32Plat_pm = File::Spec->catfile($toolpath,"E32Plat.pm");

	my $Armutl_pm = File::Spec->catfile($toolpath,"Armutl.pm");

	my $BPABIutl_pm = File::Spec->catfile($toolpath,"BPABIutl.pm");

	my $E32Variant_pm = File::Spec->catfile($toolpath,"E32Variant.pm");

	# Create symlinks for case-sensitively misnamed modules we need.

	unless ( -f $E32Plat_pm or -l $E32Plat_pm) {

		symlink($e32plat_pm,$E32Plat_pm);

	}

	unless ( -f $Armutl_pm or -l $Armutl_pm) {

		symlink($armutl_pm,$Armutl_pm);

	}

	unless ( -f $BPABIutl_pm or -l $BPABIutl_pm) {

		symlink($bpabiutl_pm,$BPABIutl_pm);

	}

	unless ( -f $E32Variant_pm or -l $E32Variant_pm) {

		symlink($e32variant_pm,$E32Variant_pm);

	}

	# Make uppercase symlinks to all .bsf files in /epoc32/tools

	my @bsf_files = glob(File::Spec->catfile($toolpath,"*.bsf"));

	foreach my $bsf_file (@bsf_files) {

		my ($vol,$dirs,$file) = File::Spec->splitpath($bsf_file);

		$file =~ /^(\S+)\.bsf/;

		my $uc_stem = uc($1);

		my $uc_bsf_file = File::Spec->catpath($vol,$dirs,($uc_stem .".bsf"));

		unless ( -f $uc_bsf_file or -l $uc_bsf_file ) {

			symlink($bsf_file,$uc_bsf_file) or die "Can't symlink $bsf_file -> $uc_bsf_file. $!";

		}

	}

}

BEGIN {

	$on_windows = $^O =~ /^MSWin/ ? 1 : 0;

	$epocroot = $ENV{EPOCROOT};

	die "ERROR: Must set the EPOCROOT environment variable.\n" if (!defined($epocroot));

	print "Environmental epocroot - >$epocroot<\n";

	$epocroot = abs_path($epocroot);

	die "ERROR: EPOCROOT must specify an existing directory.\n" if (!-d $epocroot);

	($epocroot_vol,$epocroot_dir,$epocroot_file) = File::Spec->splitpath($epocroot);

	$epocroot = File::Spec->catfile(($epocroot_vol,$epocroot_dir,$epocroot_file),undef);

	print "EPOCROOT=$ENV{EPOCROOT} resolved as \"$epocroot\"\n";

	$epoc32path = "${epocroot}epoc32";

	$toolpath = File::Spec->catfile($epoc32path,"tools");

	push @INC, $toolpath;

	nix_fixes(), unless ($on_windows);

}

my $result = GetOptions (\%opts, "assp=s",

						 "inst=s",

						 "type=s",

						 "variant=s",

						 "build=s", 

						 "conf=s",

						 "name=s",

						 "modules=s",

						 "xabi=s",

						 "clean",

						 "quiet",

						 "help",

						 "debug",

						 "zip",

						 "symbol",

						 "noheader",

						 "kerneltrace=s",

						 "rombuilder=s",

						 "define=s@",

						 "rofsbuilder=s",

						 "compress",

						 );

$debug = $opts{debug};

$quiet = $opts{quiet} unless $debug;

if ($on_windows) {

	#The cpp needed a drive apparently

	$drive = $epocroot_vol;

	$epoc32path = File::Spec->catpath($epocroot_vol,$epoc32path,undef);

}

my $cwd = Cwd::cwd();

my ($vol,$dirs,$file) = File::Spec->splitpath($cwd);

my @path_parts = File::Spec->splitdir($dirs);

while(@path_parts[-1] ne "sf") {

	pop(@path_parts);

}

$e32path = File::Spec->catdir((@path_parts,"os"));

$base_path = $e32path; # ??

$rombuildpath = File::Spec->catfile($e32path,"kernelhwsrv","kernel","eka","rombuild");

use E32Plat;

{

        Plat_Init($toolpath . ($on_windows ? '\\' : '/'));

}

if ($debug) {

	print "epocroot = $epocroot\n";

	print "epoc32path = $epoc32path\n";

	print "drive = $drive\n";

	print "toolpath = $toolpath\n";

	print "toroot = $toroot\n";

	print "e32path = $e32path\n";

	print "rombuildpath = $rombuildpath\n";

	print "base_path = $base_path\n";

}

my $cppflags="-P -undef -Wno-endif-labels -traditional -lang-c++ -nostdinc -iwithprefixbefore $rombuildpath -I $rombuildpath -I $drive$epoc32path ";

# Include variant hrh file defines when processing oby and ibys with cpp

# (Code copied from \\EPOC\master\cedar\generic\tools\romkit\tools\buildrom.pm -

# it used relative path to the working dir but we are using absolute path seems neater)

my $variantMacroHRHFile = Variant_GetMacroHRHFile();

if($variantMacroHRHFile){

	my ($ignore1,$dir,$file) = File::Spec->splitpath($variantMacroHRHFile);

	$cppflags .= " -I " . File::Spec->catpath($epocroot_vol,$dir,undef) . " -include " . File::Spec->catpath($epocroot_vol,$dir,$file); 

}

if($param_count == 0 || $opts{'help'} || !$result) {

	usage();

	exit 0;

}

# Now check that the options we have make sense

checkopts();

if (!$quiet) {

	print "Starting directory: ", Cwd::cwd(), "\n";

	print <<EOF;

OPTIONS:

\tTYPE: $opts{'type'}

\tVARIANT: $opts{'variant'}

\tINSTRUCTION SET: $opts{'inst'}

\tBUILD: $opts{'build'}

\tMODULES: $opts{'modules'}

EOF

}

#Pick out the type file

my $skel = "$opts{'type'}.oby";

unless (-e $skel) {

	$skel= File::Spec->catfile($rombuildpath,"$opts{'type'}.oby");

}

unless (-e $skel) {

	die "Can't find type file for type $opts{'type'}, $!";

}

print "Using type file $skel\n" if !$quiet;

# If clean is specified, zap all the image and .oby files

if($opts{'clean'}) {

	unlink glob("*.img");

	unlink "rom.oby";

	unlink "rombuild.log";

	unlink glob("*.rofs");

	unlink "rofsbuild.log";

}

# Now pre-pre-process this file to point to the right places for .ibys

# Unfortunately cpp won't do macro replacement in #include strings, so

# we have to do it by hand

my $k = $opts{kerneltrace};

if ($opts{assp}=~/^m(\S+)/i) {

	$kbdir="kb$1";

	$kbdir="kbarm" if (lc $1 eq 'eig');

} else {

	$kbdir="kb$opts{assp}";

}

$single=1 if ($opts{assp}=~/^s(\S+)/i);

if ($single) {

	# Hackery to cope with old compiler

	if ($main eq 'MARM') {

		$smain='SARM';

	} else {

		$smain="S$main";

	}

} else {

	$smain=$main;

}

open(X, "$skel") || die "Can't open type file $skel, $!";

open(OUT, "> rom1.tmp") || die "Can't open output file, $!";

# First output the ROM name

print OUT "\nromname=$romname\n";

while(<X>) {

	unless ($on_windows) {

		if (m/#include/) {

			s|\\|\/|g;

		}

	}

	s/\#\#ASSP\#\#/$opts{'assp'}/;

	s/\#\#VARIANT\#\#/$opts{'variant'}/;

	s/\#\#BUILD\#\#/$opts{'build'}/;

	s/\#\#MAIN\#\#/$main/;

	s/\#\#KMAIN\#\#/$kmain/;

	s/\#\#E32PATH\#\#/$e32path/;

	s/\#\#BASEPATH\#\#/$base_path/;

	s/\#\#EUSERDIR\#\#/$euserdir/;

	s/\#\#ELOCLDIR\#\#/$elocldir/;

	s/\#\#KBDIR\#\#/$kbdir/;

	print OUT;

}

close X;

close OUT;

# Use cpp to pull in include chains and replace defines

my $defines = "";

$defines .= "-D MAIN=$main ";

$defines .= "-D KMAIN=$kmain ";

$defines .= "-D EUSERDIR=$euserdir ";

$defines .= "-D ELOCLDIR=$elocldir ";

$defines .= "-D E32PATH=$e32path ";

$defines .= "-D BASEPATH=$base_path ";

$defines .= "-D EPOCROOT=$epocroot ";

$defines .= "-D SMAIN=$smain " if $smain;

foreach (@{$opts{'define'}}) {

	my @array=split(/,/,$_);

	foreach (@array) {

		$defines.="-D ".uc $_." ";

		$pagedCode = 1 if $_ eq 'PAGED_CODE';

		}

	}

if ($opts{'modules'}) {

	my @array=split(/,/,$opts{'modules'});

	foreach (@array) {

		$defines.="-D ".uc $_." ";

		}

	}

foreach (keys %opts) {

	next if ($_ eq 'name');

	next if ($_ eq 'modules');

	next if ($_ eq 'zip');

	next if ($_ eq 'symbol');

	next if ($_ eq 'kerneltrace');

	next if ($_ eq 'define');

	$defines.="-D ".uc $_."=".$opts{$_}." ";

	$defines.="-D ".uc $_."_".$opts{$_}." ";

}

$defines.="-D SINGLE " if ($single);

$defines.="-D RVCT " if (IsRVCTBuild($main));

print "Using defines $defines\n" if !$quiet;

my $ret=1;

my $cppcmd;

if($opts{'build'}=~/^u/i and $on_windows) {

	# Unicode build

	$cppcmd = File::Spec->catfile($epoc32path,"gcc","bin","cpp") . " $cppflags -D UNICODE $defines rom1.tmp rom2.tmp";

} else {

	$cppcmd = "cpp $cppflags $defines rom1.tmp rom2.tmp";

}

print "Executing CPP:\n\t$cppcmd\n" if $debug;

$ret = system($cppcmd);

die "ERROR EXECUTING CPP\n" if $ret;

# Purge remarks and blank lines. Complete source filenames and adapt them to host filesystem.

rectify("rom2.tmp", "rom3.tmp", $k);

# scan tmp file and generate auxiliary files, if required

open TMP, "rom3.tmp" or die("Can't open rom3.tmp\n");

while ($line=<TMP>)

	{

	if ($line=~/\s*gentestpaged/i) {

		genfile("paged");	}

	if ($line=~/\s*gentestnonpaged/i) {

		genfile("nonpaged");	}

	}

parsePatchData("rom3.tmp", "rom4.tmp");

# break down the oby file into rom, rofs and extensions oby files

my $oby_index =0;

my $dumpfile="rom.oby";

my $rofs=0;

my $extension=0;

my $corerofsname="";

open DUMPFILE, ">$dumpfile" or die("Can't create $dumpfile\n");

open TMP, "rom4.tmp" or die("Can't open rom4.tmp\n");

while ($line=<TMP>)

	{

	if ($line=~/^\s*rofsname/i)

		{

		close DUMPFILE;							# close rom.oby or previous rofs#/extension#.oby

		$oby_index=1;

		$corerofsname=$line;

		$corerofsname =~ s/rofsname\s*=\s*//i;		# save core rofs name

		chomp($corerofsname);

		unlink $corerofsname || print "unable to delete $corerofsname";

		my $dumpfile="rofs".$rofs.".oby";

		$rofs++;

		open DUMPFILE, ">$dumpfile" or (close TMP and die("Can't create $dumpfile\n"));

		}

	if ($line=~/^\s*coreimage/i)

		{

		close DUMPFILE;							# close rofs.oby

		if ($oby_index ne 1) {

			close TMP;

			die "Must specify ROFS image before ROFS extension\n";

		}

		my $name=$line;

		$name =~ s/coreimage\s*=\s*//i;		# read core rofs name

		chomp($name); 			# remove trailing \n

		if ($name ne $corerofsname) {

			close TMP;

			die "This extension does not relate to previous ROFS\n";

		}

		$oby_index=33;						# open window

		my $dumpfile="extension".$extension.".oby";

		$extension++;

		open DUMPFILE, ">$dumpfile" or (close TMP and die("Can't create $dumpfile\n"));

		}

	if ($line=~/^\s*extensionrofs/i)

		{

		$oby_index=3 if ($oby_index eq 2);

		}

	if (($oby_index eq 2) && !($line=~/^\s*$/)) {

		close TMP;

		die "Bad ROFS extension specification\n";

	}

	print DUMPFILE $line;

	$oby_index=2 if ($oby_index eq 33);		# close window

	}

close DUMPFILE;

close TMP;

# For paged roms that use rofs, move all data= lines in rom which are not 'paging_unmovable' to rofs, so that paged ram-loaded code

# is automatically put into rofs

rename('rom.oby', 'rom4.tmp') || die;

open(IN, 'rom4.tmp') || die "Can't read rom4.tmp";

open(ROM, '>rom.oby') || die "Can't write to rom.oby";

if ($oby_index >= 1 && $pagedCode)	{

	open(ROFS, '>>rofs0.oby') || die "Can't append to rofs0.oby";

}

while ($line=<IN>)

{

	if(($oby_index >= 1) && ($pagedCode) && ($line=~/^\s*data\s*=/) && !($line=~/\.*paging_unmovable\s*/)) {

		print ROFS $line;

	}

	else {

		$line=~s/paging_unmovable//;

		print ROM $line;

	}

}

close IN;

close ROM;

if ($oby_index >= 1 && $pagedCode)	{

	close ROFS;

}

	unlink 'rom4.tmp';

my $flags;

foreach (@{$flags{$opts{'assp'}}}) {

	$flags.=" -$_";

}

if($opts{'noheader'}) {

	$flags.=" -no-header";

}

if($opts{'compress'}) {

	$flags.=" -compress";

}

my $builder = $opts{'rombuilder'};

if ($on_windows) {

	$builder = File::Spec->catfile($toolpath,"rombuild.exe") unless ($builder);

}

else {

	$builder = File::Spec->catfile($toolpath,"rombuild") unless ($builder);

	unless ( -x $builder ) {

		chmod 0755,$builder;

	}

}

print "$builder $flags -type-safe-link -S rom.oby 2>&1\n\n";

open(Y, "$builder $flags -type-safe-link -S rom.oby 2>&1 | ") || 

	die "Can't start $builder command, $!";

my $nerrors=0;

my $nwarnings=0;

while(<Y>) {

	my $error=(/^error:/i);

	my $warning=(/^warning:/i);

	print if ($error or $warning or !$quiet);

	$nerrors++ if ($error);

	$nwarnings++ if ($warning);

}

print "\nGenerated .oby file is rom.oby\n" if !$quiet;

print "\nGenerated image file is $romname\n" if (!$nerrors);

my$rerrors;

my $rofsbuilder;

if ($rofs) {

	$rofsbuilder = $opts{'rofsbuilder'};

	$rofsbuilder = "rofsbuild" unless ($rofsbuilder);

	for(my $i=0;$i<$rofs;++$i) {

		print "Executing $rofsbuilder on main rofs\n" if !$quiet;

		my $image="rofs".$i.".oby";

		system("$rofsbuilder $image");

		if ($? != 0)

			{

			print "$rofsbuilder $image returned $?\n";

			$rerrors++;

			}

		rename "rofsbuild.log", "rofs$i.log"

		}

}

if ($rofs and $extension) {

	for(my $i=0;$i<$extension;++$i) {

		print "Executing $rofsbuilder on extension rofs\n" if !$quiet;

		my $image="extension".$i.".oby";

		system("$rofsbuilder $image");

		if ($? != 0)

			{

			print "$rofsbuilder $image returned $?\n";

			$rerrors++;

			}

		rename "rofsbuild.log", "extension$i.log"

		}

}