1966 lines
68 KiB
Perl
1966 lines
68 KiB
Perl
:
|
|
eval 'exec perl -wS $0 ${1+"$@"}'
|
|
if 0;
|
|
|
|
#*************************************************************************
|
|
#
|
|
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
#
|
|
# Copyright 2008 by Sun Microsystems, Inc.
|
|
#
|
|
# OpenOffice.org - a multi-platform office productivity suite
|
|
#
|
|
# $RCSfile: XMLBuildListParser.pm,v $
|
|
#
|
|
# $Revision: 1.3 $
|
|
#
|
|
# This file is part of OpenOffice.org.
|
|
#
|
|
# OpenOffice.org is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public License version 3
|
|
# only, as published by the Free Software Foundation.
|
|
#
|
|
# OpenOffice.org is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Lesser General Public License version 3 for more details
|
|
# (a copy is included in the LICENSE file that accompanied this code).
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# version 3 along with OpenOffice.org. If not, see
|
|
# <http://www.openoffice.org/license.html>
|
|
# for a copy of the LGPLv3 License.
|
|
#
|
|
#*************************************************************************
|
|
|
|
|
|
#************************************************************
|
|
# Data structure and XML parser/creator for the changeover *
|
|
# of the current build.lst to build.xlist files *
|
|
# programmer: Pascal Junck, Sun Microsystems GmbH *
|
|
#************************************************************
|
|
|
|
# The current XMLBuildListParser is the second step for the changeover to XML.
|
|
# It was written to create a complex structure with more possibilities to store informations
|
|
# of the 'build.lst' files in the new XML files. The important informations were parsed by the
|
|
# 'buildlst_parser.pl' from the old files and then are (temporary) stored by the set and add
|
|
# methods in the module 'XMLBuildListParser' and 'XML::Parser'. By the API of this module it's
|
|
# possible to create the new XML 'build.xlist' files.
|
|
|
|
# If the '$Product' or the '$JobPlatform' (as also '$BuildReqPlatform') have no value,
|
|
# their value are automatically 'all'.
|
|
# It doesn't matter whether it's the set/add or the get method, that receives or sends
|
|
# these optional parameters.
|
|
# In the created XML file the default values aren't set, because of the constraints of the
|
|
# 'Document Type Definition'(DTD).
|
|
# If there is no product/platform attribute in the 'build.xlist' it means a default of 'all'!
|
|
|
|
# The important parameters are:
|
|
|
|
# $ModuleName = it's the name of the current module
|
|
|
|
# $DependencyType = here are the three possible scalar dependency values
|
|
# for all other depending modules(of the current module):
|
|
# 'md-simple', 'md-always' and 'md-force'
|
|
|
|
# $Products = which products can be used for the module dependencies
|
|
# and might have more different whitespace separated values
|
|
# e.g.'so oo' (scalar type)
|
|
|
|
# $Dir = it means a string(scalar) with the current working directory,
|
|
# with a '/'(current directory) at the beginning of the string
|
|
|
|
# $JobType = it means a job e.g. 'make'
|
|
|
|
# $Platforms = in this scalar parameter might be more than one different value,
|
|
# like: 'wnt unx mac' and 'all'('all' includes the three values)
|
|
# it must be whitespace separated
|
|
|
|
# @DependingDirs = a list(array) of all inner depending directories
|
|
# of the current working directory
|
|
|
|
# %BuildReq = means a hash with build requirement pairs:
|
|
# 'BuildReqName'(key) => 'BuildReqPlatform'(value)
|
|
|
|
|
|
|
|
############################## begin of main ########################################
|
|
|
|
use strict;
|
|
|
|
use XML::Parser;
|
|
|
|
package XMLBuildListParser;
|
|
|
|
# global variable for printing out all results at parsing
|
|
# if the debug variable is set to '1' it prints the results to STDOUT
|
|
my $Debug = 0;
|
|
|
|
|
|
############################# begin of subroutines ###################################
|
|
|
|
sub new
|
|
{
|
|
my $invocant = shift;
|
|
my $class = ref($invocant) || $invocant;
|
|
|
|
my $self = {};
|
|
|
|
# no real instance data yet, might change if package is extended
|
|
bless($self, $class);
|
|
$$self{'error_string'} = '';
|
|
$self->beginXMLStructure();
|
|
|
|
return $self;
|
|
}
|
|
|
|
# VG: procedure for a better error handling
|
|
sub getError
|
|
{
|
|
my $self = shift;
|
|
return $$self{'error_string'};
|
|
};
|
|
|
|
########################################################################################
|
|
# sub: loadXMLFile
|
|
# gets: $File
|
|
# optional: -
|
|
# returns: -
|
|
# description: get the 'path' of the 'build.xlist'(s), load it in the 'xml parser tree'
|
|
# and fill it in the own data_structure to make it available for the API
|
|
########################################################################################
|
|
sub loadXMLFile
|
|
{
|
|
my $self = shift;
|
|
my $File = shift;
|
|
|
|
if (-f $File)
|
|
{
|
|
my $TreeParse = new XML::Parser(Style => 'Tree');
|
|
|
|
my $File_ref;
|
|
|
|
eval
|
|
{
|
|
$File_ref = $TreeParse->parsefile($File);
|
|
};
|
|
|
|
if ($@)
|
|
{
|
|
$@ =~ s/[\r\n]//g;
|
|
print"ERROR: $@" if ($Debug);
|
|
$$self{'error_string'} = 'ERROR: ' . $@ . ". Error occured while trying to parse $File";
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
filterXMLFile($File_ref);
|
|
|
|
$$self{"ModuleData"} = $File_ref;
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$$self{'error_string'} = "ERROR: cannot find file $File";
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: filterXMLFile
|
|
# gets: $ArrayContent_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: filters all '0' and whitespace based pairs of the XML file
|
|
# -> all spaces, tabs and new lines
|
|
########################################################################################
|
|
sub filterXMLFile
|
|
{
|
|
my $ArrayContent_ref = shift;
|
|
|
|
# get the number of elements of the array_ref
|
|
my $Count = getContentCount($ArrayContent_ref);
|
|
|
|
for (my $i = 0; $i < $Count;)
|
|
{
|
|
# get each content pair
|
|
my $Content_ref = getContent($ArrayContent_ref, $i);
|
|
|
|
# in each content pair the first element is either
|
|
# a tag name or the value '0'
|
|
my $FirstContent = getTagName($Content_ref);
|
|
|
|
# we need the second part of the content pair to check
|
|
# which value is inside
|
|
my $SecondContent = getSecondContent($Content_ref);
|
|
|
|
my $tempArray_ref = "";
|
|
if (($FirstContent eq "task") or ($FirstContent eq "depend"))
|
|
{
|
|
my $dir = $Content_ref->[1]->[0]->{dir};
|
|
$dir =~ s/\/$//;
|
|
$Content_ref->[1]->[0]->{dir} = $dir;
|
|
$i++;
|
|
filterXMLFile($Content_ref);
|
|
}
|
|
elsif ($FirstContent eq "0")
|
|
{
|
|
# only if there is in the first part a '0' and in the
|
|
# second part are whitespaces...
|
|
if ($SecondContent =~ /\s+/)
|
|
{
|
|
# ...make a ref at this position
|
|
$tempArray_ref = @$ArrayContent_ref[1];
|
|
|
|
# and delete this element pair
|
|
removeContent($tempArray_ref, $i);
|
|
|
|
# now we have one element pair fewer
|
|
$Count--;
|
|
}
|
|
else
|
|
{
|
|
# is there a '0' but in the second part not a whitespace,
|
|
# increase 'i' by 1
|
|
$i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# if it's a tag name, increase 'i' by one and call recursive
|
|
# the 'filterXMLFile' with the 'content ref'
|
|
$i++;
|
|
|
|
# look further after the '0' and whitespace content
|
|
filterXMLFile($Content_ref);
|
|
}
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: removeContent
|
|
# gets: $File_ref, $Count
|
|
# optional: -
|
|
# returns: -
|
|
# description: removes the '0' and the whitespace based pairs of the XML structure
|
|
# whitespace could be: tabs, new lines and whitespace itself
|
|
########################################################################################
|
|
sub removeContent
|
|
{
|
|
my $tempArray_ref = shift;
|
|
my $i = shift;
|
|
|
|
my $Start = (2*$i) + 1;
|
|
|
|
splice(@$tempArray_ref, $Start, 2);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: beginXMLStructure
|
|
# gets: $ModuleData_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: create a new beginning of the XML file structure
|
|
########################################################################################
|
|
sub beginXMLStructure
|
|
{
|
|
my $self = shift;
|
|
|
|
# global variable for the complete filled data structure
|
|
my $ModuleData_ref = createTag("build-list", {});
|
|
|
|
$$self{"ModuleData"} = $ModuleData_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: insertContent
|
|
# gets: $HigherLevelTag_ref, $currentTag_ref, $Pos
|
|
# optional: -
|
|
# returns: -
|
|
# description: insert a content at the right (alphabetical sorted) position
|
|
########################################################################################
|
|
sub insertContent
|
|
{
|
|
my $HigherLevelTag_ref = shift;
|
|
my $currentTag_ref = shift;
|
|
my $Pos = shift;
|
|
|
|
my $Array_ref = $HigherLevelTag_ref->[1];
|
|
|
|
$Pos = ($Pos*2)+1;
|
|
|
|
splice(@$Array_ref, $Pos, 0, @$currentTag_ref);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: saveXMLFile
|
|
# gets: $Path
|
|
# optional: -
|
|
# returns: -
|
|
# description: creates a XML file of the whole data structure
|
|
########################################################################################
|
|
sub saveXMLFile
|
|
{
|
|
my $self = shift;
|
|
my $Path = shift;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# open the filehandle 'CREATE_XML' for creating the XML files
|
|
open (SAVE_XML, ">".$Path)
|
|
or die "Error. Open the file <build.xlist> wasn't successful!\n\n";
|
|
|
|
select SAVE_XML;
|
|
|
|
print"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
|
|
print"<!DOCTYPE build-list SYSTEM \"build_xlist.dtd\">\n";
|
|
print"<!--\n"
|
|
."***************************************************************************\n"
|
|
."* \n"
|
|
."* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. \n"
|
|
."* \n"
|
|
."* Copyright 2008 by Sun Microsystems, Inc. \n"
|
|
."* \n"
|
|
."* OpenOffice.org - a multi-platform office productivity suite \n"
|
|
."* \n"
|
|
."* \$RCSfile: XMLBuildListParser.pm,v $ \n"
|
|
."* \n"
|
|
."* \$Revision: 1.3 $ \n"
|
|
."* \n"
|
|
."* This file is part of OpenOffice.org. \n"
|
|
."* \n"
|
|
."* OpenOffice.org is free software: you can redistribute it and/or modify \n"
|
|
."* it under the terms of the GNU Lesser General Public License version 3 \n"
|
|
."* only, as published by the Free Software Foundation. \n"
|
|
."* \n"
|
|
."* OpenOffice.org is distributed in the hope that it will be useful, \n"
|
|
."* but WITHOUT ANY WARRANTY; without even the implied warranty of \n"
|
|
."* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the \n"
|
|
."* GNU Lesser General Public License version 3 for more details \n"
|
|
."* (a copy is included in the LICENSE file that accompanied this code). \n"
|
|
."* \n"
|
|
."* You should have received a copy of the GNU Lesser General Public License \n"
|
|
."* version 3 along with OpenOffice.org. If not, see \n"
|
|
."* <http://www.openoffice.org/license.html> \n"
|
|
."* for a copy of the LGPLv3 License. \n"
|
|
."* \n"
|
|
."***************************************************************************\n"
|
|
."-->\n";
|
|
|
|
printTag($ModuleData_ref);
|
|
|
|
# flush the buffer
|
|
# it's the same like the both lines below here, but we make it manually without module 'IO'
|
|
# use IO::Handle;
|
|
# SAVE_XML -> autoflush(1);
|
|
$| = 1;
|
|
|
|
select STDOUT;
|
|
|
|
close (SAVE_XML);
|
|
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: printTag
|
|
# gets: $Tag_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: prints out each tag of the existing data structure (XML tree)
|
|
########################################################################################
|
|
sub printTag
|
|
{
|
|
my $Tag_ref = shift;
|
|
|
|
# the first time we call this function the 'pos counter' has the default value of '0',
|
|
# because it is for the begin tag -> it shouldn't have a distance to the left side
|
|
my $PosCounter = shift || 0;
|
|
|
|
# makes it possible that each tag has a specified distance from the left sided margin
|
|
my $Distance = " " x $PosCounter;
|
|
|
|
# it's possible that the content is a text(case 1) between a begin and end tag
|
|
# or a tag name(case 2)
|
|
# case 1: ( 0 , "Text between the begin and end tag" )
|
|
my $TagName = getTagName($Tag_ref);
|
|
|
|
if ($TagName eq "0")
|
|
{
|
|
print"$Tag_ref->[1]";
|
|
}
|
|
# case 2: ( "TagName" , (...) )
|
|
else
|
|
{
|
|
# open the tag
|
|
# only a new line if it is not the first tag
|
|
print"\n" if ($PosCounter != 0);
|
|
print $Distance."<".$TagName;
|
|
|
|
my $Attributes_ref = getAttributesRef($Tag_ref);
|
|
|
|
# print all sorted attributes of this tag
|
|
foreach my $Attribute (sort keys %$Attributes_ref)
|
|
{
|
|
my $value = $$Attributes_ref{$Attribute};
|
|
print" $Attribute=\"$value\"";
|
|
}
|
|
|
|
# get the number of elements of the array
|
|
my $ContentCount = getContentCount($Tag_ref);
|
|
|
|
# close the tag
|
|
# if it is an empty tag create a '/' before we close it with '>'
|
|
print"/" if ($ContentCount == 0);
|
|
print">";
|
|
|
|
# get and print all tags recursive
|
|
for (my $i = 0; $i < $ContentCount; $i++)
|
|
{
|
|
# here we get the content of the current tag,
|
|
# we rise the 'pos counter' that each level of tags
|
|
# has a specified distance from the left side
|
|
printTag(getContent($Tag_ref, $i), $PosCounter + 2);
|
|
}
|
|
|
|
# check that the tag has a text between the begin and end tag
|
|
# first: had the tag further inner tags?
|
|
if ($ContentCount > 0)
|
|
{
|
|
my $Content_ref = getContent($Tag_ref, 0);
|
|
my $TagName = getTagName($Tag_ref);
|
|
my $TagContent = getTagName($Content_ref);
|
|
|
|
# if a tag has a begin tag and a following text, create the end tag behind the text
|
|
print"</$TagName>" if ($TagContent eq "0");
|
|
|
|
print"\n".$Distance."</$TagName>" if ($TagContent ne "0");
|
|
}
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getTagName
|
|
# gets: $Content_ref
|
|
# optional: -
|
|
# returns: $TagName
|
|
# description: gets a reference of an array and returns the tag name at position '0'
|
|
########################################################################################
|
|
sub getTagName
|
|
{
|
|
my $Content_ref = shift;
|
|
|
|
my $TagName = $$Content_ref[0];
|
|
|
|
return $TagName;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getSecondContent
|
|
# gets: $Content_ref
|
|
# optional: -
|
|
# returns: $SecondContent
|
|
# description: gets a reference of an array and returns the second value(index '1')
|
|
########################################################################################
|
|
sub getSecondContent
|
|
{
|
|
my $Content_ref = shift;
|
|
|
|
my $SecondContent = $$Content_ref[1];
|
|
|
|
return $SecondContent;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: createSortKey
|
|
# gets: $DependencyType, $DepModuleName
|
|
# optional: -
|
|
# returns: $SortKey
|
|
# description: creates a key with a number(depending of the dependency type)
|
|
# and a string and returns it
|
|
########################################################################################
|
|
sub createSortKey
|
|
{
|
|
my $DependencyType = shift;
|
|
my $DepModuleName = shift;
|
|
|
|
my $DepTypeAsValue = 0;
|
|
|
|
if ($DependencyType eq "md-simple")
|
|
{
|
|
$DepTypeAsValue = 1;
|
|
}
|
|
elsif ($DependencyType eq "md-always")
|
|
{
|
|
$DepTypeAsValue = 2;
|
|
}
|
|
elsif ($DependencyType eq "md-force")
|
|
{
|
|
$DepTypeAsValue = 3;
|
|
}
|
|
|
|
my $SortKey = $DepTypeAsValue.$DepModuleName;
|
|
|
|
return $SortKey;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: searchTag
|
|
# gets: $TagName, $Tag_ref
|
|
# optional: -
|
|
# returns: $TagValues_ref
|
|
# description: gets a reference and goes in the lower level tag,
|
|
# looks after the specified tag name and returns the reference
|
|
# of itself and the neighbour element
|
|
########################################################################################
|
|
sub searchTag
|
|
{
|
|
my $TagName = shift;
|
|
my $Tag_ref = shift;
|
|
|
|
my $TagSerie_ref = $Tag_ref->[1];
|
|
|
|
# (all elements of the array) - 1 => highest index of the array
|
|
my $IndexEnd = scalar(@$TagSerie_ref)-1;
|
|
|
|
my $TagValues_ref = undef;
|
|
|
|
for (my $i = 1; $i <= $IndexEnd; $i += 2)
|
|
{
|
|
if ($TagSerie_ref->[$i] eq $TagName)
|
|
{
|
|
@$TagValues_ref = @$TagSerie_ref[$i..$i+1];
|
|
|
|
last;
|
|
}
|
|
}
|
|
|
|
return $TagValues_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: createTag
|
|
# gets: $TagName, $Attribute_ref
|
|
# optional: -
|
|
# returns: $Tag_ref
|
|
# description: creates an anonymous array with a tag name and the reference of its
|
|
# attributes; then returns the reference of this array
|
|
########################################################################################
|
|
sub createTag
|
|
{
|
|
my $TagName = shift;
|
|
my $Attribute_ref = shift;
|
|
|
|
my $Tag_ref = [$TagName, [$Attribute_ref]];
|
|
|
|
return $Tag_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: createText
|
|
# gets: $Text
|
|
# optional: -
|
|
# returns: $TagText_ref
|
|
# description: creates an anonymous array(which contains a '0' and a string)
|
|
# for the data structure and returns a reference of it
|
|
########################################################################################
|
|
sub createText
|
|
{
|
|
my $Text = shift;
|
|
|
|
my $TagText_ref = [0, $Text];
|
|
|
|
return $TagText_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: addContent
|
|
# gets: $Tag_ref, $NextInfos_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: creates and adds a tag with its following content
|
|
########################################################################################
|
|
sub addContent
|
|
{
|
|
# '$NextInfos_ref' has two infos:
|
|
# either: '0' and a string -> [Tag, [{}, 0 , string ]]
|
|
# or: 'tag' and a ref of a anonymous array -> [Tag, [{}, newTag, [.....] ]]
|
|
my $Tag_ref = shift;
|
|
my $NextInfos_ref = shift;
|
|
|
|
my $SecondPart_ref = $Tag_ref->[1];
|
|
|
|
# '$Tag_ref' gets now the right structure:
|
|
# e.g. ['tag1', [{}, 0, "text of tag1" ...]...]
|
|
# or ['tag1', [{}, 'tag2', [...] ...]...]
|
|
push(@$SecondPart_ref, @$NextInfos_ref);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getContent
|
|
# gets: $Tag_ref, $i
|
|
# optional: -
|
|
# returns: \@Content (ref of array 'content')
|
|
# description: creates and returns a reference of an array with two elements,
|
|
# which are a part of the array of the current tag
|
|
########################################################################################
|
|
sub getContent
|
|
{
|
|
my $Tag_ref = shift;
|
|
my $i = shift;
|
|
|
|
# e.g.
|
|
# [ "tag 1", [ {} , 0 , "string", "tag 2", [{}..], "tag 3", [{}..], ..] ..]
|
|
# $Tag_ref [ [0] [1] ..]
|
|
# $Content_ref [ [0] [1] [2] [3] [4] [5] [6] ..]
|
|
|
|
my $Content_ref = $$Tag_ref[1];
|
|
|
|
# '$start' contains: elements with the index 1, 3, 5 ...(and so on)
|
|
# '$end' contains: elements with the index 2, 4, 6 ...(and so on)
|
|
my $start = (2 * $i) + 1;
|
|
my $end = $start + 1;
|
|
|
|
my @Content = @$Content_ref[$start..$end];
|
|
|
|
return \@Content;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getAttribute
|
|
# gets: $Tag_ref, $AttributeName
|
|
# optional: -
|
|
# returns: $Attribute
|
|
# description: finds and returns an attribute as a string
|
|
########################################################################################
|
|
sub getAttribute
|
|
{
|
|
my $Tag_ref = shift;
|
|
my $AttributeName = shift;
|
|
|
|
# [ "tag1", [ { attribute1 = "..", attribute2 = ".." } , "tag2"... ] ]
|
|
# Tag_ref [ [0] [1] ] ]
|
|
# [ [0]->'attribute1' , [0]->'attribute2' , [1] ... ] ]
|
|
|
|
# get the scalar of the value of the 'AttributeName' in the anonymous hash
|
|
my $Attribute = $Tag_ref->[1]->[0]->{$AttributeName};
|
|
|
|
return $Attribute;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getAttributeRef
|
|
# gets: $Tag_ref
|
|
# optional: -
|
|
# returns: $Attribute_ref
|
|
# description: finds and returns the reference of the hash which contains the attributes
|
|
########################################################################################
|
|
sub getAttributesRef
|
|
{
|
|
my $Tag_ref = shift;
|
|
|
|
# [ "tag1", [ { attribute1 = "..", attribute2 = ".." } , "tag2"... ] ]
|
|
# Tag_ref [ [0] [1] ] ]
|
|
# [ [0] , [1] ] ]
|
|
|
|
# get the reference of the anonymous hash
|
|
my $Attribute_ref = $Tag_ref->[1]->[0];
|
|
|
|
return $Attribute_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getContentCount
|
|
# gets: $Tag_ref
|
|
# optional: -
|
|
# returns: $IndexValue
|
|
# description: returns the sum of elements pairs of the array (less the anonymous hash)
|
|
########################################################################################
|
|
sub getContentCount
|
|
{
|
|
my $Tag_ref = shift;
|
|
|
|
# get the content array (address of the inner array)
|
|
my $Content_ref = $$Tag_ref[1];
|
|
|
|
# get the number of the element pairs of the array (without the anonymous hash)
|
|
my $IndexValue = scalar(@$Content_ref);
|
|
$IndexValue = ($IndexValue-1)/2;
|
|
|
|
return $IndexValue;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getIterationData
|
|
# gets: $TagName
|
|
# optional: -
|
|
# returns: $IndexValue, $TagDepend_ref
|
|
# description: gets a tag name and returns the sum of elements pairs of the array
|
|
# (less the anonymous hash) and the reference of the anonymous array
|
|
########################################################################################
|
|
sub getIterationData
|
|
{
|
|
my $self = shift;
|
|
my $TagName = shift;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
my $TagDepend_ref = searchTag($TagName, $ModuleData_ref);
|
|
my $IndexValue = getContentCount($TagDepend_ref);
|
|
|
|
return ($IndexValue, $TagDepend_ref);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: printErrorMessage
|
|
# gets: $BuildReqPlatforms or $Platforms or $Products
|
|
# optional: -
|
|
# returns: -
|
|
# description: it's an error, if a platform or a product content (e.g.'so oo')
|
|
# has at least one valid value and also the value 'all',
|
|
# because 'all' includes all other possible values
|
|
########################################################################################
|
|
sub printErrorMessage
|
|
{
|
|
my $self = shift;
|
|
my $Content = shift;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
my $Module_ref = searchTag("module-name", $ModuleData_ref);
|
|
my $ModuleContent_ref = getContent($Module_ref, 0);
|
|
my $Module = @$ModuleContent_ref[1];
|
|
|
|
print"Error in module <$Module> in Content <$Content>!\n";
|
|
print"The value 'all' includes all currently existing valid values.\n\n";
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: adjustRedundancy
|
|
# gets: $Task_ref, $JobPlatform, $BuildReq_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: the tag <task> (it means 'job') should be created with no redundant infos,
|
|
# like: <task dir="/uno" platform="unx"> ...
|
|
# <task dir="/uno" platform="wnt"> ...
|
|
# <build-requirement name="test10" platform="wnt">
|
|
#
|
|
# it should be: <task dir="/uno" platform="unx wnt">
|
|
# <build-requirement name="test10" platform="wnt">
|
|
########################################################################################
|
|
sub adjustRedundancy
|
|
{
|
|
my $Task_ref = shift;
|
|
my $JobPlatform = shift;
|
|
my $BuildReq_ref = shift;
|
|
|
|
my %sortedJobPlatforms = ();
|
|
my @JobPlatforms = ();
|
|
my $PlatformContent = "";
|
|
|
|
# get the 'task platforms' in one content
|
|
my $Attributes_ref = getAttributesRef($Task_ref);
|
|
|
|
# get the existing 'task platform'
|
|
my $existingPlatform = getAttribute($Task_ref, "platform");
|
|
$existingPlatform = "all" if (!($existingPlatform));
|
|
|
|
if ( ($existingPlatform ne "all") && ($JobPlatform ne "all") )
|
|
{
|
|
# get the sorted platform content
|
|
$sortedJobPlatforms{$JobPlatform} = "";
|
|
$sortedJobPlatforms{$existingPlatform} = "";
|
|
|
|
@JobPlatforms = sort keys %sortedJobPlatforms;
|
|
|
|
$PlatformContent = join " ", @JobPlatforms;
|
|
|
|
$$Attributes_ref{"platform"} = $PlatformContent;
|
|
}
|
|
elsif ( ($existingPlatform ne "all") && ($JobPlatform eq "all") )
|
|
{
|
|
delete $$Attributes_ref{"platform"};
|
|
}
|
|
|
|
if ($BuildReq_ref)
|
|
{
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
|
|
# if it exists add the 'build requirements' at the
|
|
# previous(with the same directory as the current) <task> tag
|
|
addBuildReq($JobType_ref, $BuildReq_ref);
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: addBuildReq
|
|
# gets: $JobTypeInfos_ref, $BuildReq_ref
|
|
# optional: -
|
|
# returns: -
|
|
# description: add the 'build requirements' to the existing data structure
|
|
# case 1: if the 'job directory' is not redundant
|
|
# case 2: if it is redundant create it to the first existing 'job'
|
|
########################################################################################
|
|
sub addBuildReq
|
|
{
|
|
my $JobTypeInfos_ref = shift;
|
|
my $BuildReq_ref = shift;
|
|
|
|
my @sortedBuildReqPlatforms = ();
|
|
|
|
foreach my $BuildReqName (sort keys %$BuildReq_ref)
|
|
{
|
|
my $BuildReqPlatforms = $$BuildReq_ref{$BuildReqName};
|
|
|
|
$BuildReqPlatforms = "all" if (!($BuildReqPlatforms));
|
|
|
|
my $Attributes_ref = {"name" => "$BuildReqName"};
|
|
|
|
# it's wrong, if in a platform content(e.g. "unx wnt") are at least
|
|
# one or more platform(s) and within a 'all' term,
|
|
# because 'all' is default and means it includes all other possible values!
|
|
if ( ($BuildReqPlatforms ne "all") && ($BuildReqPlatforms =~ /\ball\b/) )
|
|
{
|
|
printErrorMessage($BuildReqPlatforms);
|
|
}
|
|
elsif (!($BuildReqPlatforms =~ /\ball\b/))
|
|
{
|
|
@sortedBuildReqPlatforms = sort(split(/\s+/, $BuildReqPlatforms));
|
|
$BuildReqPlatforms = join " ", @sortedBuildReqPlatforms;
|
|
|
|
$$Attributes_ref{"platform"} = "$BuildReqPlatforms";
|
|
}
|
|
|
|
# create the tag <build-requirement>
|
|
my $BuildReqInfos_ref = createTag("build-requirement", $Attributes_ref);
|
|
|
|
# append the <build-requirement> tag to the <'$JobType'> tag
|
|
addContent($JobTypeInfos_ref, $BuildReqInfos_ref);
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: checkJobRedundancy
|
|
# gets: $Task_ref, $JobType, $DependingDirs_ref, $JobPlatform, $BuildReq_ref
|
|
# optional: -
|
|
# returns: $LineIsRedundant
|
|
# description: checks whether the values of the 'job' line are redundant, like:
|
|
# 'job dir', 'job'(e.g.: make) and 'depending dirs'
|
|
########################################################################################
|
|
sub checkJobRedundancy
|
|
{
|
|
my $Task_ref = shift;
|
|
my $JobType = shift;
|
|
my $DependingDirs_ref = shift;
|
|
my $JobPlatform = shift;
|
|
my $BuildReq_ref = shift;
|
|
|
|
my $LineIsRedundant = 0;
|
|
|
|
|
|
# get the ref of the existing 'depending directories'
|
|
# if they also equal with the current 'depending directories',
|
|
# make one tag instead of two, which differences only in the platform
|
|
# (and the 'build requirement', if it exists)
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
my $JobName = getTagName($JobType_ref);
|
|
|
|
# get the existing 'task platform'
|
|
my $existingPlatform = getAttribute($Task_ref, "platform");
|
|
|
|
# are the jobs equal?
|
|
if ($JobType eq $JobName)
|
|
{
|
|
my @existingDepDirs = ();
|
|
|
|
my $IndexEnd = getContentCount($JobType_ref);
|
|
|
|
# get all existing 'depending dirs' of this redundant 'job'
|
|
for (my $j = 0; $j < $IndexEnd; $j++)
|
|
{
|
|
my $Content_ref = getContent($JobType_ref, $j);
|
|
|
|
my $TagName = getTagName($Content_ref);
|
|
|
|
# create an array of the 'depending directories'
|
|
if ($TagName eq "depend")
|
|
{
|
|
my $DepDir = getAttribute($Content_ref, "depend");
|
|
|
|
push(@existingDepDirs, $DepDir);
|
|
}
|
|
}
|
|
|
|
# if now the current 'depending dirs' equal with the existing,
|
|
# we know that is redundant and have to create only one instead
|
|
# of two tags, e.g.
|
|
# before: <task dir="/uno" platform="unx">...
|
|
# <task dir="/uno" platform="wnt"> ...
|
|
# <build-requirement name="test10" platform="wnt">
|
|
#
|
|
# it should be: <task dir="/uno" platform="unx wnt">
|
|
# <build-requirement name="test10" platform="wnt">
|
|
if (@$DependingDirs_ref eq @existingDepDirs)
|
|
{
|
|
$LineIsRedundant = 1;
|
|
|
|
# check redundant directories and create no redundant 'task dirs'
|
|
adjustRedundancy($Task_ref, $JobPlatform, $BuildReq_ref);
|
|
}
|
|
}
|
|
|
|
return $LineIsRedundant;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: existsTag
|
|
# gets: $TagName
|
|
# optional: -
|
|
# returns: $TagExists_ref
|
|
# description: checks whether that a tag exists and returns the ref of the content
|
|
########################################################################################
|
|
sub existsTag
|
|
{
|
|
my $self = shift;
|
|
my $TagName = shift;
|
|
|
|
my $TagExists_ref = undef;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <module-depend> tag exists
|
|
$TagExists_ref = searchTag($TagName, $ModuleData_ref);
|
|
|
|
return $TagExists_ref;
|
|
}
|
|
|
|
########################################################################################
|
|
# API - (internal) 'set/add' methods #
|
|
########################################################################################
|
|
|
|
########################################################################################
|
|
# sub: setModuleName
|
|
# gets: $ModuleName
|
|
# optional: -
|
|
# returns: -
|
|
# description: gets the name of the current module and set it at the right position
|
|
# in the data structure
|
|
########################################################################################
|
|
sub setModuleName
|
|
{
|
|
my $self = shift;
|
|
my $ModuleName = shift;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
my $Tag_ref = createTag("module-name", {});
|
|
my $TagText_ref = createText($ModuleName);
|
|
|
|
addContent($Tag_ref, $TagText_ref);
|
|
|
|
addContent($ModuleData_ref, $Tag_ref);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: addModuleDependencies
|
|
# gets: $ModuleName, $DependencyType, $Products
|
|
# optional: $Products(default: 'all' -> includes currently 'so' and 'oo')
|
|
# but the default should not set in the data structure,
|
|
# it's only a 'Document Type Definition' based term
|
|
# returns: -
|
|
# description: add the module dependencies and their attributes into the data structure
|
|
########################################################################################
|
|
sub addModuleDependencies
|
|
{
|
|
my $self = shift;
|
|
my $ModuleName = shift;
|
|
my $DependencyType = shift;
|
|
my $Products = shift || "all";
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
my @sortedProducts = ();
|
|
|
|
# change all possible upper cases to lower cases
|
|
$Products =~ s/($Products)/\L$Products/;
|
|
|
|
# before we add the module dependencies, we have to prove that the <module-depend> tag was set
|
|
# because this tag must be set once before the module dependency tags begin
|
|
my $ModuleDepend_ref = searchTag("module-depend", $ModuleData_ref);
|
|
|
|
# if it doesn't exist, create this tag '<module-depend>'
|
|
if (!($ModuleDepend_ref))
|
|
{
|
|
$ModuleDepend_ref = createTag("module-depend", {});
|
|
|
|
# add it to the global data structure
|
|
addContent($ModuleData_ref, $ModuleDepend_ref);
|
|
}
|
|
|
|
my $Attributes_ref = {"module" => "$ModuleName"};
|
|
|
|
# it's wrong, if in a product content(e.g. "so") are at least
|
|
# one or more product(s) and within a 'all' term,
|
|
# because 'all' is default and means it includes all other possible values!
|
|
if ( ($Products ne "all") && ($Products =~ /\ball\b/) )
|
|
{
|
|
printErrorMessage($Products);
|
|
}
|
|
elsif (!($Products =~ /\ball\b/))
|
|
{
|
|
@sortedProducts = sort(split(/\s+/ ,$Products));
|
|
$Products = join " ", @sortedProducts;
|
|
|
|
$$Attributes_ref{"product"} = "$Products";
|
|
}
|
|
|
|
my $ModuleDependenciesInfos_ref = createTag("$DependencyType", $Attributes_ref);
|
|
|
|
my $currentKey = createSortKey($DependencyType, $ModuleName);
|
|
|
|
# search and get the position in which we have to insert the current 'module depend name'
|
|
# at first get the current 'module depend name'
|
|
my $currentName = getAttribute($ModuleDependenciesInfos_ref, "module");
|
|
|
|
# get the information about the number of 'Contents'(= elements) of the array
|
|
my $ContentCount = getContentCount($ModuleDepend_ref);
|
|
|
|
# we have to sort the serie of the 'name' contents,
|
|
# therefore we need a 'Pos'(position) of the array in which we want to sort in the 'name' content
|
|
my $Pos = 0;
|
|
|
|
# and we need a control variable 'isInsert'
|
|
# that we won't add the 'name' and the content more than one time
|
|
my $isInsert = 0;
|
|
|
|
for (my $i = 0; $i < $ContentCount; $i++)
|
|
{
|
|
# get each 'Content' of the array = ('task', ARRAY(...))
|
|
my $Content_ref = getContent($ModuleDepend_ref, $i);
|
|
my $TagName = getTagName($Content_ref);
|
|
|
|
# get the existing 'task dir' to compare it with the current 'task dir'
|
|
my $existingName = getAttribute($Content_ref, "module");
|
|
|
|
my $existingKey = createSortKey(getTagName($Content_ref), $existingName);
|
|
|
|
# compare both dirs...
|
|
# only if the 'current dir' is lower than a 'existing dir'
|
|
# insert it in the data structure
|
|
if ($currentKey lt $existingKey)
|
|
{
|
|
$Pos = $i;
|
|
|
|
insertContent($ModuleDepend_ref, $ModuleDependenciesInfos_ref, $Pos);
|
|
|
|
$isInsert = 1;
|
|
|
|
last;
|
|
}
|
|
}
|
|
# only if the 'current name' is greater (or equal) than the other 'existing names'
|
|
# insert it at the end of the data structure
|
|
addContent($ModuleDepend_ref, $ModuleDependenciesInfos_ref) if ($isInsert == 0);
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: addJob
|
|
# gets: $Dir, $JobType, $JobPlatform, $DependingDirs_ref, $BuildReq_ref,
|
|
# $JobPlatform, $DependingDirs_ref, $BuildReq_ref
|
|
# optional: $JobPlatform(default: 'all' -> includes all other possible values),
|
|
# $DependingDirs_ref, $BuildReq_ref
|
|
# returns: -
|
|
# description: add the infos about a job from the old build lists(by ascii parser) and
|
|
# sort it in the data structure
|
|
########################################################################################
|
|
sub addJob
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
my $JobType = shift;
|
|
my $JobPlatform = shift || "all";
|
|
my $DependingDirs_ref = shift;
|
|
my $BuildReq_ref = shift;
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# before we add the "build" tag, we have to prove that the <build> tag was set
|
|
# because this tag must be set once before the job tag(s) follows
|
|
my $buildTag_ref = searchTag("build", $ModuleData_ref);
|
|
|
|
# if it doesn't exist, create the tag '<build>'
|
|
if (!($buildTag_ref))
|
|
{
|
|
# If the tag wasn't found, create it
|
|
$buildTag_ref = createTag("build", {});
|
|
|
|
# add it to the global data structure
|
|
addContent($ModuleData_ref, $buildTag_ref);
|
|
}
|
|
|
|
my $Attributes_ref = {"dir" => "$Dir"};
|
|
|
|
# it's wrong, if a 'job platform' content(e.g. "unx wnt") has at least
|
|
# one or more 'job platform(s)' and an 'all' term,
|
|
# because 'all' is default and means it includes all other possible values
|
|
if ( ($JobPlatform ne "all") && ($JobPlatform =~ /\ball\b/) )
|
|
{
|
|
printErrorMessage($JobPlatform);
|
|
}
|
|
elsif (!($JobPlatform =~ /\ball\b/))
|
|
{
|
|
my @sortedPlatforms = sort(split /\s+/, $JobPlatform);
|
|
$JobPlatform = join " ", @sortedPlatforms;
|
|
|
|
$$Attributes_ref{"platform"} = "$JobPlatform";
|
|
}
|
|
|
|
# create the tags: <task>, <make> and (if it exists)...
|
|
# <depend> and/or <build-requirement>
|
|
my $taskInfos_ref = createTag("task", $Attributes_ref);
|
|
|
|
# search and get the position in which we have to insert the current task
|
|
# at first get the current 'task directory'
|
|
my $currentDir = getAttribute($taskInfos_ref, "dir");
|
|
|
|
# get the information about the number of 'Contents'(= elements) of the array
|
|
my $IndexValue = getContentCount($buildTag_ref);
|
|
|
|
# we have to sort the serie of the 'task contents',
|
|
# therefore we need a '$pos'(position) of the array in which we want to sort in the 'task content'
|
|
my $Pos = 0;
|
|
|
|
# and we need a control variable 'isInsert'
|
|
# that we won't add the 'task content' more than one time
|
|
my $isInsert = 0;
|
|
|
|
# control variable for the redundancy check
|
|
my $LineIsRedundant = 0;
|
|
|
|
# go in the array of the corresponding <build> tag element
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
# get each content of the <build> tag => ('task1', ARRAY1(...), task2...)
|
|
my $Task_ref = getContent($buildTag_ref, $i);
|
|
|
|
# get the existing 'task dir' to compare it with the current 'task dir'
|
|
my $existingDir = getAttribute($Task_ref, "dir");
|
|
|
|
# is the 'job dir' redundant?
|
|
if ($currentDir eq $existingDir)
|
|
{
|
|
$LineIsRedundant = checkJobRedundancy($Task_ref, $JobType, $DependingDirs_ref, $JobPlatform, $BuildReq_ref);
|
|
}
|
|
|
|
# if it's not a redundant line, compare both dirs:
|
|
# only if the 'current dir' is lower than an 'existing dir'
|
|
# insert it in the data structure
|
|
if ( ($LineIsRedundant == 0) && ($currentDir lt $existingDir) )
|
|
{
|
|
$Pos = $i;
|
|
|
|
insertContent($buildTag_ref, $taskInfos_ref, $Pos);
|
|
|
|
$isInsert = 1;
|
|
|
|
last;
|
|
}
|
|
}
|
|
|
|
# only if the 'current dir' is greater (or equal) than the other 'existing dirs'
|
|
# and it is not redundant insert it at the end of the data structure
|
|
if ( ($isInsert == 0) && ($LineIsRedundant == 0) )
|
|
{
|
|
addContent($buildTag_ref, $taskInfos_ref);
|
|
}
|
|
|
|
if ($LineIsRedundant == 0)
|
|
{
|
|
# create the <'$JobType'> tag
|
|
my $JobTypeInfos_ref = createTag($JobType, {});
|
|
|
|
# append the <'$JobType'> tag to the <task> tag
|
|
addContent($taskInfos_ref, $JobTypeInfos_ref);
|
|
|
|
# before we add the "depend" infos
|
|
# we have to get the alphabetical sorted 'Depending Directories'
|
|
@$DependingDirs_ref = sort(@$DependingDirs_ref) if ($DependingDirs_ref);
|
|
|
|
foreach my $DependDir (@$DependingDirs_ref)
|
|
{
|
|
my $DependInfos_ref = createTag("depend", {"dir" => "$DependDir"});
|
|
|
|
# append the <depend> tag to the <'$JobType'> tag
|
|
addContent($JobTypeInfos_ref, $DependInfos_ref);
|
|
}
|
|
|
|
# if a 'build requirement' exists, create the tag <build-requirement>
|
|
if ($BuildReq_ref)
|
|
{
|
|
addBuildReq($JobTypeInfos_ref, $BuildReq_ref);
|
|
}
|
|
}
|
|
}
|
|
|
|
########################################################################################
|
|
# end of (internal) 'set/add' methods #
|
|
########################################################################################
|
|
|
|
|
|
########################################################################################
|
|
# API - (external) 'get' methods #
|
|
########################################################################################
|
|
|
|
########################################################################################
|
|
# sub: getModuleDependencies
|
|
# gets: $Product, $DependencyType
|
|
# optional: $Product(default: 'all', means all currently used valid values),
|
|
# $DependencyType(default: 'md-simple', 'md-always' and 'md-force')
|
|
# returns: @ModuleDependencies
|
|
# description: gets a ref of an array (with the products) and creates and
|
|
# returns an array with the sorted depending modules
|
|
########################################################################################
|
|
sub getModuleName {
|
|
my $self = shift;
|
|
if ($self->existsTag("module-name")) {
|
|
my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-name");
|
|
return $$ModuleDepend_ref[1][2];
|
|
};
|
|
return "";
|
|
|
|
};
|
|
sub getModuleDependencies
|
|
{
|
|
my $self = shift;
|
|
my $Products_ref = shift;
|
|
my $DependencyType = shift || "all";
|
|
|
|
push(@$Products_ref, "all") if (!scalar @$Products_ref);
|
|
|
|
my $Product = "";
|
|
my %tempModuleDeps = ();
|
|
my @ModuleDependencies = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <module-depend> tag exists
|
|
if ($self->existsTag("module-depend"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$DependencyType =~ s/($DependencyType)/\L$DependencyType/ if ($DependencyType ne "all");
|
|
|
|
foreach $Product (@$Products_ref)
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$Product =~ s/($Product)/\L$Product/;
|
|
|
|
my $ProductContent = undef;
|
|
my $ModuleDependencyName = "";
|
|
|
|
# get the number of elements and the ref of the <module-depend> tag
|
|
my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Content_ref = getContent($ModuleDepend_ref, $i);
|
|
|
|
my $ModuleDependencyName = getAttribute($Content_ref, "module");
|
|
|
|
# get the name of each existing tag
|
|
my $TagName = getTagName($Content_ref);
|
|
|
|
$ProductContent = getAttribute($Content_ref, "product");
|
|
|
|
# if the attribute 'product' wasn't set in the internal data structure,
|
|
# it means the default of 'all' is valid and includes all other possible values
|
|
$ProductContent = "all" if (!($ProductContent));
|
|
|
|
if ($Product ne "all")
|
|
{
|
|
if ($DependencyType ne "all")
|
|
{
|
|
# if the caller wants all (e.g.)'so' product based dependency types,
|
|
# we must get the 'so' and the 'all' matching products
|
|
# because 'all' matches also the product 'so'
|
|
if ( ($DependencyType eq $TagName) &&
|
|
((($ProductContent eq "all") || $ProductContent =~ /\b($Product)\b/)) )
|
|
{
|
|
$tempModuleDeps{$ModuleDependencyName} = "";
|
|
|
|
print"ModuleDeps (Product != 'all' && DepType != 'all') = <$ModuleDependencyName>\n" if ($Debug);
|
|
}
|
|
}
|
|
# we get from the caller only the 'product' parameter,
|
|
# 'dependency type' is now 'all'(default) and includes all possible values
|
|
elsif ( ($ProductContent =~ /\b($Product)\b/) || ($ProductContent eq "all") )
|
|
{
|
|
$tempModuleDeps{$ModuleDependencyName} = "";
|
|
|
|
print"ModuleDeps (Product != 'all' && DepType = 'all') = <$ModuleDependencyName>\n" if ($Debug);
|
|
}
|
|
}
|
|
# now the product is 'all' and we only need to check the 'dependency type'
|
|
elsif ($DependencyType ne "all")
|
|
{
|
|
if ($DependencyType eq $TagName)
|
|
{
|
|
$tempModuleDeps{$ModuleDependencyName} = "";
|
|
|
|
print"ModuleDeps (Product = 'all' && DepType != 'all') = <$ModuleDependencyName>\n" if ($Debug);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$tempModuleDeps{$ModuleDependencyName} = "";
|
|
|
|
print"ModuleDeps (Product = 'all' && DepType = 'all') = <$ModuleDependencyName>\n" if ($Debug);
|
|
}
|
|
}
|
|
}
|
|
|
|
@ModuleDependencies = sort keys %tempModuleDeps;
|
|
}
|
|
|
|
print"ModuleDependencies = <@ModuleDependencies>\n" if ($Debug);
|
|
|
|
return @ModuleDependencies;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getModuleDepType
|
|
# gets: $DepModuleName
|
|
# optional: -
|
|
# returns: $DependencyType
|
|
# description: gets a module name and returns the dependency type of it
|
|
########################################################################################
|
|
sub getModuleDepType
|
|
{
|
|
my $self = shift;
|
|
my $DepModuleName = shift;
|
|
|
|
my $DependencyType = "";
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <module-depend> tag exists
|
|
if ($self->existsTag("module-depend"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$DepModuleName =~ s/($DepModuleName)/\L$DepModuleName/;
|
|
|
|
my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Content_ref = getContent($ModuleDepend_ref, $i);
|
|
my $existingModuleName = getAttribute($Content_ref, "module");
|
|
|
|
if ($DepModuleName eq $existingModuleName)
|
|
{
|
|
$DependencyType = getTagName($Content_ref);
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
print"DependencyType = <$DependencyType>\n" if ($Debug);
|
|
|
|
return $DependencyType;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getModuleProducts
|
|
# gets: $DepModuleName
|
|
# optional: -
|
|
# returns: @ModuleProducts
|
|
# description: gets a module name and returns the associated products
|
|
########################################################################################
|
|
sub getModuleProducts
|
|
{
|
|
my $self = shift;
|
|
my $DepModuleName = shift;
|
|
|
|
my @ModuleProducts = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <module-depend> tag exists
|
|
if ($self->existsTag("module-depend"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$DepModuleName =~ s/($DepModuleName)/\L$DepModuleName/;
|
|
|
|
my $ProductContent = undef;
|
|
|
|
my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Content_ref = getContent($ModuleDepend_ref, $i);
|
|
|
|
my $existingModuleName = getAttribute($Content_ref, "module");
|
|
|
|
# if the attribute 'product' wasn't set in the internal data structure,
|
|
# it means the default of 'all' is valid and includes all other possible values
|
|
$ProductContent = getAttribute($Content_ref, "product");
|
|
|
|
if ($DepModuleName eq $existingModuleName)
|
|
{
|
|
$ProductContent = "all" if (!($ProductContent));
|
|
|
|
@ModuleProducts = split /\s+/, $ProductContent;
|
|
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
print"Products = <@ModuleProducts>\n" if ($Debug);
|
|
|
|
return @ModuleProducts;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getProducts
|
|
# gets: -
|
|
# optional: -
|
|
# returns: @ModuleProducts
|
|
# description: returns the products of the whole depending modules
|
|
# each found product name may occurs only once in the module products array
|
|
########################################################################################
|
|
sub getProducts
|
|
{
|
|
my $self = shift;
|
|
my $ProductContent = undef;
|
|
my @tempProducts = ();
|
|
my @ModuleProducts = ();
|
|
my %Products = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <module-depend> tag exists
|
|
if ($self->existsTag("module-depend"))
|
|
{
|
|
my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Content_ref = getContent($ModuleDepend_ref, $i);
|
|
|
|
$ProductContent = getAttribute($Content_ref, "product");
|
|
|
|
# if the attribute 'product' wasn't set in the internal data structure,
|
|
# it means the default of 'all' is valid and includes all other possible values
|
|
# but here we need only all 'not-all' values!
|
|
if (!($ProductContent))
|
|
{
|
|
$ProductContent="";
|
|
}
|
|
else
|
|
{
|
|
# here are the products of the current depending module
|
|
@tempProducts = split /\s+/, $ProductContent;
|
|
|
|
foreach my $Product (@tempProducts)
|
|
{
|
|
$Products{$Product} = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
# fill the sorted 'module products' in the array
|
|
@ModuleProducts = sort keys %Products;
|
|
}
|
|
|
|
print"All ModuleProducts = <@ModuleProducts>\n" if ($Debug);
|
|
|
|
return @ModuleProducts;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getJobDirectories
|
|
# gets: $JobType, $JobPlatform
|
|
# optional: $JobType, $JobPlatform(default: 'all' -> includes all possible values)
|
|
# returns: @JobDirectories
|
|
# description: creates and returns an array with the sorted directories, which
|
|
# fulfil the expected values of the job type and the job platform
|
|
########################################################################################
|
|
sub getJobDirectories
|
|
{
|
|
my $self = shift;
|
|
my $JobType = shift;
|
|
my $JobPlatform = shift || "all";
|
|
|
|
my @JobDirectories = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$JobType =~ s/($JobType)/\L$JobType/ if ($JobType);
|
|
$JobPlatform =~ s/($JobPlatform)/\L$JobPlatform/ if ($JobPlatform ne "all");
|
|
|
|
my $PlatformContent = undef;
|
|
my %tempJobDirectories = ();
|
|
|
|
# get the ref of the <build> tag
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Content_ref = getContent($Build_ref, $i);
|
|
|
|
my $PlatformContent = getAttribute($Content_ref, "platform");
|
|
my $existingDir = getAttribute($Content_ref, "dir");
|
|
|
|
# three cases are possible...
|
|
if ($JobType)
|
|
{
|
|
my $JobType_ref = getContent($Content_ref, 0);
|
|
my $existingJobType = getTagName($JobType_ref);
|
|
|
|
# if the attribute 'job platform' wasn't set in the internal data structure,
|
|
# it means the default of 'all' is valid and includes all other possible values
|
|
$PlatformContent = "all" if (!($PlatformContent));
|
|
|
|
# first case: we get from the caller the parameters 'job type' and 'job platform'
|
|
if ($JobPlatform ne "all")
|
|
{
|
|
# if the caller wants all e.g.'wnt' job platform based directories,
|
|
# we have to get the 'wnt' or the 'all' matching platform
|
|
# because 'all' includes also 'wnt'
|
|
if ( ($JobType eq $existingJobType) &&
|
|
(($PlatformContent =~ /\b($JobPlatform)\b/) || ($PlatformContent eq "all")) )
|
|
{
|
|
$tempJobDirectories{$existingDir} = "";
|
|
}
|
|
}
|
|
# second case: we get from the caller only the 'job type' parameter
|
|
# 'job platform' is now 'all'(default) and includes all possible values
|
|
elsif ($JobType eq $existingJobType)
|
|
{
|
|
$tempJobDirectories{$existingDir} = "";
|
|
}
|
|
}
|
|
# third case: we get from the caller no parameter; now we take each existing 'job directory',
|
|
# no matter which 'job type' and 'job platform' it has
|
|
else
|
|
{
|
|
$tempJobDirectories{$existingDir} = "";
|
|
}
|
|
}
|
|
|
|
# sort each unique 'job directory' alphabetical
|
|
@JobDirectories = sort keys %tempJobDirectories;
|
|
}
|
|
print"JobDirectories = <@JobDirectories>\n" if ($Debug);
|
|
|
|
return @JobDirectories;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getDirDependencies
|
|
# gets: $Dir, $JobType, $JobPlatform
|
|
# optional: $JobPlatform(default: 'all' -> includes all possible values)
|
|
# returns: @JobDependencies
|
|
# description: creates and returns an array with the sorted depending directories
|
|
########################################################################################
|
|
sub getDirDependencies
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
my $JobType = shift;
|
|
my $JobPlatform = shift || "all";
|
|
|
|
my @JobDependencies = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$JobType =~ s/($JobType)/\L$JobType/;
|
|
$JobPlatform =~ s/($JobPlatform)/\L$JobPlatform/ if ($JobPlatform ne "all");
|
|
|
|
my $PlatformContent = undef;
|
|
my %tempJobDependencies = ();
|
|
|
|
# first we need a reference of the higher level tag <build>
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
# get all 'job directories' with the matching values of the 'job type' and the 'job platform'
|
|
my @tempDepDirs = ();
|
|
@tempDepDirs = $self->getJobDirectories($JobType, $JobPlatform);
|
|
|
|
# get each content of the <build> tag
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
# get the ref of the content of the <build> tag
|
|
my $Task_ref = getContent($Build_ref, $i);
|
|
|
|
# get both attributes: 'job dir' and 'job platform'
|
|
my $existingDir = getAttribute($Task_ref, "dir");
|
|
my $PlatformContent = getAttribute($Task_ref, "platform");
|
|
|
|
# if the attribute 'job platform' wasn't set in the internal data structure,
|
|
# it means the default of 'all' is valid and includes all other possible values
|
|
$PlatformContent = "all" if (!($PlatformContent));
|
|
|
|
# get the 'job type' ref which is inside the <task> tag on position '0'
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
|
|
my $existingJobType = getTagName($JobType_ref);
|
|
|
|
if ( ($Dir eq $existingDir) && ($JobType eq $existingJobType) )
|
|
{
|
|
# each 'job type' can have several 'depends' and 'build requirements'
|
|
# here we get the number of the including elements
|
|
my $IndexEnd = getContentCount($JobType_ref);
|
|
|
|
for (my $j = 0; $j < $IndexEnd; $j++)
|
|
{
|
|
# create a ref of the existing content
|
|
my $Content_ref = getContent($JobType_ref, $j);
|
|
|
|
# the content_ref can be 'depend' or 'build requirement'
|
|
# but we only need the 'depend' informations
|
|
next if (getTagName($Content_ref) ne "depend");
|
|
|
|
# get the 'depend dir'
|
|
my $DependDir = getAttribute($Content_ref, "dir");
|
|
|
|
# look in the list of all existing 'job directories'
|
|
foreach my $DepDir (@tempDepDirs)
|
|
{
|
|
# get it, if one of these 'job dirs' is equal with one of the 'depending dirs'
|
|
if ($DepDir eq $DependDir)
|
|
{
|
|
# get all unique values only once
|
|
$tempJobDependencies{$DepDir} = "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# get the unique sorted values in the array
|
|
@JobDependencies = sort keys %tempJobDependencies;
|
|
}
|
|
|
|
print"Depending Dirs = <@JobDependencies>\n" if ($Debug);
|
|
|
|
return @JobDependencies;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getJobTypes
|
|
# gets: $Dir
|
|
# optional: -
|
|
# returns: @JobTypes
|
|
# description: creates and returns an array with the sorted 'job types'
|
|
########################################################################################
|
|
sub getJobTypes
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
|
|
my @JobTypes = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
# it's for creating unique 'job types' which exists only once in the (later) array
|
|
my %tempJobTypes = ();
|
|
|
|
# first we need a reference of the higher level tag <build>
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
# get the ref of the <build> tag
|
|
my $Task_ref = getContent($Build_ref, $i);
|
|
my $existingDir = getAttribute($Task_ref, "dir");
|
|
|
|
# we only need the 'task(s)' with the matching dir
|
|
next if ($Dir ne $existingDir);
|
|
|
|
# get the ref of the <task> tag at the position '0'
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
my $JobType = getTagName($JobType_ref);
|
|
|
|
# get the 'job type' as a key in the hash
|
|
# so we can guarantee that each 'job type' stays unique!
|
|
$tempJobTypes{$JobType} = "";
|
|
}
|
|
|
|
# fill the unique sorted 'job types' in the array
|
|
@JobTypes = sort keys %tempJobTypes;
|
|
}
|
|
|
|
print"JobTypes = <@JobTypes>\n" if ($Debug);
|
|
|
|
return @JobTypes;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getJobBuildReqs
|
|
# gets: $Dir, $BuildReqPlatform
|
|
# optional: $BuildReqPlatform(default: 'all' -> includes all possible values)
|
|
# returns: @JobBuildRequirements
|
|
# description: creates and returns an array with the sorted 'job build requirements'
|
|
########################################################################################
|
|
sub getJobBuildReqs
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
my $BuildReqPlatform = shift || "all";
|
|
|
|
my @JobBuildRequirements = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$BuildReqPlatform =~ s/($BuildReqPlatform)/\L$BuildReqPlatform/ if ($BuildReqPlatform ne "all");
|
|
|
|
my $BuildReqPlatformContent = undef;
|
|
my %tempJobBuildRequirements = ();
|
|
|
|
# first we need a reference of the higher level tag <build>
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
# get the ref to the content of the array of the <build> tag
|
|
my $Task_ref = getContent($Build_ref, $i);
|
|
|
|
# get the attribute 'task dir'
|
|
my $existingDir = getAttribute($Task_ref, "dir");
|
|
|
|
# get the 'job type' ref which is inside the <task> tag
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
|
|
# each 'job type' can have several 'depends' and 'build requirements'
|
|
# here we get the number of the included elements
|
|
my $IndexEnd = getContentCount($JobType_ref);
|
|
|
|
for (my $j = 0; $j < $IndexEnd; $j++)
|
|
{
|
|
# create a ref of the existing content
|
|
my $Content_ref = getContent($JobType_ref, $j);
|
|
|
|
# the content_ref can be 'build requirement' or 'depend'
|
|
# but we need only the 'build requirement' informations
|
|
next if (getTagName($Content_ref) ne "build-requirement");
|
|
|
|
my $BuildReqName = getAttribute($Content_ref, "name");
|
|
$BuildReqPlatformContent = getAttribute($Content_ref, "platform");
|
|
|
|
$BuildReqPlatformContent = "all" if (!($BuildReqPlatformContent));
|
|
|
|
if ($BuildReqPlatform ne "all")
|
|
{
|
|
# compare the parameters: 'dir' and 'platform'
|
|
# other values('wnt', 'unx' and 'mac') for 'platform'
|
|
# including the value 'all' in the existing 'platform' list
|
|
# get each 'build requirement name' only once (unique)
|
|
if ( ($Dir eq $existingDir) &&
|
|
(($BuildReqPlatformContent =~ /\b($BuildReqPlatform)\b/) || ($BuildReqPlatformContent =~ /\ball\b/)) )
|
|
{
|
|
$tempJobBuildRequirements{$BuildReqName} = "";
|
|
|
|
print"JobBuildRequirements (if) = <$BuildReqName>\n" if ($Debug);
|
|
}
|
|
}
|
|
# if the 'build requirement platform' was not allocated, it is "all" (default)
|
|
# now we only need to compare the directories
|
|
elsif ($Dir eq $existingDir)
|
|
{
|
|
$tempJobBuildRequirements{$BuildReqName} = "";
|
|
|
|
print"JobBuildRequirements (elsif) = <$BuildReqName>\n" if ($Debug);
|
|
}
|
|
}
|
|
}
|
|
|
|
# fill the unique sorted 'build requirement names' in the array
|
|
@JobBuildRequirements = sort keys %tempJobBuildRequirements;
|
|
}
|
|
|
|
print"JobBuildRequirements = <@JobBuildRequirements>\n" if ($Debug);
|
|
|
|
return @JobBuildRequirements;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getJobBuildReqPlatforms
|
|
# gets: $Dir, $BuildReqName
|
|
# optional: -
|
|
# returns: @JobBuildReqPlatforms
|
|
# description: creates and returns an array with
|
|
# the sorted 'job build requirement platforms'
|
|
########################################################################################
|
|
sub getJobBuildReqPlatforms
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
my $JobBuildReqName = shift;
|
|
|
|
my @JobBuildReqPlatforms = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
# change all possible upper cases to lower cases
|
|
$JobBuildReqName =~ s/($JobBuildReqName)/\L$JobBuildReqName/;
|
|
|
|
my $BuildReqPlatformContent = undef;
|
|
my @tempPlatforms = ();
|
|
my %tempJobBuildReqPlatforms = ();
|
|
|
|
# first we need a reference of the higher level tag <build>
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
# get the ref to the content of the array of the <build> tag
|
|
my $Task_ref = getContent($Build_ref, $i);
|
|
|
|
# get the attribute 'task dir'
|
|
my $existingDir = getAttribute($Task_ref, "dir");
|
|
|
|
# get the 'job type' ref which is inside the <task> tag
|
|
my $JobType_ref = getContent($Task_ref, 0);
|
|
|
|
# each 'job type' can have several 'depends' and 'build requirements'
|
|
# here we get the number of the included elements
|
|
my $IndexEnd = getContentCount($JobType_ref);
|
|
|
|
for (my $j = 0; $j < $IndexEnd; $j++)
|
|
{
|
|
# create a ref of the existing content
|
|
my $Content_ref = getContent($JobType_ref, $j);
|
|
|
|
# the content_ref can be 'build requirement' or 'depend'
|
|
# but we need only the 'build requirement' informations
|
|
next if (getTagName($Content_ref) ne "build-requirement");
|
|
|
|
my $existingJobBuildReqName = getAttribute($Content_ref, "name");
|
|
$BuildReqPlatformContent = getAttribute($Content_ref, "platform");
|
|
|
|
$BuildReqPlatformContent = "all" if (!($BuildReqPlatformContent));
|
|
|
|
if ( ($Dir eq $existingDir) && ($JobBuildReqName eq $existingJobBuildReqName) )
|
|
{
|
|
# here are the platforms of the current 'build requirement'
|
|
@tempPlatforms = split /\s+/, $BuildReqPlatformContent;
|
|
|
|
foreach my $BuildReqPlatform (@tempPlatforms)
|
|
{
|
|
$tempJobBuildReqPlatforms{$BuildReqPlatform} = "";
|
|
} #########
|
|
}
|
|
}
|
|
}
|
|
|
|
# fill the unique sorted 'build requirement platforms' in the array
|
|
@JobBuildReqPlatforms = sort keys %tempJobBuildReqPlatforms;
|
|
}
|
|
|
|
print"JobBuildReqPlatforms = <@JobBuildReqPlatforms>\n" if ($Debug);
|
|
|
|
return @JobBuildReqPlatforms;
|
|
}
|
|
|
|
########################################################################################
|
|
# sub: getJobPlatforms
|
|
# gets: $Dir
|
|
# optional: -
|
|
# returns: @JobPlatforms
|
|
# description: creates and returns an array with the sorted depending 'job platforms'
|
|
########################################################################################
|
|
sub getJobPlatforms
|
|
{
|
|
my $self = shift;
|
|
my $Dir = shift;
|
|
|
|
my @JobPlatforms = ();
|
|
|
|
my $ModuleData_ref = $$self{"ModuleData"};
|
|
|
|
# check whether that the <build> tag exists
|
|
if ($self->existsTag("build"))
|
|
{
|
|
my $PlatformContent = undef;
|
|
my %tempJobPlatforms = ();
|
|
|
|
# control variable: if a value 'all' exists in the platform content
|
|
# it doesn't matter which platforms are also existing,
|
|
# because 'all' includes all possible values!
|
|
my $allExists = 0;
|
|
|
|
# first we need a reference of the higher level tag <build>
|
|
my ($IndexValue, $Build_ref) = $self->getIterationData("build");
|
|
|
|
for (my $i = 0; $i < $IndexValue; $i++)
|
|
{
|
|
my $Task_ref = getContent($Build_ref, $i);
|
|
|
|
# get the attributes of the <task> tag
|
|
my $existingTaskDir = getAttribute($Task_ref, "dir");
|
|
$PlatformContent = getAttribute($Task_ref, "platform");
|
|
|
|
# if it is not set in the data structure,
|
|
# it has automatically the default value 'all'
|
|
$PlatformContent = "all" if (!($PlatformContent));
|
|
|
|
if ($Dir eq $existingTaskDir)
|
|
{
|
|
# if a platform value 'all' exists, we remember it
|
|
# and don't look further after other platforms
|
|
if ($PlatformContent =~ /\ball\b/)
|
|
{
|
|
$allExists = 1;
|
|
|
|
@JobPlatforms = "all";
|
|
|
|
last;
|
|
}
|
|
|
|
my @tempPlatforms = ();
|
|
|
|
push(@tempPlatforms, split(/\s+/, $PlatformContent));
|
|
|
|
foreach my $Platform (@tempPlatforms)
|
|
{
|
|
$tempJobPlatforms{$Platform} = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
# fill the unique sorted 'job platforms' in the array,
|
|
# but only if the content "all" is not present in the platform content
|
|
@JobPlatforms = sort keys %tempJobPlatforms if ($allExists == 0);
|
|
}
|
|
|
|
print"JobPlatforms = <@JobPlatforms>\n" if ($Debug);
|
|
|
|
return @JobPlatforms;
|
|
}
|
|
|
|
########################################################################################
|
|
# end of 'get' methods #
|
|
########################################################################################
|
|
|
|
1 ;
|