WebSVN – DevTools – Diff – /core_devl/branches/gitBuilder/TOOLS/buildlib.pl

 use Getopt::Long;
 use File::Path;
 use XML::Writer;
 use ArrayHashUtils;
 use File::Find;
+use Storable qw(dclone);
-use Digest::SHA qw(sha1);
+#use Digest::SHA qw(sha1);
+use Digest::SHA::PurePerl qw(sha1);
 use IPC::Open3;
 our $BuildVersion           = "2.1.0";
 #.. Switchs
 our $BUILDINTERFACE         = "";               # BuildInterface()
 our $BUILDLOCAL             = "";               # BuildInterface()
 our $BUILDDIRTREE           = "";               # BuildDirTree()
 our @BUILD_BADNAME          = ();               # Unknown platforms
 our @GENERIC_TARGETS        = ();               # Generic targets - only one allowed
-our %BUILDERINFO            = ();               # Complete build info
 our $BUILDNAME              = "";               # BuildName()
 our $BUILDVERSION           = "";               # BuildName()
 our $BUILDNAME_PACKAGE;                         # Name
 our $BUILDNAME_VERSION;                         # Version
+#
 # Returns         : Nothing
+#
 sub Process_TargetAlias
+{
+    #
     #   Merge any delayed aliases with the complete set of alias
     #   Delayed alias are not used in expansions during the processing
     #   of platforms and targets, but can be used to pick up errors
+    #
+        }
         $BUILDALIAS{$key} = $value;
+    }
     ErrorDoExit();
+    #
+    #   Empty so that its not seen in Buildfile.
+    #
+    %BUILDALIAS_DELAY =();
     foreach my $alias ( keys %BUILDALIAS_TARGETS )
+    {
         Debug( "BuildTargetAlias($alias)" );
+        #
+{
+    #
     #   Clean up Aliases
+    #
 #DebugDumpData("BEFORE CleanUp_Aliases", \%BUILDALIAS);
     foreach my $alias ( keys %BUILDALIAS )
+    {
+        #
+        #   Build hash of bits to be added and bits to be removed
+        #   Remove all options - only need platforms
+        #
         my @aliasList = split(/ /, $BUILDALIAS{$alias});
         my @expanded =  ExpandPlatforms(@aliasList);
         my %add;
         my %remove;
+        #
         #   If there are NO additive expressions in the alias, then
         #   assume all the active targets
+        #
         unless (keys %add) {
-            foreach  ( @BUILD_ACTIVEPLATFORMS)
+            my %add = map { $_ => 1 } @BUILD_ACTIVEPLATFORMS;
-            {
-                 $add{$_} = 1;
-            }
+        }
         foreach ( keys %remove) {
             delete $add { $_};
+        }
+        #
+        #   Delete ALIAS if it has no expansion
+        #       May cause issues with the Platforms directive
+        #
+        if (keys %add) {
-        $BUILDALIAS{$alias} = join(' ',keys %add);
+            $BUILDALIAS{$alias} = join(' ',keys %add);
+        } else {
+            delete $BUILDALIAS{$alias};
+        }
+    }
 #DebugDumpData("AFTER CleanUp_Aliases", \%BUILDALIAS);
+}
+#-------------------------------------------------------------------------------
+# Function        : ProcessBuildExclude
+#
+# Description     : Process BuildExclude directive info
+#                   A list of targets to be excluded
+#                   INSTRUMENT is a key word
+#
+#
+# Inputs          : None
+#
+# Returns         : Modifies BUILDINFO
+#
+sub ProcessBuildExclude
+{
+    for my $word (@BUILDEXCLUDE)
+    {
+        Debug("ProcessBuildExclude: $word");
+        Error('BuildExclude: Unknown option: ' . $word) if ($word =~ m~^-~);
+        Error('BuildExclude: Invalid format: ' . $word) if ($word =~ m~^!~);
+        #
+        #   INSTRUMENT is a key word
+        #       Remove all instrumented builds
+        #
+        if ($word eq 'INSTRUMENT')
+        {
+            foreach my $platform ( keys %BUILDINFO )
+            {
+                if ( PlatformConfig::targetHasTag( $platform, 'INSTRUMENT') ) {
+                    $BUILDINFO{$platform}{NOT_AVAILABLE} = 2;
+                    Debug("ProcessBuildExclude. Remove $platform ");
+                }
+            }
+        }
+        elsif (exists $BUILDINFO{$word} )
+        {
+            $BUILDINFO{$word}{NOT_AVAILABLE} = 2;
+            Debug("ProcessBuildExclude. Remove $word ");
+        } else {
+            Warning('BuildExclude: Unknown target:' . $word )
+        }
+    }
+}
 #-------------------------------------------------------------------------------
 # Function        : BuildProduct
+#
 # Description     : Create a family of Platforms with a common product line
+    #
     #   Create a basic BUILDINFO entry
+    #
     $buildentry{FNAME} = $fname;
-    $buildentry{NOT_DEFAULT} = $notdefault;
+    $buildentry{NOT_DEFAULT} = $notdefault if $notdefault;
     $buildentry{PRODUCT} = $product;
     $buildentry{TARGET} = $target;
     $buildentry{BASE} = $target;
     foreach ( @$pArgs )
+    {
         Error("Invalid use of the platform alias $reserved","The $reserved alias cannot be used to define build platforms")
             if (uc($target) eq uc($reserved));
+    }
+    #
-    #   Allow per-platform processing to alter the basic information
-    #   Special processing may be perform to extend the information
-    #   Allows special processing to be enabled on a per-target basis
-    #
-    #   There are three forms of processing that have been allowed for:
+    #   Expand families of platforms into multiple platforms
-    #       1) None:        There is not platform specific extension
-    #       2) Basic:       The extension will add or extend build information
-    #       3) Advanced:    The extension will generate additional build information
-    #                       structures.
+    #       ie: DEVLINUX -> COBRA, VIPER, ....
-    #
-    #
-    #   Locate the optional PLATFORM configuration file
-    #   If it does exist then it can alter build-time information
+    #
-    if ( my $build_cfg = Require( "$::GBE_CONFIG/PLATFORM", "$target.cfg"  ) )
+    foreach my $name (@PlatformConfig::BuildFamilies)
+    {
-        Verbose ("Processing(new) Platform Configuration file: $build_cfg");
+        #
-        #   Create package name with an uppercase target
-        #   Target should be UC, but under windows its not detected
-        #   at this time
+        #   Is this target a buildFamily alias
-        #
-        my $package_name = uc($target) . '_Build';
+        #
-        #   Ensure that the CFG is correctly formed
-        #       Perhaps the package that it implements was misnamed
-        #
-        Error ("INTERNAL: $target.cfg does not satisfy API " )
-            unless ( $package_name->can('new_platform') || $package_name->can('add_platform') );
-        if ( $package_name->can('new_platform') )
+        if (uc($target) eq uc($name))
+        {
+            #
+            #   Get the list of targets that have been tagged with the family name
+            #   Must exist - else its an internal error
+            #
-            Verbose ("Processing(new) Platform Configuration: $package_name");
+            my @targets = PlatformConfig::getTargetsByTag($name);
+            Error ("Internal: No platforms are tagged as members of $name") unless @targets;
+            #   Instantiate all targets
+            #       Give them an ALIAS for the Family name
-            $package_name->new_platform( \%buildentry );
+            #       Register new enrty with the build system
-        }
+            #
+            foreach my $target ( @targets )
-        else
+            {
+                my $pInfo = dclone(\%buildentry);
+                $pInfo->{ALIAS} = $pInfo->{TARGET};
+                $pInfo->{TARGET} = $target;
+                AddBuildPlatformEntry( $pInfo );
-        {
+            }
-            Debug ("Processing(new) Platform Configuration: $package_name. 'new_platform' function not found");
+            #   Mark the original entry as a TEMPLATE so that it won't be added
+            $buildentry{TEMPLATE} = 1;
+            last;
+        }
+    }
+    #
-    #   Add the basic entry into the build system, unless its been
+    #   Add the basic entry into the build system, unless its been flagged as a TEMPLATE
-    #   flagged as a TEMPLATE
+    #
     AddBuildPlatformEntry (\%buildentry )
         unless ( $buildentry{TEMPLATE} );
+}
-END {
-    DebugDumpData("BUILDERINFO", \%BUILDERINFO);
-    }
 #-------------------------------------------------------------------------------
 # Function        : AddBuildPlatformEntry
+#
 # Description     : Internal routine to add a Build Entry into the build system
 #                   This function MAY be called from the build extensions
+{
     my ($pInfo) = @_;
     my $fname = $pInfo->{FNAME};
+    #
+    #   Ensure that it exsists and is numeric
+    #
+    $pInfo->{NOT_AVAILABLE} = 0;
+    #
     #   Locate the optional PLATFORM configuration file
     #   If it does exist then it can extend build-time information
+    #
     my $target = $pInfo->{TARGET};
     if (PlatformConfig::targetHasTag( $target, 'GENERIC_MACHTYPE' ) )
+    {
         $pInfo->{IS_GENERIC} = 1;
         $pInfo->{ALIAS} = 'GENERIC';
         $pInfo->{NOT_AVAILABLE} = 1 unless needToolset();
-        $All = 1;
+    }
+    #
     #   Ensure target is known to JATS
-    #   Remove unknown targets from the build. Create a list of unknown
+    #   Remove unknown targets from the build.
-    #   targets and report them later.
+    #   Create a list of unknown targets and report them later.
+    #
-    unless ( $pInfo->{NOT_AVAILABLE} || exists $BUILDINFO{$target} || $pInfo->{IS_GENERIC} || ($target =~ m~^GENERIC_~) )
+    unless ( $pInfo->{NOT_AVAILABLE} || exists $BUILDINFO{$target} || $pInfo->{IS_GENERIC}  )
+    {
         my $base_target = PlatformConfig::targetHasTag( $target, 'BASE_TARGET' ) || $target;
         unless ( Exists( "$::GBE_CONFIG/PLATFORM", $base_target  ) )
+        {
             UniquePush (\@BUILD_BADNAME, $target );
-            $pInfo->{NOT_AVAILABLE} = 1;
+            $pInfo->{NOT_AVAILABLE} = 3;
+            $pInfo->{BADNAME} = 1;
+        }
+    }
+    #
+    #   Mark as NOT_AVAILABLE platforms that are not available on this machine
+    #
     if ($buildAvailability)
+    {
-        $BUILDERINFO{$target}{$buildAvailability} = 1;
+         $pInfo->{MACHTYPE} = $buildAvailability;
          $pInfo->{NOT_AVAILABLE} = 1 unless ($buildAvailability eq $::GBE_MACHTYPE)
+    }
+    #
-    #   Mark as NOT_AVAILABLE platforms that are not available on this machine
+    #   Extend the build information
+    #
     unless ($pInfo->{NOT_AVAILABLE} )
+    {
-        $pInfo->{NOT_AVAILABLE} = 1
-            unless ($buildAvailability);
-    }
-    unless ($pInfo->{NOT_AVAILABLE} )
-    {
-        my $target_cfg = $pInfo->{TARGET_CFG} || $target;
-        if ( my $build_cfg = Require( "$::GBE_CONFIG/PLATFORM", "${target_cfg}.cfg"  ) )
+        if ( my $build_cfg = Require( "$::GBE_CONFIG/PLATFORM", "${target}.cfg"  ) )
+        {
             Verbose ("Processing(add) Platform Configuration file: $build_cfg");
-            my $package_name = "${target_cfg}_Build";
+            my $package_name = "${target}_Build";
             if ( $package_name->can('add_platform') )
+            {
                 Verbose ("Processing(add) Platform Configuration: $package_name");
                 $package_name->add_platform( $pInfo );
+    }
+    #
     #   Add platform (tag) to various lists
+    #
-    UniquePush( \@BUILDPLATFORMS, $platform );
+    UniquePush( \@BUILDPLATFORMS, $platform ) unless exists ($pInfo->{BADNAME});
     UniquePush( \@DEFBUILDPLATFORMS, $platform ) unless ( $pInfo->{NOT_DEFAULT} );
+    #
     #   Create a simple alias if requested
     #   Used if a platform creates multiple entires
         HashJoin( \%BUILDALIAS_DELAY, ' ', $_, $platform )
             foreach ( ArrayList($pInfo->{USERALIAS}) );
+    }
+    #
-    #   Create a HARDWARE type alias if requested
-    #   ie: SOLARIS_SPARC or SOLARIS_X86
-    #
-    if ( $pInfo->{HARDWARE} )
-    {
-        HashJoin( \%BUILDALIAS_DELAY, ' ',  $pInfo->{BASE} . '_' . $pInfo->{HARDWARE}, $platform );
-    }
-    #
     #   Create the 'parts' of the platform. This is a list of unique
     #   bits to search. It will consist of:
     #       [0]     - platform
     #       [1]     - product
     #       ...     - Uses bits ...
 #                           in this version.
 #                   Multiple BuildExclude directives are allowed
 #                   Order or location is not important
+#
 # Inputs          : Platforms names and options
-#                   Format:
-#                       --PLATFORM=xxxxx    (Marginal use)
-#                       --PRODUCT=yyyy      (Not very useful)
-#                       --TARGET=zzzz       (Default)
+#                       zzzz                Build Platform Name
-#                       zzzz                (Same as --TARGET=ZZZZ)
+#                       INSTRUMENT          (Keyword - no instrumented builds)
+#
+#
 # Returns         : Nothing
+#
 sub BuildExclude
     #   Simply save the arguments for later
     #   Allow multiple specs in the one definition
+    #
     foreach ( @arguments)
+    {
-        Error ("Invalid format: $_") if m/[,\s]/;
+        Error ("Invalid format: $_") if m/[\s]/;
         UniquePush (\@BUILDEXCLUDE, split(/\s*,\s*/,$_));
+    }
+}
 #-------------------------------------------------------------------------------
     Log( "DPKG_SBOX .. $::GBE_DPKG_SBOX" );
     Log( "Sandbox .... Development" );
     Log( "LocalFilter. $::GBE_DPKG_SBOX/buildfilter") if ( $::GBE_DPKG_SBOX && -f $::GBE_DPKG_SBOX . '/buildfilter' );
+    #
-    #   Generate a list of platforms that are completely unknown to JATS
-    #   May be the result of a user typo or a guess
-    #
-    if ( @BUILD_BADNAME )
-    {
-        Log( "Unknown Pl . " . PrintPlatforms(\@BUILD_BADNAME, $sep) );
-        Warning ("The following platform names are not known to JATS", "@BUILD_BADNAME");
-    }
-    #
-    #   Detect multiple GENERIC targets
-    #       Only one such target can be processed on any one machine
-    #
-    if ($#GENERIC_TARGETS > 0)
-    {
-        Error ("Multiple GENERIC targets detected", PrintPlatforms(\@GENERIC_TARGETS, $sep));
-    }
-    if ($#GENERIC_TARGETS >= 0 )
-    {
-        $All = 1;
-    }
-    #
     #   Generate a list of active platforms
     #   Ensure that there are some active platforms
+    #
+    ProcessBuildExclude();
     GeneratePlatformList();
     Log( "Platforms .. " . PrintPlatforms(\@BUILDPLATFORMS, $sep) );
+    #
     #   Detect a mix of Generic and non Generic targets
             Log( "Make for ... ". PrintPlatforms(\@MAKE_PLATFORMS, $sep));
+        }
+    }
+    #
+    #   NoBuilds do not generate warnings
+    #
+    return if $NoBuild;
+    #
+    #   Generate a list of platforms that are completely unknown to JATS
+    #   May be the result of a user typo or a guess
+    #
+    if ( @BUILD_BADNAME )
+    {
+        Log( "Unknown Pl . " . PrintPlatforms(\@BUILD_BADNAME, $sep) );
+        Error ("The following platform names are not known to JATS", "@BUILD_BADNAME");
+    }
+    #
+    #   Detect multiple GENERIC targets
+    #       Only one such target can be processed on any one machine
+    #
+    if ($#GENERIC_TARGETS > 0)
+    {
+        Error ("Multiple GENERIC targets detected", PrintPlatforms(\@GENERIC_TARGETS, $sep));
+    }
     return 1;
+}
 #-------------------------------------------------------------------------------
 # Function        : needToolset
     Debug( "Name:      $name" );
     Debug( "Version:   $version" );
     DataDirective("LinkPkgArchive");            # This directive allowed here
-#   if ( $IgnorePkgs )
+   if ( $IgnorePkgs )
-#   {
+   {
-#       Log( "LinkPkgArchive .. $name ($version) - Ignored" );
+       Log( "LinkPkgArchive .. $name ($version) - Ignored" );
-#       return;
+       return;
-#   }
+   }
+    #
     #   Ensure that we have do not have multiple definitions
+    #
     if ( PackageEntry::Exists( $name, $version ) )
+    {
+        #
         #   Generate package rules for each active platform
+        #
         IncludePkg ( $name, $pkg );
-        foreach my $platform ( @BUILD_ACTIVEPLATFORMS, '--' )
+        foreach my $platform ( @BUILD_ACTIVEPLATFORMS )
+        {
             LinkEntry( $platform, $pkg, $name, $version, 0, $local, $pkgSig );
+        }
+    }
+}
+    #
     #   Package not found
     #   This is an error, although it can be bypassed
+    #
-    Error ("Required package not found: '$name/$version'" ) unless ( $NoPackageError );
+    #Error ("Required package not found by signature: '$name/$version'" ) unless ( $NoPackageError );
+    #
-    Log( "WARNING .... Package not available: '$name/$version'" );
+    #Log( "WARNING .... Package not available: '$name/$version'" );
     return;
+}
 #-------------------------------------------------------------------------------
 # Function        : LinkEntry
+#
 # Description     : Scan a package an locate platform specific directories
 #                   Create data structures to capture the information
-#                   This function is used by LinkPkgArchive and LinkSandbox
+#                   This function is used by LinkPkgArchive
 #                   to perfom the bulk of package inclusion work.
+#
 # Inputs          : platform being processed
 #                   path to the package
 #                   name of the package
     Debug( "Name:      $name" );
     Debug( "Version:   $version" );
     DataDirective("BuildPkgArchive");           # This directive allowed here
-#   if ( $IgnorePkgs )
+   if ( $IgnorePkgs )
-#   {
+   {
-#       Log( "BuildPkgArchive . $name ($version) - Ignored" );
+       Log( "BuildPkgArchive . $name ($version) - Ignored" );
-#       return;
+       return;
-#   }
+   }
+    #
     #   Ensure that we have do not have multiple definitions
+    #
     if ( PackageEntry::Exists( $name, $version ) )
 # Inputs          : GBE_BUILDFILTER from the environment
+#
 # Returns         : An array of platforms to include in the build
 #                   Maintains @BUILD_ACTIVEPLATFORMS  - the last calculated result
 #                   Ensures that @DEFBUILDPLATFORMS is a subset of @BUILD_ACTIVEPLATFORMS
+#                   Rebuilds BUILDPLATFORMS to ensure that excluded platforms are not present
+#
 sub GeneratePlatformList
+{
+    #
     #   Return the cached result for speed
     unless ( @BUILD_ACTIVEPLATFORMS )
+    {
         my ($platform_filter);
         my %result;
         my %part_to_platform;
+        my @New_BUILDPLATFORMS = ();
+        #
         #   Create a data structure to assist in the production of the platform list
         #   The structure will be a hash of hashes of arrays
+        #
         for my $platform (keys (%::BUILDINFO))
+        {
             my $pParts = $::BUILDINFO{$platform};
+            #
+            #   Include into New_BUILDPLATFORMS
+            #
+            if ($pParts->{NOT_AVAILABLE} <= 1) {
+                push @New_BUILDPLATFORMS, $platform;
+            }
+            #
             #   Skip platforms that are known to be unavailable on this build
             #   machine. Self configure
+            #
             next if ( $pParts->{NOT_AVAILABLE} );
+        {
             %result = %{$part_to_platform{'PLATFORM'}}
                 if exists $part_to_platform{'PLATFORM'} ;
+        }
+        #
+        # Add GENERIC platforms to the platform filter, if available
+        #
+        if (exists $part_to_platform{'PLATFORM'})
+        {
+            foreach my $platform( 'GENERIC', 'GENERIC_' . uc($::GBE_MACHTYPE) )
+            {
+                $result{$platform} = 1 if (exists $part_to_platform{'PLATFORM'}{$platform})
+            }
+        }
 #DebugDumpData( "PartToPlatform", \%part_to_platform );
+#DebugDumpData("Result", \%result);
+        #
         #   Process each element in the user filter list
         #   Expand platforms into known aliases
+        #
                 print "GBE_BUILDFILTER filter term not understood: $word\n";
+            }
+        }
+        #
-        #   Process BuildExclude
-        #   A list of targets to be excluded
-        #       INSTRUMENT is a key word
-        #
-        for my $word (@BUILDEXCLUDE)
-        {
-            my $platform;
-            Error('BuildExclude: Unknown option: ' . $word) if ($word =~ m~^-~);
-            Error('BuildExclude: Invalid format: ' . $word) if ($word =~ m~^!~);
-            #
-            #   INSTRUMENT is a key word
-            #       Remove all instrumented builds
-            #
-            if ($word eq 'INSTRUMENT')
-            {
-                for ( keys %result) {
-                    if ( PlatformConfig::targetHasTag( $_, 'INSTRUMENT') ) {
-                        delete $result{$_} ;
-                    }
-                }
-            }
-            else
-            {
-                #
-                #   Remove items from the result
-                #
-                my $table = "PLATFORM";
-                my $plist = $part_to_platform{$table}{$word};
-                if ($plist) {
-                    for ( @{$plist}) {
-                        delete $result{$_};
-                    }
-                }
-                else  {
-                    Warning('BuildExclude: Unknown target:' . $word )
-                        unless exists $::BUILDINFO{$word};
-                }
-            }
-        }
-        #
         #   Return an array of platforms to process
+        #
         @BUILD_ACTIVEPLATFORMS = sort keys %result;
+        #
+        {
             push @NEW_DEFBUILDPLATFORMS, $_
                 if ( exists $result{$_} );
+        }
         @DEFBUILDPLATFORMS = @NEW_DEFBUILDPLATFORMS;
+        #
+        #   Update BUILDPLATFORMS
+        #
+        @BUILDPLATFORMS = @New_BUILDPLATFORMS;
+    }
     Debug("GeneratePlatformList: Result:@BUILD_ACTIVEPLATFORMS");
     return @BUILD_ACTIVEPLATFORMS;
+}
 #-------------------------------------------------------------------------------
 # Function        : PrintPlatforms
+#
 # Description     : Petty print the specified platform list, breaking line
-#                   on either a primary key change or length width >78.
+#                   on either a primary key change or length width >100.
+#
+# Inputs          : $list           - Reference to an array
+#                   $nl             - New line stuff.
+#                                     Use to prefix new lines
+#
-# Returns         : Formated string
+# Returns         : Formatted string
+#
 # Example Output :
+#
 #           DDU_LMOS_WIN32 DDU_LMOS_linux_armv4 DDU_LMOS_linux_i386
 #           IDFC_LMOS_WIN32 IDFC_LMOS_linux_armv4 IDFC_LMOS_linux_i386
 #           LMOS_linux_i386
 #..
 sub PrintPlatforms
+{
     my ($platforms, $nl) = @_;
-    my ($string) = "";                          # result
+    my ($string) = "";
+    my $maxLen = 100 - length($nl);
     if ( @$platforms )
+    {
-        my ($key_run) = 0;
+        my $line = "";
-        my ($pkey);                             # previous key
-        #   Perform a simple formatting and determine if there is key
-        #   change greater then 1 or whether the total length exceeds 78.
-        #
+        my $pel = "";
-        #   If the line exceeds 78, the printer shall then reformat
-        #   breaking based on line length and possiblity keys.
-        #
+        my $first = 1;
-        $pkey = "";
+        my $prefix = '';
-        for my $k (sort @$platforms)
+        foreach my $k ( sort @$platforms)
         {
-            my ($d);                            # delimitor
+            my $k2 = substr($k, 0 , 2);
-            if (($d = index( $k, '_' )) != index( $pkey, '_' ) ||
-                    substr( $k, 0, $d ) ne substr( $pkey, 0, $d )) {
+            if (( $k2 ne $pel  || (length($line) + length ($k) > $maxLen) ) && (!$first)) {
-                $key_run = 1
+                $string .= $line;
-                    if ($key_run <= 1);         # change, reset run if <= 1
-            } else {
+                $line = $nl;
-                $key_run++;                     # same primary key
+                $prefix = '';
             }
-            $string .= " " if ($pkey);
+            $line .= $prefix . $k;
+            $pel = $k2;
-            $string .= $k;
+            $first = 0;
-            $pkey = $k;
+            $prefix = ' ';
+        }
-        #   Reprint if required.
-        #
-        if (length($nl)+length($string) > 78)
-        {
-            my ($llen);                         # line length
-            $llen = length($nl);
-            $pkey = "";
-            $string = "";
+        $string .= $line;
-            for my $k (sort @$platforms)
-            {
-                my ($klen, $d);                 # key length, delimitor
-                $klen = length($k);
-                if ($pkey ne "")
-                {
-                    if ($llen + $klen > 78 ||
-                        ($key_run > 1 && (
-                            ($d = index( $k, '_' )) != index( $pkey, '_' ) ||
-                            substr( $k, 0, $d ) ne substr( $pkey, 0, $d ) )) )
-                    {                           # line >70 or key change
-                        $string .= $nl;
-                        $llen = length($nl);
-                    }
-                    else
-                    {
-                        $string .= " ";
-                        $llen++;
-                    }
-                }
-                $string .= $k;
-                $pkey = $k;
-                $llen += $klen;
-            }
-        }
+    }
     return $string;
+}
 #-------------------------------------------------------------------------------
 # Function        : PrintList
+#
 # Returns         : string
+#
 sub PrintList
+{
-    my ($list, $nl) = @_;
+    my ($platforms, $nl) = @_;
-    my ($string) = '';                          # result
+    my ($string) = "";
-    my $sep;
+    my $maxLen = 100 - length($nl);
-    if ( @$list )
+    if ( @$platforms )
+    {
-        my ($llen) = length($nl);
+        my $line = "";
-        for my $k (@$list)
+        my $first = 1;
-        {
-            my $klen = length($k);
+        my $prefix = '';
-            if ($llen + $klen > 78 )
+        foreach my $k ( sort @$platforms)
-            {
+        {
-                $string .= $nl;
-                $llen = length($nl);
+            if ((length($line) + length ($k) > $maxLen) && (!$first)) {
-            }
-            else
-            {
-                if ( $sep )
-                {
-                    $string .= $sep;
+                $string .= $line;
-                    $llen++;
+                $line = $nl;
-                }
-                else
+                $prefix = '';
-                {
+            }
-                    $sep = ' ';
+            $line .= $prefix . $k;
-                }
-            }
-            $string .= $k;
+            $first = 0;
-            $llen += $klen;
+            $prefix = ' ';
+        }
+        $string .= $line;
+    }
     return $string;
+}
 #-------------------------------------------------------------------------------
+#
 sub StartBuildPhase
+{
     my ($last) = @_;
+    #
     #   Ensure directive is allowed
     #       $BUILDPHASE >  1     - No more directives allowed
     #       $BUILDPHASE == 1     - Allowed directive
+    #
+    #
     #   Calculate defined aliases
     #       Limit the Aliases to active platforms
     #       ie: NATIVE INSTRUMENT PKG_WIN PKG_RPM PKG_DEB SK
+    #
+    my %activePlatformMap;
+#    foreach my $item (@BUILD_ACTIVEPLATFORMS) {
+    foreach my $item ( keys %BUILDINFO) {
+           my $pInfo = $BUILDINFO{$item};
+           next if $pInfo->{NOT_AVAILABLE} > 1;
+           push @{$activePlatformMap{$pInfo->{TARGET}}}, $item;
+    }
     foreach my $alias ( @PlatformConfig::BuildAliases )
+    {
         if (exists $BUILDALIAS{$alias})
+        {
             # Will occur if GBE_ABT has been set, for backward compatibility
             Warning("User has manually specified a $alias alias",'Default alias will not be set.');
+            #DebugDumpData("BUILDALIAS", \%BUILDALIAS);
+        }
         else
+        {
-            my %activePlatformMap;
-            foreach my $item (@BUILD_ACTIVEPLATFORMS) {
-                    $activePlatformMap{$item} = $item;
-            }
             my @activeAliases;
             foreach my $item (PlatformConfig::getTargetsByTag($alias)) {
+                if (exists($activePlatformMap{$item})) {
-                push (@activeAliases, $activePlatformMap{$item}) if exists($activePlatformMap{$item});
+                    push (@activeAliases, @{$activePlatformMap{$item}});
+                }
+            }
             $BUILDALIAS{$alias} = join(' ', @activeAliases) if (@activeAliases);
+            #
             #   Add to the build entry too
+            #
-            foreach my $aliasTarget (@activeAliases)
+            foreach my $aliasTarget (@activeAliases) {
-            {
                 push @{$BUILDINFO{$aliasTarget}{USERALIAS}}, $alias;
+            }
+        }
+    }
     CleanUp_Aliases();
+        }
+        #
         #   See if the dependencies have changed
+        #
-        my $BuildpkgSig = Digest::SHA->new;
+        my $BuildpkgSig = Digest::SHA::PurePerl->new;
         $BuildpkgSig->add("PKGNAME: $BUILDNAME_PACKAGE $BUILDNAME_VERSION $BUILDNAME_SUFFIX");
+        #
         #   Include the signature of ALL dependent packages
         #   Ie: The build fingerprint is a function of the source and its dependents
+    #
     #   Start generating the signature
     #       Include the package Name,Version and Project
+    #
-    $BuildSignatureSha1 = Digest::SHA->new;
+    $BuildSignatureSha1 = Digest::SHA::PurePerl->new;
     $BuildSignatureSha1->add("PKGNAME: $BUILDNAME_PACKAGE $BUILDNAME_VERSION $BUILDNAME_SUFFIX");
     push @sigList, "PKGNAME: $BUILDNAME_PACKAGE $BUILDNAME_VERSION $BUILDNAME_SUFFIX: " . $BuildSignatureSha1->clone->hexdigest;
+    #
     #   Include the signature of ALL dependent packages
 #   Contains per platform options extracted from alias and platform args
+#
     my %ScmBuildPlatforms;
     foreach my $key ( @platforms_merged ) {
+        my $pInfo = $BUILDINFO{$key};
+        next if ($pInfo->{NOT_AVAILABLE});
         my( @arguments ) = ();
         UniquePush( \@arguments, split( /$;/, $BUILDPLATFORMARGS{ $key } ))
             if ( exists $BUILDPLATFORMARGS{ $key } );
         UniquePush( \@arguments, split( /$;/, $platform_args{ $key } ))
     $fh->DumpData(
         "# Platform and global argument list.\n#\n",
         "ScmBuildPlatforms", \%ScmBuildPlatforms );
+#.. Create ScmBuildMatrix
+#   Contains information on all the platforms that the package builds for and target machines
+#
+    my %ScmBuildMatrix;
+    foreach my $key ( keys %BUILDINFO ) {
+        my $pInfo = $BUILDINFO{$key};
+        next if exists ($pInfo->{BADNAME});
+        next if ($pInfo->{NOT_AVAILABLE} > 1);
+        Error ("Internal: No MACHTYPE provided for $key") unless exists $pInfo->{MACHTYPE};
+        $ScmBuildMatrix{$key} = $pInfo->{MACHTYPE};
+    }
+    $fh->DumpData(
+        "# Build Matrix.\n#\n",
+        "ScmBuildMatrix", \%ScmBuildMatrix );
 # .. Create BuildPkgRules
+#
 #    This is most of the information contained within %PKGRULES, which
 #    requires additional processing within makelib.

Subversion Repositories DevTools

(root)/core_devl/branches/gitBuilder/TOOLS/buildlib.pl – Rev 7309 → 7310