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

 our $CmdSwitch              = "";
 our $Clobber                = 0;
 our $Archive                = 0;
 our $Interface              = 0;
 our $RootOnly               = 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;
 my  $opt_help               = 0;
 my  $opt_localCache         = 0;                # Create cache within the interface directory
 my  $sandbox_exact          = 0;                # Exact or in-exact sandbox
 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,
                              );
     Usage() if ( $opt_help || !$result );
     Debug( "Host:          ", $ScmHost );
     Debug( "Cwd:           ", $CwdFull );
             $RootOnly       = 1;
         } elsif ( $CmdSwitch eq "clobber" ) {
             $Clobber        = 1;
+        } elsif ( $CmdSwitch eq "buildinfo" ) {
+            $BuildInfo      = 1;
+            $Interface      = 1;
+            unlink $BuildInfoFile;
         } elsif ( $CmdSwitch eq "help" || $CmdSwitch eq "usage" ) {
             $opt_help = 1;
             Usage();
         } else {
 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);
+    #
     #   Determine type of sandbox
+    #
     $sandbox_exact = ( -f $::GBE_DPKG_SBOX . '/.exact' )
     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 ($#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          :
 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
  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.
 =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<-all>
 This option will cause the build process to generate makefiles for all
 possible build targets ignoring the use of GBE_BUILDFILTER.
 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<clobber>
 This command will remove generated build system files and directories.
 =back

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/buildlib.pl – Rev 7262 → 7296