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

# \f32test\loader\dlltree.pl

# Generate header and build files for one or more trees

# of DLLs and EXEs according to a description file.

# 

#

require Cwd;

my $dllbasename='dllt';

my $dllext='.dll';

my $exebasename='exet';

my $exeext='.exe';

my $mmpext='.mmp';

my $defext='.def';

my $libext='.lib';

my $source0ext='.cpp';

my $source1ext='.cia';

my $xippath="sys\\bin\\";

my $nonxippath="sys\\bin\\";

my $hostpath="\\Epoc32\\Release\\##MAIN##\\##BUILD##\\";

my $flag_value_exe=1;

my $flag_value_fixed=2;

my $flag_value_data=4;

my $flag_value_xip=8;

my $flag_value_dll_in_cycle=16;

my $flag_value_data_in_tree=32;

my $flag_value_xip_data_in_tree=64;

my $flag_value_exports=128;

my $flag_value_pagedcode=256;

my $flag_value_unpagedcode=512;

my $flag_value_idrive=1024;

my $flag_value_vdrive=2048;

my $flag_value_bytepair=4096;

my $flag_value_uncompressed=8192;

my $flag_value_targetonly=16384;

my $flag_value_pageddata=32768;

my $flag_value_unpageddata=65536;

my $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst;

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime;

my $copy_end=$year+1900;

my $argc=scalar(@ARGV);

($argc==1 or $argc==2 or $argc==3) or die "Usage: perl dlltree.pl <filename> <dir> [-allowbad]\n";

my $infile=$ARGV[0];

open IN, $infile or die "Cannot open input file $infile\n";

my @in;

while (<IN>)	{

	push @in, $_;

}

close IN;

my $destdir='';

if ($argc>=2) {

	$destdir=$ARGV[1];

	unless (-d $destdir) {

		mkdir $destdir, 0777 or die "Can't create directory $destdir\n";

	}

	chdir $destdir or die "Can't chdir to directory $destdir\n";

}

my $allowbad;

if ($argc==3) {

	if ($ARGV[2] eq '-allowbad') {

		$allowbad = 1;

	}

}

$cwd=Cwd::getcwd();

$destpath=$cwd;

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

if ($destpath=~/^\w\:(.*)/) {

	$destpath=$1;

}

unless ($destpath=~/^(.*?)\\$/) {

	$destpath.='\\';

}

#print "$cwd\n";

#print "$destpath\n";

my @modules;

my @testcases;

my $line=0;

my $modnum=0;

my $state=0;

my $concat;

foreach (@in)	{

	++$line;

	next if (/^\s*$/ or /^\s*\#/);

	if ($state==0)	{

		if (/^\!TESTCASES/) {

			$state=1;

			next;

		}

		my @moddesc=split;

		my $modname=shift @moddesc;

		if (grep {lc($$_{name}) eq lc($modname)} @modules) {

			die "Duplicate module specification at line $line\n";

		}

		my %module;

		$module{name}=$modname;

		$module{num}=$modnum;

		$module{exports}=1;

		$module{nclients}=0;	# number of modules which import from this one

		while (scalar(@moddesc)) {

			my $att=shift @moddesc;

			if ($att=~/^\:$/) {

				last;

			} elsif ($att=~/^X$/i) {

				$module{exe}=1;

			} elsif ($att=~/^F$/i) {

				$module{fixed}=1;

			} elsif ($att=~/^D$/i) {

				$module{data}=1;

			} elsif ($att=~/^P$/i) {

				$module{pagedcode}=1;

			} elsif ($att=~/^PD$/i) {

				$module{pageddata}=1;

			} elsif ($att=~/^B$/i) {

				$module{bytepair}=1;

			} elsif ($att=~/^U$/i) {

				$module{uncompressed}=1;

			} elsif ($att=~/^I$/i) {

				$module{idrive}=1;

			} elsif ($att=~/^V$/i) {

				$module{vdrive}=1;

			} elsif ($att=~/^N$/i) {

				$module{unpagedcode}=1;

			} elsif ($att=~/^T$/i) {

				$module{targetonly}=1;

			} elsif ($att=~/^R(.*?)$/i) {

				$module{xip}=1;

				my $attp=$1;

				if ($attp=~/^\,(.*?)$/) {

					$module{attpname}=$1;

				} elsif (!($attp=~/^\s*$/)) {

					die "Garbage following R attribute at line $line\n";

				}

			}

		}

		if ($module{fixed} && !$module{exe}) {

			die "Can't have FIXED without EXE at line $line\n";

		}

		if ($module{pagedcode} && $module{xip}) {

			die "Can't have PAGEDCODE with XIP at line $line\n";

		}

		# makmake won't support paged binaries which aren't bytepair or uncompressed.

		# However, P can be specified without them in dlltree.txt.  This program generates

		# an MMP file with neither flag.  The flag is added when the files are copied to

		# internal media by T_LDRTST.  (It would be pointless to copy the files to removable

		# media and then edit them because removable media doesn't support paging.)

		my $bothCodePageFlags = $module{pagedcode} && $module{unpagedcode};

		if ($bothCodePageFlags && !$module{idrive}) {

			die "Can't have PAGEDCODE and UNPAGEDCODE without INTERNAL DRIVE at line $line\n";

		}

		if ($module{unpagedcode} && $module{xip}) {

			die "Can't have UNPAGEDCODE with XIP at line $line\n";

		}

		if ($module{pageddata} && !$module{exe}) {

			die "Can't have PAGEDDATA without EXE at line $line\n";

		}

		if ($module{idrive} && $module{xip}) {

			die "Can't have INTERNAL DRIVE with XIP at line $line\n";

		}

		if ($module{vdrive} && $module{xip}) {

			die "Can't have REMOVABLE DRIVE with XIP at line $line\n";

		}

		if ($module{idrive} && $module{vdrive}) {

			die "Can't have INTERNAL DRIVE with REMOVABLE DRIVE at line $line\n";

		}

		if ($module{bytepair} && $module{uncompressed}) {

			die "Can't have BYTEPAIR with UNCOMPRESSED at line $line\n";

		}

		if ($module{exe}) {

			if ($module{attpname}) {

				warn "Attach process with EXE ignored at line $line\n";

				delete $module{attpname};

			}

			$module{basefilename}=$exebasename.$modnum;

			$module{filename}=$module{basefilename}.$exeext;

			$module{source0}=$exebasename.$source0ext;

			$module{source1}="";

			$module{trgtype}='exexp';

			$module{lib}=$module{basefilename}.$libext;

		} else {

			$module{basefilename}=$dllbasename.$modnum;

			$module{filename}=$module{basefilename}.$dllext;

			$module{source0}=$dllbasename.$source0ext;

			$module{source1}=$dllbasename.$source1ext;

			$module{trgtype}='dll';

			$module{lib}=$module{basefilename}.$libext;

		}

		$module{depnames}=\@moddesc;	# dependency names are left over

		$module{line}=$line;

		$module{mark}=0;

		push @modules, \%module;

		++$modnum;

	} elsif ($state<=2) {

		if ($state==1) {

			$concat="";

			die "Syntax error at line $line\n" unless (/^(\w+)\:/);

		}

		if (/^(.*?)\\$/) {

			$concat.=$1;

			$concat.=' ';

			$state=2;

			next;

		} else {

			$concat.=$_;

			$state=1;

		}

		my @modlist=split(/\s+/, $concat);

		my $tcname=shift @modlist;

		$tcname=~/^(.*?)\:$/ or die "???\n";

		$tcname=$1;

		my %tc;

		$tc{name}=$tcname;

		$tc{mod_names}=\@modlist;

		push @testcases, \%tc;

	}

}

foreach $modref (@modules) {

	my $moddepref=$$modref{depnames};

	my @deps;

	foreach (@$moddepref) {

		my $depname=lc($_);

		my @match=grep {lc($$_{name}) eq $depname} @modules;

		if (scalar(@match)==0) {

			die "Unknown dependent module $depname at line $$modref{line}\n";

		}

		my $depref=$match[0];

		if ($$modref{xip} and !$$depref{xip}) {

			die "Illegal dependency: $$modref{name} (XIP) on $$depref{name} (non-XIP)\n";

		}

		push @deps, $$depref{num};

		++$$depref{nclients};

	}

	$$modref{deps}=\@deps;

	my $attpname=$$modref{attpname};

	if ($attpname) {

		my @match=grep {lc($$_{name}) eq lc($attpname)} @modules;

		if (scalar(@match)==0) {

			die "Unknown attach process $attpname at line $$modref{line}\n";

		}

		my $attpref=$match[0];

		if (!$$attpref{exe}) {

			die "Specified attach process is not EXE at line $$modref{line}\n";

		} elsif (!$$attpref{xip}) {

			die "Specified attach process is not XIP at line $$modref{line}\n";

		}

		$$modref{attp}=$attpref;

	}

}

foreach $tcref (@testcases) {

	my $modlistref=$$tcref{mod_names};

	my @modnums;

	foreach $modname (@$modlistref) {

		next if ($modname=~/^\s*$/);

		my @match=grep {lc($$_{name}) eq lc($modname)} @modules;

		if (scalar(@match)==0) {

			die "Unknown module $modname in test case $$tcref{name}\n";

		}

		push @modnums, $match[0]->{num};

	}

	$$tcref{modules}=\@modnums;

	$$tcref{count}=scalar(@modnums);

}

my $next_mark=0;

foreach $modref (@modules) {

	if ($$modref{nclients}==0 and $$modref{exe}) {

		# EXE with no exports

		$$modref{exports}=0;

		$$modref{trgtype}='exe';

	}

	++$next_mark;

	my $modnum=$$modref{num};

	my @tcdeps;

	calc_tc(\@tcdeps, \@modules, $modref, $next_mark);

	$$modref{tcdeps}=\@tcdeps;

	if (grep {$_==$modnum} @tcdeps) {

		$$modref{cycle}=1;

	}

	my @exes=grep {$modules[$_]->{exe}} @tcdeps;

	my $nexes=scalar(@exes);

	unless ($allowbad) {

		if ($nexes>1) {

			die "Module $$modref{name} links to more than one EXE\n";

		} elsif ($nexes==1) {

			my $exeref=$modules[$exes[0]];

			$$modref{linkexe}=$exeref;

			if ($$modref{exe}) {

				if ($$exeref{num}!=$modnum) {

					die "EXE $modref{name} links to another EXE\n";

				}

			} else {

				if ($$modref{attp} and $$exeref{num}!=$modref->{attp}->{num}) {

					die "DLL $$modref{name} ($modnum) incompatible attach process\n";

				}

				if (!$$modref{attp}) {

					$$modref{attp}=$exeref;

				}

			}

		}

	}

	if ($$modref{exe}) {

		foreach $depnum (@tcdeps) {

			my $depref=$modules[$depnum];

			my $depattpref=$depref->{attp};

			if ($depattpref and $depattpref->{num}!=$modnum) {

				die "DEP DLL $$depref{name} ($$depref{num}) incompatible attach process\n";

			}

#			if (!$depattpref) {

#				$$depref{attp}=$modref;

#			}

		}

	}

}

foreach $modref (@modules) {

	my @total_deps;

	my $tcdepref=$$modref{tcdeps};

	push @total_deps, @$tcdepref;

	my $linkexe=$$modref{linkexe};

	if ($linkexe) {

		my $exetcdepref=$$linkexe{tcdeps};

		push @total_deps, @$exetcdepref;

	}

	push @total_deps, $$modref{num};

	my $data=scalar(grep {$modules[$_]->{data}} @total_deps);

	if ($data!=0) {

		$$modref{dataintree}=1;

	}

	my $xipdata=scalar(grep {$modules[$_]->{data} and $modules[$_]->{xip}} @total_deps);

	if ($xipdata!=0) {

		$$modref{xipdataintree}=1;

	}

}

#foreach $modref (@modules) {

#	print "Module $$modref{num}:\n";

#	print "\tName:     $$modref{name}\n";

#	print "\tFilename: $$modref{filename}\n";

#	my $depref=$$modref{deps};

#	my $ndeps=scalar(@$depref);

#	print "\t#Deps:    $ndeps\n";

#	print "\tDeps:     ",join(',',@$depref),"\n";

#}

my @bldinf;

my $bldname='dlltree.inf';

push @bldinf, "// $destpath$bldname\n";

push @bldinf, "//\n";

push @bldinf, "// Copyright (c) 2000-$copy_end Symbian Ltd. All rights reserved.\n";

push @bldinf, "//\n";

push @bldinf, "\n";

push @bldinf, "PRJ_PLATFORMS\n";

push @bldinf, "BASEUSERDEFAULT\n";

push @bldinf, "\n";

push @bldinf, "PRJ_TESTMMPFILES\n";

push @bldinf, "\n";

my @dlltree;

my $dlltreename='dlltree.h';

push @dlltree, "// $destpath$dlltreename\n";

push @dlltree, "//\n";

push @dlltree, "// Copyright (c) 2000-$copy_end Symbian Ltd. All rights reserved.\n";

push @dlltree, "//\n";

push @dlltree, "\n";

push @dlltree, "#ifndef __DLLTREE_H__\n";

push @dlltree, "#define __DLLTREE_H__\n";

push @dlltree, "#include <e32std.h>\n";

push @dlltree, "\n";

push @dlltree, "class MDllList;\n";

push @dlltree, "\n";

my $ibyname='ldrtest.iby';

my @iby;

foreach $modref (@modules) {

	my @mmp;

	my $num=$$modref{num};

	my $mmpname=$$modref{basefilename}.$mmpext;

	my $defname=$$modref{basefilename}.$defext;

	my $depsref=$$modref{deps};

	my $ndeps=scalar(@$depsref);

	push @mmp, "// $destpath$mmpname\n";

	push @mmp, "//\n";

	push @mmp, "// Copyright (c) 2000-$copy_end Symbian Ltd. All rights reserved.\n";

	push @mmp, "//\n";

	push @mmp, "// Generated from $$modref{name}\n";

	push @mmp, "\n";

	push @mmp, "macro             __DLLNUM$num\n";

	push @mmp, "target            $$modref{filename}\n";

	push @mmp, "targettype        $$modref{trgtype}\n";

	push @mmp, "sourcepath        .\n";

	push @mmp, "source            $$modref{source0} $$modref{source1}\n";

	push @mmp, "library           euser.lib efsrv.lib\n";

	push @mmp, "Capability		NONE\n";

	foreach (@$depsref) {

		my $depref=$modules[$_];

		push @mmp, "library           $$depref{lib}\n";

	}

	if ($$modref{exports}) {

		push @mmp, "deffile           ./$defname\n";

		push @mmp, "nostrictdef\n";

	}

	push @mmp, "OS_LAYER_SYSTEMINCLUDE_SYMBIAN   \n";

	push @mmp, "systeminclude     ../../../e32test/mmu   \n";

	push @mmp, "userinclude       . \n";

	if ($$modref{fixed}) {

		push @mmp, "epocfixedprocess\n";

	}

	# if both paged flags are set or the compression is not pageable then print neither.

	# T_LDRTST will add the required flags when it copies the file to internal media.

	my $bothCodePageFlags = $$modref{pagedcode} && $$modref{unpagedcode};

	my $pageableCompression = $$modref{bytepair} || $$modref{uncompressed};

	if (!$bothCodePageFlags && $pageableCompression) {

		push @mmp, "pagedcode\n" if $$modref{pagedcode};

		push @mmp, "unpagedcode\n" if $$modref{unpagedcode};

	}

	if ($$modref{exe}) {

		# make exes unpageddata by default

		if (!$$modref{pageddata}) {

			$$modref{unpageddata}=1;

		}

		if ($$modref{pageddata}) {

			push @mmp, "pageddata\n";

		}

		if ($$modref{unpageddata}) {

			push @mmp, "unpageddata\n";

		}

	}

	if ($$modref{bytepair}) {

		push @mmp, "bytepaircompresstarget\n";

	}

	if ($$modref{uncompressed}) {

		push @mmp, "nocompresstarget\n";

	}

	if ($$modref{data} && !$$modref{exe}) {

		push @mmp, "epocallowdlldata\n";

	}

	push @mmp, sprintf("uid               0x00000000 0x%08x\n", $num+256);

	push @mmp, "SMPSAFE\n";

	$$modref{mmp}=\@mmp;

	if ($$modref{exports}) {

		my @def;

		push @def, "EXPORTS\n";

		if ($$modref{exe}) {

			push @def, "\tRegisterConstructorCall @ 1 NONAME\n";

			push @def, "\tRegisterInitCall @ 2 NONAME\n";

			push @def, "\tRegisterDestructorCall @ 3 NONAME\n";

		} else {

			push @def, "\tInit$num @ 1 NONAME\n";

			push @def, "\tChkC$num @ 2 NONAME\n";

			push @def, "\tBlkI$num @ 3 NONAME\n";

			push @def, "\tGetGeneration @ 4 NONAME\n";

			push @def, "\tRBlkI$num @ 5 NONAME\n";

			push @def, "\tSetCloseLib @ 6 NONAME\n";

		}

		$$modref{def}=\@def;

	}

	push @bldinf, "$$modref{basefilename}\t\tsupport\n";

	if ($num==0) {

		push @dlltree, "#if defined(__DLLNUM$num)\n";

	} else {

		push @dlltree, "#elif defined(__DLLNUM$num)\n";

	}

	push @dlltree, "#define DLLNUM               $num\n";

	if ($$modref{exe}) {

		push @dlltree, "#define EXENUM               $num\n";

		push @dlltree, "_LIT(KServerName, \"$$modref{name}\");\n";

	}

	push @dlltree, "#define INITFUNC             Init$num\n";

	push @dlltree, "#define CHKCFUNC             ChkC$num\n";

	push @dlltree, "#define BLKIFUNC             BlkI$num\n";

	push @dlltree, "#define RBLKIFUNC            RBlkI$num\n";

	push @dlltree, "#define CHKDEPS(r)           (\\\n";

	foreach (@$depsref) {

		my $depref=$modules[$_];

		unless ($$depref{exe}) {

			my $func="ChkC$_";

			push @dlltree, "\t((r)=$func())!=0 ||\\\n";

		}

	}

	push @dlltree, "\t((r)=0)!=0 )\n";

	push @dlltree, "#define INITDEPS(r,l)        (\\\n";

	foreach (@$depsref) {

		my $depref=$modules[$_];

		unless ($$depref{exe}) {

			my $func="Init$_";

			push @dlltree, "\t((r)=$func(l))!=0 ||\\\n";

		}

	}