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

 our $Clobber                = 0;
 our $Archive                = 0;
 our $Interface              = 0;
 our $RootOnly               = 0;
 our $SignatureOnly          = 0;
-our $Perms                  = 0;
+our $BuildInfo              = 0;
+our $BuildInfoFile          = 'BuildInfo.properties';
 our $Expert                 = 0;
 our $All                    = 0;
 our $Cache                  = $ENV{GBE_DPKG_CACHE_CTL} || 0;
 our $NoPackageError         = 0;
 our $ForceBuildPkg          = 0;
 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 @BUILDARGUMENTS         = ();               # Build Arguments
+our @LINKPKGEXLUDES         = ();               # LinkPkgExclude arguments
 our $Makelib                = "";
 our $GBE_CORE;                                  # Root of JATS
 our $InterfaceVersion;                          # Interface directory format version
 our $ScmRoot;                                   # Package Root
 my  $build_source_pkg       = 0;                # Flag to build source package
 my  $opt_help               = 0;
 my  $opt_localCache         = 0;                # Create cache within the interface directory
 my  $pkgFromSandbox         = 0;                # Flags that we have imported a package from a sandbox
+my  $toolsetData;                               # Parsed toolset data
 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
     EnvImport( 'GBE_CONFIG' );
     EnvImport( 'GBE_DPKG' );
     EnvImport( 'GBE_MACHTYPE' );
     EnvImport( 'USER' );
     EnvImport( 'GBE_HOSTNAME');
-    EnvImport( 'GBE_DRV' )
-        if ( $ScmHost ne 'Unix' );            # DOS or WIN special
+    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' ,'' );
     EnvImportOptional ( 'GBE_DPLY'      ,'' );
     EnvImportOptional ( 'GBE_SANDBOX'   ,'' );
-    EnvImportOptional ( 'GBE_PLATFORM' );           # optional PLATFORM filter
+    EnvImportOptional ( 'GBE_PLATFORM' );               # optional PLATFORM filter
-    EnvImportOptional ( 'GBE_BUILDFILTER' );        # optional BUILD filter
+    EnvImportOptional ( 'GBE_BUILDFILTER' );            # optional BUILD filter
-    EnvImportOptional ( 'GBE_ABT' );                # optional ABT flags
+    EnvImportOptional ( 'GBE_ABT' );                    # optional ABT flags
 #.. Common stuff
+#
     require "$::GBE_TOOLS/common.pl";
     CommonInit( 'buildlib' );
                              "nopackages"    => \$IgnorePkgs,
                              "forcebuildpkg" => \$ForceBuildPkg,
                              "force!"        => \$ForceBuild,
                              "generic!"      => \$GenericBuild,
                              "localcache!"   => \$opt_localCache,
+                             "buildinfo:s"   => \$BuildInfoFile,
                              "signature:s"   => \$CheckSignature,
                              );
     Usage() if ( $opt_help || !$result );
     Debug( "Host:          ", $ScmHost );
             $RootOnly       = 1;
         } elsif ( $CmdSwitch eq "clobber" ) {
             $Clobber        = 1;
+        } elsif ( $CmdSwitch eq "buildinfo" ) {
+            $BuildInfo      = 1;
+            $Interface      = 1;
+            unlink $BuildInfoFile;
         } elsif ( $CmdSwitch eq "signature" ) {
             $SignatureOnly  = 1;
             $Interface      = 1;
             $IgnorePkgs     = 1;
 sub Log
+{
     if ( ! $Clobber )
+    {
         print "@_\n";
-        FileAppend ('build.log', \@_ );
+        FileAppend ('build.log', \@_ ) unless $BuildInfo;
+    }
+}
 #-------------------------------------------------------------------------------
 # Function        : BuildSubDir
     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 );
+            UniquePush (\@BUILD_BADNAME, $target ) unless ($target eq 'NOBUILD');
             $pInfo->{NOT_AVAILABLE} = 3;
             $pInfo->{BADNAME} = 1;
+        }
+    }
 # Returns         :
+#
 sub BuildToolset
+{
     my( @arguments ) = @_;
-    my ($exclude, $include, $including);
     $genToolsetPlatform = 1;
     Debug( "BuildToolset(@arguments)" );
     Error( "BuildToolset must appear before BuildName()..." )
         if ( $BUILDNAME ne "" );
+    #
     #   Process TOOLSET specific options
     #       --ExcludeMachType=xxxx,yyy
     #       --MachType=xxxx,yyy
+    #
+    $toolsetData->{enableToolset} = 1;
     foreach ( @arguments )
+    {
         if ( m~^--ExcludeMachType=(.+)~i ) {
             foreach my $arch (split(',',$1))
+            {
+                ReportError("BuildToolset: Unknown MachType: $arch") unless PlatformConfig::validMachType($arch);
+                $toolsetData->{exclude}{lc $arch} = 1;
-                if (uc($arch) eq uc($::GBE_MACHTYPE))
+                if (lc($arch) eq lc($::GBE_MACHTYPE))
+                {
                     Verbose("Exclude TOOLSET on this machine");
-                    $exclude = 1;
+                    $toolsetData->{excludeThis} = lc($arch);
-                    last;
+                }
+            }
         } elsif ( m~^--MachType=(.+)~i ) {
-            $including = 1;
             foreach my $arch (split(',',$1))
+            {
+                ReportError("BuildToolset: Unknown MachType: $arch") unless PlatformConfig::validMachType($arch);
+                $toolsetData->{include}{lc $arch} = 1;
-                if (uc($arch) eq uc($::GBE_MACHTYPE))
+                if (lc($arch) eq lc($::GBE_MACHTYPE))
+                {
                     Verbose("Include TOOLSET on this machine");
-                    $include = 1;
+                    $toolsetData->{includeThis} = lc($arch);
-                    last;
+                }
+            }
         } else {
-            Error ("BuildToolset: Unknown option: $_");
+            ReportError ("BuildToolset: Unknown option: $_");
+        }
+    }
+    if ( exists $toolsetData->{exclude} && exists $toolsetData->{include}) {
+        ReportError ("BuildToolset: Cannot use both --MachType and --ExcludeMachType");
+    }
+    ErrorDoExit();
+    #
     #   Show we build for this architecture
+    #   Have three conditions:
+    #       1) Current machType specifically excluded
+    #       2) Current machtype specifically included
+    #       3) Neither - further processing required
+    #
     $genToolsetActive = 0;
-    if ($exclude) {
+    if (exists $toolsetData->{excludeThis}) {
         $toolsetPlatform = 'Excluded';
         return;
+    }
-    if ($including) {
+    if (exists $toolsetData->{include}) {
-        if ($include) {
+        if (exists $toolsetData->{includeThis}) {
             $genToolsetActive = 1;
         } else {
             $toolsetPlatform = 'Not included';
+        }
         return;
+    #
     #   Clobber processing done after values have been accumulated
     #   as they may be used later
+    #
     return if ( $Clobber );
-    ToolsetFiles::AddFile('build.log');
+    ToolsetFiles::AddFile('build.log') unless ($BuildInfo);
 #.. Create build.log summary information
+#
     my ($sep) = "\n".(" " x 11) . ". ";
     Log( "DateTime ... $::CurrentTime" );
     Log( "AutoBuild... Enabled:$::GBE_ABT" ) if defined($::GBE_ABT) ;
     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( "Build Info . $BuildInfoFile") if $BuildInfo;
     Log( "PERL ....... $::GBE_PERL" );
     Log( "BIN  ....... $::GBE_BIN" );
     Log( "TOOLS ...... $::GBE_TOOLS" );
     Log( "CONFIG ..... $::GBE_CONFIG" );
+    #
     #   Detect a mix of Generic and non Generic targets
     #       Cannot mix generic and non-generic targets
+    #
-    if ($#GENERIC_TARGETS >= 0 && $#BUILD_ACTIVEPLATFORMS >= 0)
+    if ($#GENERIC_TARGETS >= 0 && $#BUILDPLATFORMS >= 0)
+    {
-        if ($#BUILD_ACTIVEPLATFORMS != $#GENERIC_TARGETS )
+        if ($#BUILDPLATFORMS != $#GENERIC_TARGETS )
+        {
             Verbose("Active:", @BUILD_ACTIVEPLATFORMS);
             Verbose("Generic:", @GENERIC_TARGETS);
             Error("Cannot mix GENERIC and non-GENERIC targets in the one build");
+        }
+    }
+    #
     #   NoBuilds do not generate warnings
+    #
-    return if $NoBuild;
+    return if $NoBuild && !$BuildInfo;
+    #
     #   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");
+        abtWarning (1,"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));
+    }
+    generateBuildInfo() if ($BuildInfo);
     return 1;
+}
 #-------------------------------------------------------------------------------
+# Function        : generateBuildInfo
+#
+# Description     : Using in BuildInfo mode to save the required information
+#
+#                   In BuildInfo mode we have all the data that we need
+#                   Save it into a file for the build system and then exit the build process
+#                   We do not need to do any further work at this point in time
+#
+# Inputs          : Globals
+#
+# Returns         : This function does not return
+#                   It will exit as there is no more work to be done
+#
+#                   Will generate a JAVA properties file with BuildInfo required by the
+#                   Build System.
+#
+sub generateBuildInfo
+{
+    DumpCapture();
+    Message ("Generate BuildInfo Data: ". $BuildInfoFile);
+    my @propLines = ();
+    my $fh = ConfigurationFile::New( $BuildInfoFile, '--Type=Properties' );
+    $fh->HeaderSimple( "buildlib (Version $BuildVersion)", "BuildInfo properties" );
+    # Build style
+    push @propLines, "buildstyle = JATS";
+    # Current Build Filter
+    push @propLines, "buildfilter = " . join(',', sort split(' ', $::GBE_BUILDFILTER));
+    # All platforms that the package can be built for.
+    push @propLines, "platforms = " . join(',', sort @BUILDPLATFORMS);
+    # All platforms that the package will be built for with the current build filter
+    my @AllCanBuild;
+    my %filterMap;
+    foreach ( split(' ', $::GBE_BUILDFILTER) ) {
+        $filterMap{$_} = 1;
+        my $genericMachType = PlatformConfig::getGenericMachType($_);
+        if ($genericMachType) {
+            $filterMap{$genericMachType} = 1;
+        }
+    }
+    push (@AllCanBuild, 'GENERIC') if ($#GENERIC_TARGETS >= 0);
+    foreach ( @BUILDPLATFORMS ) {
+        if (exists $filterMap{$_}) {
+            push @AllCanBuild, $_;
+        }
+    }
+    push @propLines, "build.platforms = " . join(',', sort @AllCanBuild);
+    # Platforms that have been specifically excluded from the build
+    push @propLines, "excluded.platforms = " . join(',', sort @BUILDEXCLUDE);
+    # Platforms not known to JATS
+    # Only works in ABT mode. Errors will be detected before this
+    push @propLines, "unknown.platforms = " . join(',', sort @BUILD_BADNAME);
+    # Toolset build information
+    CalcToolsetBuildInfo(@AllCanBuild);
+    if (exists $toolsetData->{platforms}) {
+        push @propLines, "toolset.platforms = " . join(',', sort @{$toolsetData->{platforms}});
+    }
+    # Indication of production and debug builds
+    my (@OnlyProd, @OnlyDebug);
+    foreach my $platform ( sort keys %BUILDPLATFORMARGS) {
+        foreach my $arg ( split($;, $BUILDPLATFORMARGS{$platform})) {
+            push (@OnlyProd,  $platform) if ($arg =~ m~--OnlyProd~);
+            push (@OnlyDebug, $platform)  if ($arg =~ m~--OnlyDebug~);
+        }
+    }
+    push @propLines, "prod.platforms = " . join(',', sort @OnlyProd) ;
+    push @propLines, "debug.platforms = " . join(',', sort @OnlyDebug) ;
+    # JAVA version specified
+    if ($BUILDPLATFORMARGS{JAVA}) {
+        foreach my $arg ( split($;, $BUILDPLATFORMARGS{JAVA})) {
+            if ($arg =~ m~^--Version=(.*)~i) {
+                push @propLines, "java.version = " . $1;
+                last;
+            }
+        }
+    }
+    # The package is GENERIC
+    if ($#GENERIC_TARGETS >= 0) {
+        push @propLines, "generic.build = 1";
+    }
+    $fh->WriteLn(@propLines);
+    $fh->Close();
+    # Display for user gratification (and build system logging)
+    Information($BuildInfoFile,@propLines);
+    exit 0;
+}
+#-------------------------------------------------------------------------------
 # Function        : needToolset
+#
 # Description     : Internal. Determine if this machine needs to build for
 #                   a TOOLSET or a GENERIC_<MachType>
+#
+    #
     #   Need to ensure that we have a TOOLSET platform in the build set
+    #
     my %activePlatformMap = map {$_ => 1} @BUILD_ACTIVEPLATFORMS;
     my @toolsetTargets = PlatformConfig::getTargetsByTag('TOOLSET');
     foreach my $item (@toolsetTargets)
+    {
         if (exists($activePlatformMap{$item}))
+        {
+            #
     $BUILDALIAS{TOOLSET} = $toolset;
     push @{$BUILDINFO{$toolset}{USERALIAS}}, 'TOOLSET';
+}
 #-------------------------------------------------------------------------------
+# Function        : CalcToolsetBuildInfo
+#
+# Description     : Calculate the Toolset component of the BuildInfo
+#                   Note: Similar to ProcessToolSetPlatform (above)
+#
+#                   Need to determine the most suitable platform for building toolsets.
+#                   Only consider those that are a part of the build set
+#
+# Inputs          : AllPlatforms    - an Array of all platrform that this package can
+#                                     be built on with the current build filter
+#
+# Returns         :
+#
+sub  CalcToolsetBuildInfo {
+    my (@allPlatforms) = @_;
+    return unless $toolsetData->{enableToolset};
+    my %toolsetSelected;
+    my %platformMap = map {$_ => 1} @allPlatforms;
+    my @toolsetTargets = PlatformConfig::getTargetsByTag('TOOLSET');
+    foreach my $item (@toolsetTargets)
+    {
+        if (exists($platformMap{$item}))
+        {
+            my $include = 0;
+            my $toolMachType = PlatformConfig::targetHasTag($item, 'MACHTYPE');
+            # Specifically included
+            if (exists $toolsetData->{include}){
+                if (exists $toolsetData->{include}{ lc $toolMachType}) {
+                    $include = 1;
+                }
+            # Specifically excluded
+            } elsif (exists $toolsetData->{exclude}) {
+                unless (exists $toolsetData->{exclude}{ lc $toolMachType}) {
+                    $include = 1;
+                }
+            # Default
+            } else {
+                $include = 1;
+            }
+            if ($include) {
+                unless (exists $toolsetSelected{$toolMachType}) {
+                    $toolsetSelected{$toolMachType} = $item;
+                    push @{$toolsetData->{platforms}}, $item;
+                }
+            }
+        }
+    }
+#DebugDumpData("toolsetSelected", \%toolsetSelected);
+}
+#-------------------------------------------------------------------------------
 # Function        : BuildPreviousVersion
+#
 # Description     : Deprecated. Do not use
+#
 # Inputs          :
+        }
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : LinkPkgExclude
+#
+# Description     : Mark a package to be excluded / included for a specific build
+#                   Intended use:
+#                       Recover from really (reaaly) badly constructed packages
+#
+#                   Essentially this directive will 'Exclude' packages from the
+#                   a specific build target (platform) by removing it from data
+#                   structures that are exported to the make stage
+#
+#                   Process ONLY works for LinkPkgArchive packages
+#
+# Inputs          : platform-selector   - A JATS style platform specifier
+#                   package-list        - one or or packages to process
+#
+# Example         : LinkPkgExclude('!SK100', 'PulseSdk');
+#                   LinkPkgExclude('SK100' , 'crypto');
+#
+sub LinkPkgExclude
+{
+    DataDirective('LinkPkgExclude');
+    Error("LinkPkgExclude(@_) requires at least two arguments") unless ((scalar @_) >= 2);
+    #
+    #   Simply save the arguments for later processing
+    #
+    push @LINKPKGEXLUDES, join($;, @_);
+}
+#-------------------------------------------------------------------------------
+# Function        : ProcessLinkPkgExclude
+#
+# Description     : INTERNAL Function
+#                   Process the data collected by the LinkPkgExclude directives
+#
+# Inputs          : None
+#                   Uses: LINKPKGEXLUDES
+#
+# Returns         : Will modify interal classes and data structures
+#
+sub ProcessLinkPkgExclude
+{
+    my @unknownPlatforms;
+    my @unknownPkg;
+    my @notLinkPkg;
+    #
+    #   Create a hash of known platforms - detect and report bad user input
+    #
+    my %fullPlatformList =  map { $_ => 1 } @BUILDPLATFORMS;
+    #
+    #   Process each directive
+    #
+    foreach ( @LINKPKGEXLUDES )
+    {
+        my (@add, @remove);
+        my ($pSel, @pkgList) = split($;, $_);
+        Log("LinkPkgExclude $pSel, @pkgList");
+        #
+        #   Process the selector in the same manor as makefiles
+        #       Need the selector to be active
+        #       Selector may be an alias or a platform
+        #       Selector may be negated
+        #       Selectors are comma seperated
+        #       Additive elements are processed before subtactive elements
+        #
+        my @pItems = split(/\s*,\s*/, $pSel);
+        @pItems = ExpandPlatforms( @pItems );
+         foreach my $platform ( @pItems) {
+             my $pname = $platform;
+             my $invert;
+             if (substr($platform, 0, 1) eq '!') {
+                 $invert = 1;
+                 $pname = substr($platform, 1)
+                 }
+             unless (exists($fullPlatformList{$pname})) {
+                 UniquePush(\@unknownPlatforms, $pname);
+                 next;
+                 }
+             if ( $invert )  {
+                 push @remove, $pname;
+             } else {
+                 push @add, $pname;
+             }
+         }
+         #
+         #   Build complete list of allowed platforms
+         #       Process additive rules before removal rules
+         #       If there are no additive rules, then assume all protaforms
+         #
+         my %calcList;
+         @add = @BUILDPLATFORMS unless @add;
+         $calcList{uc $_} = 1 foreach (@add);
+         delete $calcList{uc $_} foreach (@remove);
+         Verbose2("LinkPkgExclude ", keys %calcList,",", @pkgList);
+         #
+         #  Now have a list of platforms to process (exclude)
+         #  Now have a list of packages to exclude
+         #
+         #  Iterate over the package rules and mark those to be excluded
+         #
+         foreach my $platform ( keys %calcList )
+         {
+             unless (exists($PKGRULES{$platform})) {
+                 next;
+             }
+             foreach my $ePackage (@pkgList) {
+                 my $pkgFound;
+                 foreach my $package ( @{$PKGRULES{$platform}} )
+                 {
+                     my $fname = $package->{'dname'};
+                     if ( $package->{'dproj'}) {
+                         $fname .= '.' . $package->{'dproj'};
+                     }
+                     if ( $ePackage eq $package->{'dname'}  || $ePackage eq $fname) {
+                         $pkgFound = 1;
+                         if ($package->{'type'} ne 'link') {
+                             UniquePush(\@notLinkPkg, $ePackage);
+                             last;
+                         }
+                         $package->{'EXCLUDE'} = 1;
+                         Debug("Exclude", $platform, $fname );
+                         last;
+                     }
+                 }
+                 UniquePush(\@unknownPkg, $ePackage) unless $pkgFound;
+             }
+         }
+   }
+    ReportError("LinkPkgExclude. Unknown platforms:", @unknownPlatforms) if @unknownPlatforms;
+    ReportError("LinkPkgExclude. Unknown packages:", @unknownPkg) if @unknownPkg;
+    ReportError("LinkPkgExclude. BuildPkgArchive not allowed for:", @notLinkPkg) if @notLinkPkg;
+    ErrorDoExit();
+}
+#-------------------------------------------------------------------------------
 # Function        : CreateInterfacePackage
+#
 # Description     : Create a dummy package entry to describe the Interface
 #                   This is done AFTER all the BuildPkgArchive directives have
 #                   been processed so that the interface directory is fully
+            }
+        }
+    }
     CleanUp_Aliases();
     ProcessBuildArgument();
+    ProcessLinkPkgExclude();
+    #
     #   Create dummy package to describe the Interface directory
+    #
     CreateInterfacePackage();
     my %ScmBuildPkgRules;
     foreach my $platform ( keys %PKGRULES )
+    {
         foreach my $package ( @{$PKGRULES{$platform}} )
+        {
+            next if exists $package->{'EXCLUDE'};
             my %entry;
             $entry{ROOT}     = TruePath( $package->{'base'} );
             $entry{NAME}     = $package->{'name'};
             $entry{VERSION}  = $package->{'version'};
 jats build [options] [command]
      [perl buildlib.pl [options] PWD [command]]
  Options:
-    -help          - Display terse usage
+    -help           - Display terse usage
-    -help -help    - Display verbose usage
+    -help -help     - Display verbose usage
-    -man           - Display internal manual
+    -man            - Display internal manual
-    -verbose[=n]   - Set level of progress verbosity
+    -verbose[=n]    - Set level of progress verbosity
-    -debug[=n]     - Set the debug level
+    -debug[=n]      - Set the debug level
-    -cache         - Cache packages in the local dpkg_package cache
+    -cache          - Cache packages in the local dpkg_package cache
-    -localcache    - Cache packages into the interface directory
+    -localcache     - Cache packages into the interface directory
-    -cache -cache  - Forced refresh dependent packages in the local cache
+    -cache -cache   - Forced refresh dependent packages in the local cache
-    -package       - Ignore packages that are not available and continue
+    -package        - Ignore packages that are not available and continue
-    -nopackages    - Ignore package processing directives
+    -nopackages     - Ignore package processing directives
-    -forcebuildpkg - Treat LinkPkgArchive directives as BuildPkgArchive
+    -forcebuildpkg  - Treat LinkPkgArchive directives as BuildPkgArchive
-                     Also suppress the use of symlinks so that the physical
+                      Also suppress the use of symlinks so that the physical
-                     file will be copied locally.
+                      file will be copied locally.
-    -[no]force     - Force build even if build.pl is not newer
+    -[no]force      - Force build even if build.pl is not newer
-                     Default: -force
+                      Default: -force
-    -[no]generic   - Build system sanity test
+    -[no]generic    - Build system sanity test
-                     Default: Do not test
+                      Default: Do not test
+    -buildinfo=path - Specify name of the buildinfo file
     -signature=xx  - Check package signature
  Sticky settings:
     -all           - Build for all platforms ignoring GBE_BUILDFILTER
     -expert[=n]    - Relaxing dependency checks on the user makefiles
  Commands:
     clobber        - Remove generated build system (eg Makefiles).
     interface      - Only (re)build the interface tree.
     rootonly       - Only (re)build the root directory.
+    buildinfo      - Only generate build system info.
     signature      - Create the packages signature
 =head1 OPTIONS
 =over 8
 The default is to not perform the test.
 This option is intended to be used by the automated build system.
+=item B<-buildinfo>
+This option is only used in conjunction with the 'buildinfo' command. It will specify
+the path of a file to write the build information. The dafault value is 'BuildInfo.properties'.
+This option, by itslef, will not invoke the buildinfo mode.
 =item B<-signature=xxxx>
 If used, this option will perform a sanity test on the packages signature. It will
 ensure that the generated package signature is the same as that provided.
 the root-level makefiles.
 The build process will not recurse through the subdirectories creating
 makefiles. These can be made on-demand by jats if a 'make' command is issued.
+=item B<buildinfo>
+This command is used by the build system to generate information about the
+build. It will create a file with the following information.
+=over 4
+=item * All platforms that the package can be built for.
+=item * All platforms that the package will be built for with the current build filter
+=item * Platforms that have been specifically excluded from the build
+=item * Platforms not known to JATS
+=item * Toolset build information
+=item * Generic build information
+=item * Indication of production and debug builds
+=item * JAVA version specified
+=back
 =item B<signature>
 This command will only build, or rebuild, the 'interface' directory and
 the root-level makefiles. It will not process external packages.

Subversion Repositories DevTools

(root)/core_devl/branches/gitBuilder/TOOLS/buildlib.pl – Rev 7322 → 7323