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

 #  @{G|L}_LIBDIRS       List containing all of library search paths
 #  @LDFLAGS             List containing all of the defined linker flags
 #  @SRCS                List of ALL source files. ie. C/C++ and other (eg .x)
 #                       Key is source file, value is source path
 #  @OBJS                List of ALL (non-shared) object files.
-#  %SHOBJ_LIB           List of ALL shared library object files and there
+#  %SHOBJ_LIB           List of ALL shared library object files and associated library.
-#                       associated library.
 #  %OBJSOURCE           List of ALL object files
 #                       from that should result from later makes.
 #                       Key is objectfile, value is source file
 #  %OBJREFS             List of ALL object files, built options.
 #  @PROGOBJS            List of ALL application object files.
 #  %INSTALL_HDRS        List of headers that are to be installed for later
 #                       "public" consumption.
 #  %INSTALL_CLSS        List of Java classes or JAR files that are to be installed
 #                       for later "public" consumption.
 #  @LIBS                List of libraries that are to be built.
-#  %LIB_OBJS            List of objects that are to be combined to build the
-#                       nominated library.  Key is the library name, the
-#                       value is a string of object files to go into
-#                       the library.  The object files are '$;' separated.
-#  %LIB_ARGS            List of arguments that are to be used when making
-#                       the nominated library.  Key is the library name, the
+#  $LIBS                Ref to a collection of static library descriptors
-#                       value is a string of arguments to apply.  The
-#                       arguments are '$;' separated.
+#                       Indexed by lib name
 #  %INSTALL_LIBS        List of libraries that are to be installed for later
 #                       public consumption.
 #  @MLIBS               List of libraries that are to be built via merging
-#  %MLIB_LIBS           List of objects that are to be combined to build the
-#                       nominated library.  Key is the library name, the
-#                       value is a string of library files to go into
+#  $MLIBS               Ref to a collection of merged lib descriptors
-#                       the library.  The object files are '$;' separated.
 #  @SHLIBS              List of shared libraries that are to be built.
-#  %SHLIB_OBJS          List of objects that are to be combined to build the
-#                       nominated library.  Key is the library name, the
-#                       value is a string of object files to go into
-#                       the library.  The object files are '$;' separated.
-#  %SHLIB_ARGS          List of arguments that are to be used when making
-#                       the nominated library.  Key is the library name, the
+#  $SHLIBS              Ref to collection of shared library information
-#                       value is a string of arguments to apply.  The
-#                       arguments are '$;' separated.
 #  %INSTALL_SHLIBS      List of libraries that are to be installed for later
 #                       public consumption.
 #  @PROGS               List of programs (binary executables) that are
 #                       to be built
-#  %PROG_OBJS           List of objects that are to be combined to build the
-#                       nominated program.  Key is the program name, the
+#  $PROGS               Ref to collection of program information
-#                       value is a string of object files to go into
-#                       the program.  The object files are '$;' separated.
-#  %PROG_LIBS           List of libraries that are to be combined to
-#                       build the nominated program.  Key is the program
-#                       name, the value is a string of library files to
-#                       go into the program.  The library files are '$;'
-#                       separated.
-#  %PROG_ARGS           List of arguments that are to be used when making the
-#                       nominated program.  Key is the program name, the
-#                       value is a string of arguments to apply.  The
-#                       arguments are '$;' separated.
 #  %SCRIPTS             List of scripts to 'create' (key) and whether they
 #                       should be made executable or not (value).  Script
 #                       set to executable is denoted by the value being
 #                       defined AND true.
 #  %INSTALL_PROGS       List of programs for "public" cosumption to install
 use JatsEnv;
 use MakeEntry;
 use JatsLocateFiles;
 use JatsDPackage;
 use MakeIf;
+use ToolsetPrinter;
+use MakeObject;
 our $ScmVersion             = "2.34";
 our $ScmGlobal              = 0;
 our $ScmExpert              = 0;
 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 $ScmToolsetSingleType   = 0;                # Toolset does not support Debug and Production
 our $ScmToolsetProgSource   = ();               # Toolset Program Source
 our $ScmRoot                = "";
 our $ScmMakelib             = "";
 our $ScmPlatform            = "";
 our $ScmMachType            = "";
 our $ScmSrcDir              = "";
 our @ScmPlatformDirs        = ();
 our @ScmPlatformArgs        = ();
+our $ScmBuildType           = 0;                # 0, P, D. 0 == P and D
 our $ScmProduct             = "";
 our $ScmTarget              = "";
 our $ScmTargetHost          = "";
 our $ScmToolset             = "";
 our @ScmToolsetArgs         = ();
 our @INITS                  = ();
 our @DEFINES                = ();
 our @OBJS                   = ();
 our %SHOBJ_LIB              = ();
 our @PROGOBJS               = ();
+our @TESTPROGOBJS           = ();
 our %OBJSOURCE              = ();
 our @CHDRS                  = ();
 our @CSRCS                  = ();
 our @CXXSRCS                = ();
 our @ASHDRS                 = ();
 our @TOOLSETPROGS           = ();
 our %INSTALL_HDRS           = ();
 our %INSTALL_CLSS           = ();
 our @LIBS                   = ();
-our %LIB_OBJS               = ();
-our %LIB_ARGS               = ();
+our $LIBS                   = ();
 our %LIB_PKG                = ();
 our %LIB_INS                = ();
 our %INSTALL_LIBS           = ();
 our @MLIBS                  = ();
-our %MLIB_LIBS              = ();
-our %MLIB_ARGS              = ();
+our $MLIBS                  = ();
 our @SHLIBS                 = ();
+our $SHLIBS                 = ();
 our @SHLIB_TARGETS          = ();
-our %SHLIB_VER              = ();
-our %SHLIB_OBJS             = ();
-our %SHLIB_LIBS             = ();
-our %SHLIB_ARGS             = ();
 our %SHLIB_PKG              = ();
 our %SHLIB_INS              = ();
 our %INSTALL_SHLIBS         = ();
-our %TESTPROGS              = ();
+our $TESTPROGS              = ();
-our %TESTPROG_OBJS          = ();
-our %TESTPROG_LIBS          = ();
-our %TESTPROG_ARGS          = ();
+our @TESTPROGS              = ();
-our %PROGS                  = ();           # Simplify tracking of progs
+our $PROGS                  = ();           # Simplify tracking of progs
 our @PROGS                  = ();
-our @PROGS_EXTRA            = ();
+our @PROGS_EXTRA            = ();           # Look at doing better !!
-our %PROG_OBJS              = ();
-our %PROG_LIBS              = ();
-our %PROG_ARGS              = ();
 our %PROG_PKG               = ();
 our %PROG_INS               = ();
 our %INSTALL_PROGS          = ();
 our %PACKAGE_DIST           = ();
                    "Pbase    : $::Pbase",
                    "BuildName: $::ScmBuildPackage")
                 if ( $::Pbase ne $::ScmBuildPackage );
+        }
+    }
+    #
+    #   Create objects to keep track of Libraies and Programs
+    #
+    $LIBS       = MakeObject::NewType( 'Library',       \@LIBS,     '$(LIBDIR)/', \&GenLibName);
+    $MLIBS      = MakeObject::NewType( 'MergedLibrary', \@MLIBS,    '$(LIBDIR)/', \&GenLibName);
+    $SHLIBS     = MakeObject::NewType( 'SharedLibrary', \@SHLIBS,   '$(LIBDIR)/', \&GenLibName);
+    $PROGS      = MakeObject::NewType( 'Program',       \@PROGS,    '$(BINDIR)/', \&GenProgName);
+    $TESTPROGS  = MakeObject::NewType( 'TestProgram',   \@TESTPROGS,'$(BINDIR)/', \&GenProgName);
+}
+#-------------------------------------------------------------------------------
+# Function        : GenLibName
+#
+# Description     : Helper function to generate a (static) library name
+#                   Used by MakeObject::NewType
+#
+#                   If the toolset doesn't support Debug and Prod, then
+#                   The library name will not have the suffix
+#
+# Inputs          : arg0        - Base name of the library
+#
+# Returns         : Name of the library as used in the makefiles
+#                   Does not include base directory
+#
+sub GenLibName
+{
+    if ( $ScmToolsetSingleType ) {
+        return "$_[0].$::a"
+    } else {
+        return "$_[0]\$(GBE_TYPE).$::a"
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : GenProgName
+#
+# Description     : Helper function to generate a program name
+#                   Used by MakeObject::NewType
+#
+# Inputs          : arg0        - Base name of the library
+#
+# Returns         : Name of the program as used in the makefiles
+#                   Does not include base directory
+#
+sub GenProgName
+{
+    return "$_[0]$::exe"
+}
+#-------------------------------------------------------------------------------
 # Function        : CommandLine
+#
 # Description     : Process the command line.
 #                   Arguments describes below
+#
     Error( "Toolset undefined for platform $ScmPlatform ...")
         unless( $ScmToolset );
 #.. Toolset
+#
-    $file = Require( "$::GBE_TOOLS/LIB", "ToolsetPrinter.pm", "Toolset common components " );
-    push( @ScmDepends, "$file" );
     $file = Require( "$::GBE_CONFIG/TOOLSET", $ScmToolset, "Toolset definition " );
     push( @ScmDepends, "$file" );
 #.. Package definitions
+#
         $ScmProcessingRootMake = 0;
         push( @ScmDepends, "$file" );
+    }
+    #
+    #   Sanity Test for platforms that do not support both debug and production
+    #   builds at the same time. This information is flagged by the toolset
+    #   which we have now loaded.
+    #
+    if ( $ScmToolsetSingleType  )
+    {
+        unless ( $ScmBuildType )
+        {
+            Error ("The toolset used by the \"$ScmPlatform\" platform does not support",
+                   "both Production and Debug Builds" );
+        }
+    }
+    #
     #   Restore global status ...
+    #
     $ScmGlobal = $global;
+}
+#
 #   Add arguments to the ScmPlatformArgs, but remove "Global" arguments
 #       --OnlyDebug
 #       --OnlyProduction
+#
+#   Capture OnlyDebug and OnlyProd information
+#   Will be sanitized by caller.
+#
 sub AddPlatformArg
+{
     Debug("AddPlatformArg: @_" );
+    foreach  ( @_ )
+    {
-    my @args = grep ( !/^--Only((Debug)|(Prod))/, @_ );
+        if ( m~^--OnlyDebug~ ) {
+            $ScmBuildType = 'D';
+        } elsif ( m~--OnlyProd~ ) {
+            $ScmBuildType = 'P';
+        } else {
-    UniquePush( \@::ScmPlatformArgs, @args );
+            UniquePush( \@::ScmPlatformArgs, @_ );
+        }
+    }
     Debug("AddPlatformArg: Result: @::ScmPlatformArgs" );
 ;
+}
+{
     Debug2( "ToolsetLib(@_)" );
     foreach my $lib ( @_ )
+    {
-        UniquePush( \@TOOLSETLIBS, "$lib.$::a" );
+        UniquePush( \@TOOLSETLIBS, GenLibName( $lib ) );
+    }
+}
 sub ToolsetProg
+{
     Debug2( "ToolsetProg(@_)" );
     foreach my $prog ( @_ )
+    {
-        UniquePush( \@TOOLSETPROGS, "$prog$::exe" );
+        UniquePush( \@TOOLSETPROGS, GenProgName( $prog ) );
+    }
+}
 sub ToolsetRule
 #       (binary) is to be made, what libraries and object it is
 #       made from, and any special commands required to perform
 #       the program creation.
+#
 #       @PROGS          Updated list of programs to create
-#       %PROG_OBJS      Updated list of [library-name (key) vs. objects]
-#                       used to generate this program
-#       %PROG_LIBS      Updated list of [library-name (key) vs. libraries]
-#                       used to generate this program
-#       %PROG_PARGS     Updated list of [library-name (key) vs. options]
-#                       used to generate this program
+#
 #   TestProg( 'platform [, ... ]', 'name', ['obj', ... ],
 #               ['-llib', ... ], ['options'] )
 #       This subroutine takes a list that defines which test program
 #       (binary) is to be made, what libraries and object it is
 #       made from, and any special commands required to perform
 #       the program creation.
+#
 #       @TESTPROGS      Updated list of programs to create
-#       %TESTPROG_OBJS  Updated list of [library-name (key) vs. objects]
-#                       used to generate this program
-#       %TESTPROG_LIBS  Updated list of [library-name (key) vs. libraries]
-#                       used to generate this program
-#       %TESTPROG_PARGS Updated list of [library-name (key) vs. options]
-#                       used to generate this program
+#
 #   InstallHdr( 'platform [, ... ]', 'file' [, ...], ['-arg'] )
 #       This subroutine takes the given list of files and adds them
 #       to the install header files list.  Files in this list will be
 #       installed into the 'local header directory' area for public
     return if ( ! ActivePlatform($platforms) );
     foreach my $prog (@progs)
+    {
+        my $pProg = $PROGS->Get($prog);
         Warning( "Duplicate prog ignored '$prog'" )
-            unless ( UniquePush(\@PROGS, $prog) );
+            if ( $pProg );
-        $PROGS{$prog} = 1;
+        $pProg = $PROGS->NewAdd($prog)
+    }
+}
 sub AddSourceType
     } elsif ( $tool =~ /^--Prog=(.*)$/ ) {
+        #
         #   Using a program that has been created within this script
+        #
         my $prog = $1;
-        if ( exists $PROGS{$prog} )
+        if ( my $pProg = $PROGS->Get($prog) )
+        {
-            $tool = "\$(BINDIR)/$prog$::exe"
+            $tool = $pProg->getPath()
                 unless ( $tool = $SRCS{$prog} );
         UniquePush (\@preq_files, $tool);
+        }
         else
+        {
+    }
+    #
     #   Try a PROG
+    #
-    if ( exists $PROGS{$name} )
+    if ( my $pProg = $PROGS->Get($name) )
+    {
-        return "\$(BINDIR)/$name$::exe"
+        return $pProg->getPath();
+    }
+    #
     #   Try searching for the file
     #   Uses Data from AddSrcDir
     $lib = "lib$lib"
        if ( $ScmTargetHost eq "Unix" && $lib !~ m/^lib/);
     Debug( "Lib: $lib" );
+    #
+    #   Create a new object to describe the library
     #   Ensure that only one such lib exists
+    #   Add the library to the list of static libraries
+    #
     Error( "Library of the same name already defined: $lib" )
-        if ( grep /^$lib$/, @LIBS );
+        if ( $LIBS->Get($lib) );
+    $LIBS->NewAdd($lib);
+    #
-    #   Add the library to the list of static libraries
     #   Process arguments
+    #
-    push( @LIBS, $lib );
     push( @LINTLIBS, $lib );
     _LibArgs( $lib, @args );
+}
     Debug( "ShLib: $lib" );
+    #
     #   Ensure that only one such lib exists
+    #
-    Error("Library of the same name already defined: $lib")
+    Error( "Library of the same name already defined: $lib" )
-        if ( grep /^$lib$/, @SHLIBS );
+        if ( $SHLIBS->Get($lib) );
+    $SHLIBS->NewAdd($lib);
+    #
     #   If the user has not specified a --Shared parameter then provide one
+    #
     push @args, "--Shared=Current"
         unless ( grep (/^--Shared/, @args) );
+    #
-    #   Add the library to the list of shared libraries
     #   Process arguments
+    #
-    push( @SHLIBS, $lib );
     push( @LINTSHLIBS, $lib );
     _SharedLibArgs( $lib, @args );
+}
     $lib = "lib$lib"
        if ( $ScmTargetHost eq "Unix" && $lib !~ m/^lib/);
     Debug( "LibArgs: $lib" );
+    #
-    #   Ensure that only one such lib exists
-    #
-    Error("Library name not defined: $lib")
-        unless ( grep /^$lib$/, @LIBS );
-    #
     #   Process the arguments
+    #
     _LibArgs( $lib, @args );
+}
+{
     my( $lib, @elements) = @_;
     my $obj;
+    #
+    #   Ensure that only one such lib exists
+    #
+    my $libp = $LIBS->Get($lib);
+    Error("Library name not defined: $lib")
+        unless ( $libp );
+    #
     #   Process each element
+    #
     foreach (@elements)
+    {
         if ( /^--Shared/ )
+        {
             Debug( "LibArgs: arg $_" );
             #.. Argument specified - add to argument list
+            #
-            HashJoin( \%LIB_ARGS, $;, $lib, "$_" );
+            $libp->addItem('ARGS', $_);
             next;
+        }
         if ( defined %::ScmToolsetProgSource )
+        {
             if ( exists ($::ScmToolsetProgSource{$ext}) )
+            {
                 my $full_path = MakeSrcResolve ( $_ );
                 my $flag = $::ScmToolsetProgSource{$ext};
                 Debug( "LibArgs: src $_" );
-                HashJoin( \%LIB_ARGS, $;, $lib, "$flag$full_path" );
+                $libp->addItem('ARGS', "$flag$full_path" );
                 next;
+            }
+        }
         if ( $::o )
         #.. Add to object list.
         #   Note:   Object path must be explicit as several
         #           toolsets add additional objects.
+        #
-            HashJoin( \%LIB_OBJS, $;, $lib, "\$(OBJDIR)/$obj" );
+            $libp->addItem('OBJS', "\$(OBJDIR)/$obj" );
             next;
+        }
+        #
         #   Don't know how to handle this type of argument
 #.. Fully qualify library path for addition to library list.
     $lib = "lib$lib"
        if ( $ScmTargetHost eq "Unix" && $lib !~ m/^lib/);
     Debug( "ShLibArgs: $lib" );
-    #
-    #   Ensure that only one such lib exists
-    #
-    Error ("Library name not defined: $lib\n")
-        unless ( grep /^$lib$/, @SHLIBS );
     _SharedLibArgs( $lib, @args );
+}
 #-------------------------------------------------------------------------------
 #                   Arguments to process
+#
 sub _SharedLibArgs
+{
     my ( $lib, @elements) = @_;
-    my ( $shared ) = $SHLIB_VER{ $lib };
+    my $libp = $SHLIBS->Get($lib);
+    Error("Library name not defined: $lib")
+        unless ( $libp );
+    #
-    #.. Collect --shared arguments
+    #.. Collect --Shared arguments
+    #
     foreach (@elements)
+    {
+        next unless ( /^--Shared/ );
+        my $shared;
         if ( /^--Shared$/ )
+        {
         #.. Shared library, default library version 1.0
+        #
-            Warning( "multiple --Shared arguments" )
-               if ( $shared );
             $shared = "1.0";
-            Debug( "ShLibArgs: shared $_ ($shared)" );
-            $SHLIB_VER{ $lib } = $shared;
+        }
         elsif ( /^--Shared=Current$/ )
+        {
         #.. Shared library, using 'current' build version
+        #
-            Warning( "multiple --Shared arguments" )
-               if ( $shared );
             $shared = $::ScmBuildVersion;
-            $shared = "1.0"
-               if ($shared eq "");
+            $shared = "1.0" if ($shared eq "");
-            Debug( "ShLibArgs: shared $_ ($shared)" );
-            $SHLIB_VER{ $lib } = $shared;
+        }
         elsif ( /^--Shared=(.*)/ )
+        {
         #.. Shared library, specific version
+        #
             my($M, $m) = LibNameSplit($1);
+            $shared = "$M.$m";
+        }
+        #
+        #   Update the shared Names
+        #
+        if ( defined $shared )
+        {
             Warning( "multiple --Shared arguments" )
-            if ($shared);
-                $shared = "$M.$m";
+                if ($libp->{ VERSION });
             Debug( "ShLibArgs: shared $_ ($shared)" );
-            $SHLIB_VER{ $lib } = $shared;
+            $libp->{ VERSION } = $shared;
+        }
+        else
+        {
+            Error ("ShLibArgs: --Shared argument not understood");
+        }
+    }
 #.. Parse all of the object and argument entries.
+#
     foreach (@elements)
+    {
-        if ( /^--Shared(.*)/ )
+        next if ( /^--Shared(.*)/ );
-        {
-        #.. Preprocessed above
-        #
-            next;
-        }
         if ( /^[-]{1,2}([lL])(.*)/ )
+        {
         #.. Target library specified - add to library list.
+        #
             Debug( "ShLibArgs: lib  -$1$2" );
-            HashJoin( \%SHLIB_LIBS, $;, $lib, "-$1$2" );
+            $libp->addItem('LIBS', "-$1$2" );
             next;
+        }
         if ( /^--if(.*)/ )
+        {
         #.. Library conditional - add to library list.
+        #
             Debug( "ShLibArgs: cond $_" );
-            HashJoin( \%SHLIB_LIBS, $;, $lib, "$_" );
+            $libp->addItem('LIBS', $_);
             next;
+        }
         if ( /^-(.*)/ )
+        {
         #.. Argument specified - add to argument list
+        #
             Debug( "ShLibArgs: arg  $_" );
-            $SHLIB_VER{ $lib } = $shared;
+            $libp->addItem('ARGS', $_);
-            HashJoin( \%SHLIB_ARGS, $;, $lib, "$_" );
             next;
+        }
         if ( defined %::ScmToolsetProgSource )
+        {
             if ( exists ($::ScmToolsetProgSource{$ext}) )
+            {
                 my $full_path = MakeSrcResolve ( $_ );
                 my $flag = $::ScmToolsetProgSource{$ext};
                 Debug( "ShLibArgs: src $_" );
-                HashJoin( \%SHLIB_ARGS, $;, $lib, "$flag$full_path" );
+                $libp->addItem('ARGS', "$flag$full_path");
                 next;
+            }
+        }
         if ( $::o )
         #.. Add to object list.
         #   Note:   Object path must be explicit as several
         #           toolsets add additional objects.
+        #
             $SHOBJ_LIB{ $obj } = $lib;
-            HashJoin( \%SHLIB_OBJS, $;, $lib, "\$(OBJDIR)/$obj" );
+            $libp->addItem('OBJS', "\$(OBJDIR)/$obj");
             next;
+        }
+        #
         #   Don't know how to handle this type of argument
 #.. Fully qualify library path for addition to library list.
     $lib = "lib$lib"
        if ( $ScmTargetHost eq "Unix" && $lib !~ m/^lib/);
     Debug( "MergeLibrary: $lib" );
+    #
+    #   Create a new object to describe the library
+    #   Ensure that only one such lib exists
+    #   Add the library to the list of static libraries
+    #
+    Error( "Merged Library of the same name already defined: $lib" )
+        if ( $MLIBS->Get($lib) );
+    my $libp = $MLIBS->NewAdd($lib);
 #.. Parse all of the object and argument entries.
+#
     foreach (@elements)
+    {
         if ( /^--(.*)/ )
+        {
-            HashJoin( \%MLIB_ARGS, $;, $lib, "$_" );
+            $libp->addItem('ARGS', $_);
+        }
         else
+        {
             my ($llib);
             } else {
                 $llib = $_;
+            }
             Debug( "MergeLibrary: merge $llib" );
-            HashJoin( \%MLIB_LIBS, $;, $lib, $llib );
+            $libp->addItem('LIBS', $llib);
+        }
+    }
-    UniquePush( \@MLIBS, $lib );
+}
 #-------------------------------------------------------------------------------
 # Function        : Script
+#
     #   If not, then may be a script or a TESTPROGS
+    #
     unless ( $framework )
+    {
-        if ( exists $TESTPROGS{$prog} ||  exists $PROGS{$prog} ) {
+        if ( $TESTPROGS->Get($prog) || $PROGS->Get($prog)  ) {
+            #
             #   Append a suitable EXE suffix
+            #
-            $prog .= "$::exe";
+            $prog = GenProgName( $prog );
         } elsif ( exists $SCRIPTS{$prog} ) {
+            #
             #   Script names are raw
             #   Perl script are invoked directly
     return if ( ! ActivePlatform($platforms) );
     Error ("TestProg: Program name not defined") unless ( $prog );
     Error ("Programs are not supported") unless ( defined $::exe );
+    #
-#.. Fully qualify program path for addition to program list
+    #   Create a new Prog object, or retrieve any existing one
+    #
+    my $pProg = $TESTPROGS->Get($prog);
+    $pProg = $TESTPROGS->NewAdd($prog)
-    $TESTPROGS{$prog} = 1;
+        unless ( $pProg );
 #.. Parse all of the object, library and argument entries
     Debug( "TestProg: $prog" );
     foreach (@elements)
+    {
         if ( /^[-]{1,2}([lL])(.*)/ )
+        {
         #.. Target Library specified - add to library list.
+        #
             Debug( "TestProg: lib  -$1$2" );
-            HashJoin( \%TESTPROG_LIBS, $;, $prog, "-$1$2" );
+            $pProg->addItem('LIBS', "-$1$2");
             next;
+        }
         if ( /^--if(.*)/ )
+        {
         #.. Library conditional - add to library list.
+        #
             Debug( "TestProg: cond $_" );
-            HashJoin( \%TESTPROG_LIBS, $;, $prog, "$_" );
+            $pProg->addItem('LIBS', $_);
             next;
+        }
         if ( /^-(.*)/ )
+        {
         #.. Argument specified - add to argument list
+        #
             Debug( "TestProg: arg $_" );
-            HashJoin( \%TESTPROG_ARGS, $;, $prog, "$_" );
+            $pProg->addItem('ARGS', $_);
             next;
+        }
         if ( defined %::ScmToolsetProgSource )
+        {
             if ( exists ($::ScmToolsetProgSource{$ext}) )
+            {
                 my $full_path = MakeSrcResolve ( $_ );
                 my $flag = $::ScmToolsetProgSource{$ext};
                 Debug( "TestProg: src $_" );
-                HashJoin( \%TESTPROG_ARGS, $;, $prog, "$flag$full_path" );
+                $pProg->addItem('ARGS', "$flag$full_path");
                 next;
+            }
+        }
         if ( $::o )
         #.. Object specified - add to object list.
+        #
             my $obj = _LibObject( "", $_ );
         #.. Add to program object list.
-            HashJoin( \%TESTPROG_OBJS, $;, $prog, "\$(OBJDIR)/$obj" );
+            $pProg->addItem('OBJS', "\$(OBJDIR)/$obj");
             next;
+        }
+        #
         #   Don't know how to handle this type of argument
     return if ( ! ActivePlatform($platforms) );
     Error ("Prog: Program name not defined") unless ( $prog );
     Error ("Programs are not supported") unless ( defined $::exe );
+    #
-#.. Fully qualify program path for addition to program list
+    #   Create a new Prog object, or retrieve any existing one
+    #
-    UniquePush( \@PROGS, $prog );
+    my $pProg = $PROGS->Get($prog);
+    $pProg = $PROGS->NewAdd($prog)
-    $PROGS{$prog} = 1;
+        unless ( $pProg );
 #.. Parse all of the object, library and argument entries
     Debug( "Prog: $prog" );
     foreach (@elements)
+    {
         if ( /^[-]{1,2}([lL])(.*)/ )
+        {
         #.. Target Library specified - add to library list.
+        #
             Debug( "Prog: lib  -$1$2" );
-            HashJoin( \%PROG_LIBS, $;, $prog, "-$1$2" );
+            $pProg->addItem('LIBS', "-$1$2");
             next;
+        }
         if ( /^--if(.*)/ )
+        {
         #.. Library conditional - add to library list.
+        #
             Debug( "Prog: cond $_" );
-            HashJoin( \%PROG_LIBS, $;, $prog, "$_" );
+            $pProg->addItem('LIBS', $_);
             next;
+        }
         if ( /^-(.*)/ )
+        {
         #.. Argument specified - add to argument list
+        #
             Debug( "Prog: arg $_" );
-            HashJoin( \%PROG_ARGS, $;, $prog, "$_" );
+            $pProg->addItem('ARGS', $_);
             next;
+        }
         if ( defined %::ScmToolsetProgSource )
+        {
             if ( exists ($::ScmToolsetProgSource{$ext}) )
+            {
                 my $full_path = MakeSrcResolve ( $_ );
                 my $flag = $::ScmToolsetProgSource{$ext};
                 Debug( "Prog: src $_" );
-                HashJoin( \%PROG_ARGS, $;, $prog, "$flag$full_path" );
+                $pProg->addItem('ARGS', "$flag$full_path");
                 next;
+            }
+        }
         if ( $::o )
         #.. Object specified - add to object list.
+        #
             my $obj = _LibObject( "", $_ );
         #.. Add to program object list.
-            push @PROGOBJS, $obj;
-            HashJoin( \%PROG_OBJS, $;, $prog, "\$(OBJDIR)/$obj" );
+            $pProg->addItem('OBJS', "\$(OBJDIR)/$obj");
             next;
+        }
+        #
         #   Don't know how to handle this type of argument
 sub InstallLib
+{
     my( $platforms, @elements ) = @_;
     my( $base, $dir, $package );
     my( $lib, $strip );
+    my $org_lib;
     Debug2( "InstallLib($platforms, @elements)" );
     return if ( ! ActivePlatform($platforms) );
     Warning ("InstallLib: Needs local directory specified in build.pl") unless ( $::ScmLocal );
         my %package_entry;
         if ( ! /^--(.*)/ )
+        {
             $_ = basename ($_)
                 if ( $strip );
+            $org_lib = $_;                      # Original name
             if ( $ScmTargetHost eq "Unix" ) {
                 $lib = "lib$_";                 # Prefix "lib" ....
                 $lib =~ s/^liblib/lib/;         # @LIBS already has lib added
             } else {
                 $lib = $_;
+            }
-            if ( exists $SHLIB_VER { $lib } )
+            if (  my $libp = $SHLIBS->Get($lib) )
+            {
                 Debug( "InstallLib( $dir/$lib\$(GBE_TYPE).$::so, " .
                     "src: \$(LIBDIR)/$lib\$(GBE_TYPE).$::so, dest: $dir)" );
+                #
                 #   The exact format of the name of the shared library is
                 #   toolset specific. Create an entry to allow the toolset
                 #   to extend the packaging information when the shared library
                 #   recipe is constructed.
+                #
-                my $ver = $SHLIB_VER { $lib };
+                my $ver = $libp->{ VERSION };
                 my $name = "$dir/$lib.$ver.PlaceKeeper";
-                push @{$SHLIB_INS{$lib}}, $name;
                 $package_entry{'placekeeper'} = 1;
                 $package_entry{'version'} = $ver;
                 $package_entry{'lib'} = $lib;
                 $package_entry{'dir'} = $dir;
+                push @{$SHLIB_INS{$lib}}, $name;
                 $INSTALL_SHLIBS{$name} = {%package_entry};
+            }
+            #
+            #   Clean up the package_entry
+            #   Insert common items
+            #
+            %package_entry = ();
+            $package_entry{'lib'} = $lib;
+            $package_entry{'dir'} = $dir;
             if ( my $libfile = $SRCS{$lib} )
+            {
+                #
                 #   Allow the user to package a sourced file as a library
+                #   But must be the un-massaged name of the file.
+                #
-                Debug( "InstallLib( $dir/$lib, " .
-                    "src: $libfile, dest: $dir )" );
-                push @{$LIB_INS{$lib}}, "$dir/$lib";
-                $package_entry{'src'} = "$libfile";
+                $package_entry{'dst'} = "$dir/$org_lib";
-                $package_entry{'dir'} = $dir;
+                $package_entry{'src'} = $libfile;
-                $INSTALL_LIBS{ "$dir/$lib" } = {%package_entry};
+            }
-            elsif ( exists $LIB_OBJS { $lib } || ! exists $SHLIB_VER { $lib } )
+            elsif ( $LIBS->Get($lib) )
+            {
+                #
-                Debug( "InstallLib( $dir/$lib\$(GBE_TYPE).$::a, " .
+                #   Install a library known to the makefile
-                    "src: \$(LIBDIR)/$lib\$(GBE_TYPE).$::a, dest: $dir )" );
+                #
-                push @{$LIB_INS{$lib}}, "$dir/$lib\$(GBE_TYPE).$::a";
+                my $libp = $LIBS->Get($lib);
-                $package_entry{'src'} = "\$(LIBDIR)/$lib\$(GBE_TYPE).$::a";
+                $package_entry{'dst'}    = $dir . '/' . $libp->getFullName();
-                $package_entry{'dir'} = $dir;
+                $package_entry{'src'}    = $libp->getPath();
+            }
+            elsif ( ! $SHLIBS->Get($lib) )
+            {
+                #
+                #   Not a known shared lib
+                #   Not a known static lib
+                #   Not a 'sourced' file
+                #   Assume the a static library has magically appeared
+                #   in the standard LIB directory. May have been placed there
+                #   by a 'rule'
+                #
+                my $libp = $LIBS->New($lib);
-                $INSTALL_LIBS{ "$dir/$lib\$(GBE_TYPE).$::a" } = {%package_entry};
+                $package_entry{'dst'}    = $dir . '/' . $libp->getFullName();
+                $package_entry{'src'}    = $libp->getPath();
+            }
+            #
+            #   Add entry to various lists if required
+            #
+            PackageLib_AddEntry ('InstallLib', \%LIB_INS, \%INSTALL_LIBS, \%package_entry )
+                if ( exists $package_entry{'dst'} );
+        }
+    }
 #.. Package
+#
+            #
             #   If the named target is a program then append the correct
             #   extension. Otherwise assume that the target is either a script
             #   or a some other file - and don't append an extension
+            #
-            #   A program may not have any object files, only libraries
-            #
             $ext = $::exe
-                if ( exists $PROGS{$prog} );
+                if ( $PROGS->Get($prog) );
+            #
             #   A "file" that is specified with a "Src" directive may be
             #   installed as though it were a program
+            #
                 $lib =~ s/^liblib/lib/;         # @LIBS already has lib added
             } else {
                 $lib = $_;
+            }
-            if ( exists $SHLIB_VER { $lib } )
+            if (  my $libp = $SHLIBS->Get($lib) )
+            {
                 Debug( "PackageLib( $dir/$lib\$(GBE_TYPE).$::so, " .
                     "src: \$(LIBDIR)/$lib\$(GBE_TYPE).$::so, dest: $dir, dist: $dist, type: $type )" );
+                #
                 #   toolset specific. Create an entry to allow the toolset
                 #   to extend the packaging information when the shared library
                 #   recipe is constructed.
+                #
+                #
-                my $ver = $SHLIB_VER{ $lib };
+                my $ver = $libp->{ VERSION };
                 my $name = "$dir/$lib.$ver.PlaceKeeper";
-                push @{$SHLIB_PKG{$lib}}, $name;
                 $package_entry{'placekeeper'} = 1;
                 $package_entry{'version'} = $ver;
                 $package_entry{'lib'} = $lib;
                 $package_entry{'dir'} = $dir;
                 $package_entry{'set'} = $dist;
                 $package_entry{'type'} = $type if ( $type );
                 $package_entry{'extras'} = {%extras} if ( scalar %extras );
+                push @{$SHLIB_PKG{$lib}}, $name;
                 $PACKAGE_SHLIBS{$name} = {%package_entry};
+            }
+            #
+            #   Clean up the package_entry
+            #   Insert common items
+            #
+            %package_entry = ();
+            $package_entry{'lib'} = $lib;
+            $package_entry{'dir'} = $dir;
+            $package_entry{'set'} = $dist;
+            $package_entry{'extras'} = {%extras} if ( scalar %extras );
+            $package_entry{'type'} = $type if ( $type );
             if ( my $libfile = $SRCS{$org_lib} )
+            {
+                #
                 #   Allow the user to package a sourced file as a library
                 #   But must be the un-massaged name of the file.
+                #
-                Debug( "PackageLib( $dir/$org_lib, " .
-                    "src: $libfile, dest: $dir, dist: $dist, type: $type )" );
-                push @{$LIB_PKG{$lib}}, "$dir/$lib";
-                $package_entry{'src'} = "$libfile";
+                $package_entry{'dst'} = "$dir/$org_lib";
-                $package_entry{'dir'} = $dir;
-                $package_entry{'set'} = $dist;
+                $package_entry{'src'} = $libfile;
-                $package_entry{'extras'} = {%extras} if ( scalar %extras );
-                $package_entry{'type'} = $type if ( $type );
-                $PACKAGE_LIBS{ "$dir/$org_lib" } = {%package_entry};
+            }
-            elsif ( exists $LIB_OBJS { $lib } || ! exists $SHLIB_VER { $lib } )
+            elsif ( $LIBS->Get($lib) )
+            {
-                Debug( "PackageLib( $dir/$lib\$(GBE_TYPE).$::a, " .
+                #
-                    "src: \$(LIBDIR)/$lib\$(GBE_TYPE).$::a, dest: $dir, dist: $dist, type: $type )" );
+                #   Package up a library known to the makefile
+                #
-                push @{$LIB_PKG{$lib}}, "$dir/$lib\$(GBE_TYPE).$::a";
+                my $libp = $LIBS->Get($lib);
-                $package_entry{'src'} = "\$(LIBDIR)/$lib\$(GBE_TYPE).$::a";
+                $package_entry{'dst'}    = $dir . '/' . $libp->getFullName();
-                $package_entry{'dir'} = $dir;
+                $package_entry{'src'}    = $libp->getPath();
+            }
+            elsif ( ! $SHLIBS->Get($lib) )
+            {
+                #
+                #   Not a known shared lib
-                $package_entry{'set'} = $dist;
+                #   Not a known static lib
+                #   Not a 'sourced' file
-                $package_entry{'extras'} = {%extras} if ( scalar %extras );
+                #   Assume the a static library has magically appeared
+                #   in the standard LIB directory. May have been placed there
+                #   by a 'rule'
+                #
-                $package_entry{'type'} = $type if ( $type );
+                my $libp = $LIBS->New($lib);
-                $PACKAGE_LIBS{ "$dir/$lib\$(GBE_TYPE).$::a" } = {%package_entry};
+                $package_entry{'dst'}    = $dir . '/' . $libp->getFullName();
+                $package_entry{'src'}    = $libp->getPath();
+            }
+            #
+            #   Add entry to various lists if required
+            #
+            PackageLib_AddEntry ('PackageLib', \%LIB_PKG, \%PACKAGE_LIBS, \%package_entry )
+                if ( exists $package_entry{'dst'} );
+        }
+    }
+}
+#-------------------------------------------------------------------------------
+# Function        : PackageLib_AddEntry
+#
+# Description     : Helper function to add a package entry
+#                   to the lists
+#
+# Inputs          : $directive          - Directive name
+#                   $pList              - Ref to array list to maintain
+#                   $pHash              - Ref to hash to maintain
+#                   $pData              - Packaging Data
+#                                         Must Take a copy.
+#
+# Returns         :
+#
+sub PackageLib_AddEntry
+{
+    my ($directive, $pList, $pHash, $pData) = @_;
+    my $lib = delete $pData->{'lib'};
+    my $dst = delete $pData->{'dst'};
+    Error ("INTERNAL PackageLib_AddEntry: lib or dst not defined")
+        unless ( $lib && $dst );
+    Debug( "$directive( ",$dst,
+            ", src: " ,$pData->{'src'},
+            ", dest: ",$pData->{'dir'},
+            ", dist: ",$pData->{'set'},
+            ", type: ",$pData->{'type'} || '',
+            " )" );
+    push @{$pList->{$lib }}, $dst;
+    $pHash->{$dst } = {%$pData};
+}
 sub PackageProg
+{
     my( $platforms, @elements ) = @_;
     my( $base, $dir, $dist, $type );
             #   or a some other file - and don't append an extension
+            #
             #   A program may not have any object files, only libraries
+            #
             $ext = $::exe
-                if ( exists $PROGS{$prog} );
+                if ( $PROGS->Get($prog) );
+            #
             #   A "file" that is specified with a "Src" directive may be
             #   installed as though it were a program
+            #
 #                   ie: Add a MAP file to be packaged with a program
+#
 # Inputs          : ref_spkg  - Reference to the hash that contains the package data
 #                   ref_dpkg  - Reference to the target package/install hash
 #                               Normally the same as ref_dpkg, but does allow
-#                               a static librry to be added to a dynamic library
+#                               a static library to be added to a dynamic library
 #                               package.
 #                   ref_list  - Reference to a hash that may contain package keys to process
 #                   prog      - Key for index to above
 #                   file      - A file to be added
 #                   args      - Additional packaging arguments
 #   This is done fairly early to allow the toolsets to extend various
 #   definitions that may be used later in the makefile construction
+#
     MakeHeader ("Construct Programs");
-    sub argsplit
-    {
-        my ($ref) = @_;
-        my (@ret) = ();
-        @ret = split( /$;/, $ref )              # split, only if defined
-            if ( defined($ref) );
-        return @ret;
-    }
     foreach my $i ( @PROGS )
+    {
-        my( @args, @objects, @libs, $l );
+        my $pProg = $PROGS->Get($i);
-        @args    = argsplit( $PROG_ARGS{ $i } );
+        my $pArgs = $pProg->getItems('ARGS');
-        @objects = argsplit( $PROG_OBJS{ $i } );
+        my $pObjs = $pProg->getItems('OBJS');
-        @libs    = argsplit( $PROG_LIBS{ $i } );
+        my $pLibs = $pProg->getItems('LIBS');
+        #
+        #   Create a list of program object files
+        #
+        push @PROGOBJS, @$pObjs;
         MakePrint( "#---- (${i})\n\n" );
         if ( $ScmToolsetProgDependancies )
+        {
+            #
             #          by many,many lines of output. This makes it difficult
             #          to see the error.
+            #
             #       2) Lack of Flexability
+            #
-            MakeEntry( "\$(BINDIR)/$i$::exe: ", "", "\\\n\t\t", ".$::o ", @objects );
+            MakeEntry( "\$(BINDIR)/$i$::exe: ", "", "\\\n\t\t", ".$::o ", $pObjs );
+        }
         else
+        {
+            #
             #   New Style Prog Interface
             #   The toolset will replace/update it.
+            #
             PackageProgRemoveFiles( $i );
+        }
-        $if->LD( $i, \@args, \@objects, \@libs );
+        $if->LD    ( $i, $pArgs, $pObjs, $pLibs );
-        $if->LDLINT( $i, \@args, \@objects, \@libs );
+        $if->LDLINT( $i, $pArgs, $pObjs, $pLibs );
+    }
 #-------------------------------------------------------------------------------
+#
+#
     MakeHeader ("Construct Test Programs");
-    foreach my $i ( keys %TESTPROGS )
+    foreach my $i ( @TESTPROGS )
+    {
-        my( @args, @objects, @libs, $l );
+        my $pProg = $TESTPROGS->Get($i);
-        @args    = argsplit( $TESTPROG_ARGS{ $i } );
+        my $pArgs = $pProg->getItems('ARGS');
-        @objects = argsplit( $TESTPROG_OBJS{ $i } );
+        my $pObjs = $pProg->getItems('OBJS');
-        @libs    = argsplit( $TESTPROG_LIBS{ $i } );
+        my $pLibs = $pProg->getItems('LIBS');
+        #
+        #   Create a list of program object files
+        #
+        push @TESTPROGOBJS, @$pObjs;
         MakePrint( "#---- (${i})\n\n" );
         if ( $ScmToolsetProgDependancies )
+        {
-            MakeEntry( "\$(BINDIR)/$i$::exe: ", "", "\\\n\t\t", ".$::o ", @objects );
+            MakeEntry( "\$(BINDIR)/$i$::exe: ", "", "\\\n\t\t", ".$::o ", $pObjs );
+        }
         else
+        {
             PackageProgRemoveFiles( $i );
+        }
-        $if->LD( $i, \@args, \@objects, \@libs );
+        $if->LD    ( $i, $pArgs, $pObjs, $pLibs );
-        $if->LDLINT( $i, \@args, \@objects, \@libs );
+        $if->LDLINT( $i, $pArgs, $pObjs, $pLibs );
+    }
 #-------------------------------------------------------------------------------
+#
+#
+#
+#
     MakeHeader ("Construct Libraries");
     foreach my $i ( @LIBS )
+    {
-        my( @args, @objects );
+        my $pLib  = $LIBS->Get($i);
-        @objects = argsplit( $LIB_OBJS{ $i } );
+        my $pArgs = $pLib->getItems('ARGS');
-        @args    = argsplit( $LIB_ARGS{ $i } );
+        my $pObjs = $pLib->getItems('OBJS');
         MakePrint "#---- (${i})\n\n";
-        $if->AR( $i, \@args, \@objects );
+        $if->AR(     $i, $pArgs, $pObjs, $pLib);
-        $if->ARLINT( $i, \@args, \@objects );
+        $if->ARLINT( $i, $pArgs, $pObjs, $pLib );
+    }
+#-------------------------------------------------------------------------------
+#
+#
+    MakeHeader ("Construct Merged Libraries");
     sub MlibEntry
+    {
-        my( $mlib, @libs ) = @_;
+        my( $mlib, $plib, $pLibs ) = @_;
         my @flib;
-        MakePrint "\$(LIBDIR)/$mlib\$(GBE_TYPE).$::a:\t";
+        MakePrint '$(LIBDIR)/' . GenLibName($mlib) . ":";
-        foreach my $lib ( @libs )
+        foreach my $lib ( @$pLibs )
+        {
+            #
+            #   Each library name may contains one embedded option which
+            #   specifies the source directory
+            #       libname[,--Option | BaseSubdir]
+            #
             my ($slib, $sdir) = split( ',', $lib );
+            #
             #   By default the librares are pulled from LOCAL unless the
             #   library is built in this directory, in which case it will
+            #   be used.
+            #
-            #
-            unless ( $sdir )
-            {
-                $sdir = ( exists $LIB_OBJS { $slib } ) ? '--Here' : '--Local';
+            $sdir = ( $LIBS->Get($slib) ) ? '--Here' : '--Local'
-            }
+                unless ( $sdir );
+            #
             #   --Interface     - Pull library from the interface directory
             #   --Local         - Pull library from the local directory
             #   --SubDir=xxxx   - Pull library from specified subdirectory
             } else {
                 $sdir .= '/$(LIBDIR)';
+            }
-            MakePrint "\\\n\t\t${sdir}/${slib}\$(GBE_TYPE).$::a";
+            MakePrint " \\\n\t\t${sdir}/" . GenLibName($slib);
             push @flib, "${sdir}/${slib}";
+        }
-        return @flib;
+        return \@flib;
+    }
     foreach my $i ( @MLIBS )
+    {
+        my $pLib  = $MLIBS->Get($i);
-        my( @args, @libs );
+        my $pArgs = $pLib->getItems('ARGS');
+        my $pLibs = $pLib->getItems('LIBS');
         MakePrint "#---- (${i})\n\n";
-        @libs    = argsplit( $MLIB_LIBS{ $i } );
-        @args    = argsplit( $MLIB_ARGS{ $i } );
         unless ( defined &ToolsetARMerge )
+        {
             Warning( "Merging of libraries not supported in this toolset yet" );
             Warning( "MergeLibrary: \"$i\" will not be created" );
+        }
+            #
             #   Create the dependency rule
             #       Target library : source library list
             #           Recipe - generated by the toolset
+            #
-            foreach ( @args )
+            foreach ( @$pArgs )
+            {
                 Warning( "Ignoring unknown argument to MergeLibrary. $_" );
+            }
-            @libs = MlibEntry( $i, @libs );
+            $pLibs = MlibEntry( $i, $pLib, $pLibs );
-            $if->ARMerge( $i, \@args, \@libs );
+            $if->ARMerge( $i, $pArgs, $pLibs, $pLib );
+        }
+    }
+#-------------------------------------------------------------------------------
+#
+#
+    MakeHeader ("Construct Shared Libraries");
     foreach my $i ( @SHLIBS )
+    {
-        my( @args, @objects, @libs );
+        my $pShlib  = $SHLIBS->Get($i);
-        @args    = argsplit( $SHLIB_ARGS{ $i } );
+        my $pArgs = $pShlib->getItems('ARGS');
-        @objects = argsplit( $SHLIB_OBJS{ $i } );
+        my $pObjs = $pShlib->getItems('OBJS');
-        @libs    = argsplit( $SHLIB_LIBS{ $i } );
+        my $pLibs = $pShlib->getItems('LIBS');
+        my $version = $pShlib->{VERSION};
-        $if->SHLD( $i, \@args, \@objects, \@libs );
+        $if->SHLD    ( $i, $pArgs, $pObjs, $pLibs, $version );
-        $if->SHLDLINT( $i, \@args, \@objects, \@libs );
+        $if->SHLDLINT( $i, $pArgs, $pObjs, $pLibs, $version );
+    }
 #-------------------------------------------------------------------------------
 #   Construct Objects
 #   For each object within OBJSOURCE construct the following:
 MakeDefEntry( "GENERATEDCLEAN",  "=",  CreateNameList( 'clean_generate_', '', ListCleanGenerated() ));
 MakeDefEntry( "INSTALL_HDRS",    "=",  \%INSTALL_HDRS ) if ( %INSTALL_HDRS );
 MakeDefEntry( "INSTALL_CLSS",    "=",  \%INSTALL_CLSS ) if ( %INSTALL_CLSS );
 MakeDefEntry( "OBJS",            "=", CreateNameList( '$(OBJDIR)/', ".$::o", \@OBJS) );
 MakeDefEntry( "SHOBJS",          "=", CreateNameList( '$(OBJDIR)/', ".$::o", \%SHOBJ_LIB ));
-MakeDefEntry( "PROGOBJS",        "=", CreateNameList( '$(OBJDIR)/', ".$::o", \@PROGOBJS ));
+MakeDefEntry( "PROGOBJS",        "=", CreateNameList( '', ".$::o", \@PROGOBJS ));
-MakeDefEntry( "TESTPROGOBJS",    "=", CreateNameList( '$(OBJDIR)/', ".$::o", \%TESTPROG_OBJS ));
+MakeDefEntry( "TESTPROGOBJS",    "=", CreateNameList( '', ".$::o", \@TESTPROGOBJS ));
-MakeDefEntry( "LIBS",            "=", CreateNameList( '$(LIBDIR)/', "\$(GBE_TYPE).$::a", \@LIBS)) if ($::a);
+MakeDefEntry( "LIBS",            "=", $LIBS->AllTargets() ) if ($::a);
-MakeDefEntry( "MLIBS",           "=", CreateNameList( '$(LIBDIR)/', "\$(GBE_TYPE).$::a", \@MLIBS)) if ($::a);
+MakeDefEntry( "MLIBS",           "=", $MLIBS->AllTargets() ) if ($::a);
 MakeDefEntry( "SHNAMES",         "=", \@SHLIBS );
 MakeDefEntry( "SHDIRS",          "=", CreateNameList( '$(OBJDIR)/', "", \@SHLIBS ));
 MakeDefEntry( "SHLIBS",          "=", \@SHLIB_TARGETS );
 MakeDefEntry( "SCRIPTS",         "=", CreateNameList( '$(BINDIR)/', "", \%SCRIPTS ));
 MakeDefEntry( "COPYIN",          "=", \@COPYIN );
-MakeDefEntry( "PROGS",           "=", CreateNameList( '$(BINDIR)/', "$::exe", \@PROGS ));
+MakeDefEntry( "PROGS",           "=", $PROGS->AllTargets() );
 MakeDefEntry( "PROGS_EXTRA",     "=", \@PROGS_EXTRA );
-MakeDefEntry( "TESTPROGS",       "=", CreateNameList( '$(BINDIR)/', "$::exe", \%TESTPROGS ));
+MakeDefEntry( "TESTPROGS",       "=", $TESTPROGS->AllTargets());
 MakeDefEntry( "LINTLIBS",        "=", CreateNameList( 'lib_', '_lint', \@LINTLIBS ));
 MakeDefEntry( "LINTSHLIBS",      "=", CreateNameList( 'shlib_', '_lint', \@LINTSHLIBS ));
 MakeDefEntry( "LINTPROGS",       "=", CreateNameList( 'prog_', '_lint', \@PROGS ));
-MakeDefEntry( "LINTPROGS",      "+=", CreateNameList( 'prog_', '_lint', \%TESTPROGS ));
+MakeDefEntry( "LINTPROGS",      "+=", CreateNameList( 'prog_', '_lint', \@TESTPROGS ));
 MakeDefEntry( "PROJECTS",        "=", CreateNameList( 'Project_', '', ListGeneratedProjects(1) ));
 MakeDefEntry( "PROJECTSGEN",     "=", CreateNameList( 'Project_', '', ListGeneratedProjects(0) ));
 MakeDefEntry( "PROJECTSCLEAN",   "=", CreateNameList( 'ProjectClean_', '', \%PROJECTS ));
 MakeHeader ("Toolset components");
 endif
 EOF
 #-------------------------------------------------------------------------------
-#   Special targets
-#
-MakeHeader ("Special targets",
-            "These targets are not used by JATS",
-            "They can only used when the makefile is used directly",
-            "This is not the intended use of this makefile",
-           );
-print MAKEFILE <<EOF;
-.PHONY:		debug
-debug:
-	@\$(MAKE) -f \$(GBE_PLATFORM).mk DEBUG=1 build
-.PHONY:		prod
-prod:
-	@\$(MAKE) -f \$(GBE_PLATFORM).mk DEBUG=0 build
-EOF
-    #
-    #   It would appear that these targets are not directly available
-    #   They can only be accessed if the makefile is used directly, and this
-    #   is not the intended use
-    #
-    MakePrint("#   PROGS\n");
-    foreach my $i ( @PROGS ) {
-        MakePrint "${i}:\tmake_init \$(BINDIR)/${i}$::exe\n";
-    }
-    MakeNewLine();
-    MakePrint("#   TESTPROGS\n");
-    foreach my $i ( sort keys %TESTPROGS ) {
-        MakePrint "${i}:\tmake_init \$(BINDIR)/${i}$::exe\n";
-    }
-    MakeNewLine();
-    MakePrint("#   PACKAGE_DIST\n");
-    foreach my $i ( sort keys %PACKAGE_DIST ) {
-        my(@sets) = split( /$;/, $PACKAGE_DIST{$i} );
-        MakeEntry( "package-${i}:\tmake_init package_setALL",
-                "\n", " package_set", "", @sets );
-    }
-    MakeNewLine();
-#-------------------------------------------------------------------------------
 #   Standard rules
+#
 MakeHeader ("Standard rules");
     print MAKEFILE <<EOF;
 	"  rmlitter:        remove litter (core, bak, tmp, err and cmd files)\\n"\\
 	"  clean:           delete generate, obj, libraries and programs\\n"\\
 	"  unbuild:         delete everything which can be remade\\n"\\
 	"  clobber:         unbuilds and deletes packages\\n"\\
 EOF
-if ( scalar @PROGS ) {
-    print MAKEFILE <<EOF;
-	"\\n"\\
-	"Application targets:\\n"\\
-	"  @PROGS\\n"\\
-EOF
-}
-if ( %TESTPROGS ) {
-    print MAKEFILE <<EOF;
-	"\\n"\\
-	"Test Application targets:\\n"\\
-EOF
-        MakeEntry( "\t\"   ", "\\n\"\\\n", " ", "", sort keys(%TESTPROGS) );
-}
-if ( %PACKAGE_DIST ) {
-    print MAKEFILE <<EOF;
-	"\\n"\\
-	"Package distributions:\\n"\\
-EOF
-    foreach my $i ( sort keys %PACKAGE_DIST ) {
-        my(@sets) = split( /$;/, $PACKAGE_DIST{$i} );
-        MakeEntry( "\t\"   ${i}, using set(s)", "\\n\"\\\n", " ", "", @sets );
-    }
-}
     print MAKEFILE <<EOF;
 	"\\n"
 make_clean:
 .PHONY:		rmlitter
 rmlitter:
 	-\$(XX_PRE)( echo "Removing litter"; \\
 		\$(touch) _delete.bak _delete.tmp _delete.err ;\\
 		\$(rm) -f core *.bak *.tmp *.err ;\\
-		for subdir in \$(SHDIRS) \$(OBJDIR) ; do \\
+		for subdir in \$(SHDIRS) ; do \\
+			if [ -d \$\$subdir ] ; then \\
+				( cd \$\$subdir ;\\
+				\$(touch) _delete.err _delete.cmd ;\\
+				\$(rm) -r * ; );\\
+			fi ;\\
+		done;\\
+		for subdir in \$(OBJDIR) ; do \\
 			if [ -d \$\$subdir ] ; then \\
 				( cd \$\$subdir ;\\
 				\$(touch) _delete.err _delete.cmd ;\\
 				\$(rm) -r *.err *.cmd ; );\\
 			fi ;\\
+#
 #   Dependencies for 'make_dir'
+#
 my @mkdirdep;
-push @mkdirdep, '$(GBE_OBJDIR)' if ( @CSRCS || @CXXSRCS || @OBJS || %PROG_OBJS || %TESTPROG_OBJS );
+push @mkdirdep, '$(GBE_OBJDIR)' if ( @CSRCS || @CXXSRCS || @OBJS || @PROGOBJS || @TESTPROGOBJS );
 push @mkdirdep, '$(SHDIRS)'     if ( %SHOBJ_LIB || @SHLIBS);
 push @mkdirdep, '$(GBE_LIBDIR)' if ( @LIBS || @MLIBS || @SHLIBS || %INSTALL_LIBS || %PACKAGE_LIBS );
-push @mkdirdep, '$(GBE_BINDIR)' if ( @SHLIBS || %SCRIPTS || @PROGS || %TESTPROGS || %INSTALL_PROGS || %PACKAGE_PROGS );
+push @mkdirdep, '$(GBE_BINDIR)' if ( @SHLIBS || %SCRIPTS || @PROGS || @TESTPROGS || %INSTALL_PROGS || %PACKAGE_PROGS );
+#
 #   Actions for for 'unobj'
+#
 my @unobjact;
 push @unobjact, RmFilesCmd( 'OBJS' )            if ( @OBJS );
 push @unobjact, RmFilesCmd( 'SHOBJS' )          if ( %SHOBJ_LIB );
 push @unobjact, RmFilesCmd( 'PROGOBJS' )        if ( @PROGOBJS );
-push @unobjact, RmFilesCmd( 'TESTPROGOBJS' )    if ( %TESTPROG_OBJS );
+push @unobjact, RmFilesCmd( 'TESTPROGOBJS' )    if ( @TESTPROGOBJS );
 push @unobjact, RmFilesCmd( 'TOOLSETOBJS' )     if ( @TOOLSETOBJS );
+#
 #   Dependencies for 'make_lib'
+#
+#
 #   Dependencies for 'lint_prog'
+#
 my @proglintdep;
-push @proglintdep, 'lint_init', '$(GBE_OBJDIR)', '$(GBE_BINDIR)', '$(LINTPROGS)' if ( @PROGS || %TESTPROGS );
+push @proglintdep, 'lint_init', '$(GBE_OBJDIR)', '$(GBE_BINDIR)', '$(LINTPROGS)' if ( @PROGS || @TESTPROGS );
+#
 #   Actions for 'unmake_prog'
+#
 my @unprogact;
+#
 #   Dependencies for 'lint_prog'
+#
 my @testprogdep;
-push @testprogdep, '$(GBE_OBJDIR)', '$(GBE_BINDIR)', '$(TESTPROGS)' if ( %TESTPROGS );
+push @testprogdep, '$(GBE_OBJDIR)', '$(GBE_BINDIR)', '$(TESTPROGS)' if ( @TESTPROGS );
+#
 #   Dependencies for 'run_tests' and friends
+#
 my @untestprogact;
-push @untestprogact ,RmFilesCmd( 'TESTPROGS' ) if ( %TESTPROGS );
+push @untestprogact ,RmFilesCmd( 'TESTPROGS' ) if ( @TESTPROGS );
+#
 #   Dependencies for 'generated'
+#
 my @generatedep;
+{
     my( $file ) = @_;
     return "\t\$(call UnpackageFile,$file)";
+}
 ;

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/makelib.pl2 – Rev 285 → 289