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

 our @CXXFLAGS_PROD          = ();
 our @CXXLINTFLAGS           = ();
 our @CXXLINTFLAGS_DEBUG     = ();
 our @CXXLINTFLAGS_PROD      = ();
 our @ASFLAGS                = ();
+our @ASFLAGS_DEBUG          = ();
+our @ASFLAGS_PROD           = ();
 our @LDFLAGS                = ();
+our @LDFLAGS_DEBUG          = ();
+our @LDFLAGS_PROD           = ();
 our @INCDIRS                = ();
 our @NODEPDIRS              = ();
 our @S_INCDIRS              = ();
 our @G_INCDIRS              = ();
 #our $CurrentDate           = "";
 #our $Cwd                   = "";
 our @GENERATE_FILES         = ();
 our %DEPLOYPACKAGE          = ();
+our $DEPLOYPACKAGE          = 0;
 our %MakeTags;
+#
 #   Some toolset options that affect the generation of the makefile
+#
         'compile_as_cpp'        => { 'FORCE_CC_COMPILE'    => '1',
                                      'FORCE_C_COMPILE'     => undef },
         'compile_as_c'          => { 'FORCE_C_COMPILE'     => '1',
                                      'FORCE_CC_COMPILE'    => undef },
+        'no_define_source_file' => { 'DISABLE__SOURCE__' => '1' },
+        'define_source_file'    => { 'DISABLE__SOURCE__' => undef },    # Default
     );
+#
 #   The toolset can extend the options by setting the following hash
+#
     Debug2( "AddASFlags($platforms, @elements)" );
     return if ( ! ActivePlatform($platforms) );
-    __AddFlags( "ASFLAGS", \@elements, \@ASFLAGS );
+    __AddFlags( "ASFLAGS", \@elements,
+                \@ASFLAGS, undef,
+                \@ASFLAGS_DEBUG, undef,
+                \@ASFLAGS_PROD, undef );
+}
 sub AddLDFlags
+{
     my( $platforms, @elements ) = @_;
     return if ( ! ActivePlatform($platforms) );
     foreach  ( @elements )
+    {
+        next if ( m~^--(Debug|Prod)~ );
         Warning("Use of linker flag discouraged (will be used): $_");
+    }
-    __AddFlags( "LDFLAGS", \@elements, \@LDFLAGS );
+    __AddFlags( "LDFLAGS", \@elements,
+                \@LDFLAGS, undef,
+                \@LDFLAGS_DEBUG, undef,
+                \@LDFLAGS_PROD, undef );
+}
 sub AddLintFlags
+{
+#
 #                   There are many constraints:
 #                       Cannot be mixed with multi-platform builds
 #                       Some parameters are tool specific
+#
+#                   Allow programs to be Installed as well as Packaged
+#                   The 'Progect' is treated' as a program and it doesn't work
+#                   to well if we Install libraries.
+#
+#                   Only Reason to Install Programs is to allow the Cab Maker
+#                   to locate them.
+#
 # Inputs          : Platform        - Active platform
 #                   Project         - Project Name with extension
 #                   Options         - Many options
+#
             $PROJECTS{$proj}{'Debug'} = 1;
         } elsif ( m/^--Prod/ ) {
             $PROJECTS{$proj}{'Prod'} = 1;
-        } elsif ( m/^--PackageProgDebug=(.*)/ ) {
+        } elsif ( m/^--(Package|Install)ProgDebug=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir,'Prog', 'D', $1 );
+            _PackageFromProject( $1, $proj, $basedir,'Prog', 'D', $2 );
-        } elsif ( m/^--PackageProg(Prod)*=(.*)/ ) {
+        } elsif ( m/^--(Package|Install)Prog(Prod)*=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Prog', 'P', $2 );
+            _PackageFromProject( $1, $proj, $basedir, 'Prog', 'P', $3 );
-        } elsif ( m/^--PackageLibDebug=(.*)/ ) {
+        } elsif ( m/^--(Package)LibDebug=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Lib', 'D', $1 );
+            _PackageFromProject( $1, $proj, $basedir, 'Lib', 'D', $2 );
-        } elsif ( m/^--PackageLib(Prod)*=(.*)/ ) {
+        } elsif ( m/^--(Package)Lib(Prod)*=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Lib', 'P', $2 );
+            _PackageFromProject( $1, $proj, $basedir, 'Lib', 'P', $3 );
-        } elsif ( m/^--PackageSharedLibDebug=(.*)/ ) {
+        } elsif ( m/^--(Package)SharedLibDebug=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Lib', 'D', $1 );
+            _PackageFromProject( $1, $proj, $basedir, 'Lib', 'D', $2 );
-        } elsif ( m/^--PackageSharedLib(Prod)*=(.*)/ ) {
+        } elsif ( m/^--(Package)SharedLib(Prod)*=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Lib', 'P', $2 );
+            _PackageFromProject( $1, $proj, $basedir, 'Lib', 'P', $3 );
-        } elsif ( m/^--PackageHdr=(.*)/ ) {
+        } elsif ( m/^--(Package)Hdr=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Hdr', undef, $1 );
+            _PackageFromProject( $1, $proj, $basedir, 'Hdr', undef, $2 );
-        } elsif ( m/^--PackageFile=(.*)/ ) {
+        } elsif ( m/^--(Package)File=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'File', undef, $1 );
+            _PackageFromProject( $1, $proj, $basedir, 'File', undef, $2 );
-        } elsif ( m/^--PackageTool(Prod)*=(.*)/ ) {
+        } elsif ( m/^--(Package)Tool(Prod)*=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Tool', 'P', $2 );
+            _PackageFromProject( $1, $proj, $basedir, 'Tool', 'P', $3 );
-        } elsif ( m/^--PackageToolDebug=(.*)/ ) {
+        } elsif ( m/^--(Package)ToolDebug=(.*)/ ) {
-            _PackageFromProject( $proj, $basedir, 'Tool', 'D', $1 );
+            _PackageFromProject( $1, $proj, $basedir, 'Tool', 'D', $2 );
-        } elsif ( m/^--Package/ ) {
+        } elsif ( m/^--(Package|Install)/ ) {
-            Error("MakeProject. Unknown Package option: $_");
+            Error("MakeProject. Unknown $1 option: $_");
         } else {
             push @tool_options, $_;
+        }
+    }
 #-------------------------------------------------------------------------------
 # Function        : _PackageFromProject
+#
 # Description     : Save Packaged data from the project
+#
+# Inputs          : $tgt        - Install or Package
-# Inputs          : $proj       - Name of the project
+#                   $proj       - Name of the project
 #                   $base       - Base directory of files
 #                   $etype      - Type of Package (Progs, Libs, ... )
 #                   $type       - Debug or Production or both
 #                   $items      - Item to add. It may be comma seperated
+#
+my %PackageToData = ( 'Package' =>
-my %PackageToData = ( 'Hdr'   => \%PACKAGE_HDRS,
+                        { 'Hdr'   => \%PACKAGE_HDRS,
-                      'Lib'   => \%PACKAGE_LIBS,
+                          'Lib'   => \%PACKAGE_LIBS,
-                      'Prog'  => \%PACKAGE_PROGS,
+                          'Prog'  => \%PACKAGE_PROGS,
-                      'File'  => \%PACKAGE_FILES,
+                          'File'  => \%PACKAGE_FILES,
-                      'Tool'  => \%PACKAGE_FILES,
+                          'Tool'  => \%PACKAGE_FILES,
+                          '_BASE' => 'PBase',
+                        },
+                      'Install' =>
+                        { 'Hdr'   => \%INSTALL_HDRS,
+                          'Lib'   => \%INSTALL_LIBS,
+                          'Prog'  => \%INSTALL_PROGS,
+                          'File'  => undef,
+                          'Tool'  => undef,
+                          '_BASE' => 'IBase',
+                        },
                     );
 sub _PackageFromProject
+{
-    my( $proj, $base, $etype, $type, $items ) = @_;
+    my( $tgt, $proj, $base, $etype, $type, $items ) = @_;
     my $subdir = '';
+    #
+    #   Sanity test
+    #
+    $type = '' unless ( $type );
+    Error ("INTERNAL. Bad packaging option: $tgt")   unless ( exists $PackageToData{$tgt} );
+    Error ("INTERNAL. Bad packaging option: $etype") unless ( exists $PackageToData{$tgt}{$etype} );
+    Error ("Unsupported packaging combination: $tgt$etype$type=$items") unless ( defined $PackageToData{$tgt}{$etype} );
+    #
+    #   Determine the index into the 'PackageInfo' structure
+    #   This provides the symbolic name for the target package path
+    #   for Package or Install
+    #
+    #   The key '_BASE' is internal. Used only to provide this information
+    #
+    my $tbase = $PackageToData{$tgt}{'_BASE'};
+    #
     #   Process options
+    #
     foreach my $item ( split (/,/, $items ) )
+    {
         next unless ( $item =~ m/^--/ );
+    #
     foreach my $item ( split (/,/, $items ) )
+    {
         next if ( $item =~ m/^--/ );
-        my $tdir = $PackageInfo{$etype}{'PBase'} . $PackageInfo{$etype}{'Dir'} . $subdir ;
+        my $tdir = $PackageInfo{$etype}{$tbase} . $PackageInfo{$etype}{'Dir'} . $subdir ;
         my $fname = StripDir( $item );
         my $target = $tdir . '/' . $fname;
         $item = "$base/$item" if ( $base );
         $target =~ s~\$\(GBE_TYPE\)~$type~ if ($type);
+        #
         #   Create a PACKAGE entry suitable for processing by the normal packaging
         #   routines. This is complicated because the Projects do not adhere to
-        #   the JATS file name convenstions
+        #   the JATS file name conventions
+        #
         my %package_entry;
         $package_entry{'src'}   = $item;
         $package_entry{'dir'}   = $tdir;
-        $package_entry{'set'}   = 'ALL';
+        $package_entry{'set'}   = 'ALL' if ($tgt eq 'Package');
         $package_entry{'type'}  = $type if ($type);
-        $PackageToData{$etype}->{$target} = {%package_entry};
+        $PackageToData{$tgt}{$etype}->{$target} = {%package_entry};
+    }
+}
 #-------------------------------------------------------------------------------
 # Function        : MakeAnt
+    #
         HashJoin( \%PACKAGE_DIST, $;, $name, "$_" );
     #.. Summary of distribution sets
+    #
-        $PACKAGE_SETS{ $_ } = 1
+        $PACKAGE_SETS{ $_ }{'TAG'} = 1
-            if ( ! exists $PACKAGE_SETS{ $_ } );
+            if ( ! exists $PACKAGE_SETS{ $_ }{'TAG'} );
+    }
+}
 sub PackageFile
+{
+{
     my( $platforms, @elements ) = @_;
     my $dir;
     my $name;
+    #
+    #   Flag that this build creates a deployable package, even if its not
+    #   active on this platform.
+    #
+    $DEPLOYPACKAGE = 1;
     Debug2( "DeployPackage($platforms, @elements)" );
     return if ( ! ActivePlatform($platforms) );
+    #
     #   Only allow one use of this directive
+    #
     Error("DeployPackage can only be used once" ) if ( %DEPLOYPACKAGE );
+    $DEPLOYPACKAGE = 2;
+    #
     #   Ensure that the deployment file is available
+    #
     my $command_file = $ScmDeploymentPatch ? "deploypatch.pl" : "deployfile.pl";
+    #
     if ( defined $prod && defined $prod->[0] )
+    {
         print MAKEFILE 'ifeq "$(DEBUG)" "0"' . "\n";
         MakeEntry3( $tag, "+=", $prod );
-        print MAKEFILE 'endif' . "\n\n";
+        print MAKEFILE 'endif' . "\n";
+    }
     if ( defined $debug && defined $debug->[0] )
+    {
         print MAKEFILE 'ifeq "$(DEBUG)" "1"' . "\n";
         MakeEntry3( $tag, "+=", $debug );
-        print MAKEFILE 'endif' . "\n\n";
+        print MAKEFILE 'endif' . "\n";
+    }
+}
 sub MakeIfDefEntry
 else
 SCM_MAKEFILE	:= $Makefile
 endif
 EOF
+#
+#   Setup the base directory for the packaging process
+#   When building a deployable package the base directory is changed to match
+#   that used by the deployment world. This is done so that the descpkg file
+#   can be created in the correct location
+#
+my  $PKGDIR = "pkg/$::Pbase";
+    $PKGDIR = "build/deploy" if ( $DEPLOYPACKAGE );
+Verbose("Setting PKGDIR: $PKGDIR");
 print MAKEFILE <<EOF;
 #--------- Targets -------------------------------------------------------------
 .PHONY: 	default all build install package unpackage uninstall \\
 OBJDIR		= \$(GBE_PLATFORM)\$(GBE_TYPE).OBJ
 LIBDIR		= \$(GBE_PLATFORM).LIB
 BINDIR		= \$(GBE_PLATFORM)\$(GBE_TYPE).BIN
 CLSDIR		= classes\$(GBE_TYPE)
-PKGDIR		= \$(GBE_ROOT)/pkg/$::Pbase
+PKGDIR		= \$(GBE_ROOT)/$PKGDIR
 INCDIR_PKG	= \$(PKGDIR)/include
 LIBDIR_PKG	= \$(PKGDIR)/lib
 BINDIR_PKG	= \$(PKGDIR)/bin
 CLSDIR_PKG	= \$(PKGDIR)/classes
     MakeDefEntry( "CLINTFLAGS",     "=", \@CLINTFLAGS, \@CLINTFLAGS_PROD, \@CLINTFLAGS_DEBUG );
     MakeDefEntry( "CDEPENDFLAGS",   "=", \@CFLAGS, \@CFLAGS_PROD, \@CFLAGS_DEBUG );
     MakeDefEntry( "CXXFLAGS",       "=", \@CXXFLAGS, \@CXXFLAGS_PROD, \@CXXFLAGS_DEBUG );
     MakeDefEntry( "CXXLINTFLAGS",   "=", \@CXXLINTFLAGS, \@CXXLINTFLAGS_PROD, \@CXXLINTFLAGS_DEBUG );
     MakeDefEntry( "CXXDEPENDFLAG",  "=", \@CXXFLAGS, \@CXXFLAGS_PROD, \@CXXFLAGS_DEBUG );
-    MakeDefEntry( "ASFLAGS",        "=", \@ASFLAGS );
+    MakeDefEntry( "ASFLAGS",        "=", \@ASFLAGS, \@ASFLAGS_PROD, \@ASFLAGS_DEBUG );
-    MakeDefEntry( "LDFLAGS",        "=", \@LDFLAGS );
+    MakeDefEntry( "LDFLAGS",        "=", \@LDFLAGS, \@LDFLAGS_PROD, \@LDFLAGS_DEBUG );
 #-------------------------------------------------------------------------------
+#
+#
         MakeEntry( "package-${i}:\tmake_init package_setALL",
                 "\n", " package_set", "", @sets );
+    }
     MakeNewLine();
-    MakePrint("#   PACKAGE SETS\n");
-    MakePrint ".PHONY:\t\tpackage_setALL\n" .
-                "package_setALL:\n";
-    foreach my $i ( sort keys %PACKAGE_SETS ) {
-        MakePrint ".PHONY:\t\tpackage_set${i}\n" .
-                "package_set${i}:\n";
-    }
-    MakeNewLine();
 #-------------------------------------------------------------------------------
 #   Standard rules
+#
 MakeHeader ("Standard rules");
 UnpackageRule( "unpackage_shlib",       \&UnpackageCmd, \%PACKAGE_SHLIBS );
 UnpackageRule( "unpackage_prog",        \&UnpackageCmd, \%PACKAGE_PROGS );
 UnpackageRule( "unpackage_class",       \&UnpackageCmd, \%PACKAGE_CLSS );
 #-------------------------------------------------------------------------------
+#   Distribution Sets
+#
+MakeHeader ("Distribution Sets");
+PackageSetRules();
+#-------------------------------------------------------------------------------
+#
 #   Subdir deletion
 #   This is done AFTER the toolset functions have been invoked to create the
 #   build artifacts so that the toolsets can create directories too
+#
         #   Distribution sets
+        #
         my $dist = $entry->{'set'};
         if ( $dist )
+        {
-            my (@sets, $set, $sep);
+            foreach my $set ( split( ',', $dist ) )
-            $sep = "";
+            {
-            @sets = split( ',', $dist );        # foreach(set)
-            foreach $set ( @sets ) {            # append
-                MakePrint $sep."package_set$set:\t$dest\n";
+                push @{$PACKAGE_SETS{$set}{LIST}}, $dest;
-                $sep = "\n";
+            }
             MakeNewLine();
+        }
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : PackageSetRules
+#
+# Description     : Generate the packageset rules
+#                   These appear to be a now-defuct feature
+#
+#                   By default all packaged files are a part of package_setALL
+#
+# Inputs          : None
+#                   Takes data from %PACKAGE_SET
+#
+# Returns         : Nothing
+#
+sub PackageSetRules
+{
+    foreach my $set ( sort keys %PACKAGE_SETS )
+    {
+        my $me = MakeEntry::New( *MAKEFILE, "package_set$set", '--Phony' );
+        $me->AddDependancy( @{$PACKAGE_SETS{$set}{LIST}} );
+        $me->Print();
+    }
+}
+#-------------------------------------------------------------------------------
 # Function        : UnPackageRule
+#
 # Description     : Generate rules and recipes to "uninstall" and "unpackage" files
+#
 # Inputs          : target      - Name of the target

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/makelib.pl2 – Rev 263 → 267