summaryrefslogtreecommitdiff
path: root/soldep/bootstrp/XMLBuildListParser.pm
diff options
context:
space:
mode:
Diffstat (limited to 'soldep/bootstrp/XMLBuildListParser.pm')
-rw-r--r--soldep/bootstrp/XMLBuildListParser.pm1966
1 files changed, 0 insertions, 1966 deletions
diff --git a/soldep/bootstrp/XMLBuildListParser.pm b/soldep/bootstrp/XMLBuildListParser.pm
deleted file mode 100644
index 857723657568..000000000000
--- a/soldep/bootstrp/XMLBuildListParser.pm
+++ /dev/null
@@ -1,1966 +0,0 @@
-:
-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 ;
generated by cgit (git 2.34.1) at 2025-01-06 11:53:30 +0000