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

package Cl_gccxml;

require Exporter;
@ISA=qw(Exporter);
@EXPORT=qw(
	PMHelp_Mmp
	PMStartBldList
	PMBld
	PMStartSrcList
	PMStartSrc
	PMSrcDepend
	PMSrcBldDepend
	PMEndSrcBld
	PMEndSrc
	PMEndSrcList
	PMBitMapBld
	PMResrcBld

);

use cl_generic;
use Genutl;
use File::Path;
use Cwd;
use Pathutl;

sub PMHelp_Mmp {
	print "// No additional keywords for this platform\n";
}

	# takes an 'expression'  to evaluate with $_ bound to each of the
	# remaining args
	sub PrintList
	{
		my $expr = shift @_;
		foreach (@_) {
		my $str = eval($expr);
		&main::Output($str);
		}
	}

my $epocroot = $ENV{EPOCROOT};
$epocroot=~ s-\\$--;            # chop trailing \\
my $Makecmd;
sub PMStartBldList($) {
	($Makecmd) = @_;
	my $BasicTrgType=&main::BasicTrgType;
	my @BldList=&main::BldList;
	my @ChopSysIncPaths=&main::Path_Chop(&main::SysIncPaths);
	my @ChopUserIncPaths=&main::Path_Chop(&main::UserIncPaths);
	my $RelPath="$epocroot\\EPOC32\\RELEASE";
	my @MacroList=&main::MacroList();
	my $VariantFile=&main::VariantFile();
	my $Trg=&main::Trg;
	my $DPath = &main::Path_RltToWork($epocroot);
	my $DefFile = &main::DefFile;
	my $EABIDefFile = &main::EABIDef;
	my $ExtCompileOption = &main::CompilerOption("GCCXML");
	
	&Generic_Header(0,$Makecmd);	# define standard things using absolute paths

	$DefFile="" if(!(-e $DefFile));
	&main::Output(
		"GXPTRGUDEB = $RelPath\\GCCXML\\UDEB\n",
		"GXPTRGUREL = $RelPath\\GCCXML\\UREL\n\n",
		"DEFFILE = $DefFile\n\n",
        "EABIDEFFILE = $EABIDefFile\n\n"
	);

	&main::Output(
		"INCDIR  ="
	);

	foreach (@ChopUserIncPaths) {
		&main::Output(
			" -I \"$_\""
		);
	}

	&main::Output(
		" -I- "
	);

	foreach (@ChopSysIncPaths) {
		&main::Output(
			" -I \"$_\""
		);
	}
	if($VariantFile){
	    &main::Output("\\\n  -include \"$VariantFile\"");
	}
	&main::Output(
		"\n",
		"\n"
	);

	&main::Output( 		
		"GCCFLAGS= -nostdinc -Wall -Wno-ctor-dtor-privacy -Wno-unknown-pragmas -UWIN32 -fshort-wchar -quiet -w $ExtCompileOption\n",  # -fsyntax-only
		"\n"
	);

	&main::Output(
		"GCCDEFS = -D __EABI__ -D __SUPPORT_CPP_EXCEPTIONS__"
	);
	foreach(@MacroList) {
		&main::Output(
			" -D$_"
		);
	}
	&main::Output(
		" \$(USERDEFS)\n",
		"\n"
	);

	foreach (@BldList) {
		&main::Output(
			"GCC$_ = gccxml_cc1plus -bi"
		);
		if (/REL$/o) {
			&main::Output(
				      ' -fomit-frame-pointer '
			);
		}
		elsif (/DEB$/o) {
			&main::Output(
				' -g'
			);
		}
		&main::Output(
			' $(GCCFLAGS)'
		);
		foreach (&main::MacroList($_)) {
			&main::Output(
				" -D$_"
			);
		}
                
		&main::Output(
			" \$(GCCDEFS)\n"
		);
	}
	&main::Output(
		"\n",
		"\n"
	);
	
	&main::Output(
			"LIBRARY:\n",
			"\t\@echo Nothing to do\n"
	);

	# Resource building is done entirely via cl_generic.pm
	PrintList("\"\nRESOURCE\$_ : MAKEWORK\$_\"", @BldList)
	&main::Output(
		"\n",
		"\n",
	);

	foreach (@BldList) {
		&main::Output(
			"$_ :"
		);

		if ($BasicTrgType !~ /IMPLIB/io) {
			my $TrgBase = &main::Path_Split('base',$Trg);           
			&main::Output (
			" \\\n\t",
			&Generic_Quote("\$(GXPTRG$_)\\$TrgBase$BasicTrgType.gxp")
			);
		}
		&main::Output(
			"\n",
			"\n"
		);
	}
}

# DumpToFile
sub DumpMMPToFile
{
	my $rfiFileList;
	my @rfiFiles;
	if(scalar @_) # if an argument has been passed then it is a reference to the list of .RFI files.
	{
		($rfiFileList) = @_;
		@rfiFiles = @$rfiFileList;
	}

	my $BldPath=&main::BldPath;
	my $Target = &main::Trg; 
	my $TargetBase = &main::Path_Split('Base', $Target); 
	my $Gxpurel="$epocroot\\epoc32\\release\\gccxml\\urel";
	my $Gxpudeb="$epocroot\\epoc32\\release\\gccxml\\udeb";
	unless (-d $BldPath) {
		mkpath([$BldPath]);
	}
	unless (-d $Gxpurel) {
		mkpath([$Gxpurel]);
	}
	unless (-d $Gxpudeb) {
		mkpath([$Gxpudeb]);
	}
    $BldPath = (&main::Path_StepDirs($BldPath))[-2];
	use File::Basename;
    my $FileName = basename(&main::MmpFile());
    $FileName = $BldPath.$FileName.".xml";
    open FILE,"> $FileName" or die "Cannot open mmp info dump file $FileName: $!";
    print FILE "<?xml version=\"1.0\"?>\n<mmpInfo>\n"; 
   
    my $Path = &main::RelPath();
    my $MmpFile = &main::MmpFile();  
    my $TrgType = &main::TrgType(); 
    my $TrgPath = &main::TrgPath(); 
    print FILE "\t<mmp path=\"$MmpFile\"/>\n"; 
	print FILE "\t<target name=\"$Target\" type=\"$TrgType\" ";
    
	if(not $TrgPath eq '') 
	{
		print FILE "path=\"$TrgPath\""; 
	}
	print FILE "/>\n";
	# insert current working directory
	my $WorkPath = &main::Path_WorkPath();
	print FILE "\t<cwd path=\"$WorkPath\"/>\n";
    
    my $ABI = &main::ABI; 
    print FILE "\t<abi type=\"$ABI\"/>\n"; 
    my $LinkAs = &main::LinkAs;
    print FILE "\t<linkAs name=\"$LinkAs\"/>\n"; 
    my $LinkAsBase = &main::LinkAsBase;
    print FILE "\t<linkAsBase name=\"$LinkAsBase\"/>\n"; 
    
    # Uids
    my @UidList=&main::UidList;
    my $count = 0;
    print FILE "\t<uids";
    foreach my $uid(@UidList)
    {
		print FILE " u$count=\"$uid\"" ;
		$count++; 
    }
    print FILE "/>\n";
    
    # Versioning 
    my %Version = &main::Version; 
    print FILE "\t<version";
    foreach my $var (sort keys %Version)
    {
        print FILE " $var=\"$Version{$var}\"";
    }
    print FILE "/>\n";
    
    # Capabilities
    my $Capability = &main::Capability;
    print FILE "\t<capability id=\"$Capability\"/>\n"; 
    
	# DefFile
	my $DefFile = &main::DefFile;
	$DefFile="" if(!(-e $DefFile));
	print FILE "\t<defFile path=\"$DefFile\" type=\"GCC\"/>\n";

	# EABIDefFile
	my $EABIDefFile = &main::EABIDef;
	print FILE "\t<defFile path=\"$EABIDefFile\" type=\"EABI\"/>\n";
        
    # Handle All types of libraries
    my $FirstLib = &main::FirstLib; 
    my @LibList = &main::LibList;
    my @ASSPLibList = &main::ASSPLibList;
    my @StatLibList = &main::StatLibList;;    
    print FILE "\t<libs>\n"; 
    
	#first
    print FILE "\t\t<lib name=\"$FirstLib\" type=\"First\"/>\n"; 
    
    #  normal
    foreach my $lib (@LibList)
    {
        print FILE "\t\t<lib name=\"$lib\"/>\n"; 
    }
    # ASSP Specific
    foreach my $lib (@ASSPLibList)
    {
        print FILE "\t\t<lib name=\"$lib\" type=\"ASSP\"/>\n";
    }
    
    # Static Libraries
    foreach my $lib (@StatLibList)
    {
        print FILE "\t\t<lib name=\"$lib\" type=\"Static\"/>\n";
    }
    print FILE "\t</libs>\n";

    # Resources
    print FILE "\t<resources>\n";
    my $rfiFile;
    foreach $rfiFile (@rfiFiles)
    {
	    print FILE "\t\t<resource name=\"$rfiFile\"/>\n";
    }
    print FILE "\t</resources>\n";

    close FILE;
}
	
sub PMBld {
	my @ASSPLibList=&main::ASSPLibList;
	my @SrcList=&main::SrcList;
	my $BaseTrg=&main::BaseTrg;
	my $Bld=&main::Bld;
	my $ChopBldPath=&main::Path_Chop(&main::BldPath);
	my $EPOCIncPath=&main::EPOCIncPath;
	my $BasicTrgType=&main::BasicTrgType;
	my $ChopRelPath=&main::Path_Chop(&main::RelPath);
	my $RelPath=&main::RelPath;
	my $Trg=&main::Trg;
	my $TrgType=&main::TrgType;
	my @UidList=&main::UidList;
	# DefFile
	my $DefFile = &main::DefFile;
	# EABIDefFile
	my $EABIDefFile = &main::EABIDef;

	my $rfiList = GatherResourceInformation();
	my @RfiFiles = @$rfiList;



	DumpMMPToFile(\@RfiFiles);

	# REAL TARGETS
	#-------------
	&main::Output(
		"# REAL TARGET - BUILD VARIANT $Bld\n",
		"\n"
	);

	&main::Output(
		"WHAT$Bld : WHATGENERIC\n",
		"\n",
		"CLEAN$Bld : CLEANBUILD$Bld CLEANRELEASE$Bld\n",
		"\n",
		"CLEANBUILD$Bld : \n",
		"\t\@perl -S ermdir.pl \"\$(EPOCBLD$Bld)\"\n",
		"\n",
		"CLEANRELEASE$Bld : CLEANGENERIC\n",
		"\n"
	);
	my @releaseables;
	&Generic_WhatCleanTargets($Bld, "WHAT$Bld", "CLEANRELEASE$Bld", @releaseables);
	&Generic_MakeWorkDir("MAKEWORK$Bld",$ChopBldPath);
	&Generic_MakeWorkDir("MAKEWORK$Bld",$ChopRelPath);
	&Generic_Releaseables;

	&main::Output(
		"\n",
		"\n"
	);

	# XML Stuff
	&main::Output(
				&Generic_Quote("\$(GXPTRG$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : ",
				&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"),
				"\n\tcopy \"\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp\" \"\$@\""
	); 
	
	&main::Output(
		"\n",
		"\n"
	);
        
	# TARGET *.GXP
	#------------
	if (scalar @SrcList >150) {
		# deal with very long lists by splitting them into 150 file pieces, which allows
		# about 200 bytes per filename if the underlying max size is 32K
		#

		my $counter1=150;	# i.e. trigger new variable immediately
		my $counter2=0;
		my @objvarlist=();
		foreach (@SrcList) {
			if ($counter1==150) {
				$counter1=0;
				$counter2++;
				my $objvar = "OBJECTS$Bld$counter2";
				push @objvarlist, " \$($objvar)";
				&main::Output(
					"\n",
					"$objvar="
				);
			}
			my $BaseSrc = &main::Path_Split('Base', $_);
			my $Ext = &main::Path_Split('Ext', $_);
			$BaseSrc.='_' if (lc($Ext) eq '.cia');
			&main::Output(
				" \\\n\t", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.xml")
			);
			$counter1++;
		}
		use File::Basename;
	    my $FileName = basename(&main::MmpFile()).".xml";
		&main::Output(
			" \\\n\t\$(EPOCBLD)\\$FileName",
			"\n",
			"\n",
			&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : ", @objvarlist,"\n",
			"\tif exist \"\$\@\" del \"\$\@\"\n"
		);
		foreach (@objvarlist) {
			&main::Output(
				"\tzip -j \$\@$_\n"
			);
		}
		&main::Output(
			"\tif exist \$(EABIDEFFILE) zip -j \$\@ \$(EABIDEFFILE)\n",
			"\n\n"
		);
	} else {
		# shorter lists remain unchanged
		#
		&main::Output(
			"OBJECTS$Bld="
		);
		use File::Basename;
	    my $FileName = basename(&main::MmpFile()).".xml";

		&main::Output("\$(EPOCBLD)\\$FileName");
        foreach (@SrcList) {
			my $BaseSource = &main::Path_Split('Base', $_);
			my $Ext = &main::Path_Split('Ext', $_);
			$BaseSource.='_' if (lc($Ext) eq '.cia');
			&main::Output(
			" \\\n\t", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSource.xml")
			);
		}       
		
		&main::Output(
			"\n",
			"\n"
		);

		&main::Output("RESOURCEINFO$Bld=");
		foreach (@RfiFiles)
		{
			&main::Output(" \\\n\t\$(EPOCBLD)\\$_");
		}
		&main::Output("\n\n");

		&main::Output(

			&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : \$(OBJECTS$Bld) \$(EABIDEFFILE) \$(RESOURCEINFO$Bld)\n",

			"\tif exist \"\$\@\" del \"\$\@\"\n",
			"\tzip -j \$\@ \$^ \$(EABIDEFFILE) \$(RESOURCEINFO$Bld)\n",
			"\n\n"
		);
	}
}


sub PMStartSrcList {

	&main::Output(
		"# SOURCES\n",
		"\n"
	);
}

sub PMBitMapBld {
	&Generic_BitMapBld;
}

sub PMResrcBld {
	&Generic_ResrcBld;
}

sub PMStartSrc {
	my $Src=&main::Src;

	&main::Output(
		"# Source $Src\n",
		"\n"
	);
}

sub PMSrcDepend {
	my @BldList=&main::BldList;	
	my @DepList=&main::DepList;
	my $BaseSrc=&main::BaseSrc;
	my $ExtSrc=&main::ExtSrc;
	my $cia = (lc($ExtSrc) eq '.cia') ? "_" : "";

	return if (@DepList == 0);

	foreach (@BldList) {
		&main::Output(
			&Generic_Quote("\$(EPOCBLD$_)\\$BaseSrc$cia.lis"), " ",
			&Generic_Quote("\$(EPOCBLD$_)\\$BaseSrc$cia.xml"), " \\\n",
		);
	}
	&main::Output(
		":"
	);
	foreach (@DepList) {
		&main::Output(
		" \\\n\t", &Generic_Quote($_)
		);
	}
	&main::Output(
		"\n",
		"\n"
	);
}

sub PMSrcBldDepend {
	my $Bld=&main::Bld;
	my @DepList=&main::DepList;
	my $BaseSrc=&main::BaseSrc;
	my $ExtSrc=&main::ExtSrc;
	my $cia = (lc($ExtSrc) eq '.cia') ? "_" : "";

	return if (@DepList == 0);

	&main::Output(
		&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc$cia.lis"), " ",
		&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc$cia.xml"), " :",
	);
	foreach (@DepList) {
		&main::Output(
			" \\\n\t", &Generic_Quote($_)
		);
	}
	&main::Output( 
		"\n",
		"\n"
	);
}

my %sources;

sub PMEndSrcBld {
	my $ABI=&main::ABI;
	my $BaseSrc=&main::BaseSrc;
	my $Bld=&main::Bld;
	my $Src=ucfirst lc &main::Src;
	my $SrcPath=&main::SrcPath;
	my $Ext = &main::Path_Split('Ext', $Src);
	my $Cia = (lc($Ext) eq '.cia') ? 1 : 0;

	my $ChopSrcPath=&main::Path_Chop($SrcPath);

	# add source path, source file and build type to hashmap. 
    $sources{$SrcPath}{$Src}{$Bld}=1;
   
	# Use GCC trick to get assembler source files preprocessed with CPP
	$Src =~ s/\.s$/.S/i;

	if ($Cia) {
		&main::Output(
			&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.xml"), " : ",
			&Generic_Quote("$SrcPath$Src"), "\n",
			"\t\$(GCC$Bld) -D__CIA__ -I \"$ChopSrcPath\" \$(INCDIR) -fxml=\$\@ -o nul \"$ChopSrcPath\\$Src\"\n",
			"\n",
		);
	} else {
		&main::Output(
			&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.xml"), " : ",
			&Generic_Quote("$SrcPath$Src"), "\n",
			"\t\$(GCC$Bld) -I \"$ChopSrcPath\" \$(INCDIR) -fxml=\$\@ -o nul \"$ChopSrcPath\\$Src\"\n",
			"\n",
		);
	}

	#Keep the staus of the dependency-generation-flag was enabled or disabled.
	my $Deps_Stat = &main::Deps_GetNoDependencies();
	if($Deps_Stat){
		#If the no-dependency-generation-flag turned on, turn it off temporarily, so that we can get 
		#the dependencies.
		&main::Deps_SetNoDependenciesStatus(0);
	}
	# Code to print the log file includeheaders.txt
	my $IncFileName = "$epocroot\\epoc32\\release\\gccxml\\includeheaders.txt";
	open INC_FILE,">> $IncFileName" or die "Cannot open file $IncFileName";

	#Get the dependencies for the current source file.
	my @DepList=&main::Deps_GenDependsL("$SrcPath$Src");
	foreach(@DepList) {
		print INC_FILE "$_\n";
	}
	close INC_FILE;
	
	#Set the dependency-generation-flag to its original state so that, it doesn't affect the other target 
	#builds.
	&main::Deps_SetNoDependenciesStatus($Deps_Stat);

	# Code to print the existance of the file in logs
	my $neededfile="$epocroot\\epoc32\\release\\gccxml\\includeheaders.txt";
	if (!-e $neededfile)
	{ 
		print "!!! File $epocroot\\epoc32\\release\\gccxml\\includeheaders.txt does not exist\n";
	}
}

sub PMEndSrc {
	&main::Output(
		"\n",
		"\n"
	);
}

sub PMEndSrcList {
        my $BldPath=&main::BldPath;
        my $Target = &main::Trg; 
        my $TargetBase = &main::Path_Split('Base', $Target);
		use File::Basename;
	    my $FileName = basename(&main::MmpFile());
	    $FileName = $BldPath.$FileName.".xml";
        open FILE,">> $FileName" or die "Cannot open mmp info dump file $FileName: $!";
		my $path;
        foreach $path (keys %sources)
        {
            my %thing =  %{$sources{$path}}; # {"UREL"}; 
            my $file;
            foreach $file (keys %thing)
            {
                if( defined $thing{$file}{"UREL"})
                {
                    if( defined  $thing{$file}{"UDEB"} )
                    {
                        print FILE "\t<sourceFile name=\"$file\" path=\"$path\"/>\n";
                    }
                    else
                    {
                        print FILE "\t<sourceFile name=\"$file\" path=\"$path\" type=\"UREL\"/>\n";
                    }
                }
                else
                {
                    if(defined $thing{$file}{"UDEB"})
                    {
                        print FILE "\t<sourceFile name=\"$file\" path=\"$path\" type=\"UDEB\"/>\n";
                    }
                    else
                    {
                        die "Should Never Get HERE!";
                    }
                }
                
            }
        }
        


        my $BldInfDir=&Path_WorkPath;
        my $PrjBldDir=$E32env::Data{BldPath};
        $PrjBldDir=~s-^(.*)\\-$1-o;
        $PrjBldDir.=$BldInfDir;
        $PrjBldDir=~m-(.*)\\-o; # remove backslash because some old versions of perl can't cope


        ### the export call is like this
        my $lCmd = "make -r -f \"${PrjBldDir}EXPORT.make\" WHAT";
        my @lExportDump = split(/\n/,`$lCmd`);
        foreach my $lLine (@lExportDump) {
            $lLine =~ s/"//g;
            chomp($lLine);
            if($lLine =~ /.*\.h/i) {
                print FILE "\t<export name=\"$lLine\"/>\n";
            }
        }

		print FILE "</mmpInfo>\n\n";
        close FILE;



		&Generic_End;
}


sub GetRelDir
{
	my ($fileName) = @_;
	$fileName = CleanPath($fileName); # make sure that /'s are use rather than \ or \\
	if($fileName!~m-\/-) # no directory, just a file name, so return ./
	{
		return "./";
	}
	elsif($fileName=~m-^(.*\/)[^\/]+$-) # return directory
	{
		return $1;
	}
	else # don't know how could get here
	{
		return "./";
	}
}


sub SearchMmpFile
{
	my @rfiFiles;
	my @SystemIncludes = &main::SysIncPaths;
	my @UserIncludes = &main::UserIncPaths;
	my $ResourceStruct = &main::ResourceStructRef;
	
	foreach my $ResourceStructure (@$ResourceStruct)
	{
		push @rfiFiles, AnalyseResourceFile($$ResourceStructure{Source}, \@SystemIncludes, \@UserIncludes);
	}
	return \@rfiFiles;
}

sub AnalyseResourceFile
{ # when get to here $rssFile should be fully qualified relative to mmp file location (i.e. base: .../name.rss)
	my ($rssFile, $systemIncludeList, $userIncludeList) = @_;
	my @resourceRelatedFiles = ($rssFile);
	my $baseFile = 0; #flag to indicate whether this is the base file which the rfi file is named after
	my $rssItem;
	my $containerFile;
	foreach $rssItem (@resourceRelatedFiles) #@resourceRelatedFiles is added to during this foreach loop as included files are found
	{
		$rssItem = CleanPath($rssItem);
		if( ! ($baseFile) )
		{
			$baseFile = 1; # set to non-zero so that setting up the rfi file is only done once
			if($rssItem =~m-\/-)
			{
				if($rssItem =~m-^\S*\/([^\/]+)$-) # just extracts file name
				{
					$containerFile = $1 . ".rfi";
				}
			}
			else
			{
				$containerFile = $rssItem . ".rfi";
			}
			open CONTAINER, ">$containerFile";
		}
		OutputHeader($rssItem);
		my $resourceFiles = ReadFile($rssItem, \@resourceRelatedFiles, $systemIncludeList, $userIncludeList);
		@resourceRelatedFiles = @$resourceFiles;
	}
	close CONTAINER;
	return $containerFile;
}

sub CheckForInclude
{ # check whether the passed line from the resource type file is a #include line, if it is then store it to be added to the rfi file
	my ($line, $dir, $resourceFiles, $systemIncludeList, $userIncludeList) = @_;
	my @resourceFiles = @$resourceFiles;
	if($line =~ /^\s*\#include\s+([\<\"])(\S+)([\>\"])(\s+\/\/.*)?/)
	{
		if( ($1 eq "\"") and ($3 eq "\"") )
		{
			my $possibleAddition = SearchDirectories($2, "quoted", $dir, $systemIncludeList, $userIncludeList);
			if($possibleAddition ne "")
			{
				push @resourceFiles, $possibleAddition;
			}
		}
		elsif( ($1 eq "\<") and ($3 eq "\>") )
		{
			my $possibleAddition = SearchDirectories($2, "angle", $dir, $systemIncludeList, $userIncludeList);
			if($possibleAddition ne "")
			{
				push @resourceFiles, $possibleAddition;
			}
		}
	}
	return \@resourceFiles;
}

sub ReadFile
{ # copy the passed file into the rfi file and check it for included files
	my ($fileName, $resourceFiles, $systemIncludeList, $userIncludeList) = @_;
	my $dir = GetRelDir($fileName);

	open RESOURCE, $fileName or die "Can't open file $fileName from " . cwd() . "\n";
	my $line;
	foreach $line (<RESOURCE>)
	{
		print CONTAINER $line;
		$resourceFiles = CheckForInclude($line, $dir, $resourceFiles, $systemIncludeList, $userIncludeList);
	}
	close RESOURCE;
	return $resourceFiles;
}

sub OutputHeader
{
	my ($fileName) = @_;
	print CONTAINER "\n\n/* GXP ***********************\n";
	if($fileName =~m-\/-)
	{ # remove path as only want to store file name
		if($fileName =~m-^\S*\/([^\/]+)$-)
		{
			print CONTAINER " * $1\n";
		}
	}
	else
	{
		print CONTAINER " * $fileName\n";
	}
	print CONTAINER " ****************************/\n\n";
}


sub RecordSystemIncludes
{
	my ($line) = @_;
	my @terms = split(/ /, $line);
	my $term;
	my @systemIncludes = ();
	foreach $term (@terms)
	{
		if($term!~m/\/\//) # if term is not the start of a c++ style comment
		{
			push @systemIncludes, $term;
		}
		else
		{
			last;
		}
	}
	return \@systemIncludes;
}

sub RecordUserIncludes
{
	my ($line) = @_;
	my @terms = split(/ /, $line);
	my $term;
	my @userIncludes = ();
	foreach $term (@terms)
	{
		if($term!~m/\/\//) # if term is not the start of a c++ style comment
		{
			push @userIncludes, $term;
		}
		else
		{
			last;
		}
	}
	return \@userIncludes;
}

sub CleanPath # change \ and \\ in path to /
{
	my ($fileName) = @_;
	$fileName =~ s-\\\\-\/-og;
	$fileName =~ s-\\-\/-og;
	return $fileName;
}

sub RecordSourcePath
{
	my ($line) = @_;
	my $sourcePath;
	if($line=~/^(\S+)/) # in case of comments at end of line
	{
		$sourcePath = $1;
		$sourcePath = CleanPath($sourcePath);
		if($sourcePath !~ m/\/$/)
		{
			$sourcePath .= "\/";
		}
	}
	return $sourcePath;
}

sub SearchDirectories
{
	my ($fileName, $includeType, $base, $systemIncludeList, $userIncludeList) = @_;
	my @systemIncludes = @$systemIncludeList;
	my @userIncludes = @$userIncludeList;

	$fileName = CleanPath($fileName);

	if(-e $base.$fileName)
	{
		return $base.$fileName;
	}
	if($includeType eq "quoted")
	{
		# search through the user includes and return dir + file name if found
		my $directory;
		foreach $directory (@userIncludes)
		{
			my $qualifiedFileName = $directory . "/" . $fileName;
			if(-e $qualifiedFileName)
			{
				return $qualifiedFileName;
			}
		}
	}

	# search through the system includes
	my $directory;
	foreach $directory (@systemIncludes)
	{
		my $qualifiedFileName = $directory . "/" . $fileName;
		if(-e $qualifiedFileName)
		{
			return $qualifiedFileName;
		}
	}
	return "";
}


sub GatherResourceInformation
{
	my $BldPath=&main::BldPath;
	unless (-d $BldPath) {
		mkpath([$BldPath]);
	}
	$BldPath = (&main::Path_StepDirs($BldPath))[-2];
	my $bldInfDirectory = cwd(); # store current directory so can return to it later
	my $MmpFile = &main::MmpFile();
	$MmpFile = CleanPath($MmpFile);
	my $MmpFileDir = "./";
	my $MmpFileName = $MmpFile;
	if($MmpFile=~m-\/-)
	{
		if($MmpFile=~m-^(.*)\/([^\/]*)$-)
		{
			$MmpFileDir = $1;
			$MmpFileName = $2;
		}
	}
	chdir($MmpFileDir) or die "Error: Could not change to MMP file directory: $MmpFileDir\n";
	
	my $rfiFileList = &SearchMmpFile; # analyse the mmp file for resource files

	my @RfiFiles = @$rfiFileList;
	foreach (@RfiFiles) # copy the rfi files to the BldPath and delete them from temporary locations
	{
		system("copy \"$_\" \"$BldPath$_\"");
		unlink $_;
	}
	chdir($bldInfDirectory); # return to the orignial directory

	return \@RfiFiles; # return list of rfi files to be added to .mmp.xml file
}
1;