soldep/bootstrp/XMLBuildListParser.pm

   1 :
   2 eval 'exec perl -wS $0 ${1+"$@"}'
   3     if 0;
   4
   5 #*************************************************************************
   6 #
   7 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   8 #
   9 # Copyright 2008 by Sun Microsystems, Inc.
  10 #
  11 # OpenOffice.org - a multi-platform office productivity suite
  12 #
  13 # $RCSfile: XMLBuildListParser.pm,v $
  14 #
  15 # $Revision: 1.3 $
  16 #
  17 # This file is part of OpenOffice.org.
  18 #
  19 # OpenOffice.org is free software: you can redistribute it and/or modify
  20 # it under the terms of the GNU Lesser General Public License version 3
  21 # only, as published by the Free Software Foundation.
  22 #
  23 # OpenOffice.org is distributed in the hope that it will be useful,
  24 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 # GNU Lesser General Public License version 3 for more details
  27 # (a copy is included in the LICENSE file that accompanied this code).
  28 #
  29 # You should have received a copy of the GNU Lesser General Public License
  30 # version 3 along with OpenOffice.org.  If not, see
  31 # <http://www.openoffice.org/license.html>
  32 # for a copy of the LGPLv3 License.
  33 #
  34 #*************************************************************************
  35
  36
  37 #************************************************************
  38 # Data structure and XML parser/creator for the changeover  *
  39 # of the current build.lst to build.xlist files             *
  40 # programmer: Pascal Junck, Sun Microsystems GmbH           *
  41 #************************************************************
  42
  43 # The current XMLBuildListParser is the second step for the changeover to XML.
  44 # It was written to create a complex structure with more possibilities to store informations
  45 # of the 'build.lst' files in the new XML files. The important informations were parsed by the
  46 # 'buildlst_parser.pl' from the old files and then are (temporary) stored by the set and add
  47 # methods in the module 'XMLBuildListParser' and 'XML::Parser'. By the API of this module it's
  48 # possible to create the new XML 'build.xlist' files.
  49
  50 # If the '$Product' or the '$JobPlatform' (as also '$BuildReqPlatform') have no value,
  51 # their value are automatically 'all'.
  52 # It doesn't matter whether it's the set/add or the get method, that receives or sends
  53 # these optional parameters.
  54 # In the created XML file the default values aren't set, because of the constraints of the
  55 # 'Document Type Definition'(DTD).
  56 # If there is no product/platform attribute in the 'build.xlist' it means a default of 'all'!
  57
  58 # The important parameters are:
  59
  60 #     $ModuleName      =  it's the name of the current module
  61
  62 #     $DependencyType  =  here are the three possible scalar dependency values
  63 #                         for all other depending modules(of the current module):
  64 #                         'md-simple', 'md-always' and 'md-force'
  65
  66 #     $Products        =  which products can be used for the module dependencies
  67 #                         and might have more different whitespace separated values
  68 #                         e.g.'so oo' (scalar type)
  69
  70 #     $Dir             =  it means a string(scalar) with the current working directory,
  71 #                         with a '/'(current directory) at the beginning of the string
  72
  73 #     $JobType         =  it means a job e.g. 'make'
  74
  75 #     $Platforms       =  in this scalar parameter might be more than one different value,
  76 #                         like: 'wnt unx mac' and 'all'('all' includes the three values)
  77 #                         it must be whitespace separated
  78
  79 #     @DependingDirs   =  a list(array) of all inner depending directories
  80 #                         of the current working directory
  81
  82 #     %BuildReq        =  means a hash with build requirement pairs:
  83 #                         'BuildReqName'(key) => 'BuildReqPlatform'(value)
  84
  85
  86
  87 ##############################  begin of main   ########################################
  88
  89 use strict;
  90
  91 use XML::Parser;
  92
  93 package XMLBuildListParser;
  94
  95 # global variable for printing out all results at parsing
  96 # if the debug variable is set to '1' it prints the results to STDOUT
  97 my $Debug = 0;
  98
  99
 100 #############################  begin of subroutines  ###################################
 101
 102 sub new
 103 {
 104     my $invocant = shift;
 105     my $class = ref($invocant) || $invocant;
 106
 107     my $self = {};
 108
 109     # no real instance data yet, might change if package is extended
 110     bless($self, $class);
 111     $$self{'error_string'} = '';
 112     $self->beginXMLStructure();
 113
 114     return $self;
 115 }
 116
 117 # VG: procedure for a better error handling
 118 sub getError
 119 {
 120    my $self = shift;
 121    return $$self{'error_string'};
 122 };
 123
 124 ########################################################################################
 125 #         sub: loadXMLFile
 126 #        gets: $File
 127 #    optional: -
 128 #     returns: -
 129 # description: get the 'path' of the 'build.xlist'(s), load it in the 'xml parser tree'
 130 #              and fill it in the own data_structure to make it available for the API
 131 ########################################################################################
 132 sub loadXMLFile
 133 {
 134    my $self = shift;
 135    my $File = shift;
 136
 137    if (-f $File)
 138    {
 139       my $TreeParse = new XML::Parser(Style => 'Tree');
 140
 141       my $File_ref;
 142
 143       eval
 144       {
 145          $File_ref = $TreeParse->parsefile($File);
 146       };
 147
 148       if ($@)
 149       {
 150          $@ =~ s/[\r\n]//g;
 151          print"ERROR: $@" if ($Debug);
 152          $$self{'error_string'} = 'ERROR: ' . $@ . ". Error occured while trying to parse $File";
 153
 154          return 0;
 155       }
 156       else
 157       {
 158          filterXMLFile($File_ref);
 159
 160          $$self{"ModuleData"} = $File_ref;
 161
 162          return 1;
 163       }
 164    }
 165    else
 166    {
 167       $$self{'error_string'} = "ERROR: cannot find file $File";
 168       return 0;
 169    }
 170 }
 171
 172 ########################################################################################
 173 #         sub: filterXMLFile
 174 #        gets: $ArrayContent_ref
 175 #    optional: -
 176 #     returns: -
 177 # description: filters all '0' and whitespace based pairs of the XML file
 178 #              -> all spaces, tabs and new lines
 179 ########################################################################################
 180 sub filterXMLFile
 181 {
 182    my $ArrayContent_ref = shift;
 183
 184    # get the number of elements of the array_ref
 185    my $Count = getContentCount($ArrayContent_ref);
 186
 187    for (my $i = 0; $i < $Count;)
 188    {
 189       # get each content pair
 190       my $Content_ref = getContent($ArrayContent_ref, $i);
 191
 192       # in each content pair the first element is either
 193       # a tag name or the value '0'
 194       my $FirstContent = getTagName($Content_ref);
 195
 196       # we need the second part of the content pair to check
 197       # which value is inside
 198       my $SecondContent = getSecondContent($Content_ref);
 199
 200       my $tempArray_ref = "";
 201       if (($FirstContent eq "task") or ($FirstContent eq "depend"))
 202       {
 203         my $dir = $Content_ref->[1]->[0]->{dir};
 204         $dir =~ s/\/$//;
 205         $Content_ref->[1]->[0]->{dir} = $dir;
 206         $i++;
 207         filterXMLFile($Content_ref);
 208       }
 209       elsif ($FirstContent eq "0")
 210       {
 211          # only if there is in the first part a '0' and in the
 212          # second part are whitespaces...
 213          if ($SecondContent =~ /\s+/)
 214          {
 215             # ...make a ref at this position
 216             $tempArray_ref = @$ArrayContent_ref[1];
 217
 218             # and delete this element pair
 219             removeContent($tempArray_ref, $i);
 220
 221             # now we have one element pair fewer
 222             $Count--;
 223          }
 224          else
 225          {
 226             # is there a '0' but in the second part not a whitespace,
 227             # increase 'i' by 1
 228             $i++;
 229          }
 230       }
 231       else
 232       {
 233          # if it's a tag name, increase 'i' by one and call recursive
 234          # the 'filterXMLFile' with the 'content ref'
 235          $i++;
 236
 237          # look further after the '0' and whitespace content
 238          filterXMLFile($Content_ref);
 239       }
 240    }
 241 }
 242
 243 ########################################################################################
 244 #         sub: removeContent
 245 #        gets: $File_ref, $Count
 246 #    optional: -
 247 #     returns: -
 248 # description: removes the '0' and the whitespace based pairs of the XML structure
 249 #              whitespace could be: tabs, new lines and whitespace itself
 250 ########################################################################################
 251 sub removeContent
 252 {
 253    my $tempArray_ref = shift;
 254    my $i = shift;
 255
 256    my $Start = (2*$i) + 1;
 257
 258    splice(@$tempArray_ref, $Start, 2);
 259 }
 260
 261 ########################################################################################
 262 #         sub: beginXMLStructure
 263 #        gets: $ModuleData_ref
 264 #    optional: -
 265 #     returns: -
 266 # description: create a new beginning of the XML file structure
 267 ########################################################################################
 268 sub beginXMLStructure
 269 {
 270    my $self = shift;
 271
 272    # global variable for the complete filled data structure
 273    my $ModuleData_ref = createTag("build-list", {});
 274
 275    $$self{"ModuleData"} = $ModuleData_ref;
 276 }
 277
 278 ########################################################################################
 279 #         sub: insertContent
 280 #        gets: $HigherLevelTag_ref, $currentTag_ref, $Pos
 281 #    optional: -
 282 #     returns: -
 283 # description: insert a content at the right (alphabetical sorted) position
 284 ########################################################################################
 285 sub insertContent
 286 {
 287    my $HigherLevelTag_ref = shift;
 288    my $currentTag_ref = shift;
 289    my $Pos = shift;
 290
 291    my $Array_ref = $HigherLevelTag_ref->[1];
 292
 293    $Pos = ($Pos*2)+1;
 294
 295    splice(@$Array_ref, $Pos, 0, @$currentTag_ref);
 296 }
 297
 298 ########################################################################################
 299 #         sub: saveXMLFile
 300 #        gets: $Path
 301 #    optional: -
 302 #     returns: -
 303 # description: creates a XML file of the whole data structure
 304 ########################################################################################
 305 sub saveXMLFile
 306 {
 307    my $self = shift;
 308    my $Path = shift;
 309
 310    my $ModuleData_ref = $$self{"ModuleData"};
 311
 312    # open the filehandle 'CREATE_XML' for creating the XML files
 313    open (SAVE_XML, ">".$Path)
 314    or die "Error. Open the file <build.xlist> wasn't successful!\n\n";
 315
 316    select SAVE_XML;
 317
 318    print"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
 319    print"<!DOCTYPE build-list SYSTEM \"build_xlist.dtd\">\n";
 320    print"<!--\n"
 321        ."***************************************************************************\n"
 322        ."*                                                                          \n"
 323        ."* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.            \n"
 324        ."*                                                                          \n"
 325        ."* Copyright 2008 by Sun Microsystems, Inc.                                 \n"
 326        ."*                                                                          \n"
 327        ."* OpenOffice.org - a multi-platform office productivity suite              \n"
 328        ."*                                                                          \n"
 329        ."* \$RCSfile: XMLBuildListParser.pm,v $                                     \n"
 330        ."*                                                                          \n"
 331        ."* \$Revision: 1.3 $                                                        \n"
 332        ."*                                                                          \n"
 333        ."* This file is part of OpenOffice.org.                                     \n"
 334        ."*                                                                          \n"
 335        ."* OpenOffice.org is free software: you can redistribute it and/or modify   \n"
 336        ."* it under the terms of the GNU Lesser General Public License version 3    \n"
 337        ."* only, as published by the Free Software Foundation.                      \n"
 338        ."*                                                                          \n"
 339        ."* OpenOffice.org is distributed in the hope that it will be useful,        \n"
 340        ."* but WITHOUT ANY WARRANTY; without even the implied warranty of           \n"
 341        ."* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            \n"
 342        ."* GNU Lesser General Public License version 3 for more details             \n"
 343        ."* (a copy is included in the LICENSE file that accompanied this code).     \n"
 344        ."*                                                                          \n"
 345        ."* You should have received a copy of the GNU Lesser General Public License \n"
 346        ."* version 3 along with OpenOffice.org.  If not, see                        \n"
 347        ."* <http://www.openoffice.org/license.html>                                 \n"
 348        ."* for a copy of the LGPLv3 License.                                        \n"
 349        ."*                                                                          \n"
 350        ."***************************************************************************\n"
 351        ."-->\n";
 352
 353    printTag($ModuleData_ref);
 354
 355    # flush the buffer
 356    # it's the same like the both lines below here, but we make it manually without module 'IO'
 357    # use IO::Handle;
 358    # SAVE_XML -> autoflush(1);
 359    $| = 1;
 360
 361    select STDOUT;
 362
 363    close (SAVE_XML);
 364
 365 }
 366
 367 ########################################################################################
 368 #         sub: printTag
 369 #        gets: $Tag_ref
 370 #    optional: -
 371 #     returns: -
 372 # description: prints out each tag of the existing data structure (XML tree)
 373 ########################################################################################
 374 sub printTag
 375 {
 376    my $Tag_ref = shift;
 377
 378    # the first time we call this function the 'pos counter' has the default value of '0',
 379    # because it is for the begin tag -> it shouldn't have a distance to the left side
 380    my $PosCounter = shift || 0;
 381
 382    # makes it possible that each tag has a specified distance from the left sided margin
 383    my $Distance = " " x $PosCounter;
 384
 385    # it's possible that the content is a text(case 1) between a begin and end tag
 386    # or a tag name(case 2)
 387    # case 1: (    0      , "Text between the begin and end tag" )
 388    my $TagName = getTagName($Tag_ref);
 389
 390    if ($TagName eq "0")
 391    {
 392         print"$Tag_ref->[1]";
 393    }
 394    # case 2: ( "TagName" , (...) )
 395    else
 396    {
 397       # open the tag
 398       # only a new line if it is not the first tag
 399       print"\n" if ($PosCounter != 0);
 400       print $Distance."<".$TagName;
 401
 402       my $Attributes_ref  = getAttributesRef($Tag_ref);
 403
 404       # print all sorted attributes of this tag
 405       foreach my $Attribute (sort keys %$Attributes_ref)
 406       {
 407          my $value = $$Attributes_ref{$Attribute};
 408          print" $Attribute=\"$value\"";
 409       }
 410
 411       # get the number of elements of the array
 412       my $ContentCount = getContentCount($Tag_ref);
 413
 414       # close the tag
 415       # if it is an empty tag create a '/' before we close it with '>'
 416       print"/" if ($ContentCount == 0);
 417       print">";
 418
 419       # get and print all tags recursive
 420       for (my $i = 0; $i < $ContentCount; $i++)
 421       {
 422          # here we get the content of the current tag,
 423          # we rise the 'pos counter' that each level of tags
 424          # has a specified distance from the left side
 425          printTag(getContent($Tag_ref, $i), $PosCounter + 2);
 426       }
 427
 428       # check that the tag has a text between the begin and end tag
 429       # first: had the tag further inner tags?
 430       if ($ContentCount > 0)
 431       {
 432          my $Content_ref = getContent($Tag_ref, 0);
 433          my $TagName = getTagName($Tag_ref);
 434          my $TagContent = getTagName($Content_ref);
 435
 436          # if a tag has a begin tag and a following text, create the end tag behind the text
 437          print"</$TagName>" if ($TagContent eq "0");
 438
 439          print"\n".$Distance."</$TagName>" if ($TagContent ne "0");
 440       }
 441    }
 442 }
 443
 444 ########################################################################################
 445 #         sub: getTagName
 446 #        gets: $Content_ref
 447 #    optional: -
 448 #     returns: $TagName
 449 # description: gets a reference of an array and returns the tag name at position '0'
 450 ########################################################################################
 451 sub getTagName
 452 {
 453    my $Content_ref = shift;
 454
 455    my $TagName = $$Content_ref[0];
 456
 457    return $TagName;
 458 }
 459
 460 ########################################################################################
 461 #         sub: getSecondContent
 462 #        gets: $Content_ref
 463 #    optional: -
 464 #     returns: $SecondContent
 465 # description: gets a reference of an array and returns the second value(index '1')
 466 ########################################################################################
 467 sub getSecondContent
 468 {
 469    my $Content_ref = shift;
 470
 471    my $SecondContent = $$Content_ref[1];
 472
 473    return $SecondContent;
 474 }
 475
 476 ########################################################################################
 477 #         sub: createSortKey
 478 #        gets: $DependencyType, $DepModuleName
 479 #    optional: -
 480 #     returns: $SortKey
 481 # description: creates a key with a number(depending of the dependency type)
 482 #              and a string and returns it
 483 ########################################################################################
 484 sub createSortKey
 485 {
 486    my $DependencyType = shift;
 487    my $DepModuleName = shift;
 488
 489    my $DepTypeAsValue = 0;
 490
 491    if ($DependencyType eq "md-simple")
 492    {
 493       $DepTypeAsValue = 1;
 494    }
 495    elsif ($DependencyType eq "md-always")
 496    {
 497       $DepTypeAsValue = 2;
 498    }
 499    elsif ($DependencyType eq "md-force")
 500    {
 501       $DepTypeAsValue = 3;
 502    }
 503
 504    my $SortKey = $DepTypeAsValue.$DepModuleName;
 505
 506    return $SortKey;
 507 }
 508
 509 ########################################################################################
 510 #         sub: searchTag
 511 #        gets: $TagName, $Tag_ref
 512 #    optional: -
 513 #     returns: $TagValues_ref
 514 # description: gets a reference and goes in the lower level tag,
 515 #              looks after the specified tag name and returns the reference
 516 #              of itself and the neighbour element
 517 ########################################################################################
 518 sub searchTag
 519 {
 520    my $TagName = shift;
 521    my $Tag_ref = shift;
 522
 523    my $TagSerie_ref = $Tag_ref->[1];
 524
 525    # (all elements of the array) - 1 => highest index of the array
 526    my $IndexEnd = scalar(@$TagSerie_ref)-1;
 527
 528    my $TagValues_ref = undef;
 529
 530    for (my $i = 1; $i <= $IndexEnd; $i += 2)
 531    {
 532       if ($TagSerie_ref->[$i] eq $TagName)
 533       {
 534          @$TagValues_ref = @$TagSerie_ref[$i..$i+1];
 535
 536          last;
 537       }
 538    }
 539
 540    return $TagValues_ref;
 541 }
 542
 543 ########################################################################################
 544 #         sub: createTag
 545 #        gets: $TagName, $Attribute_ref
 546 #    optional: -
 547 #     returns: $Tag_ref
 548 # description: creates an anonymous array with a tag name and the reference of its
 549 #              attributes; then returns the reference of this array
 550 ########################################################################################
 551 sub createTag
 552 {
 553    my $TagName = shift;
 554    my $Attribute_ref = shift;
 555
 556    my $Tag_ref = [$TagName, [$Attribute_ref]];
 557
 558    return $Tag_ref;
 559 }
 560
 561 ########################################################################################
 562 #         sub: createText
 563 #        gets: $Text
 564 #    optional: -
 565 #     returns: $TagText_ref
 566 # description: creates an anonymous array(which contains a '0' and a string)
 567 #              for the data structure and returns a reference of it
 568 ########################################################################################
 569 sub createText
 570 {
 571    my $Text = shift;
 572
 573    my $TagText_ref = [0, $Text];
 574
 575    return $TagText_ref;
 576 }
 577
 578 ########################################################################################
 579 #         sub: addContent
 580 #        gets: $Tag_ref, $NextInfos_ref
 581 #    optional: -
 582 #     returns: -
 583 # description: creates and adds a tag with its following content
 584 ########################################################################################
 585 sub addContent
 586 {
 587    # '$NextInfos_ref' has two infos:
 588    # either:  '0' and a string                          -> [Tag, [{}, 0     ,  string ]]
 589    #     or:  'tag' and a ref of a anonymous array      -> [Tag, [{}, newTag, [.....] ]]
 590    my $Tag_ref = shift;
 591    my $NextInfos_ref = shift;
 592
 593    my $SecondPart_ref = $Tag_ref->[1];
 594
 595    # '$Tag_ref' gets now the right structure:
 596    # e.g.  ['tag1', [{}, 0, "text of tag1" ...]...]
 597    # or    ['tag1', [{}, 'tag2', [...]     ...]...]
 598    push(@$SecondPart_ref, @$NextInfos_ref);
 599 }
 600
 601 ########################################################################################
 602 #         sub: getContent
 603 #        gets: $Tag_ref, $i
 604 #    optional: -
 605 #     returns: \@Content (ref of array 'content')
 606 # description: creates and returns a reference of an array with two elements,
 607 #              which are a part of the array of the current tag
 608 ########################################################################################
 609 sub getContent
 610 {
 611    my $Tag_ref = shift;
 612    my $i = shift;
 613
 614    # e.g.
 615    #          [ "tag 1",  [  {} ,  0 , "string", "tag 2", [{}..], "tag 3", [{}..], ..] ..]
 616    # $Tag_ref [  [0]     [1]                                                           ..]
 617    # $Content_ref         [ [0]   [1]    [2]       [3]    [4]      [5]     [6]     ..]
 618
 619    my $Content_ref = $$Tag_ref[1];
 620
 621    # '$start' contains: elements with the index 1, 3, 5 ...(and so on)
 622    #  '$end'  contains: elements with the index 2, 4, 6 ...(and so on)
 623    my $start = (2 * $i) + 1;
 624    my $end = $start + 1;
 625
 626    my @Content = @$Content_ref[$start..$end];
 627
 628    return \@Content;
 629 }
 630
 631 ########################################################################################
 632 #         sub: getAttribute
 633 #        gets: $Tag_ref, $AttributeName
 634 #    optional: -
 635 #     returns: $Attribute
 636 # description: finds and returns an attribute as a string
 637 ########################################################################################
 638 sub getAttribute
 639 {
 640    my $Tag_ref = shift;
 641    my $AttributeName = shift;
 642
 643    #          [ "tag1",  [   { attribute1 = "..",    attribute2 = ".." } , "tag2"...  ]  ]
 644    # Tag_ref  [  [0]    [1]                                                           ]  ]
 645    #                    [  [0]->'attribute1'    , [0]->'attribute2'      ,   [1] ...  ]  ]
 646
 647    # get the scalar of the value of the 'AttributeName' in the anonymous hash
 648    my $Attribute = $Tag_ref->[1]->[0]->{$AttributeName};
 649
 650    return $Attribute;
 651 }
 652
 653 ########################################################################################
 654 #         sub: getAttributeRef
 655 #        gets: $Tag_ref
 656 #    optional: -
 657 #     returns: $Attribute_ref
 658 # description: finds and returns the reference of the hash which contains the attributes
 659 ########################################################################################
 660 sub getAttributesRef
 661 {
 662    my $Tag_ref = shift;
 663
 664    #         [ "tag1",  [   {  attribute1 = "..",    attribute2 = ".." } , "tag2"... ]  ]
 665    # Tag_ref [  [0]   [1]                                                            ]  ]
 666    #                   [   [0]                                           ,  [1]      ]  ]
 667
 668    # get the reference of the anonymous hash
 669    my $Attribute_ref = $Tag_ref->[1]->[0];
 670
 671    return $Attribute_ref;
 672 }
 673
 674 ########################################################################################
 675 #         sub: getContentCount
 676 #        gets: $Tag_ref
 677 #    optional: -
 678 #     returns: $IndexValue
 679 # description: returns the sum of elements pairs of the array (less the anonymous hash)
 680 ########################################################################################
 681 sub getContentCount
 682 {
 683    my $Tag_ref = shift;
 684
 685    # get the content array (address of the inner array)
 686    my $Content_ref = $$Tag_ref[1];
 687
 688    # get the number of the element pairs of the array (without the anonymous hash)
 689    my $IndexValue = scalar(@$Content_ref);
 690    $IndexValue = ($IndexValue-1)/2;
 691
 692    return $IndexValue;
 693 }
 694
 695 ########################################################################################
 696 #         sub: getIterationData
 697 #        gets: $TagName
 698 #    optional: -
 699 #     returns: $IndexValue, $TagDepend_ref
 700 # description: gets a tag name and returns the sum of elements pairs of the array
 701 #             (less the anonymous hash) and the reference of the anonymous array
 702 ########################################################################################
 703 sub getIterationData
 704 {
 705    my $self = shift;
 706    my $TagName = shift;
 707
 708    my $ModuleData_ref = $$self{"ModuleData"};
 709
 710    my $TagDepend_ref = searchTag($TagName, $ModuleData_ref);
 711    my $IndexValue = getContentCount($TagDepend_ref);
 712
 713    return ($IndexValue, $TagDepend_ref);
 714 }
 715
 716 ########################################################################################
 717 #         sub: printErrorMessage
 718 #        gets: $BuildReqPlatforms or $Platforms or $Products
 719 #    optional: -
 720 #     returns: -
 721 # description: it's an error, if a platform or a product content (e.g.'so oo')
 722 #              has at least one valid value and also the value 'all',
 723 #              because 'all' includes all other possible values
 724 ########################################################################################
 725 sub printErrorMessage
 726 {
 727    my $self = shift;
 728    my $Content = shift;
 729
 730    my $ModuleData_ref = $$self{"ModuleData"};
 731
 732    my $Module_ref = searchTag("module-name", $ModuleData_ref);
 733    my $ModuleContent_ref = getContent($Module_ref, 0);
 734    my $Module = @$ModuleContent_ref[1];
 735
 736    print"Error in module <$Module> in Content <$Content>!\n";
 737    print"The value 'all' includes all currently existing valid values.\n\n";
 738 }
 739
 740 ########################################################################################
 741 #         sub: adjustRedundancy
 742 #        gets: $Task_ref, $JobPlatform, $BuildReq_ref
 743 #    optional: -
 744 #     returns: -
 745 # description: the tag <task> (it means 'job') should be created with no redundant infos,
 746 #              like: <task dir="/uno" platform="unx"> ...
 747 #                    <task dir="/uno" platform="wnt"> ...
 748 #                       <build-requirement name="test10" platform="wnt">
 749 #
 750 #              it should be: <task dir="/uno" platform="unx wnt">
 751 #                               <build-requirement name="test10" platform="wnt">
 752 ########################################################################################
 753 sub adjustRedundancy
 754 {
 755    my $Task_ref = shift;
 756    my $JobPlatform = shift;
 757    my $BuildReq_ref = shift;
 758
 759    my %sortedJobPlatforms = ();
 760    my @JobPlatforms = ();
 761    my $PlatformContent = "";
 762
 763    # get the 'task platforms' in one content
 764    my $Attributes_ref = getAttributesRef($Task_ref);
 765
 766    # get the existing 'task platform'
 767    my $existingPlatform = getAttribute($Task_ref, "platform");
 768    $existingPlatform = "all" if (!($existingPlatform));
 769
 770    if ( ($existingPlatform ne "all") && ($JobPlatform ne "all") )
 771    {
 772       # get the sorted platform content
 773       $sortedJobPlatforms{$JobPlatform} = "";
 774       $sortedJobPlatforms{$existingPlatform} = "";
 775
 776       @JobPlatforms = sort keys %sortedJobPlatforms;
 777
 778       $PlatformContent = join " ", @JobPlatforms;
 779
 780       $$Attributes_ref{"platform"} = $PlatformContent;
 781    }
 782    elsif ( ($existingPlatform ne "all") && ($JobPlatform eq "all") )
 783    {
 784       delete $$Attributes_ref{"platform"};
 785    }
 786
 787    if ($BuildReq_ref)
 788    {
 789       my $JobType_ref = getContent($Task_ref, 0);
 790
 791       # if it exists add the 'build requirements' at the
 792       # previous(with the same directory as the current) <task> tag
 793       addBuildReq($JobType_ref, $BuildReq_ref);
 794    }
 795 }
 796
 797 ########################################################################################
 798 #         sub: addBuildReq
 799 #        gets: $JobTypeInfos_ref, $BuildReq_ref
 800 #    optional: -
 801 #     returns: -
 802 # description: add the 'build requirements' to the existing data structure
 803 #              case 1: if the 'job directory' is not redundant
 804 #              case 2: if it is redundant create it to the first existing 'job'
 805 ########################################################################################
 806 sub addBuildReq
 807 {
 808    my $JobTypeInfos_ref = shift;
 809    my $BuildReq_ref = shift;
 810
 811    my @sortedBuildReqPlatforms = ();
 812
 813    foreach my $BuildReqName (sort keys %$BuildReq_ref)
 814    {
 815       my $BuildReqPlatforms = $$BuildReq_ref{$BuildReqName};
 816
 817       $BuildReqPlatforms = "all" if (!($BuildReqPlatforms));
 818
 819       my $Attributes_ref = {"name" => "$BuildReqName"};
 820
 821       # it's wrong, if in a platform content(e.g. "unx wnt") are at least
 822       # one or more platform(s) and within a 'all' term,
 823       # because 'all' is default and means it includes all other possible values!
 824       if ( ($BuildReqPlatforms ne "all") && ($BuildReqPlatforms =~ /\ball\b/) )
 825       {
 826          printErrorMessage($BuildReqPlatforms);
 827       }
 828       elsif (!($BuildReqPlatforms =~ /\ball\b/))
 829       {
 830          @sortedBuildReqPlatforms = sort(split(/\s+/, $BuildReqPlatforms));
 831          $BuildReqPlatforms = join " ", @sortedBuildReqPlatforms;
 832
 833          $$Attributes_ref{"platform"} = "$BuildReqPlatforms";
 834       }
 835
 836       # create the tag <build-requirement>
 837       my $BuildReqInfos_ref = createTag("build-requirement", $Attributes_ref);
 838
 839       # append the <build-requirement> tag to the <'$JobType'> tag
 840       addContent($JobTypeInfos_ref, $BuildReqInfos_ref);
 841    }
 842 }
 843
 844 ########################################################################################
 845 #         sub: checkJobRedundancy
 846 #        gets: $Task_ref, $JobType, $DependingDirs_ref, $JobPlatform, $BuildReq_ref
 847 #    optional: -
 848 #     returns: $LineIsRedundant
 849 # description: checks whether the values of the 'job' line are redundant, like:
 850 #              'job dir', 'job'(e.g.: make) and 'depending dirs'
 851 ########################################################################################
 852 sub checkJobRedundancy
 853 {
 854    my $Task_ref = shift;
 855    my $JobType = shift;
 856    my $DependingDirs_ref = shift;
 857    my $JobPlatform = shift;
 858    my $BuildReq_ref = shift;
 859
 860    my $LineIsRedundant = 0;
 861
 862
 863    # get the ref of the existing 'depending directories'
 864    # if they also equal with the current 'depending directories',
 865    # make one tag instead of two, which differences only in the platform
 866    # (and the 'build requirement', if it exists)
 867    my $JobType_ref = getContent($Task_ref, 0);
 868    my $JobName = getTagName($JobType_ref);
 869
 870    # get the existing 'task platform'
 871    my $existingPlatform = getAttribute($Task_ref, "platform");
 872
 873    # are the jobs equal?
 874    if ($JobType eq $JobName)
 875    {
 876       my @existingDepDirs = ();
 877
 878       my $IndexEnd = getContentCount($JobType_ref);
 879
 880       # get all existing 'depending dirs' of this redundant 'job'
 881       for (my $j = 0; $j < $IndexEnd; $j++)
 882       {
 883          my $Content_ref = getContent($JobType_ref, $j);
 884
 885          my $TagName = getTagName($Content_ref);
 886
 887          # create an array of the 'depending directories'
 888          if ($TagName eq "depend")
 889          {
 890             my $DepDir = getAttribute($Content_ref, "depend");
 891
 892             push(@existingDepDirs, $DepDir);
 893          }
 894       }
 895
 896       # if now the current 'depending dirs' equal with the existing,
 897       # we know that is redundant and have to create only one instead
 898       # of two tags, e.g.
 899       #            before: <task dir="/uno" platform="unx">...
 900       #                    <task dir="/uno" platform="wnt"> ...
 901       #                       <build-requirement name="test10" platform="wnt">
 902       #
 903       #      it should be: <task dir="/uno" platform="unx wnt">
 904       #                       <build-requirement name="test10" platform="wnt">
 905       if (@$DependingDirs_ref eq @existingDepDirs)
 906       {
 907          $LineIsRedundant = 1;
 908
 909          # check redundant directories and create no redundant 'task dirs'
 910          adjustRedundancy($Task_ref, $JobPlatform, $BuildReq_ref);
 911       }
 912    }
 913
 914    return $LineIsRedundant;
 915 }
 916
 917 ########################################################################################
 918 #         sub: existsTag
 919 #        gets: $TagName
 920 #    optional: -
 921 #     returns: $TagExists_ref
 922 # description: checks whether that a tag exists and returns the ref of the content
 923 ########################################################################################
 924 sub existsTag
 925 {
 926    my $self = shift;
 927    my $TagName = shift;
 928
 929    my $TagExists_ref = undef;
 930
 931    my $ModuleData_ref = $$self{"ModuleData"};
 932
 933    # check whether that the <module-depend> tag exists
 934    $TagExists_ref = searchTag($TagName, $ModuleData_ref);
 935
 936    return $TagExists_ref;
 937 }
 938
 939 ########################################################################################
 940 #                           API - (internal) 'set/add' methods                         #
 941 ########################################################################################
 942
 943 ########################################################################################
 944 #         sub: setModuleName
 945 #        gets: $ModuleName
 946 #    optional: -
 947 #     returns: -
 948 # description: gets the name of the current module and set it at the right position
 949 #              in the data structure
 950 ########################################################################################
 951 sub setModuleName
 952 {
 953    my $self = shift;
 954    my $ModuleName = shift;
 955
 956    my $ModuleData_ref = $$self{"ModuleData"};
 957
 958    my $Tag_ref = createTag("module-name", {});
 959    my $TagText_ref = createText($ModuleName);
 960
 961    addContent($Tag_ref, $TagText_ref);
 962
 963    addContent($ModuleData_ref, $Tag_ref);
 964 }
 965
 966 ########################################################################################
 967 #         sub: addModuleDependencies
 968 #        gets: $ModuleName, $DependencyType, $Products
 969 #    optional: $Products(default: 'all' -> includes currently 'so' and 'oo')
 970 #              but the default should not set in the data structure,
 971 #              it's only a 'Document Type Definition' based term
 972 #     returns: -
 973 # description: add the module dependencies and their attributes into the data structure
 974 ########################################################################################
 975 sub addModuleDependencies
 976 {
 977    my $self = shift;
 978    my $ModuleName = shift;
 979    my $DependencyType = shift;
 980    my $Products = shift || "all";
 981
 982    my $ModuleData_ref = $$self{"ModuleData"};
 983
 984    my @sortedProducts = ();
 985
 986    # change all possible upper cases to lower cases
 987    $Products =~ s/($Products)/\L$Products/;
 988
 989    # before we add the module dependencies, we have to prove that the <module-depend> tag was set
 990    # because this tag must be set once before the module dependency tags begin
 991    my $ModuleDepend_ref = searchTag("module-depend", $ModuleData_ref);
 992
 993    # if it doesn't exist, create this tag '<module-depend>'
 994    if (!($ModuleDepend_ref))
 995    {
 996       $ModuleDepend_ref = createTag("module-depend", {});
 997
 998       # add it to the global data structure
 999       addContent($ModuleData_ref, $ModuleDepend_ref);
1000    }
1001
1002    my $Attributes_ref = {"module" => "$ModuleName"};
1003
1004    # it's wrong, if in a product content(e.g. "so") are at least
1005    # one or more product(s) and within a 'all' term,
1006    # because 'all' is default and means it includes all other possible values!
1007    if ( ($Products ne "all") && ($Products =~ /\ball\b/) )
1008    {
1009       printErrorMessage($Products);
1010    }
1011    elsif (!($Products =~ /\ball\b/))
1012    {
1013       @sortedProducts = sort(split(/\s+/ ,$Products));
1014       $Products = join " ", @sortedProducts;
1015
1016       $$Attributes_ref{"product"} = "$Products";
1017    }
1018
1019    my $ModuleDependenciesInfos_ref = createTag("$DependencyType", $Attributes_ref);
1020
1021    my $currentKey = createSortKey($DependencyType, $ModuleName);
1022
1023    # search and get the position in which we have to insert the current 'module depend name'
1024    # at first get the current 'module depend name'
1025    my $currentName = getAttribute($ModuleDependenciesInfos_ref, "module");
1026
1027    # get the information about the number of 'Contents'(= elements) of the array
1028    my $ContentCount = getContentCount($ModuleDepend_ref);
1029
1030    # we have to sort the serie of the 'name' contents,
1031    # therefore we need a 'Pos'(position) of the array in which we want to sort in the 'name' content
1032    my $Pos = 0;
1033
1034    # and we need a control variable 'isInsert'
1035    # that we won't add the 'name' and the content more than one time
1036    my $isInsert = 0;
1037
1038    for (my $i = 0; $i < $ContentCount; $i++)
1039    {
1040       # get each 'Content' of the array = ('task', ARRAY(...))
1041       my $Content_ref = getContent($ModuleDepend_ref, $i);
1042       my $TagName = getTagName($Content_ref);
1043
1044       # get the existing 'task dir' to compare it with the current 'task dir'
1045       my $existingName = getAttribute($Content_ref, "module");
1046
1047       my $existingKey = createSortKey(getTagName($Content_ref), $existingName);
1048
1049       # compare both dirs...
1050       # only if the 'current dir' is lower than a 'existing dir'
1051       # insert it in the data structure
1052       if ($currentKey lt $existingKey)
1053       {
1054          $Pos = $i;
1055
1056          insertContent($ModuleDepend_ref, $ModuleDependenciesInfos_ref, $Pos);
1057
1058          $isInsert = 1;
1059
1060          last;
1061       }
1062    }
1063    # only if the 'current name' is greater (or equal) than the other 'existing names'
1064    # insert it at the end of the data structure
1065    addContent($ModuleDepend_ref, $ModuleDependenciesInfos_ref) if ($isInsert == 0);
1066 }
1067
1068 ########################################################################################
1069 #         sub: addJob
1070 #        gets: $Dir, $JobType, $JobPlatform, $DependingDirs_ref, $BuildReq_ref,
1071 #              $JobPlatform, $DependingDirs_ref, $BuildReq_ref
1072 #    optional: $JobPlatform(default: 'all' -> includes all other possible values),
1073 #              $DependingDirs_ref, $BuildReq_ref
1074 #     returns: -
1075 # description: add the infos about a job from the old build lists(by ascii parser) and
1076 #              sort it in the data structure
1077 ########################################################################################
1078 sub addJob
1079 {
1080    my $self = shift;
1081    my $Dir = shift;
1082    my $JobType = shift;
1083    my $JobPlatform = shift || "all";
1084    my $DependingDirs_ref = shift;
1085    my $BuildReq_ref = shift;
1086
1087    my $ModuleData_ref = $$self{"ModuleData"};
1088
1089    # before we add the "build" tag, we have to prove that the <build> tag was set
1090    # because this tag must be set once before the job tag(s) follows
1091    my $buildTag_ref = searchTag("build", $ModuleData_ref);
1092
1093    # if it doesn't exist, create the tag '<build>'
1094    if (!($buildTag_ref))
1095    {
1096       # If the tag wasn't found, create it
1097       $buildTag_ref = createTag("build", {});
1098
1099       # add it to the global data structure
1100       addContent($ModuleData_ref, $buildTag_ref);
1101    }
1102
1103    my $Attributes_ref = {"dir" => "$Dir"};
1104
1105    # it's wrong, if a 'job platform' content(e.g. "unx wnt") has at least
1106    # one or more 'job platform(s)' and an 'all' term,
1107    # because 'all' is default and means it includes all other possible values
1108    if ( ($JobPlatform ne "all") && ($JobPlatform =~ /\ball\b/) )
1109    {
1110       printErrorMessage($JobPlatform);
1111    }
1112    elsif (!($JobPlatform =~ /\ball\b/))
1113    {
1114       my @sortedPlatforms = sort(split /\s+/, $JobPlatform);
1115       $JobPlatform = join " ", @sortedPlatforms;
1116
1117       $$Attributes_ref{"platform"} = "$JobPlatform";
1118    }
1119
1120    # create the tags: <task>, <make> and (if it exists)...
1121    #                  <depend> and/or <build-requirement>
1122    my $taskInfos_ref = createTag("task", $Attributes_ref);
1123
1124    # search and get the position in which we have to insert the current task
1125    # at first get the current 'task directory'
1126    my $currentDir = getAttribute($taskInfos_ref, "dir");
1127
1128    # get the information about the number of 'Contents'(= elements) of the array
1129    my $IndexValue = getContentCount($buildTag_ref);
1130
1131    # we have to sort the serie of the 'task contents',
1132    # therefore we need a '$pos'(position) of the array in which we want to sort in the 'task content'
1133    my $Pos = 0;
1134
1135    # and we need a control variable 'isInsert'
1136    # that we won't add the 'task content' more than one time
1137    my $isInsert = 0;
1138
1139    # control variable for the redundancy check
1140    my $LineIsRedundant = 0;
1141
1142    # go in the array of the corresponding <build> tag element
1143    for (my $i = 0; $i < $IndexValue; $i++)
1144    {
1145       # get each content of the <build> tag => ('task1', ARRAY1(...), task2...)
1146       my $Task_ref = getContent($buildTag_ref, $i);
1147
1148       # get the existing 'task dir' to compare it with the current 'task dir'
1149       my $existingDir = getAttribute($Task_ref, "dir");
1150
1151       # is the 'job dir' redundant?
1152       if ($currentDir eq $existingDir)
1153       {
1154          $LineIsRedundant = checkJobRedundancy($Task_ref, $JobType, $DependingDirs_ref, $JobPlatform, $BuildReq_ref);
1155       }
1156
1157       # if it's not a redundant line, compare both dirs:
1158       # only if the 'current dir' is lower than an 'existing dir'
1159       # insert it in the data structure
1160       if ( ($LineIsRedundant == 0) && ($currentDir lt $existingDir) )
1161       {
1162          $Pos = $i;
1163
1164          insertContent($buildTag_ref, $taskInfos_ref, $Pos);
1165
1166          $isInsert = 1;
1167
1168          last;
1169       }
1170    }
1171
1172    # only if the 'current dir' is greater (or equal) than the other 'existing dirs'
1173    # and it is not redundant insert it at the end of the data structure
1174    if ( ($isInsert == 0) && ($LineIsRedundant == 0) )
1175    {
1176       addContent($buildTag_ref, $taskInfos_ref);
1177    }
1178
1179    if ($LineIsRedundant == 0)
1180    {
1181       # create the <'$JobType'> tag
1182       my $JobTypeInfos_ref = createTag($JobType, {});
1183
1184       # append the <'$JobType'> tag to the <task> tag
1185       addContent($taskInfos_ref, $JobTypeInfos_ref);
1186
1187       # before we add the "depend" infos
1188       # we have to get the alphabetical sorted 'Depending Directories'
1189       @$DependingDirs_ref = sort(@$DependingDirs_ref) if ($DependingDirs_ref);
1190
1191       foreach my $DependDir (@$DependingDirs_ref)
1192       {
1193          my $DependInfos_ref = createTag("depend", {"dir" => "$DependDir"});
1194
1195          # append the <depend> tag to the <'$JobType'> tag
1196          addContent($JobTypeInfos_ref, $DependInfos_ref);
1197       }
1198
1199       # if a 'build requirement' exists, create the tag <build-requirement>
1200       if ($BuildReq_ref)
1201       {
1202          addBuildReq($JobTypeInfos_ref, $BuildReq_ref);
1203       }
1204    }
1205 }
1206
1207 ########################################################################################
1208 #                           end of (internal) 'set/add' methods                        #
1209 ########################################################################################
1210
1211
1212 ########################################################################################
1213 #                             API - (external) 'get' methods                           #
1214 ########################################################################################
1215
1216 ########################################################################################
1217 #         sub: getModuleDependencies
1218 #        gets: $Product, $DependencyType
1219 #    optional: $Product(default: 'all', means all currently used valid values),
1220 #              $DependencyType(default: 'md-simple', 'md-always' and 'md-force')
1221 #     returns: @ModuleDependencies
1222 # description: gets a ref of an array (with the products) and creates and
1223 #              returns an array with the sorted depending modules
1224 ########################################################################################
1225 sub getModuleName {
1226    my $self = shift;
1227    if ($self->existsTag("module-name")) {
1228        my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-name");
1229        return $$ModuleDepend_ref[1][2];
1230    };
1231    return "";
1232
1233 };
1234 sub getModuleDependencies
1235 {
1236    my $self = shift;
1237    my $Products_ref = shift;
1238    my $DependencyType = shift || "all";
1239
1240    push(@$Products_ref, "all") if (!scalar @$Products_ref);
1241
1242    my $Product = "";
1243    my %tempModuleDeps = ();
1244    my @ModuleDependencies = ();
1245
1246    my $ModuleData_ref = $$self{"ModuleData"};
1247
1248    # check whether that the <module-depend> tag exists
1249    if ($self->existsTag("module-depend"))
1250    {
1251       # change all possible upper cases to lower cases
1252       $DependencyType =~ s/($DependencyType)/\L$DependencyType/ if ($DependencyType ne "all");
1253
1254       foreach $Product (@$Products_ref)
1255       {
1256          # change all possible upper cases to lower cases
1257          $Product =~ s/($Product)/\L$Product/;
1258
1259          my $ProductContent = undef;
1260          my $ModuleDependencyName = "";
1261
1262          # get the number of elements and the ref of the <module-depend> tag
1263          my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
1264
1265          for (my $i = 0; $i < $IndexValue; $i++)
1266          {
1267             my $Content_ref = getContent($ModuleDepend_ref, $i);
1268
1269             my $ModuleDependencyName = getAttribute($Content_ref, "module");
1270
1271             # get the name of each existing tag
1272             my $TagName = getTagName($Content_ref);
1273
1274             $ProductContent = getAttribute($Content_ref, "product");
1275
1276             # if the attribute 'product' wasn't set in the internal data structure,
1277             # it means the default of 'all' is valid and includes all other possible values
1278             $ProductContent = "all" if (!($ProductContent));
1279
1280             if ($Product ne "all")
1281             {
1282                if ($DependencyType ne "all")
1283                {
1284                   # if the caller wants all (e.g.)'so' product based dependency types,
1285                   # we must get the 'so' and the 'all' matching products
1286                   # because 'all' matches also the product 'so'
1287                   if ( ($DependencyType eq $TagName) &&
1288                        ((($ProductContent eq "all") || $ProductContent =~ /\b($Product)\b/)) )
1289                   {
1290                      $tempModuleDeps{$ModuleDependencyName} = "";
1291
1292                      print"ModuleDeps (Product != 'all' && DepType != 'all') = <$ModuleDependencyName>\n" if ($Debug);
1293                   }
1294                }
1295                # we get from the caller only the 'product' parameter,
1296                # 'dependency type' is now 'all'(default) and includes all possible values
1297                elsif ( ($ProductContent =~ /\b($Product)\b/) || ($ProductContent eq "all") )
1298                {
1299                   $tempModuleDeps{$ModuleDependencyName} = "";
1300
1301                   print"ModuleDeps (Product != 'all' && DepType = 'all') = <$ModuleDependencyName>\n" if ($Debug);
1302                }
1303             }
1304             # now the product is 'all' and we only need to check the 'dependency type'
1305             elsif ($DependencyType ne "all")
1306             {
1307                if ($DependencyType eq $TagName)
1308                {
1309                   $tempModuleDeps{$ModuleDependencyName} = "";
1310
1311                   print"ModuleDeps (Product = 'all' && DepType != 'all') = <$ModuleDependencyName>\n" if ($Debug);
1312                }
1313             }
1314             else
1315             {
1316                $tempModuleDeps{$ModuleDependencyName} = "";
1317
1318                print"ModuleDeps (Product = 'all' && DepType = 'all') = <$ModuleDependencyName>\n" if ($Debug);
1319             }
1320          }
1321       }
1322
1323       @ModuleDependencies = sort keys %tempModuleDeps;
1324    }
1325
1326    print"ModuleDependencies            =  <@ModuleDependencies>\n" if ($Debug);
1327
1328    return @ModuleDependencies;
1329 }
1330
1331 ########################################################################################
1332 #         sub: getModuleDepType
1333 #        gets: $DepModuleName
1334 #    optional: -
1335 #     returns: $DependencyType
1336 # description: gets a module name and returns the dependency type of it
1337 ########################################################################################
1338 sub getModuleDepType
1339 {
1340    my $self = shift;
1341    my $DepModuleName = shift;
1342
1343    my $DependencyType = "";
1344
1345    my $ModuleData_ref = $$self{"ModuleData"};
1346
1347    # check whether that the <module-depend> tag exists
1348    if ($self->existsTag("module-depend"))
1349    {
1350       # change all possible upper cases to lower cases
1351       $DepModuleName =~ s/($DepModuleName)/\L$DepModuleName/;
1352
1353       my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
1354
1355       for (my $i = 0; $i < $IndexValue; $i++)
1356       {
1357          my $Content_ref = getContent($ModuleDepend_ref, $i);
1358          my $existingModuleName = getAttribute($Content_ref, "module");
1359
1360          if ($DepModuleName eq $existingModuleName)
1361          {
1362             $DependencyType = getTagName($Content_ref);
1363             last;
1364          }
1365       }
1366    }
1367
1368    print"DependencyType                =  <$DependencyType>\n" if ($Debug);
1369
1370    return $DependencyType;
1371 }
1372
1373 ########################################################################################
1374 #         sub: getModuleProducts
1375 #        gets: $DepModuleName
1376 #    optional: -
1377 #     returns: @ModuleProducts
1378 # description: gets a module name and returns the associated products
1379 ########################################################################################
1380 sub getModuleProducts
1381 {
1382    my $self = shift;
1383    my $DepModuleName = shift;
1384
1385    my @ModuleProducts = ();
1386
1387    my $ModuleData_ref = $$self{"ModuleData"};
1388
1389    # check whether that the <module-depend> tag exists
1390    if ($self->existsTag("module-depend"))
1391    {
1392       # change all possible upper cases to lower cases
1393       $DepModuleName =~ s/($DepModuleName)/\L$DepModuleName/;
1394
1395       my $ProductContent = undef;
1396
1397       my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
1398
1399       for (my $i = 0; $i < $IndexValue; $i++)
1400       {
1401          my $Content_ref = getContent($ModuleDepend_ref, $i);
1402
1403          my $existingModuleName = getAttribute($Content_ref, "module");
1404
1405          # if the attribute 'product' wasn't set in the internal data structure,
1406          # it means the default of 'all' is valid and includes all other possible values
1407          $ProductContent = getAttribute($Content_ref, "product");
1408
1409          if ($DepModuleName eq $existingModuleName)
1410          {
1411             $ProductContent = "all" if (!($ProductContent));
1412
1413             @ModuleProducts = split /\s+/, $ProductContent;
1414
1415             last;
1416          }
1417       }
1418    }
1419
1420    print"Products                      =  <@ModuleProducts>\n" if ($Debug);
1421
1422    return @ModuleProducts;
1423 }
1424
1425 ########################################################################################
1426 #         sub: getProducts
1427 #        gets: -
1428 #    optional: -
1429 #     returns: @ModuleProducts
1430 # description: returns the products of the whole depending modules
1431 #              each found product name may occurs only once in the module products array
1432 ########################################################################################
1433 sub getProducts
1434 {
1435    my $self = shift;
1436    my $ProductContent = undef;
1437    my @tempProducts = ();
1438    my @ModuleProducts = ();
1439    my %Products = ();
1440
1441    my $ModuleData_ref = $$self{"ModuleData"};
1442
1443    # check whether that the <module-depend> tag exists
1444    if ($self->existsTag("module-depend"))
1445    {
1446       my ($IndexValue, $ModuleDepend_ref) = $self->getIterationData("module-depend");
1447
1448       for (my $i = 0; $i < $IndexValue; $i++)
1449       {
1450          my $Content_ref = getContent($ModuleDepend_ref, $i);
1451
1452          $ProductContent = getAttribute($Content_ref, "product");
1453
1454          # if the attribute 'product' wasn't set in the internal data structure,
1455          # it means the default of 'all' is valid and includes all other possible values
1456          # but here we need only all 'not-all' values!
1457          if (!($ProductContent))
1458          {
1459             $ProductContent="";
1460          }
1461          else
1462          {
1463             # here are the products of the current depending module
1464             @tempProducts = split /\s+/, $ProductContent;
1465
1466             foreach my $Product (@tempProducts)
1467             {
1468                $Products{$Product} = "";
1469             }
1470          }
1471       }
1472
1473       # fill the sorted 'module products' in the array
1474       @ModuleProducts = sort keys %Products;
1475    }
1476
1477    print"All ModuleProducts            =  <@ModuleProducts>\n" if ($Debug);
1478
1479    return @ModuleProducts;
1480 }
1481
1482 ########################################################################################
1483 #         sub: getJobDirectories
1484 #        gets: $JobType, $JobPlatform
1485 #    optional: $JobType, $JobPlatform(default: 'all' -> includes all possible values)
1486 #     returns: @JobDirectories
1487 # description: creates and returns an array with the sorted directories, which
1488 #              fulfil the expected values of the job type and the job platform
1489 ########################################################################################
1490 sub getJobDirectories
1491 {
1492    my $self = shift;
1493    my $JobType = shift;
1494    my $JobPlatform = shift || "all";
1495
1496    my @JobDirectories = ();
1497
1498    my $ModuleData_ref = $$self{"ModuleData"};
1499
1500    # check whether that the <build> tag exists
1501    if ($self->existsTag("build"))
1502    {
1503       # change all possible upper cases to lower cases
1504       $JobType =~ s/($JobType)/\L$JobType/ if ($JobType);
1505       $JobPlatform =~ s/($JobPlatform)/\L$JobPlatform/ if ($JobPlatform ne "all");
1506
1507       my $PlatformContent = undef;
1508       my %tempJobDirectories = ();
1509
1510       # get the ref of the <build> tag
1511       my ($IndexValue, $Build_ref)  = $self->getIterationData("build");
1512
1513       for (my $i = 0; $i < $IndexValue; $i++)
1514       {
1515          my $Content_ref = getContent($Build_ref, $i);
1516
1517          my $PlatformContent = getAttribute($Content_ref, "platform");
1518          my $existingDir = getAttribute($Content_ref, "dir");
1519
1520          # three cases are possible...
1521          if ($JobType)
1522          {
1523             my $JobType_ref = getContent($Content_ref, 0);
1524             my $existingJobType = getTagName($JobType_ref);
1525
1526             # if the attribute 'job platform' wasn't set in the internal data structure,
1527             # it means the default of 'all' is valid and includes all other possible values
1528             $PlatformContent = "all" if (!($PlatformContent));
1529
1530             # first case: we get from the caller the parameters 'job type' and 'job platform'
1531             if ($JobPlatform ne "all")
1532             {
1533                # if the caller wants all e.g.'wnt' job platform based directories,
1534                # we have to get the 'wnt' or the 'all' matching platform
1535                # because 'all' includes also 'wnt'
1536                if ( ($JobType eq $existingJobType) &&
1537                     (($PlatformContent =~ /\b($JobPlatform)\b/) || ($PlatformContent eq "all")) )
1538                {
1539                   $tempJobDirectories{$existingDir} = "";
1540                }
1541             }
1542             # second case: we get from the caller only the 'job type' parameter
1543             #              'job platform' is now 'all'(default) and includes all possible values
1544             elsif ($JobType eq $existingJobType)
1545             {
1546                $tempJobDirectories{$existingDir} = "";
1547             }
1548          }
1549          # third case: we get from the caller no parameter; now we take each existing 'job directory',
1550          #             no matter which 'job type' and 'job platform' it has
1551          else
1552          {
1553             $tempJobDirectories{$existingDir} = "";
1554          }
1555       }
1556
1557       # sort each unique 'job directory' alphabetical
1558       @JobDirectories = sort keys %tempJobDirectories;
1559    }
1560    print"JobDirectories                =  <@JobDirectories>\n" if ($Debug);
1561
1562    return @JobDirectories;
1563 }
1564
1565 ########################################################################################
1566 #         sub: getDirDependencies
1567 #        gets: $Dir, $JobType, $JobPlatform
1568 #    optional: $JobPlatform(default: 'all' -> includes all possible values)
1569 #     returns: @JobDependencies
1570 # description: creates and returns an array with the sorted depending directories
1571 ########################################################################################
1572 sub getDirDependencies
1573 {
1574    my $self = shift;
1575    my $Dir = shift;
1576    my $JobType = shift;
1577    my $JobPlatform = shift || "all";
1578
1579    my @JobDependencies = ();
1580
1581    my $ModuleData_ref = $$self{"ModuleData"};
1582
1583    # check whether that the <build> tag exists
1584    if ($self->existsTag("build"))
1585    {
1586       # change all possible upper cases to lower cases
1587       $JobType =~ s/($JobType)/\L$JobType/;
1588       $JobPlatform =~ s/($JobPlatform)/\L$JobPlatform/ if ($JobPlatform ne "all");
1589
1590       my $PlatformContent = undef;
1591       my %tempJobDependencies = ();
1592
1593       # first we need a reference of the higher level tag <build>
1594       my ($IndexValue, $Build_ref) = $self->getIterationData("build");
1595
1596       # get all 'job directories' with the matching values of the 'job type' and the 'job platform'
1597       my @tempDepDirs = ();
1598       @tempDepDirs = $self->getJobDirectories($JobType, $JobPlatform);
1599
1600       # get each content of the <build> tag
1601       for (my $i = 0; $i < $IndexValue; $i++)
1602       {
1603          # get the ref of the content of the <build> tag
1604          my $Task_ref = getContent($Build_ref, $i);
1605
1606          # get both attributes: 'job dir' and 'job platform'
1607          my $existingDir = getAttribute($Task_ref, "dir");
1608          my $PlatformContent = getAttribute($Task_ref, "platform");
1609
1610          # if the attribute 'job platform' wasn't set in the internal data structure,
1611          # it means the default of 'all' is valid and includes all other possible values
1612          $PlatformContent = "all" if (!($PlatformContent));
1613
1614          # get the 'job type' ref which is inside the <task> tag on position '0'
1615          my $JobType_ref = getContent($Task_ref, 0);
1616
1617          my $existingJobType = getTagName($JobType_ref);
1618
1619          if ( ($Dir eq $existingDir) && ($JobType eq $existingJobType) )
1620          {
1621             # each 'job type' can have several 'depends' and 'build requirements'
1622             # here we get the number of the including elements
1623             my $IndexEnd = getContentCount($JobType_ref);
1624
1625             for (my $j = 0; $j < $IndexEnd; $j++)
1626             {
1627                # create a ref of the existing content
1628                my $Content_ref = getContent($JobType_ref, $j);
1629
1630                # the content_ref can be 'depend' or 'build requirement'
1631                # but we only need the 'depend' informations
1632                next if (getTagName($Content_ref) ne "depend");
1633
1634                # get the 'depend dir'
1635                my $DependDir = getAttribute($Content_ref, "dir");
1636
1637                # look in the list of all existing 'job directories'
1638                foreach my $DepDir (@tempDepDirs)
1639                {
1640                   # get it, if one of these 'job dirs' is equal with one of the 'depending dirs'
1641                   if ($DepDir eq $DependDir)
1642                   {
1643                      # get all unique values only once
1644                      $tempJobDependencies{$DepDir} = "";
1645                   }
1646                }
1647             }
1648          }
1649       }
1650
1651       # get the unique sorted values in the array
1652       @JobDependencies = sort keys %tempJobDependencies;
1653    }
1654
1655    print"Depending Dirs                =  <@JobDependencies>\n" if ($Debug);
1656
1657    return @JobDependencies;
1658 }
1659
1660 ########################################################################################
1661 #         sub: getJobTypes
1662 #        gets: $Dir
1663 #    optional: -
1664 #     returns: @JobTypes
1665 # description: creates and returns an array with the sorted 'job types'
1666 ########################################################################################
1667 sub getJobTypes
1668 {
1669    my $self = shift;
1670    my $Dir = shift;
1671
1672    my @JobTypes = ();
1673
1674    my $ModuleData_ref = $$self{"ModuleData"};
1675
1676    # check whether that the <build> tag exists
1677    if ($self->existsTag("build"))
1678    {
1679       # it's for creating unique 'job types' which exists only once in the (later) array
1680       my %tempJobTypes = ();
1681
1682       # first we need a reference of the higher level tag <build>
1683       my ($IndexValue, $Build_ref)  = $self->getIterationData("build");
1684
1685       for (my $i = 0; $i < $IndexValue; $i++)
1686       {
1687          # get the ref of the <build> tag
1688          my $Task_ref = getContent($Build_ref, $i);
1689          my $existingDir = getAttribute($Task_ref, "dir");
1690
1691          # we only need the 'task(s)' with the matching dir
1692          next if ($Dir ne $existingDir);
1693
1694          # get the ref of the <task> tag at the position '0'
1695          my $JobType_ref = getContent($Task_ref, 0);
1696          my $JobType = getTagName($JobType_ref);
1697
1698          # get the 'job type' as a key in the hash
1699          # so we can guarantee that each 'job type' stays unique!
1700          $tempJobTypes{$JobType} = "";
1701       }
1702
1703       # fill the unique sorted 'job types' in the array
1704       @JobTypes = sort keys %tempJobTypes;
1705    }
1706
1707    print"JobTypes                      =  <@JobTypes>\n" if ($Debug);
1708
1709    return @JobTypes;
1710 }
1711
1712 ########################################################################################
1713 #         sub: getJobBuildReqs
1714 #        gets: $Dir, $BuildReqPlatform
1715 #    optional: $BuildReqPlatform(default: 'all' -> includes all possible values)
1716 #     returns: @JobBuildRequirements
1717 # description: creates and returns an array with the sorted 'job build requirements'
1718 ########################################################################################
1719 sub getJobBuildReqs
1720 {
1721    my $self = shift;
1722    my $Dir = shift;
1723    my $BuildReqPlatform = shift || "all";
1724
1725    my @JobBuildRequirements = ();
1726
1727    my $ModuleData_ref = $$self{"ModuleData"};
1728
1729    # check whether that the <build> tag exists
1730    if ($self->existsTag("build"))
1731    {
1732       # change all possible upper cases to lower cases
1733       $BuildReqPlatform =~ s/($BuildReqPlatform)/\L$BuildReqPlatform/ if ($BuildReqPlatform ne "all");
1734
1735       my $BuildReqPlatformContent = undef;
1736       my %tempJobBuildRequirements = ();
1737
1738       # first we need a reference of the higher level tag <build>
1739       my ($IndexValue, $Build_ref)  = $self->getIterationData("build");
1740
1741       for (my $i = 0; $i < $IndexValue; $i++)
1742       {
1743          # get the ref to the content of the array of the <build> tag
1744          my $Task_ref = getContent($Build_ref, $i);
1745
1746          # get the attribute 'task dir'
1747          my $existingDir = getAttribute($Task_ref, "dir");
1748
1749          # get the 'job type' ref which is inside the <task> tag
1750          my $JobType_ref = getContent($Task_ref, 0);
1751
1752          # each 'job type' can have several 'depends' and 'build requirements'
1753          # here we get the number of the included elements
1754          my $IndexEnd = getContentCount($JobType_ref);
1755
1756          for (my $j = 0; $j < $IndexEnd; $j++)
1757          {
1758             # create a ref of the existing content
1759             my $Content_ref = getContent($JobType_ref, $j);
1760
1761             # the content_ref can be 'build requirement' or 'depend'
1762             # but we need only the 'build requirement' informations
1763             next if (getTagName($Content_ref) ne "build-requirement");
1764
1765             my $BuildReqName = getAttribute($Content_ref, "name");
1766             $BuildReqPlatformContent = getAttribute($Content_ref, "platform");
1767
1768             $BuildReqPlatformContent = "all" if (!($BuildReqPlatformContent));
1769
1770             if ($BuildReqPlatform ne "all")
1771             {
1772                # compare the parameters: 'dir' and 'platform'
1773                # other values('wnt', 'unx' and 'mac') for 'platform'
1774                # including the value 'all' in the existing 'platform' list
1775                # get each 'build requirement name' only once (unique)
1776                if ( ($Dir eq $existingDir) &&
1777                     (($BuildReqPlatformContent =~ /\b($BuildReqPlatform)\b/) || ($BuildReqPlatformContent =~ /\ball\b/)) )
1778                {
1779                   $tempJobBuildRequirements{$BuildReqName} = "";
1780
1781                   print"JobBuildRequirements   (if)   =  <$BuildReqName>\n" if ($Debug);
1782                }
1783             }
1784             # if the 'build requirement platform' was not allocated, it is "all" (default)
1785             # now we only need to compare the directories
1786             elsif ($Dir eq $existingDir)
1787             {
1788                $tempJobBuildRequirements{$BuildReqName} = "";
1789
1790                print"JobBuildRequirements (elsif)  =  <$BuildReqName>\n" if ($Debug);
1791             }
1792          }
1793       }
1794
1795       # fill the unique sorted 'build requirement names' in the array
1796       @JobBuildRequirements = sort keys %tempJobBuildRequirements;
1797    }
1798
1799    print"JobBuildRequirements          =  <@JobBuildRequirements>\n" if ($Debug);
1800
1801    return @JobBuildRequirements;
1802 }
1803
1804 ########################################################################################
1805 #         sub: getJobBuildReqPlatforms
1806 #        gets: $Dir, $BuildReqName
1807 #    optional: -
1808 #     returns: @JobBuildReqPlatforms
1809 # description: creates and returns an array with
1810 #              the sorted 'job build requirement platforms'
1811 ########################################################################################
1812 sub getJobBuildReqPlatforms
1813 {
1814    my $self = shift;
1815    my $Dir = shift;
1816    my $JobBuildReqName = shift;
1817
1818    my @JobBuildReqPlatforms = ();
1819
1820    my $ModuleData_ref = $$self{"ModuleData"};
1821
1822    # check whether that the <build> tag exists
1823    if ($self->existsTag("build"))
1824    {
1825       # change all possible upper cases to lower cases
1826       $JobBuildReqName =~ s/($JobBuildReqName)/\L$JobBuildReqName/;
1827
1828       my $BuildReqPlatformContent = undef;
1829       my @tempPlatforms = ();
1830       my %tempJobBuildReqPlatforms = ();
1831
1832       # first we need a reference of the higher level tag <build>
1833       my ($IndexValue, $Build_ref)  = $self->getIterationData("build");
1834
1835       for (my $i = 0; $i < $IndexValue; $i++)
1836       {
1837          # get the ref to the content of the array of the <build> tag
1838          my $Task_ref = getContent($Build_ref, $i);
1839
1840          # get the attribute 'task dir'
1841          my $existingDir = getAttribute($Task_ref, "dir");
1842
1843          # get the 'job type' ref which is inside the <task> tag
1844          my $JobType_ref = getContent($Task_ref, 0);
1845
1846          # each 'job type' can have several 'depends' and 'build requirements'
1847          # here we get the number of the included elements
1848          my $IndexEnd = getContentCount($JobType_ref);
1849
1850          for (my $j = 0; $j < $IndexEnd; $j++)
1851          {
1852             # create a ref of the existing content
1853             my $Content_ref = getContent($JobType_ref, $j);
1854
1855             # the content_ref can be 'build requirement' or 'depend'
1856             # but we need only the 'build requirement' informations
1857             next if (getTagName($Content_ref) ne "build-requirement");
1858
1859             my $existingJobBuildReqName = getAttribute($Content_ref, "name");
1860             $BuildReqPlatformContent = getAttribute($Content_ref, "platform");
1861
1862             $BuildReqPlatformContent = "all" if (!($BuildReqPlatformContent));
1863
1864             if ( ($Dir eq $existingDir) && ($JobBuildReqName eq $existingJobBuildReqName) )
1865             {
1866                # here are the platforms of the current 'build requirement'
1867                @tempPlatforms = split /\s+/, $BuildReqPlatformContent;
1868
1869                foreach my $BuildReqPlatform (@tempPlatforms)
1870                {
1871                   $tempJobBuildReqPlatforms{$BuildReqPlatform} = "";
1872                }                                                                                                                                        #########
1873             }
1874          }
1875       }
1876
1877       # fill the unique sorted 'build requirement platforms' in the array
1878       @JobBuildReqPlatforms = sort keys %tempJobBuildReqPlatforms;
1879    }
1880
1881    print"JobBuildReqPlatforms          =  <@JobBuildReqPlatforms>\n" if ($Debug);
1882
1883    return @JobBuildReqPlatforms;
1884 }
1885
1886 ########################################################################################
1887 #         sub: getJobPlatforms
1888 #        gets: $Dir
1889 #    optional: -
1890 #     returns: @JobPlatforms
1891 # description: creates and returns an array with the sorted depending 'job platforms'
1892 ########################################################################################
1893 sub getJobPlatforms
1894 {
1895    my $self = shift;
1896    my $Dir = shift;
1897
1898    my @JobPlatforms = ();
1899
1900    my $ModuleData_ref = $$self{"ModuleData"};
1901
1902    # check whether that the <build> tag exists
1903    if ($self->existsTag("build"))
1904    {
1905       my $PlatformContent = undef;
1906       my %tempJobPlatforms = ();
1907
1908       # control variable: if a value 'all' exists in the platform content
1909       #                   it doesn't matter which platforms are also existing,
1910       #                   because 'all' includes all possible values!
1911       my $allExists = 0;
1912
1913       # first we need a reference of the higher level tag <build>
1914       my ($IndexValue, $Build_ref) = $self->getIterationData("build");
1915
1916       for (my $i = 0; $i < $IndexValue; $i++)
1917       {
1918          my $Task_ref = getContent($Build_ref, $i);
1919
1920          # get the attributes of the <task> tag
1921          my $existingTaskDir = getAttribute($Task_ref, "dir");
1922          $PlatformContent = getAttribute($Task_ref, "platform");
1923
1924          # if it is not set in the data structure,
1925          # it has automatically the default value 'all'
1926          $PlatformContent = "all" if (!($PlatformContent));
1927
1928          if ($Dir eq $existingTaskDir)
1929          {
1930             # if a platform value 'all' exists, we remember it
1931             # and don't look further after other platforms
1932             if ($PlatformContent =~ /\ball\b/)
1933             {
1934                $allExists = 1;
1935
1936                @JobPlatforms = "all";
1937
1938                last;
1939             }
1940
1941             my @tempPlatforms = ();
1942
1943             push(@tempPlatforms, split(/\s+/, $PlatformContent));
1944
1945             foreach my $Platform (@tempPlatforms)
1946             {
1947                $tempJobPlatforms{$Platform} = "";
1948             }
1949          }
1950       }
1951
1952       # fill the unique sorted 'job platforms' in the array,
1953       # but only if the content "all" is not present in the platform content
1954       @JobPlatforms = sort keys %tempJobPlatforms if ($allExists == 0);
1955    }
1956
1957    print"JobPlatforms                  =  <@JobPlatforms>\n" if ($Debug);
1958
1959    return @JobPlatforms;
1960 }
1961
1962 ########################################################################################
1963 #                                 end of 'get' methods                                 #
1964 ########################################################################################
1965
1966 1 ;