# This file is part of Nokia EC Tools release

#

#============================================================================ 

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

# 

#==============================================================================

my $version=35;

# 35 2008-09-26 jaakpaak:ou1tools#2679 Changed copyright symbol. Two days to go and I'm off to Atomia. Have fun.

# 34 2008-09-23 jaakpaak:ou1tools#2677 Added command line options to revert to "make" instead of anything else for selected commands

# 33 2008-09-19 jaakpaak:ou1tools#2673 Added copyright notice

# 32 2008-09-11 jaakpaak:ou1tools#2661 Changed abld what and abld check targets to always use "make" in MAKE variable

# 31 2008-09-03 jaakpaak:ou1tools#2627 Added creation of *-other-files.txt and *-other.zip

# 30 2008-08-05 jaakpaak:ou1tools#2610 Add quoting of direct to file operator >

# 29 2008-07-17 jaakpaak:ou1tools#2611 Get rid of symbian tool chain patching for emake

# 28 2008-07-07 jaakpaak:ou1tools#2607 sysdef2make.pl to generate correct makefile independent of the location where the script is located

# 27 2008-07-01 jaakpaak:ou1tools#2604 -n configuration option to sysdef2make to make it generate only configuration specific makefile

# 26 2008-05-23 jaakpaak:ou1tools#2566 Improve output warnings and errors to be symbian compatible

# 25 2008-03-26 jaakpaak:ou1tools#2531 Fix the output for log processor to be more compatible with EBS, increased quoting for special characters

# 24 2008-03-13 jaakpaak:ou1tools#2522 Fix for last special instruction missing

# 23 2008-03-07 jaakpaak:ou1tools#2516 Fix for buildLayer instructions which are executed twice

# 22 2008-03-03 jaakpaak:ou1tools#2511 Targets for creating zip files from your workarea

# 21 2008-02-29 jaakpaak:ou1tools#2510 Do not overwrite configuration-task targets targets with layer-task targets, printing of filters

# 20 2008-02-28 jaakpaak:ou1tools#2495 Fix for specialInstruction dependencies and build time loggin dependencies

# 19 2007-12-20 jaakpaak:ou1tools#2440 Fix for unitlists containing white spaces

# 18 2007-12-17 jaakpaak:ou1tools#2432 Restructured variables, quoted echoing of command line

# 17 2007-11-29 jaakpaak:ou1tools#2427 Fix to layer names containing white spaces, prefix also to specialInstructions

# 16 2007-11-15 jaakpaak:ou1tools#2420 Fixed issue with multiple filters and empty unit lists

# 15 2007-11-15 jaakpaak:ou1tools#2408 Added configuration-UNITS variable and optionless generic component rules

# 14 2007-11-12 jaakpaak:ou1tools#2407 Added warning to layers not having any units

# 13 2007-11-09 jaakpaak:ou1tools#2405 Fix to layers

# 12 2007-10-31 jaakpaak:ou1tools#2402 Added -s option for path prefix and priorities

# 11 2007-10-18 jaakpaak:ou1tools#2356 Fixed problems with filters and buildtime logging

# 10 2007-10-18 jaakpaak:ou1tools#2356 Fixed dependency problems on EC, made everyting unit based (previously bld.inf based)

# 09 2007-09-07 jaakpaak:ou1tools#2351 Added build time logging

# 08 2007-09-01 jaakpaak:ou1tools#2340 Added error ignoring for selected commands and -v option

# 07 2007-08-23 jaakpaak:ou1tools#2320 Submaked execution

# 06 2007-08-15 jaakpaak:ou1tools#2311 Removed printing of empty unit lists, timestamp as perl script, makefiled unitlist/layernames

# 05 2007-08-08 jaakpaak:ou1tools#2291 Added -filter option for user defined filters

# 04 2007-08-07 jaakpaak:ou1tools#2290 Added tags for scanlog to specialInstructions also

# 03 2007-07-04 jaakpaak:ou1tools#2275 htmlscanlog compatibility fixes

# 02 2007-07-03 jaakpaak:ou1tools#2274 fixed specialInstructions handling

# 01 2007-06-29 jaakpaak:ou1tools#2273 abldOption also valid for bldmake commands

my $scriptDir=$0;

# Strip the file from the path

$scriptDir =~ s{[^\\\/]*$}{};

use lib "$ENV{EPOCROOT}epoc32/tools/build/lib";

use XML::DOM;

my @userFilters = ();

my @forceMakeCommands = ("abld.*\-(w|what|c|check|checkwhat|cw)[^a-zA-Z0-9]");

my $file = "";

my $pathPrefix = "";

my @userConfigurations = ();

my @configurations = ();

my $makefileName = "makefile";

my $makefileOption = "";

my $i=0;

while ( $i < scalar (@ARGV) ) {

	if ( $ARGV[$i] eq "-filter" ) {

		push( @userFilters, $ARGV[$i+1] );

		$i += 2;

	} elsif ( $ARGV[$i] eq "-forcemake" ) {

		push( @forceMakeCommands, $ARGV[$i+1] );

		$i += 2;

	} elsif ( $ARGV[$i] eq "-s" ) {

		$pathPrefix = $ARGV[$i+1];

		$i += 2;

	} elsif ( $ARGV[$i] eq "-n" ) {

		push( @configurations, $ARGV[$i+1] );

		$i += 2;

	} else {

		$file = $ARGV[$i];

		$i++;

	}

}

my $otherCommandLineOptions;

my $i=1;

while ( $i < scalar(@forceMakeCommands) ) {

    $otherCommandLineOptions.="-forcemake \"".quoteCommandForEcho($forceMakeCommands[$i])."\" ";

    $i++;

}

if ( @configurations ) {

    push(@userConfigurations,@configurations);

    $makefileName = join("_",@configurations).".make";

} 

open(MAKEFILE,"> $makefileName");

my $parser = XML::DOM::Parser->new();

my $doc = $parser->parsefile($file);

# Commands which' errors will be ignored 

my %ignoreErrorCommands = ( "mkdir" => 1,

                            "md" => 1,

                            "del" => 1,

                            "rmdir" => 1,

                            "echo" => 1,

                            "rem" => 1,

                            "xcopy" => 1,

                            "dir" => 1 );

# Hash containing unitID's and bldFiles.

# Keys are unitID's

my %bldFiles;

# Hash containing the units of each layer and unitlist

# Key is the name of list, value is a list of unitId.s

# The bldFile has to be obtained from unitIDs

my %units;

# Hash containing the actual abldTarget's of the command line. 

# The key is the name of the target in System Definition xml

my %targets;

# Hash containing arrays of the real abldTarget's 

# Key is the name defined in targetList in system definition xml

my %targetLists;

# Hash containing the default unitlists of each configuration

# Key is the name of the configuration

my %unitLists;

# Hash containing contents of each specialInstruction

# Key is the makefile target name of each specialInstruction

# Value is the command line including cd part

my %specialInstructions;

# The bldfiles which are excluded from each configuration

my %excludedUnits;

# Hash containing the makefile targets for each task

# Key is the task as a makefile target and values is a hash of buildlayer task

my %buildLayerTasks;

# So you cannot execute _any_ buildLayer command for _any_ unitList or layer

# The combination must exist also in system definition xml

# $unitId -> filterhash

my %unitFilters;

# List of all filters set in units

my %filters;

# Priorities of each unit

# unitId -> priority

my %unitPriorities;

# Configuration makefile rules

my %configurationTasks = ();

my %optionNames;

my %options;

# Set verbose option on manually

push( @{$options{abldOption}},"VERBOSE");

push( @{$options{bldmakeOption}},"VERBOSE");

$optionNames{"VERBOSE"} = "-v";

# Loop through all the layers

foreach my $layer ( $doc->getElementsByTagName('layer') ) {

    my $layerName = $layer->getAttribute('name');

    # Loop through all the units in the layer

    foreach my $unit ( $layer->getElementsByTagName('unit') ) {

        my $unitID = $unit->getAttribute('unitID');

        my $bldFile = $unit->getAttribute('bldFile');

        my $priority = $unit->getAttribute('priority');

        # Set the filter status

        $unitFilters{$unitID} = $unit->getAttribute('filter');

        # Set filters to global hash

        foreach my $word ( split(/,/,$unitFilters{$unitID}) ) {

            $word =~ s{^!}{};

            $filters{$word} = 1;

        }

        if ( $pathPrefix &&

             $bldFile !~ m{^\Q$pathPrefix\E}i ) {

            $bldFile = $pathPrefix.$bldFile;

        }

        if (-d $bldFile) {

	        # Set bldFile to the unitID

    	    $bldFiles{$unitID} = $bldFile;

        } else {

            print(STDERR "ERROR: could not find $bldFile.\n");

            next;

        }

        # Set the default priority

        if ( ! $priority ) {

            $priority = 1000;

        }

        $unitPriorities{$unitID} = $priority;

        # Set the bldfile to the unitlist

        my $i = scalar(@{$units{$layerName}});

        while ( $i > 0 ) {

            my $prevUnit = $units{$layerName}[$i-1];

            if ( $unitPriorities{$prevUnit} <= $unitPriorities{$unitID}  ) {

                last;

            } else {

                $i--;

            }           

        }

        # Insert init to slot $i

        splice( @{$units{$layerName}},$i,0,$unitID);

    }

}

# Loop through all unitLists

foreach my $unitList ( $doc->getElementsByTagName('unitList') ) {

	my $unitListName = $unitList->getAttribute('name');

	# Loop through all unitRefs inside the unitLiss

	foreach my $unitRef ( $unitList->getElementsByTagName('unitRef') ) {

		my $unitID = $unitRef->getAttribute('unit');

		# Set the bldfile to the unitlist

		if ( $bldFiles{$unitID} ) {

			my $i = scalar(@{$units{$unitListName}});

			while ( $i > 0 ) {

				my $prevUnit = $units{$unitListName}[$i-1];

				if ( $unitPriorities{$prevUnit} <= $unitPriorities{$unitID}  ) {

					last;

				} else {

					$i--;

				}			

			}

            # Insert init to slot $i

			splice( @{$units{$unitListName}},$i,0,$unitID);

		} else {

			print(STDERR "ERROR: unitList by the name \"".$unitListName."\" has unitRef to \"".$unitID."\" which is not defined.\n");

		}

	}

}

# Get targets from the whole SystemDefinition.xml

foreach my $target ( $doc->getElementsByTagName('target') ) {

	my $targetName = $target->getAttribute('name');

	my $abldTarget = $target->getAttribute('abldTarget');

	$targets{$targetName} = $abldTarget;

}

# Get targetLists

foreach my $targetList ( $doc->getElementsByTagName('targetList') ) {

	my $name = $targetList->getAttribute('name');

	my $targetString = $targetList->getAttribute('target');

	foreach my $target ( split( /\s+/, $targetString ) ) {

		push( @{$targetLists{$name}}, $targets{$target} )

	}

}

# Get options

foreach my $option ( $doc->getElementsByTagName('option') ) 

# Loop through all option elements

{

	my $attributes = $option->getAttributes();

	my $i = 0;

	my %attributeHash;

	while ( $i < $attributes->getLength() ) 

	# go through all attributes

	{

		my $item = $attributes->item($i);

		# Get name and value for each item in option attributes

		my $name = $item->getName();

		my $value = $item->getValue();

		# Insert attribute value into hash by key as name

		$attributeHash{$name} = $value;

		$i++;

	}

	foreach my $key ( keys(%attributeHash) ) 

	# Go through generated attribute hash

	{

		if ( $key =~ m{.*Option} && $attributeHash{'enable'} =~ m{y}i ) 

		# Attribute key is somethingOption and it is enabled

		{

			# Set options hash

			$optionNames{$attributeHash{"name"}} = $attributeHash{$key};

			push( @{$options{$key}}, $attributeHash{"name"} );

			# abldOptions become bldmakeOptions

			# bldMake only supports -keepgoing and -verbose options

			if ( $key eq "abldOption" && 

				 ( $attributeHash{$key} =~ /^\s*-k/i ||

				   $attributeHash{$key} =~ /^\s*-v/i )) {

				push( @{$options{bldmakeOption}}, $attributeHash{"name"} );

			}

		}

	}

}

my @xmlConfigurations = ();

# This loop digs out unitlists, layers and tasks from each configuration

foreach my $xmlConfiguration ( $doc->getElementsByTagName('configuration') ) {

    my $configurationName = $xmlConfiguration->getAttribute('name');

    # Store all configurations to a list

    push( @xmlConfigurations, $configurationName );

    # Check we are not using configuration name which overlaps with unit list name

    foreach my $layer ( keys(%units)) {

        if ( lc($layer) eq lc($configurationName) ) {

            print(STDERR "ERROR: Configuration \"$configurationName\" is defined also as unitList/layer \"$layer\". Names MUST BE UNIQUE!\n");

            last;

        }

    }

    my $taskId=1;

    # Get the filters of the configuration

    my @configurationFilters = split( /,/, $xmlConfiguration->getAttribute('filter') );

    # Add user specified filters to current configuration

    push( @configurationFilters, @userFilters );

    # Get the first child of the configuration

    my $xmlElement = $xmlConfiguration->getFirstChild();

    # This variable keeps track when specialInstruction changes 

    # by storing the name of the current specialInstruction

    my %currentSpecialInstruction=();

    do { 

        my $tagName = $xmlElement->getNodeName();

        # Both unitListRef and layerRef end up to same place; unitLists hash

        # From makefile point of view they have no difference what so ever

        if ( $tagName eq "unitListRef" || 

            $tagName eq "layerRef" ) {

            my $unitList;

            if ( $tagName eq "unitListRef" ) {

                $unitList = $xmlElement->getAttribute('unitList'); 

            } else {

                $unitList = $xmlElement->getAttribute('layerName');

            }

            if ( scalar(@{$units{$unitList}}) == 0 ) {

                print(STDERR "WARNING: unit list \"$unitList\" included to configuration \"$configurationName\" has no units.\n");

            } else {

                # Go through bldfiles and check their filters

                foreach my $unit ( @{$units{$unitList}} ) {

                    my $i = 0;

                    my $exclude = check_filter( $unitFilters{$unit}, \@configurationFilters);

                    if ( $exclude )

                    # If there was an exclusion filter, exclude

                    # If bldfile had filters set but include filter was not among them, exclude

                    {

                        push( @{$excludedUnits{$configurationName}}, $unit );

                    }

                }

            }

            # Add the new unitlist to current configuration

            push( @{$unitLists{$configurationName}}, $unitList );

        }

        if ( $tagName eq "task" ) {

            # The unitlists applied for the current task

            my @taskUnitLists=();

            # First get possible task specific unitListRefs

            foreach my $xmlUnitListRef ( $xmlElement->getElementsByTagName('unitListRef') ) {

                push( @taskUnitLists, $xmlUnitListRef->getAttribute('unitList') );

            }

            my $xmlTask = $xmlElement->getFirstChild();

            do {

                my $taskType = $xmlTask->getNodeName();

                # For specialInstructions we only need the name

                # This is because the content in specialInstructions is determined later

                if ( $taskType eq "specialInstructions" ) {

                    my $name = $xmlTask->getAttribute('name');

                    if ( $name ne $currentSpecialInstruction{specialInstruction} ) 

                    # The specialInstruction has just changed

                    {

                        if ( $currentSpecialInstruction{specialInstruction} ) 

                        # but it's not the first one

                        {

                            # Store the previous special instruction

                            my %configurationTask = %currentSpecialInstruction;

                            push( @{$configurationTasks{$configurationName}}, \%configurationTask );

                            # And clear up for next one

                            %currentSpecialInstruction = ();

                        }

                        $currentSpecialInstruction{specialInstruction} = $name;

                        $currentSpecialInstruction{taskId} = $taskId++;

                    } 

                    my $cwd = $xmlTask->getAttribute('cwd');

                    my $command = quoteCommand($xmlTask->getAttribute('command'));

                    if ( $cwd ne "." ) {

                        $command = "cd ".$cwd." && ".$command." ";

                    }

                    if ( $ignoreErrorCommands{getExecutable($command)} ) 

                    # Command is listed as "ignore error" command

                    {

                        $command = "-".$command;

                    } 

                    push( @{$currentSpecialInstruction{commands}}, $command );

                } 

                if ( $taskType eq "buildLayer" ) {

                    if ( $currentSpecialInstruction{specialInstruction} ) 

                    # Last task was a specialInstruction

                    {

                        # Store the previous special instruction

                        my %configurationTask = %currentSpecialInstruction;

                        push( @{$configurationTasks{$configurationName}}, \%configurationTask );

                    }

                    # And clear up for next one

                    %currentSpecialInstruction = ();

                    # Set command and targets

                    my $targetList = $xmlTask->getAttribute('targetList');

                    my @targets = @{$targetLists{$targetList}};

                    my $command = $xmlTask->getAttribute('command');

                    my $executable = getExecutable($command);

                    my $option;

                    # abldOption specified, append makefile variable to command

                    # you can screw up what check and export by defining wrong options

                    # We are ignoring the fact that abld export doesnt work with all possible

                    # options. 

                    # It is more important to relay the -keepgoing to abld export

                    # than try to protect the environment from user who uses abldOption wrong

                    if ( @{$options{$executable.'Option'}} &&

                         $command !~ m{abld.*\-(w|what|c|check|checkwhat|cw)\s}i ) {

                        $option =" \$(".$executable."Option)";

                    }

                    if ( ! @targets ) {

                        my %configurationTask;

                        $configurationTask{executable} = $executable;

                        $configurationTask{command} = quoteCommand($command);

                        $configurationTask{option} = $option;

                        if ( @taskUnitLists ) {

                            $configurationTask{unitLists} = \@taskUnitLists;

                        } else {

                            if ( ! @{$unitLists{$configurationName}} ) {

                                print(STDERR "Warning: buildLayer task \"".$command."\" in configuration \"".$configurationName."\" does not contain any units.\n");

                            }

                        }

                        $configurationTask{taskId} = $taskId++;

                        push( @{$configurationTasks{$configurationName}},\%configurationTask );

                    } else {

                        foreach my $target ( @targets ) {

                            my %configurationTask;

                            # Append the target to the command

                            $configurationTask{executable} = $executable;

                            $configurationTask{command} = quoteCommand($command);

                            $configurationTask{option} = $option;

                            $configurationTask{target} = $target;

                            if ( @taskUnitLists ) {

                                $configurationTask{unitLists} = \@taskUnitLists;

                            } elsif ( ! @{$unitLists{$configurationName}} ) {

                                print(STDERR "Warning: buildLayer task \"".$command."\" in configuration \"".$configurationName."\" does not contain any units.\n");

                            }

                            $configurationTask{taskId} = $taskId++;

                            push( @{$configurationTasks{$configurationName}},\%configurationTask );

                        }

                    }

                }

            } while ( $xmlTask = $xmlTask->getNextSibling() ) ;

        }

    } while ( $xmlElement = $xmlElement->getNextSibling() ) ;

    if ( $currentSpecialInstruction{specialInstruction} ) 

    # Last task was a specialInstruction

    {

        # Store the previous special instruction

        my %configurationTask = %currentSpecialInstruction;

        push( @{$configurationTasks{$configurationName}}, \%configurationTask );

    }

    # And clear up for next one

    %currentSpecialInstruction = ();

}