#!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:

#

# Description:

#

# rom.pl - Build a rom

#

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

#Getopt::Long::Configure("ignore_case");

my %opts=();

my $param_count = scalar(@ARGV);

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"

						 );

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 = $opts{_debug};

my $quiet;

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

my $drive;

# discover where this script is running from to set the $toroot and $e32path variables

my $toolpath;

my $Epoc32Path;

my $EpocRoot;

my $drive;

my $BasePath;

BEGIN {

	$EpocRoot = $ENV{EPOCROOT};

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

	$EpocRoot =~ s-/-\\-go;	# for those working with UNIX shells

	die "ERROR: EPOCROOT must be an absolute path, " .

		"not containing a drive letter.\n" if ($EpocRoot !~ /^\\/);

	die "ERROR: EPOCROOT must not be a UNC path.\n" if ($EpocRoot =~ /^\\\\/);

	die "ERROR: EPOCROOT must end with a backslash.\n" if ($EpocRoot !~ /\\$/);

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

	# The cpp needed a drive apparently

	my $cwd = Cwd::cwd();

	$cwd =~ /^(.)/;

	$drive = "$1:";

	my $fp0 = $0;

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

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

	unless ($fp0 =~ /^([A-Za-z]:)?\\/) {

		if ($cwd =~ /\\$/) {

			$fp0 = "$cwd$fp0";

		} else {

			$fp0 = "$cwd\\$fp0";

		}

	}

	my @path = split(/\\/, $cwd);

	shift(@path);

	$toroot = ('..\\') x @path;

	$e32path = $fp0;

	$e32path =~ s/\\kernelhwsrv\\kernel\\eka\\rombuild\\rom\.pl$//i;

	$e32path =~ s/^[A-Za-z]://;

	$rombuildpath = $toroot."os\\kernelhwsrv\\kernel\\eka\\rombuild";

	$Epoc32Path = $toroot;

	$Epoc32Path =~ s/\\$//;

	$Epoc32Path .= $EpocRoot . "epoc32";

	$toolpath = "$Epoc32Path\\tools\\";

	push @INC, $toolpath;

	$BasePath = $toroot;

	$BasePath =~ s/\\$/$e32path\\/;

}

use E32Plat;

{

        Plat_Init($toolpath);

}

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 "BasePath = $BasePath\n";

}

my $cppflags="-P -undef -traditional -lang-c++ -nostdinc -iwithprefixbefore $rombuildpath -I $rombuildpath -I $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)

use E32Variant;

use Pathutl;

my $variantMacroHRHFile = Variant_GetMacroHRHFile();

if($variantMacroHRHFile){

	# Using absolute paths so must include drive letter otherwise cpp will fail

	# Also adding the directory containing the HRH file to main includes paths in

	# case it includes files

	my $variantFilePath = Path_Split('Path',$variantMacroHRHFile);

	$cppflags .= " -I $drive$variantFilePath -include $drive$variantMacroHRHFile";

}

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;

if (-e "$opts{'type'}.oby") {

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

} elsif (-e "$rombuildpath\\$opts{'type'}.oby") {

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

} else {

	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>) {

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

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

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

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

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

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

	s/\#\#BASEPATH\#\#/$BasePath/;

	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=$BasePath ";

$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);

sub IsRVCTBuild($) {

    my ($build)=@_;

    return 1 if ($build =~ /^ARMV/i);

	my @customizations = Plat_Customizations('ARMV5');

	return 1 if (grep /$build/, @customizations);

	return 0;

}

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

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

my $ret=1;

my $cppcmd;

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

	# Unicode build

	$cppcmd = "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;

# Zap any ## marks REMS or blank lines

cleanup("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");

my $line;

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, extensions and smr oby files

my $oby_index =0;

my $dumpfile="rom.oby";

my $rofs=0;

my $smr=0;

my $extension=0;

my $corerofsname="";

my $smrname="";

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

my $line;

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

		$corerofsname =~ s/\s*$//g; 			# remove trailing \n

		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*imagename/i)

		{

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

		$smrname=$line;

		$smrname =~ s/imagename\s*=\s*//i;		# save smr name

		$smrname =~ s/\s*$//g; 			# remove trailing \n

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

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

		$smr++;

		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

		$name =~ s/\s*$//g; 			# 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'};

$builder = "rombuild" unless ($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"

		}

}

if ($smr) {

	$rofsbuilder = $opts{'rofsbuilder'};

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

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

		print "Executing $rofsbuilder on smr partition\n" if !$quiet;

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

		system("$rofsbuilder -smr=$image");

		if ($? != 0)

			{

			print "$rofsbuilder -smr=$image returned $?\n";

			$rerrors++;

			}

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

		}

}

if ($nerrors) {

	print "\n\n Errors found during $builder!!\n\nLeaving tmp files\n";

} elsif ($nwarnings) {

	print "\n\n Warnings during $builder!!\n\nLeaving tmp files\n";

} elsif ($rerrors) {

	print "\n\n Errors during $rofsbuilder!!\n\nLeaving tmp files\n";

} else {

	unlink glob("*.tmp") if !$debug;

}

if ($opts{zip} or $zip{$opts{assp}}) {

	my $zipname=$romname;

	$zipname =~ s/\.(\w+)$/\.zip/i;

	unlink $zipname;

	system("zip $zipname $romname");

}

if ($opts{symbol}) {

	my $logname=$romname;

	$logname =~ s/\.(\w+)$/\.log/i;

	my $obyname=$romname;

	$obyname =~ s/\.(\w+)$/\.oby/i;

	unlink $logname;

	unlink $obyname;

	system("rename rombuild.log $logname");

	system("rename rom.oby $obyname");

	system("maksym $logname");

}

if ($nerrors || $nwarnings || $rerrors) {

	exit 4;

}	

exit 0;

################################ Subroutines  ##################################

sub usage {

	print <<EOT;

rom <options>

Generate a rom image for the specified target, along with a rom.oby file

that can be fed to (a) rombuild to regenerate the image.

The following options are required:

  --variant=<variant>         e.g. --variant=assabet

  --inst=<instruction set>    e.g. --inst=arm4

  --build=<build>             e.g. --build=udeb

  --type=<type of rom>  

         tshell for a text shell rom

         e32tests for a rom with e32tests

         f32tests for rom with f32tests

         alltests for all the tests

The following are optional:

  --name=<image name>               Give image file specified name

  --noheader                        Pass -no-header option on to rombuild

  --help                            This help message.

  --clean                           Remove existing generated files first

  --quiet                           Be less verbose

  --modules=<comma separated list>  List of additional modules for this ROM

  --define=<comma separated list>   List of CPP macros to define

Options may be specified as a short abbreviation 

e.g. -b udeb instead of --build udeb

EOT

}

sub cleanup($$$) {

	my ($in, $out, $k) = @_;

	my ($line, $lastblank);

	open(OUTPUT_FILE, "> $out") or die "Cannot open $out for output";

	open(INPUT_FILE, "< $in") or die "Cannot open for $in input";

	while ($line=<INPUT_FILE>) {

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

		# file=\epoc32\...  ==> file=%EPOCROOT%\epoc32\...

		$line =~ s/(=\s*)\\epoc32/\1${EpocRoot}Epoc32/i;

		# Now compress blank lines down to one

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

			if($lastblank) {

				# Do nothing

			} else {

				# This is the first blank line

				$lastblank=1;

				print OUTPUT_FILE $line;

			}

		} else {

			# Not blank

			$lastblank=0;

			if ($k and $line=~/^\s*kerneltrace/i) {

				$line = "kerneltrace $k\n";

			}

			print OUTPUT_FILE $line if !($line=~/^\s*REM\s+/i);

		}

	}

	close(INPUT_FILE);

	close(OUTPUT_FILE);

}

sub IsSmp($) {

	my %SmpKernelDirs=(

		'x86smp' => 1,

		'x86gmp' => 1,

		'arm4smp' => 1,

		'armv4smp' => 1,

		'armv5smp' => 1

	);

	my ($kdir) = @_;

	return $SmpKernelDirs{lc $kdir};

}

sub checkopts {

	unless($opts{variant}) { die "No Variant specified"; }

	$opts{'build'}="UDEB" unless($opts{'build'});

	$opts{'type'}="TSHELL" unless($opts{'type'});

	$opts{'inst'}="ARM4" unless($opts{'inst'});

	my $additional;

	if ($opts{'modules'}) {

		$additional="_".$opts{modules};

		$additional=~ s/,/_/ig;

	}

	my $build=lc $opts{build};

	my $inst=uc $opts{'inst'};

	if ($inst eq "MARM") {

		# Hackery to cope with old compiler

		$main="MARM";

		$euserdir="MARM";

		$elocldir="MARM";

	}

	else {

		$main=$inst;

		if ($main eq "THUMB") {

			$euserdir="ARMI";

		} else {

			$euserdir=$main;

		}

		if ($main eq "ARMI" or $main eq "THUMB") {

			$elocldir="ARM4";

		} else {

			$elocldir=$main;

		}

	}

	$kmain = $opts{'xabi'};

	$kmain = $main unless ($kmain);

	if (IsSmp($kmain)) {

		$euserdir = $kmain;

	}

	if ($opts{name}) {

		$romname=$opts{name};

	} else {

		$romname=uc($opts{variant}.$additional.$main);

		if ($build=~/^\w*DEB$/i) {

			$romname.='D';

		}

		$romname.='.IMG';

	}

}

sub lookupFileInfo($$)

{

	my ($infile, $fullname) = @_;

	my ($name, $ext) = $fullname =~ /^(.+)\.(\w+)$/ ? ($1, $2) : ($fullname, undef);

	open TMP, $infile or die("Can't open $infile\n");

	while(<TMP>)

	{

		$_ = lc;

		if(/^\s*(\S+)\s*=\s*(\S+)\s+(\S+)/i)

		{

			my ($src, $dest) = ($2, $3);

			my $destFullname = $dest =~ /^.*\\(.+)$/ ? $1 : $dest;

			my ($destName, $destExt) = $destFullname =~ /^(.+?)\.(\w+)$/ ? ($1, $2) : ($destFullname, undef);

			if ($destName eq $name && (!$ext || $ext eq $destExt))

			{

				close TMP;

				return ($src, $dest);

			}

		}

	}

	die "patchdata: Can't find file $fullname\n";

}

sub lookupSymbolInfo($$)

{

	my ($file, $name) = @_;

	open TMP, $file or die "Can't read $file\n";

	# ignore local symbols.

	while (<TMP> !~ /Global Symbols/) { }

	while (<TMP>)

	{

		if (/^\s*(\S+)\s+(\S+)\s+data\s+(\S+)/i)

		{

			my ($symbol, $addr, $size) = ($1, $2, $3);

			if ($symbol eq $name)

			{

				close TMP;

				return ($addr, $size);

			}

		}

		# This is a quick fix for RVCT 3.1, which uses the text "(EXPORTED)"

		# in the map file. Here is an example:

		#

		# KHeapMinCellSize (EXPORTED) 0x0003d81c Data 4 mem.o(.constdata)

		#

		elsif (/^\s*(\S+)\s+\(exported\)\s+(\S+)\s+data\s+(\S+)/i)

		{

			my ($symbol, $addr, $size) = ($1, $2, $3);

			if ($symbol eq $name)

			{

				close TMP;

				return ($addr, $size);

			}

		}

	}

	die "patchdata: Can't find symbol $name\n";

}

sub parsePatchData($$)

{

	my ($infile, $outfile) = @_;

	open IN, $infile or die("Can't read $infile\n");

	open OUT, ">$outfile" or die("Can't write $outfile\n");

	my $line;

	while($line = <IN>)

	{

		if ($line =~ /^\s*patchdata\s+(.+?)\s*$/i)

		{

			if ($1 !~ /(\S+)\s*@\s*(\S+)\s+(\S+)\s*$/)

			{

				die "Bad patchdata command: $line\n";

			}

			my ($file, $symbol, $value) = (lc $1, $2, $3);

			my ($srcFile, $destFile) = lookupFileInfo($infile, $file);

			my ($index, $elementSize) = (undef, undef);

			if ($symbol =~ s/:(\d+)\[(\d+)\]$//)

			{

				($index, $elementSize) = ($2, $1);

				$index = hex($index) if $index =~ /^0x/i;

			}

			if ($srcFile =~ /\\armv5(smp)?\\/i)

			{

				my ($symbolAddr, $symbolSize) = lookupSymbolInfo("$srcFile.map", $symbol);

				my $max;

				if (defined($index))

				{

					my $bytes;

					$bytes = 1, $max = 0xff       if $elementSize ==  8;

					$bytes = 2, $max = 0xffff     if $elementSize == 16;

					$bytes = 4, $max = 0xffffffff if $elementSize == 32;

					die("patchdata: invalid element size $elementSize: $line\n") unless defined($bytes);

					if ($bytes > 1 && (($symbolSize & ($bytes-1)) != 0))

					{

						die("patchdata: unexpected symbol size $symbolSize for array $symbol ($elementSize-bit elements)\n");

					}

					if ($index >= int($symbolSize / $bytes))

					{

						die("patchdata: index $index out of bounds for $symbol of $symbolSize bytes ($elementSize-bit elements)\n");

					}

					$symbolAddr = hex($symbolAddr) if $symbolAddr =~ /^0x/i;

					$symbolAddr += $index * $bytes;

					$symbolAddr = sprintf("0x%x", $symbolAddr);

					$symbolSize = $bytes;

				}

				elsif ($symbolSize == 1) { $max = 0xff; }

				elsif ($symbolSize == 2) { $max = 0xffff; }

				elsif ($symbolSize == 4) { $max = 0xffffffff; }

				else { die "patchdata: Unexpected symbol size $symbolSize for $symbol\n"; }

				$value = hex($value) if $value =~ /^0x/i;

				if ($value > $max)

				{

					print("Warning:  Value overflow of $symbol\n");

					$value &= $max;

				}					

				$value = sprintf("0x%08x", $value);

				$line = "patchdata $destFile addr $symbolAddr $symbolSize $value\n";

			}

			else

			{

				$line = "";

			}

		}

		print OUT $line;

	}

	close IN;

	close OUT;

}

sub genfile {

	my $count=0;

	if($_[0] eq 'paged') {

		my $file='gentestpaged.txt';

		unlink $file;

		open(OUTFILE, ">$file") or die "Can't open output file, $!";

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

			if(($i >5) && ($i % 40 ==0)) {

			print OUTFILE "\n";

			$count++;

			} 

			if(($i+$count) % 5 ==0) {

			print OUTFILE "SATOR ";

			}

			if(($i+$count) % 5 ==1) {

			print OUTFILE "AREPO ";

			}

			if(($i+$count) % 5 ==2) {

			print OUTFILE "TENET ";

			}

			if(($i+$count) % 5 ==3) {

			print OUTFILE "OPERA ";

			}

			if(($i+$count) % 5 ==4) {

			print OUTFILE "ROTAS ";

			}

		}

	} else {

		my $file='gentestnonpaged.txt';

		unlink $file;

		open(OUTFILE, ">$file") or die "Can't open output file, $!";

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

			if(($i >5) && ($i % 40 ==0)) {

			print OUTFILE "\n";

			$count++;

			} 

			if(($i+$count) % 4 ==0) {

			print OUTFILE "STEP ";

			}

			if(($i+$count) % 4 ==1) {

			print OUTFILE "TIME ";

			}

			if(($i+$count) % 4 ==2) {

			print OUTFILE "EMIT ";

			}

			if(($i+$count) % 4 ==3) {

			print OUTFILE "PETS ";

			}

		}

	}

}

__END__

# Tell emacs that this is a perl script even 'though it has a .bat extension

# Local Variables:

# mode:perl

# tab-width:4

# End: