WebSVN – DevTools – Diff – /core_devl/trunk/TOOLS/makelib.pl2

 use JatsDPackage;
 use MakeIf;
 use ToolsetPrinter;
 use MakeObject;
 use JatsVersionUtils;
+use ToolsetFiles;
 our $ScmVersion             = "2.34";
 our $ScmGlobal              = 0;
 our $ScmExpert              = 0;
 our $ScmInterface           = "interface";      # default 'interface'
 our $ScmPackage             = 1;                # package active by default.
 our $ScmProcessingRootMake  = 0;                # Processing root makefile.pl
 our $ScmPlatformSeen        = 0;                # Platform directive has been seen
+my  $ScmNotGeneric          = 1;                # Not a generic build
 our $ScmToolsetVersion      = "";               # version of toolset
 our $ScmToolsetGenerate     = 1;                # generate active by default.
 our $ScmToolsetProgDependancies = 1;            # 1: Write program dependancies
                                                 # 0: Don't write progdeps. Prog is Phony
 our $ScmToolsetProgSource   = ();               # Toolset Program Source
 our $ScmToolsetSoName       = 0;                # 1: Shared library supports SoName
 our $ScmToolsetNillLibSrc   = 0;                # 1: Librarys created without source specified
 our %ScmToolsetProperties   = ();               # Toolset specific features and limitations
                                                 # Known values: UnitTests, AutoUnitTests
-my  %ScmGlobalOptions       = ();               # Hash of Global(platform) options. Access via functions
+our  %ScmGlobalOptions       = ();              # Hash of Global(platform) options. Access via functions
 our $ScmRoot                = "";
 our $ScmMakelib             = "";
 our $ScmPlatform            = "";
 our $ScmMachType            = "";
                                                 # Platform specific
         MakeIf::PackageDirs( \@ScmPlatformDirs, $ScmPlatform );
         push @ScmPlatformDirs, "$::GBE_CONFIG"; # .. plus default
-        #   Map all GENERIC builds onto the one platformm definition
+        #   Map all GENERIC builds onto the one platform definition
         my $platformDefs = $ScmPlatform;
-        $platformDefs = 'GENERIC' if ($::BUILDINFO{$ScmPlatform}{IS_GENERIC});
+        if ($::BUILDINFO{$ScmPlatform}{IS_GENERIC})
+        {
+            $ScmNotGeneric = 0;
+            $platformDefs = 'GENERIC' ;
+        }
         $file = Require( "PLATFORM", $platformDefs,
                     "Platform definition ", @ScmPlatformDirs );
+    }
     push( @ScmDepends, "$file" );
     my $local_base_dir = "$ScmRoot/gbe/DIRECTIVES";
     if ( -d $local_base_dir )
+    {
         foreach my $file  ( glob ("$local_base_dir/*.pm") )
+        {
+DebugDumpData("Include: $file",);
             push( @ScmDepends, "$file" );
             require $file;
+        }
+    }
+        #
         #   Add to suitable list
+        #
         push @{$tlist_ref}, $_;
+        ToolsetFiles::AddDir($_, 'Include');
+        #
         #   Add to the no dependancy list (ie generated depend file)
         #   Only used by AddIncDir, accepted by AddSrcDir
+        #
+    #
     #   Object files are saved in
     #       OBJSOURCE   - Generate a recipe to create the object
     #       OBJS        - A list of ALL non-shared object files
+    #
-    if ( $is_obj && $::o )
+    if ( $is_obj && $::o && $ScmNotGeneric )
+    {
         $OBJSOURCE{ "$obj" } = $srcfile;
         push( @OBJS, $obj )
             if ($push);
+    }
     'BuildVersionNum'   => '$(BUILDVERNUM)',
     'PackageDir'        => '$(PKGDIR),+',
     'PackagePkgDir'     => '$(PKGDIR)/pkg/pkg.$(GBE_PLATFORM),+',
     'PackageIncDir'     => '$(INCDIR_PKG),+',
+    'PackageIncPlatDir' => '$(INCDIR_PKG)/$(GBE_PLATFORM),+',
     'PackageLibDir'     => '$(LIBDIR_PKG)/$(GBE_PLATFORM),+',
     'PackageBinDir'     => '$(BINDIR_PKG)/$(GBE_PLATFORM)$(GBE_TYPE),+',
     'PackageToolDir'    => '$(PKGDIR)/tools,+',
     'PackageToolBin'    => '$(PKGDIR)/tools/bin/$(GBE_HOSTMACH),+',
     'Verbose'           => '$(CC_PRE)',
     'LeaveTmp'          => '$(LEAVETMP)',
     'Cwd'               => '$(CURDIR),-',
+    # Generated when used
     'CompilerPath'      => '$(SCM_COMPILERPATH)',
     'PkgArch'           => '$(PACKAGE_ARCH)',
+    'Native'            => '0',
+    'Toolset'           => '0',
     );
 sub ExpandGenVar
+{
     my ($dname, $args, @uopts) = @_;
     #   Most of it can be initialised at startup - but not all of it.
+    #
     $ExpandGenVarConvert{CompilerPath} = undef unless $::ScmToolsetCompilerPath;
     $ExpandGenVarConvert{Product}      = '$(GBE_PLATFORM)' unless $ScmProduct;
+    $ExpandGenVarConvert{Native}      = '1'  if isAnAlias ('NATIVE');
+    $ExpandGenVarConvert{Toolset}     = '1'  if isAnAlias ('TOOLSET');
+    #
     #   Look up a hash of conversions
     #   Could allow for a code ref, but not needed yet
+    #
     Error ("$dname: Unknown expansion --Var($tag)")
     return $prefix , $expansion, $is_path ? 1 : 0, $is_abs;
+}
 #-------------------------------------------------------------------------------
+# Function        : isAnAlias
+#
+# Description     : Internal Helper
+#                   Determine if this platform is an alias for ...
+#
+# Inputs          :  $target    - Test against this target
+#
+# Returns         :  True - Is an alais for $target.
+#
+sub isAnAlias
+{
+    my ($target) = @_;
+    if (exists ($::BUILDINFO{$ScmPlatform}{'USERALIAS'}) )
+    {
+        if ( grep /^$target$/, @{$::BUILDINFO{$ScmPlatform}{'USERALIAS'}} )
+        {
+                return 1;
+        }
+    }
+    if (exists ($::BUILDINFO{$ScmPlatform}{'ALIAS'}) )
+    {
+        if ( $target eq $::BUILDINFO{$ScmPlatform}{'ALIAS'} )
+        {
+                return 1;
+        }
+    }
+    return 0;
+}
+#-------------------------------------------------------------------------------
 # Function        : ProcessPathName
+#
 # Description     : Massage a pathname according to a set of flags
+#
 # Inputs          : $fn         - Patchname to massage
     my( $platforms, @elements ) = @_;
     my( $base, $dir, $full, $path, $dist, $strip, $exefile, $type );
     my( $name, $basename, $len, $srcfile );
     my( $dir_tree, @dir_tree_exclude, @dir_tree_include, $strip_base, $strip_dots );
     my $recurse = 1;
+    my $preserveSymlink = 0;
     Debug2( "PackageFile($platforms, @elements)" );
     return if ( !$ScmPackage );                 # Packaging enabled ?
     return if ( ! ActivePlatform($platforms) );
             $strip = 1;
         } elsif (/^--Executable$/) {            # Mark the file as executable
             $exefile = "X";
+        } elsif (/^--PreserveSymlink/i) {       # Preserve symlink to local file
+            $preserveSymlink = 1;
         } elsif ( /^--DirTree=(.*)/ ) {
             Error("DirTree. Multiple directories not allowed.") if ( $dir_tree );
             $dir_tree =  $1;
             Error("DirTree. No path specified") unless ( defined($dir_tree) && $dir_tree ne "" );
+#
     foreach ( @elements )
+    {
         my %package_entry;
         $name = $_;
+        my $symlink;
+        #
         #   Trap special files
         #       DPACKAGE - but only if we have a DPackageLibrary directive
         #                  in the same makefile.
             $dir =~ s~//~/~g;
             $dir =~ s~/$~~;
+            #
+            #   Preserve Symlink
+            #
+            if ($preserveSymlink && -l $srcfile)
+            {
+                $symlink = 1;
+            }
+            #
             #   Sanity test the source filename
             #   User may have misused an option
+            #
             if ( ( $srcfile =~ m/=/ ) || ( $srcfile =~ m/^-/ ) || ( $srcfile =~ m~/-~ )  )
+            {
             $package_entry{'src'} = $srcfile;
             $package_entry{'dir'} = StripFileExt( "$dir/$name" );
             $package_entry{'set'} = $dist;
             $package_entry{'exe'} = $exefile if $exefile;
             $package_entry{'type'} = $type if ( $type );
+            $package_entry{'symlink'} = 1 if ( $symlink );
             $PACKAGE_FILES{ "$dir/$name" } = {%package_entry};
+        }
+    }
+}
+    }
     return 0;
+}
 #-------------------------------------------------------------------------------
+# Function        : ActiveAlias
+#
+# Description     : Determine if the specified Alias is currenly 'active'
+#
+# Inputs          : $mtype              - one or more alias names separated
+#                                         by either a comma or a colon
+#
+# Returns         : TRUE    if any of the current Aliases is in the list
+#
+sub ActiveAlias
+{
+    my ($mtype) = @_;
+    foreach (  split( '\s*[:,]\s*', $mtype ) )
+    {
+        return 1
+            if ( isAnAlias( uc($_) ) );
+    }
+    return 0;
+}
+#-------------------------------------------------------------------------------
 # Function        : ActivePlatform
+#
 # Description     : Determine if the specified platform is currently 'active'
 #                   This is used by all user directives in order to determine
 #                   if the directive should be ignored for the current platform
 #                                         This is a bit complex.
+#
 #                   Format of platform_spec. One or more of
 #                       PlatformName
 #                       AliasName
-#                       TargetName,--Target
+#                       TargetName[,--Target]
 #                   Special Options (Must all be True)
 #                       --Project=ProjectName[:ProjectName]+
 #                       --Defined=SomeValue[:SomeValue]+
-#                       --MachType=SomeValue[:SomeValue]+
+#                       --MachType=SomeMachType[:SomeMachType]+
+#                       --Alias=SomeAlias[:SomeAlias]+
+#                   Some shortcuts
-#                   Each can be prefixed with a '!' to negate the test
+#                       '*'     ==> Always true
+#
+#                   Each can be prefixed with a '!' to negate the test
+#
+#                   PlatformNames are either additive or negative(prefixed with !)
+#                       Order is not important
+#                       All additive names are accumulated before the negative items are considered.
+#                           ie: aa,!bb => !bb,aa
+#                       If only negative names are provided then JATS assumes a leading '*'
+#                           ie: !aaa => *,!aaa
+#
 #                   Valid options are:
 #                       --Target        - indicates that the platform is a 'target'
+#
 # Returns         : TRUE if the platform spec is satisfied
+#
 sub ActivePlatform
+{
     my( $platform_spec ) = @_;
     my( @platforms, $scmplatform, $platform );
-    my( %arguments, @args, $filter );
+    my( %arguments, @args );
     my @plist;
-    my ($match_count, $count_invert, $count_vert) = (0,0,0);
+    #
     #   Short circuit check
-    #   '*' is used so often that it pays to check it first
+    #       '*' is used so often that it pays to check it first
+    #
     if ( $platform_spec eq '*' )
+    {
         Debug3( " ActivePlatform(@_) = TRUE" );
         return 1;
         } elsif ( m~^(!?)--MachType=(.+)~ ) {
             $not = $1;
             $result = ActiveMachType($2);
+        } elsif ( m~^(!?)--Alias=(.+)~ ) {
+            $not = $1;
+            $result = ActiveAlias($2);
         } else {
+            #
             #   Must be a platform argument
             #   Add to a list
+            #
         return 0 unless ( $result );
+    }
+    #
     #   If we have no platforms then the test was purely non-platform arguments.
-    #
+    #
-    if ($platform_spec ne '' && ! @platforms)
+    if ($platform_spec ne '' && ! @platforms) {
-    {
+        Debug3( " ActivePlatform(@_ == $ScmPlatform) = TRUE" );
         return 1;
+    }
+    unless (@platforms) {
+        Debug3( " ActivePlatform(@_ == $ScmPlatform) = FALSE" );
+        return 0;
+    }
     #   Platform specified may be an Alias
     #   Perform alias expansion
+    #
     @platforms = ExpandPlatforms( @platforms );         # aliasing
     Debug3( " ActivePlatform(@_)" );
+    }
 #.. Scan the expression
+#
     $scmplatform = uc( $ScmPlatform );          # current platform
+    my @add;
+    my @remove;
-    foreach ( @plist )
+    foreach ( @plist ) {
-    {
-        $platform = uc( Trim( $_ ) );           # trim white and convert case
+        my $platform = uc( Trim( $_ ) );           # trim white and convert case
+        my $pname = $platform;
+        my $invert = 0;
+        if (substr($platform, 0, 1) eq '!') {
+            $invert = 1;
+            $pname = substr($platform, 1)
+        }
+        #
         #   Determine filter comparison
-        #   Either a Platform or a Target
+        #       Either a Platform or a Target
+        #
-        if ( $arguments{$platform}{'Target'} )
+        if ( $arguments{$platform}{'Target'} ) {
-        {
-            $filter = uc( $ScmTarget );
-        }
-        else
-        {
-            $filter = $scmplatform;             # filter specification
+            $pname = $scmplatform if ($pname eq  uc( $ScmTarget ));
+        }
+        #
+        #   Catch some historically bad practices
+        #
+        $pname = $scmplatform if ( $pname eq '*'  || $pname eq '1' );
-        Debug3( "   Platform=$platform, Filter=$filter" );
+        Debug3( "   Platform=$platform, PName=$pname" );
+        #
         #   Examine platform names
-        #   Allow negation of name (!), but all the names must be negated
+        #   Allow negation (removal) of the name
-        #   as a mix does not make sense.
-        #   ie:     !P1,!P2,!P3     - All except P1,P2 or P3
-        #            P1,P2,P2       - Only P1,P2,P3
+        #
-        my $invert = 0;
-        if ( substr($platform, 0, 1) eq '!' )
+        if ( substr($platform, 0, 1) eq '!' )  {
-        {
-            $count_invert++;
+            push @remove, $pname;
-            $platform = substr($platform, 1);
-        }
-        else
+        } else {
-        {
-            $count_vert++;
+            push @add, $pname;
+        }
-        $match_count++ if ( $platform eq ''  ||
-                            $platform eq '*' ||
-                            $platform eq '1' ||
-                            $platform eq $filter );
+    }
+    #
-    #   Sanity test
+    #   Build complete list of allowed platforms
-    #   Force failure on bad sanity
+    #       Process additive rules before removal rules
+    #       If there are no additive rules, then assume all protaforms
+    #
+    my %calcList;
-    if ( $count_vert && $count_invert )
+    @add = @::BUILDPLATFORMS unless @add;
-    {
+    $calcList{$_} = 1 foreach (@add);
-        Warning( "Platform expression makes no sense. Mixed use of '!' operator",
+    delete $calcList{$_} foreach (@remove);
-                 "Expression: @_" );
+#DebugDumpData("Add", \@add);
-        return 0;
+#DebugDumpData("Remove", \@remove);
-    }
+#DebugDumpData("calcList", \%calcList);
+    #
-    #   Test for pass
-    #   If not using '!', then any match passes : P1 or P2 or P3
-    #   If are using '!', then any match is bad : !P1 and !P2 and !P3 == !(P1 or P2 or P3)
+    #   If the current build target is left in the platform list, then we are building for it
     #
-    if ( ( $count_vert && $match_count ) || ( $count_invert && ( not $match_count) )   )
+    if (exists $calcList{$ScmPlatform}) {
-    {
         Debug3( " ActivePlatform(@_ == $ScmPlatform) = TRUE" );
         return 1;
+    }
     Debug3( " ActivePlatform(@_ == $ScmPlatform) = FALSE" );
+    }
+    #
     #   Now start to create the makefile
+    #
-    ::ToolsetFile ($Makefile);
+    ToolsetFiles::AddFile($Makefile);
     open( MAKEFILE, '>', $Makefile ) || Error( "Cannot create $Makefile" );
     ::MakefileHeader( *MAKEFILE,
                       'Auto-generated Platform Dependent Makefile',
                       "$ScmMakelib (version $ScmVersion)",
                       "# Copyright (c) VIX TECHNOLOGY (AUST) LTD",
 #   NODEPEND is used to disable, at make-time, the dependency generation
 #   and inclusion process.
+#
+#
 MakeHeader ("Depend");
-if ($::o && (@CSRCS || @CXXSRCS))
+if ($::o && (@CSRCS || @CXXSRCS) && $ScmNotGeneric)
+{
     $ScmDependTags = 1;
     print MAKEFILE <<EOF;
 depend:			\$(OBJDIR)/depend

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/makelib.pl2 – Rev 6073 → 6133