WebSVN – DevTools – Diff – /core_devl/trunk/TOOLS/buildlib.pl

 use Pod::Usage;
 use Getopt::Long;
 use File::Path;
 use XML::Writer;
 use ArrayHashUtils;
+use Storable qw(dclone);
 our $BuildVersion           = "2.1.0";
 #.. Switchs
+#
 our @BUILDSETENV            = ();               # BuildSetenv()
 our $BUILDINTERFACE         = "";               # BuildInterface()
 our $BUILDLOCAL             = "";               # BuildInterface()
 our $BUILDDIRTREE           = "";               # BuildDirTree()
 our @BUILD_BADNAME          = ();               # Unknown platforms
 our @GENERIC_TARGETS        = ();               # Generic targets - only one allowed
 our $BUILDNAME              = "";               # BuildName()
 our $BUILDVERSION           = "";               # BuildName()
 our $BUILDNAME_PACKAGE;                         # Name
 our $BUILDNAME_VERSION;                         # Version
 our $BUILDPHASE             = 0;                # In Build Phase
 our @CLOBBERDIRS            = ();               # Directories to clobber
 our @REMOVEDIRS             = ();               # Directories to remove - if empty
 our %BUILD_KNOWNFILES       = ();               # Files that will be known
 our @BUILDEXCLUDE           = ();               # Platforms to be excluded
+our @BUILDARGUMENTS         = ();               # Build Atguments
 our $Makelib                = "";
 our $GBE_CORE;                                  # Root of JATS
 our $InterfaceVersion;                          # Interface directory format version
 our $ScmRoot;                                   # Package Root
 my  $genToolsetPlatform     = 0;                # BuildToolset directive has been seen
 my  $genToolsetActive       = 0;                # TOOLSET platform required:1, Error:2
 my  $toolsetPlatform        = 'NONE';           # TOOLSET Display Value
 my  @genToolsetArgs;                            # Args for a generated TOOLSET
+my  $descpkgPath;                               # Path to the dscpkg file
 BuildLibInit();
 sub BuildLibInit
+{
     EnvImport( 'USER' );
     EnvImport( 'GBE_HOSTNAME');
     EnvImport( 'GBE_DRV' )
         if ( $ScmHost ne 'Unix' );            # DOS or WIN special
+    EnvImportOptional ( 'GBE_DPKG_ESCROW','' );
     EnvImportOptional ( 'GBE_DPKG_REPLICA','' );
     EnvImportOptional ( 'GBE_DPKG_STORE','' );
     EnvImportOptional ( 'GBE_DPKG_CACHE','' );
     EnvImportOptional ( 'GBE_DPKG_LOCAL','' );
     EnvImportOptional ( 'GBE_DPKG_SBOX' ,'' );
     Require( "$::GBE_CONFIG/PLATFORM", "PLATFORM_CFG.PM"  );
 #.. Parse command line
+#
     $ScmBuildSrc = $0;                          # Name of the build file
-    $Cwd = shift @ARGV;
-    $Cwd =~ tr~\\/~/~s;;                        # Need / in path, Remove doubles
+    shift @ARGV;                                # No longer used
-    $::ScmRoot = StripDrive($Cwd);
+    $::ScmRoot = $CwdFull;                      # $CwdFull does not have a driver letter. $CwdFull does
     $Makelib = shift @ARGV;                     # Only for legacy build.pl files
     Verbose ("Command Line: @ARGV");
     my $result = GetOptions( "help|h:+"      => \$opt_help,
                              "man:3"         => \$opt_help,
                              "generic!"      => \$GenericBuild,
                              );
     Usage() if ( $opt_help || !$result );
     Debug( "Host:          ", $ScmHost );
-    Debug( "Cwd:           ", $Cwd );
+    Debug( "Cwd:           ", $CwdFull );
+    Debug( "ScmRoot:       ", $::ScmRoot );
     Debug( "Makelib:       ", $Makelib );
     Debug( "BuildFile:     ", $ScmBuildSrc );
     Debug( "Debug:         ", $::ScmDebug );
     Debug( "Verbose:       ", $::ScmVerbose );
     Debug( "Expert:        ", $Expert );
+                    {
                         push @pargs, '--NotDefault' if ( $notdefault );
                         push @pargs, '--FunctionName=BuildAlias';
                         BuildPlatforms( $platform, @pargs );
+                    }
+                    else
+                    {
+                        my @badArgs = grep (/^--/, @pargs) ;
+                        if (@badArgs) {
+                            Warning("Platform arguments in define mode are ignored:($platform)", @badArgs);
+                        }
+                    }
+                }
+                #
                 #   Start collecting args for the next platform
+                #
+#
 # 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)
+            %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 {
+            abtWarning(0,'BuildExclude: Unknown target:' . $word )
+        }
+    }
+    ErrorDoExit();
+}
 #-------------------------------------------------------------------------------
 # 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
+    foreach my $name (@PlatformConfig::BuildFamilies)
-    #   If it does exist then it can alter build-time information
-    #
-    if ( my $build_cfg = Require( "$::GBE_CONFIG/PLATFORM", "$target.cfg"  ) )
+    {
-        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} );
+}
 #-------------------------------------------------------------------------------
 # 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};
+    #
-    #   Locate the optional PLATFORM configuration file
-    #   If it does exist then it can extend build-time information
+    #   Ensure that it exsists and is numeric
+    #
-    my $target = $pInfo->{TARGET};
+    $pInfo->{NOT_AVAILABLE} = 0;
+    #
-    #   Yukky Kludge
-    #   JATS has a mechanism whereby packages can create new platforms
-    #   Luckily this has only been done for LMOS - don't every do it again
+    #   Locate the optional PLATFORM configuration file
-    #   One problem is that we can't validate the target name at this point
-    #   in time: as the packages are loaded much later.
+    #   If it does exist then it can extend build-time information
-    #
-    #   Kludge. Assume that a leading LMOS_ can be removed when determing
-    #           validity of the target platform.
+    #
-    my $base_target = $target;
+    my $target = $pInfo->{TARGET};
-    $base_target =~ s~^LMOS_~~;
+    #
     #   Detect GENERIC targets
     #       The Build file is only allowed to have one that can be built on any one machine
+    #
-    my $buildAvailability = PlatformConfig::targetHasTag( $base_target, 'KNOWN' );
+    my $buildAvailability = PlatformConfig::targetHasTag( $target, 'MACHTYPE' );
-    if (PlatformConfig::targetHasTag( $base_target, 'GENERIC' ) )
+    if (PlatformConfig::targetHasTag( $target, 'GENERIC' ) )
+    {
         UniquePush (\@GENERIC_TARGETS, $target );
+    }
+    #
     #   Detect GENERIC_<machType> targets
+    #
-    if (PlatformConfig::targetHasTag( $base_target, 'GENERIC_MACHTYPE' ) )
+    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.
-    #
-    #   If there are signs that the target has been processed, then it may be
-    #   an alias that has not been expanded.
+    #
-    #   One result will be that alias platforms, such as DEVLINUX, that don't
-    #   expand on WIN32 will be shown as DEVLINUX and not its components.
-    #
-    unless ( $pInfo->{NOT_AVAILABLE} || exists $BUILDINFO{$target} || $pInfo->{IS_GENERIC} || ($base_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
+    #
-    unless ($pInfo->{NOT_AVAILABLE} )
+    if ($buildAvailability)
+    {
-        $pInfo->{NOT_AVAILABLE} = 1
+         $pInfo->{MACHTYPE} = $buildAvailability;
-            if ($buildAvailability == 0 )
+         $pInfo->{NOT_AVAILABLE} = 1 unless ($buildAvailability eq $::GBE_MACHTYPE)
+    }
+    #
+    #   Extend the build information
+    #
     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 ...
 sub BuildArgument
+{
     my( $platform, @arguments ) = @_;
-    my( @platforms );
     Debug( "BuildArgument($platform, @arguments)" );
-    Error( "BuildArgument must appear before BuildName()..." )
+    Error( "BuildArgument must appear before BuildName()..." ) if ( $BUILDNAME ne "" );
-        if ( $BUILDNAME ne "" );
+    #
-    #   Allow a wildcard to apply a single argument to all platforms
+    #   Just save the arguments for later processing
-    #   Should only be used AFTER all the platforms have been specified
+    #
-    if ( $platform eq '*' )
+    push @BUILDARGUMENTS, \@_;
-    {
-        @platforms = @BUILDPLATFORMS;          # Simple Wildcard
-    }
-    else
-    {
-        @platforms = ExpandPlatforms( $platform );  # aliasing
-    }
+}
+#-------------------------------------------------------------------------------
+# Function        : ProcessBuildArgument
+#
+# Description     : Process BuildArgument operations
+#                   This needs to be done AFTER aliases have been created (cleaned up )
+#
+# Inputs          : Global data: @BUILDARGUMENTS
+#
+# Returns         :
+#
+sub ProcessBuildArgument
+{
-    foreach my $platform ( @platforms )
+    foreach my $set ( @BUILDARGUMENTS )
+    {
+        my ($platform, @arguments ) = @{$set};
+        my @platforms;
+        #
+        #   Allow a wildcard to apply a single argument to all platforms
+        #   Should only be used AFTER all the platforms have been specified
+        #
+        if ( $platform eq '*' )
+        {
-        next if ( $platform =~ /^--/ );         # argument, ignore
+            @platforms = @BUILDPLATFORMS;          # Simple Wildcard
+        }
+        else
+        {
+            @platforms = ExpandPlatforms( $platform );  # aliasing
+        }
+        foreach my $platform ( @platforms )
+        {
+            next if ( $platform =~ /^--/ );         # argument, ignore
-        PlatformArgument( $platform, @arguments );
+            PlatformArgument( $platform, @arguments );
+        }
+    }
+}
 sub BuildPlatforms
+    #
     #   Expand the user specified platforms to allow the use of BuildAlias
     #   The (bad) side effect of this is that platform options get reorganised
     #       PLATFORM,--Uses=ANOTHER  ==> PLATFORM --Uses=ANOTHER
+    #
-    #   Insert markers(++) into @aruments to mark when to process collected data
+    #   Insert markers(++) into @arguments to mark when to process collected data
     #   Insert before each PLATFORM and at the end of the list
     #   platform specifier or the end of the list. Scan the arguments
+    #
     @arguments = ExpandPlatforms( @arguments );
     my @new_args;
 #                           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( "DeployPatch. $DEPLOY_PATCH" ) if ($DEPLOY_PATCH);
     Log( "Project .... $BUILDNAME_PROJECT" )if ($BUILDNAME_PROJECT);
     Log( "Project .... ****** Specifically supressed ******" )unless ($BUILDNAME_PROJECT);
     Log( "DateTime ... $::CurrentTime" );
     Log( "AutoBuild... Enabled:$::GBE_ABT" ) if defined($::GBE_ABT) ;
-    Log( "Build dir... $Cwd" ) if defined($::GBE_ABT) || $::GBE_DPKG_SBOX;
+    Log( "Build dir... $CwdFull" ) if defined($::GBE_ABT) || $::GBE_DPKG_SBOX;
     Log( "Build Mach.. $::GBE_HOSTNAME" ) if defined($::GBE_ABT);
+    Log( "Build Cmd .. $CmdSwitch") if $CmdSwitch;
     Log( "PERL ....... $::GBE_PERL" );
     Log( "BIN  ....... $::GBE_BIN" );
     Log( "TOOLS ...... $::GBE_TOOLS" );
     Log( "CONFIG ..... $::GBE_CONFIG" );
     Log( "BUILDFILTER. " . PrintList([split(' ', $::GBE_BUILDFILTER)], $sep) ) if defined ($::GBE_BUILDFILTER);
     Log( "DPKG_STORE.. $::GBE_DPKG_STORE" );
     Log( "DPKG ....... $::GBE_DPKG" );
     Log( "DPKG_REPLI . $::GBE_DPKG_REPLICA" );
+    Log( "DPKG_ESCROW. $::GBE_DPKG_ESCROW" ) if $::GBE_DPKG_ESCROW;
     Log( "DPKG_CACHE . $::GBE_DPKG_CACHE" );
     Log( "DPKG_LOCAL . $::GBE_DPKG_LOCAL" );
     Log( "DPKG_SBOX .. $::GBE_DPKG_SBOX" );
     Log( "Sandbox .... " . ($sandbox_exact ? "Exact" : "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
             #   Flag for jmake to do very little
+            #
             CreateBuildPlatformEntry('Internal', 0, undef, 'NOBUILD');
             $IgnorePkgs = 1;
             $NoBuild = 1;
+            $genToolsetActive = 0;
             Log( "Build for .. ". PrintPlatforms(['NOBUILD - ' . $msg], $sep));
         } else {
             Error( $msg );
+        }
             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
+    #
     #   Locate the package ONCE
+    #
     Log( "LinkPkgArchive .. $name ($version)" );
-    my ($pkg, $local ) = PackageLocate( $name, $version );
+    my ($pkg, $local, $pkgSig ) = PackageLocate( $name, $version );
     if ( $pkg )
+    {
+        #
+        #   Create a Package Entry
+        #
+        my $entry = PackageEntry::New( $pkg, $name, $version, 'link', $local, $pkgSig );
+        #
         #   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 );
+            LinkEntry( $platform, $entry );
+        }
+    }
+}
 #-------------------------------------------------------------------------------
 # Inputs          : package name
 #                   package version
+#
 # Returns         : path to the package
 #                   local       1 - From local package repository
+#                   Package Signature
+#
 sub PackageLocate
+{
     my ($name, $uversion ) = @_;
     my $pkg;
                        '--NotSandbox',
                        split( $::ScmPathSep, $::GBE_DPKG_LOCAL),
                        '--NotLocal',
                        split( $::ScmPathSep, $::GBE_DPKG_CACHE),
                        '--NotCache',
+                       split( $::ScmPathSep, $::GBE_DPKG_ESCROW),
+                       '--NotEscrow',
                        split( $::ScmPathSep, $::GBE_DPKG_REPLICA),
                        split( $::ScmPathSep, $::GBE_DPKG),
                        split( $::ScmPathSep, $::GBE_DPLY),
                        split( $::ScmPathSep, $::GBE_DPKG_STORE) )
+    {
         if ( $dpkg eq '--NotCache' )
+        {
             $isa_cache = 0;
             next;
+        }
+        if ( $dpkg eq '--NotEscrow' )
+        {
+            last if ($::GBE_DPKG_ESCROW);
+            next;
+        }
+        #
         #   If we are playing in a sandbox, then the version number is
         #   not used. The Package suffix is still used so that we can
         #   differentiate sysbasetypes.xxxxx.mas and sysbasetypes.xxxxx.syd
 #-------------------------------------------------------------------------------
 # 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
+# Inputs          : $platform   - Platform being processed
-#                   path to the package
-#                   name of the package
-#                   version of the package
+#                   $entry      - Reference to a PackageEntry
-#                   sandbox support (non-zero)
-#                   local package
+#
 sub LinkEntry
+{
-    my( $platform, $pkg, $name, $version, $sandbox, $local ) = @_;
+    my( $platform, $base_entry ) = @_;
-    my( $entry );
-    #   Create entry record
+    #
+    #   Clone the entry - we will add platform specific data into it
-    #..
+    #
-    $entry = PackageEntry::New( $pkg, $name, $version, $sandbox, 'link', $local );
+    my $entry = dclone($base_entry);
     #   Populate includes:
+    #
     #   - include/$platform                 (eg include/solaris)
     #   - inc/$platform                     (eg inc/solaris)
     #..
     my $parts = $BUILDINFO{$platform}{PARTS};
     foreach my $part ( @$parts )
+    {
-        $entry->RuleInc( "/include." . $part ) if ( !$sandbox );
+        $entry->RuleInc( "/include." . $part );
-        $entry->RuleInc( "/inc." . $part )     if ( !$sandbox );
+        $entry->RuleInc( "/inc." . $part );
-        $entry->RuleInc( "/include/" . $part ) if ( !$sandbox );
+        $entry->RuleInc( "/include/" . $part );
         $entry->RuleInc( "/inc/" . $part );
+    }
+    #
     #   Also search the root include directory - last
+    #
-    $entry->RuleInc( "/include" )               if ( !$sandbox );
+    $entry->RuleInc( "/include" );
     $entry->RuleInc( "/inc" );
     #   Populate libraries:
+    #
     #   - lib/lib.$platform[D|P]            (eg lib/lib.sparcD)
     #..
     $parts = $BUILDINFO{$platform}{PARTS};
     foreach my $part ( @$parts )
+    {
-        $entry->RuleLib("/lib" . ".$part" )     if ( !$sandbox );
+        $entry->RuleLib("/lib" . ".$part" );
-        $entry->RuleLib("/lib" . "/lib.$part" ) if ( !$sandbox );
+        $entry->RuleLib("/lib" . "/lib.$part" );
         $entry->RuleLib("/lib" . "/$part" );
+    }
+    #
     #   Some extra places to search
+    #
     #   Locate the package
     #   Use the first instance of the package that is found
+    #
     Log( "BuildPkgArchive . $name ($version)" );
-    my ( $pkg, $local ) = PackageLocate( $name, $version );
+    my ( $pkg, $local, $pkgSig ) = PackageLocate( $name, $version );
     if ( $pkg )
+    {
+        #
         #   Create a Package Entry
+        #
-        my $entry = PackageEntry::New( $pkg, $name, $version, 0, 'build', $local );
+        my $entry = PackageEntry::New( $pkg, $name, $version, 'build', $local, $pkgSig );
+        #
         #   Determine if the package needs to be installed:
         #       If the package is a 'local' package then force transfer
         #       If the user has specified --cache then force transfer
         #       If package is newer that copy, then force transfer
         #       If copy does not exist, then force a transfer
+        #
-        my $tag_dir = "$Cwd/$BUILDINTERFACE/BuildTags";
+        my $tag_dir = "$CwdFull/$BUILDINTERFACE/BuildTags";
         my $tag_file = "$tag_dir/${name}_${version}.tag";
         my $arglist = GenerateInstallArgumentList();
         my $package_installed;
         $package_installed = 1
+                #
                 #   Determine all the Platforms, Products and Targets
                 #   that need to be installed
+                #
-                System( "cd $pkg; $::GBE_PERL $::GBE_TOOLS/installpkg.pl $Cwd/$BUILDINTERFACE $Cwd @opts $arglist");
+                System( "cd $pkg; $::GBE_PERL $::GBE_TOOLS/installpkg.pl $CwdFull/$BUILDINTERFACE $CwdFull @opts $arglist");
                 Error( "Package installation error" ) if ( $? != 0 );
+            }
             else
+            {
                 Error ("Unknown package format for package $name/$version found in $pkg");
+#
 sub CreateInterfacePackage
+{
     foreach my $platform ( @BUILD_ACTIVEPLATFORMS )
+    {
-        my $entry = PackageEntry::Interface( "$::Cwd/$BUILDINTERFACE" );
+        my $entry = PackageEntry::Interface( "$CwdFull/$BUILDINTERFACE" );
+        #
         #   Locate include and lib bits within the interface
         #   This is much simpler than for a LinkPkgArchive as the form
         #   has been sanitized
 # 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} );
             $platform_filter = "";
+        }
         else
+        {
             $platform_filter = "";
-            $platform_filter = $::GBE_BUILDFILTER
+            $platform_filter = uc $::GBE_BUILDFILTER
                 if ( defined($::GBE_BUILDFILTER) );
+        }
         Debug( "GeneratePlatformList: Filter:$platform_filter" );
+        #
+        {
             %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;
+}
 #-------------------------------------------------------------------------------
     Process_TargetAlias();
+    #
     #   Calculate defined aliases
     #       Limit the Aliases to active platforms
-    #       Another LMOS kudge. LMOS targets pick up alias from their base target
     #       ie: NATIVE INSTRUMENT PKG_WIN PKG_RPM PKG_DEB SK
+    #
+    my %activePlatformMap;
+    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) {
-                if ($item =~ m~^LMOS_(.*)~) {
-                    $activePlatformMap{$1} = $item;
-                } else {
-                    $activePlatformMap{$item} = $item;
-                }
-            }
             my @activeAliases;
-            foreach my $item (PlatformConfig::getTargetsByTag($alias))
+            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();
+    ProcessBuildArgument();
+    #
     #   Create dummy package to describe the Interface directory
+    #
     CreateInterfacePackage();
     return if ( $Clobber );
     if ( ! $ForceBuild  )
+    {
         my @build_warn;
-        my $bstamp = -M "$Cwd/$ScmBuildSrc";
+        my $bstamp = -M "$CwdFull/$ScmBuildSrc";
-        my $tstamp = -M "$Cwd/Makefile.gbe";
+        my $tstamp = -M "$CwdFull/Makefile.gbe";
         push @build_warn, "Missing: Makefile.gbe" unless ( defined $tstamp );
         push @build_warn, "Modified build file ($ScmBuildSrc)" if ( $tstamp && $bstamp < $tstamp );
+        #
     my $link_file;
     my $tag;
     my $root_path;
+    #
+    #   In the build system we do NOT want to consume packages from within the sandbox
+    #   because they may be partially formed. They need to be consumed from a published
+    #   archive.
+    #
+    #   If we are in an ABT sandbox, then don't create a link file
+    #
+    return if (defined($::GBE_ABT));
+    #
     #   Determine the path (and name) of the target archive
     #   Use sandbox_dpkg_archive if it exists
     #   Use local_dpkg_acrhive for backward compatability (should be removed after JATS 2.64.2+)
+    #
     if ( $target_archive = $::GBE_DPKG_SBOX )
+        }
         else
+        {
             $link_file  = 'sandbox' . ${BUILDNAME_SUFFIX} . '.lnk';
+        }
-        $root_path = 'GBE_SANDBOX' . substr($Cwd, length($::GBE_SANDBOX));
+        $root_path = 'GBE_SANDBOX' . substr($CwdFull, length($::GBE_SANDBOX));
         Verbose2("Root Path: $::GBE_SANDBOX, $root_path");
+    }
     elsif ( $target_archive = $::GBE_DPKG_LOCAL )
+    {
         $target_archive_name = "local_dpkg_archive";
         $link_file = "$BUILDVERSION.lnk";
         $tag = "Local";
-        $root_path = $Cwd;
+        $root_path = $CwdFull;
+    }
     else
+    {
         Verbose("Cannot locate local or sandbox archive")
             unless $Clobber;
+        #
         #   File with path to the interface directory
         #   Relative to the base of the sandbox
+        #
-        FileCreate($int_path, catdir('GBE_SANDBOX',RelPath($Cwd,$::GBE_SANDBOX),$BUILDINTERFACE ));
+        FileCreate($int_path, CatPaths('GBE_SANDBOX',RelPath($CwdFull,$::GBE_SANDBOX),$BUILDINTERFACE ));
+        #
         #   Indicate packages not build on this machine
+        #
         unlink $nob_path;           # Delete the NoBuild marker
+    }
     if ( $Clobber )                             # clobber mode ?
+    {
+        #
-        #   Unmake all the makefiles
-        #   No longer needed as we track the file that are created
-        #
-        #if ( -e "Makefile.gbe" )
-        #{
-        #    JatsTool ( 'jmake.pl', 'unmakefiles');
-        #}
-        #
         #   Delete my own configuration files
+        #
         DeleteCfg();
+        #
         BuildPackageLink();
         BuildSandboxData();
         return;
+    }
+    #
+    #   Generate the path to the descpkg file
+    #   The file is created later in the build proccess, but the makefile generation
+    #   needs to have a known path to the file.
+    #
+    #   It will be a file that is 'known' to JATS
+    #
+    $descpkgPath = BuildAddKnownFile ( $NoBuild ? $CwdFull : $Srcdir, 'descpkg' );
     #.. Build support files
+    #
     DeleteCfg();
     BuildConfig();
     BuildSharedLibFiles();
     WriteParsedBuildConfig();
     BuildPackageLink();
     BuildSandboxData();
-    NoBuildMarker();
+    #
     #  ONLY (re)building interface dir
+    #
-    return
-        if ( $Interface );
+    unless ( $Interface ) {
-    #---------------------------------------------------------------------------
+        #---------------------------------------------------------------------------
-    #
+        #
-    #.. Make bootstrap "makefile",
+        #.. Make bootstrap "makefile",
-    #   Simulate a top level makefile
+        #   Simulate a top level makefile
-    #       Pass argumenst to makelib
+        #       Pass argumenst to makelib
-    #       Sumulate SubDir() operations
+        #       Sumulate SubDir() operations
-    #       Sumulate a Platform(*);
+        #       Sumulate a Platform(*);
-    #
+        #
-    #       Due to the normal way that makelib.pl is executed,
+        #       Due to the normal way that makelib.pl is executed,
-    #       the following substitutions are done.
+        #       the following substitutions are done.
-    #
+        #
-    @ARGV = ();
+        @ARGV = ();
-    $0 = "makefile.pl ";
+        $0 = "makefile.pl ";
-    push @ARGV, "$Cwd";                         # current working directory
+        push @ARGV, "$CwdFull";                         # current working directory
-    push @ARGV, "$::GBE_TOOLS/makelib.pl";     # makelib.pl image
+        push @ARGV, "$::GBE_TOOLS/makelib.pl";      # makelib.pl image
-    push @ARGV, "--interface=$BUILDINTERFACE"
+        push @ARGV, "--interface=$BUILDINTERFACE"
-        if ($BUILDINTERFACE);
+            if ($BUILDINTERFACE);
-    Debug( "ARGV:      @ARGV" );
-    #.. (re)Build root makefile
-    #
-    $ScmBuildlib = 0;                           # clear Buildlib flag for 'makelib.pl'
-    RootMakefile();                             # inform 'makelib.pl'
-    MakeLibInit();                              # run initialisation
-    #.. Register subdir(s)
-    #
-    UniquePush (\@BUILDSUBDIRS, $Srcdir );
-    SubDir( @BUILDSUBDIRS );
-    Platform( @BUILD_ACTIVEPLATFORMS );
-    #.. (re)build src makefiles and associated information
-    #   JatsTool will not return on error
-    #
-    my @cmds = ('jmake.pl', 'rebuild');
-    push @cmds, 'NORECURSE=1' if ( $RootOnly );
-    JatsTool ( @cmds);
+        Debug( "ARGV:      @ARGV" );
+        #.. (re)Build root makefile
+        #
+        $ScmBuildlib = 0;                           # clear Buildlib flag for 'makelib.pl'
+        RootMakefile();                             # inform 'makelib.pl'
+        MakeLibInit();                              # run initialisation
+        #.. Register subdir(s)
+        #
+        UniquePush (\@BUILDSUBDIRS, $Srcdir );
+        SubDir( @BUILDSUBDIRS );
+        Platform( @BUILD_ACTIVEPLATFORMS );
+        #.. (re)build src makefiles and associated information
+        #   JatsTool will not return on error
+        #
+        my @cmds = ('jmake.pl', 'rebuild');
+        push @cmds, 'NORECURSE=1' if ( $RootOnly );
+        JatsTool ( @cmds);
+    }
+    #
+    #   Generate package signature
+    #   Write the descpkg file again - with a signature this time
+    #
     ErrorConfig( 'name' => 'buildlib')   ;
+    WriteDescpkg();
+    NoBuildMarker();
+    #
     #   Generate some warnings that will be seen at the end of the build
+    #
     Warning ("BuildSrcArchive Directive Present","Read JATS Manual for correct usage")
         if ($build_source_pkg);
+}
 #                   The format of this file matches that generated by JANTS
 #                   Take care when extending the format
+#
 #                   NOTE: It turns out that JANTS is not a standard and the
 #                         implementors (of JANTS) kept on changing it.
+#
+#                   NOTE: This directive is now ignored
+#                         The descpkg file is generated internally
+#
-# Inputs          :
+# Inputs          : $mode - 'Internal' - Skip sanity test
+#
 # Returns         :
+#
 sub BuildDescpkg
+{
-    StartBuildPhase();                      # Starting the build phase. No more data collection
+    StartBuildPhase();                  # Starting the build phase. No more data collection
-    return if ( $Clobber );                 # clobber mode ?
+}
+#-------------------------------------------------------------------------------
+# Function        : WriteDescpkg
-    #
+#
+# Description     : Create a package description file
-    #   Store the files location for use at runtime
+#                   The format of this file matches that generated by JANTS
-    #   It will be a file that is 'known' to JATS
+#                   Take care when extending the format
-    #
+#
-    my $pkgfile = BuildAddKnownFile ( $NoBuild ? $Cwd : $Srcdir, 'descpkg' );
+#                   NOTE: It turns out that JANTS is not a standard and the
+#                         implementors (of JANTS) kept on changing it.
+#
+# Inputs          :
+#
+# Returns         :
+#
+sub WriteDescpkg
+{
+    return if ( $Clobber );                 # clobber mode ?
     my @desc;
     push @desc, "Package Name:  $BUILDNAME_PACKAGE";
     push @desc, "Version:       $BUILDVERSION";
     push @desc, "Released By:   $::USER";
     push @desc, "Released On:   $::CurrentTime";
     push @desc, "Build Machine: $::GBE_HOSTNAME";
-    push @desc, "Path:          $Cwd";
+    push @desc, "Path:          $CwdFull";
     push @desc, "Jats Version:  $::GBE_VERSION";
     push @desc, "Jats Path:     $::GBE_CORE";
     push @desc, "";
     push @desc, "Build Dependencies:";
     push @desc, "";
         push @attributes, "build=\"true\"" if $type =~ /Build/i;
         push @desc, "<sandbox @attributes/>";
+    }
-    FileCreate ($pkgfile, \@desc );
+    FileCreate ($descpkgPath, \@desc );
+}
 #-------------------------------------------------------------------------------
 # Function        : NoBuildMarker
+#
 #   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/trunk/TOOLS/buildlib.pl – Rev 6198 → 6276