WebSVN – DevTools – Diff – /core_devl/branches/gitBuilder/TOOLS/makelib.pl2

 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
-our  %ScmGlobalOptions       = ();              # Hash of Global(platform) options. Access via functions
+our %ScmGlobalOptions       = ();               # Hash of Global(platform) options. Access via functions
+our %ScmRecipeTags          = ();               # Hash of exposed recipe names
 our $ScmRoot                = "";
 our $ScmMakelib             = "";
 our $ScmPlatform            = "";
 our $ScmMachType            = "";
 our $SHLIBS                 = ();
 our @SHLIB_TARGETS          = ();
 our %SHLIB_PKG              = ();
 our %SHLIB_INS              = ();
 our %INSTALL_SHLIBS         = ();
+our @INSTALL_DIRS           = ();
 our $TESTPROGS              = ();
 our @TESTPROGS              = ();
 our $PROGS                  = ();           # Simplify tracking of progs
 our %PACKAGE_LIBS           = ();
 our %PACKAGE_CLSS           = ();
 our %PACKAGE_SHLIBS         = ();
 our %PACKAGE_PROGS          = ();
 our %PACKAGE_FILES          = ();
-our @PACKAGE_VARS           = ( '%PACKAGE_CLSS',  '%PACKAGE_FILES', '%PACKAGE_HDRS',
+our @PACKAGE_DIRS           = ();
-                                '%PACKAGE_LIBS',  '%PACKAGE_PROGS', '%PACKAGE_SHLIBS' );
-our @INSTALL_VARS           = ( '%INSTALL_CLSS',  '%INSTALL_HDRS',  '%INSTALL_LIBS',
-                                '%INSTALL_PROGS', '%INSTALL_SHLIBS');
 our @LINTLIBS               = ();
 our @LINTSHLIBS             = ();
 our @TESTS_TO_RUN           = ();                           # Info from 'RunTest' directives
+    #
     #   Include local toolset extensions
     #   These are rooted in the build directory and are not to be confused with
     #   extensions that may be packaged
+    #   Simplify life - add the directory to the BUILDTOOLSPATH
+    #
     my $local_base_dir = "$ScmRoot/gbe/DIRECTIVES";
     if ( -d $local_base_dir )
+    {
+        unshift @::BUILDTOOLSPATH, AbsPath($local_base_dir);
         foreach my $file  ( glob ("$local_base_dir/*.pm") )
+        {
             push( @ScmDepends, "$file" );
             require $file;
+        }
 #                                                 Refer to ExpandGenVar function for details
 #                                                 of Name and available options
 #                                                 The expanded text will be replaced with an
 #                                                 suitable makefile variables that will be
 #                                                 replaced at run-time.
+#
+#                       --Tool(Name,opt)        - Name is the name of a 'tool' found withnin a package
+#                                                 The argument is replaced with the full path of the
+#                                                 tool. opt may be
+#                                                   --dir
+#                                                   --file
+#                                                   --abspath
+#                                                   --absdrive
+#
 #                   The keyword will be replaced with the resolved name. This may be a file,
 #                   a directory or other text.
+#
 #                   Options do not alter command line text. They do affect the way the command is
 #                                                 creation of files.
 #                       --Text=<text>           - Display text for command
+#
 #                       --Clean[=arg]           - Call script with arg[-clean] for cleaning.
 #                       --PreDelete             - Delete generated files before running the command
+#                       --RecipeTag=Name        - Name the recipe
+#                                                 Allows recipe to be called by Name and clean_Name
+#
 #               Eg: GenerateFiles ( '*', "--Tool=mod_if.pl",
 #                                        "-src --Prerequisite(udh_module.cfg)",
 #                                        "-direct -hdr --Generated(udp.h) -quiet" );
+#
 my $NoGenIndex = 0;
+my %recipeTags;
 sub GenerateFiles
+{
+    #
+    #   Remove undfined arguments
+    #   Simplifies programatic construction of argument lists
+    #
-    my ( $platforms, $tool, @args) = @_;
+    my ( $platforms, $tool, @args) = grep defined, @_;
     return if ( ! ActivePlatform($platforms) );
-    Debug2( "GenerateFiles:($platforms, $tool, @args)" );
+    Debug( "GenerateFiles:($platforms, $tool, @args)" );
     my @preq_files;
     my $preq_unknown;
     my @gen_files;
     my $shell_script;
     my $gtype = 1;
     my @has_source;
     my @var_opts;
     my @genreq_seen;
     my $predelete;
+    my $recipeTag;
+    #
     #   Process the first argument - this describes the program that will be used
     #   to generate the files. It may be:
     #       --Tool          - A Jats Tool or Plugin
         if ( $arg =~ /^--NoVarTag$/ )
+        {
+            #
             #   Modify the operation of --Var to supress the tags
-            #   Should be usd early as will only affect following --Var usage
+            #   Should be used early as will only affect following --Var usage
+            #
             push @var_opts, "--notag";
             next;
+        }
             #   Display this text when executing commands
+            #
             $text = $1;
             next;
+        }
+        if ( $arg =~ /^--RecipeTag=(.*)/ )
+        {
+            #
+            #   Tag the generated Recipe
+            #   Only use the last tag - allow users to overwrite system tags
+            #
+            $recipeTag = $1;
+            Error ("Duplicate RecipeTag - $recipeTag") if ($recipeTags{$recipeTag}++ > 1);
+            next;
+        }
         #   Not an option. Must be an argument to the tool/program
         #   Process the tool arguments and extract file information
         #   Extract all fields of the form:
         #           --xxxxx(yyyyyy[,zzzzz])
             my $ufn = $3 || $4 || $5;           # User filename + options
             my $mb = $-[0];                     # Match begin offset
             my $me = $+[0];                     # Match end
             my $flags = '';                     # Optional flags ( --dir or --file )
             my $raw_arg = $ufn;                 # Raw arguments
-            my $all = substr( $arg, $mb, $me ); # All of match. Avoid use of $&
+            my $all = substr( $arg, $mb, $me - $mb ); # All of match. Avoid use of $&
             my $is_path = 1;
             Error ("GenerateFiles. Empty element not allowed: $all")
                 unless ( defined($ufn) );
+            {
                 $fn = GetPackageInfo( "GenerateFiles", $raw_arg );
+            }
             elsif ( $cmd =~ /^Var/ )
+            {
+                # --Var(...)
                 ($fnp, $fn, $is_path) = ExpandGenVar( "GenerateFiles", $raw_arg, @var_opts );
                 $flags = '';
                 if ( $raw_arg eq 'ObjDir' ) {
                     UniquePush (\@preq_files, '$(GBE_OBJDIR)');
                 } elsif ( $raw_arg eq 'BinDir' ) {
                     UniquePush (\@preq_files, '$(GBE_BINDIR)');
                 } elsif ( $raw_arg eq 'LibDir' ) {
                     UniquePush (\@preq_files, '$(GBE_LIBDIR)');
+                }
+            }
+            elsif ( $cmd =~ /^Tool/ ) {
+                # --Tool(toolName)
+                ($fn, $is_path) = ExpandTool( "GenerateFiles", $raw_arg );
+            }
             else
+            {
                 Warning ("GenerateFiles: Unknown replacement command: $cmd");
                 $fn = $ufn;
+            }
     Warning( "GenerateFiles. --AutoGenerate option has no effect",
              "The following files are 'source' files",  @has_source ) if ( @has_source );
     Warning( "No Prerequisite files found in $tool",@tool_args) unless ( $no_warn || $#preq_files >= 0 );
     Error  ( "No generated files found in $tool",@tool_args) unless ($#gen_files >= 0);
+    #
+    #   Determine the text to display while generating files
+    #   Will be either user-text or the first target file (default)
+    #   Suffix with RecipeTag, if provided
+    #
+    my $txtSuffix = '';
+    $txtSuffix = "($recipeTag)" if defined $recipeTag;
+    $text = $gen_files[0] unless defined $text;
+    $text .= $txtSuffix;
+    #
     #   Save information
     #   Will be used to create makefile statements later
+    #
     my %gen_data;
     $gen_data{'index'}      = $NoGenIndex++;
+    $gen_data{'recipeTag'}  = $recipeTag if defined $recipeTag;
     $gen_data{'shell'}      = $shell_cmds;
     $gen_data{'gen'}        = \@gen_files;
     $gen_data{'preq'}       = \@preq_files;
     $gen_data{'tool'}       = $tool;
     $gen_data{'toolargs'}   = \@tool_args;
     $gen_data{'clean'}      = $clean_tag;
-    $gen_data{'text'}       = $text || $gen_files[0];
+    $gen_data{'text'}       = $text;
     $gen_data{'preq_sus'}   = 1 if ( $preq_unknown );
     $gen_data{'predelete'}  = 1 if ( $predelete );
     push(@GENERATE_FILES, \%gen_data);
+#DebugDumpData("GenerateFiles", \%gen_data);
     Debug2( "GenerateFiles: cmd: $tool @tool_args" );
+}
 #-------------------------------------------------------------------------------
 # Function        : MakePerlModule
     return $prefix , $expansion, $is_path ? 1 : 0, $is_abs;
+}
 #-------------------------------------------------------------------------------
+# Function        : ExpandTool
+#
+# Description     : Locate a 'tool' and provide the complete path
+#
+# Inputs          : $dname         - Directive name     (Reporting)
+#                   $arg           - Name of the tool to locate (no extension) with
+#                                    embedded options. Options are:
+#                                       --dir
+#                                       --file
+#                                       --abspath
+#                                       --absdrive
+#
+#
+# Returns         : Path/Value      - Path/Value of the component
+#                   is_path         - Above is a path
+#                   is_abs          - Path is absolute
+#
+sub ExpandTool
+{
+    my ($dname, $args) = @_;
+    my ($toolName, @opts) = split('\s*,\s*', $args);
+    my $is_abs = 1;
+    my $is_path = 1;
+    #
+    #   Locate the tool in one of the dependent packages
+    #
+    my @extension_list;
+    push @extension_list, '.exe' if ( $::ScmHost ne "Unix" );
+    my $toolFullPath =  ToolExtensionProgram( $toolName, @extension_list );
+    if ($toolFullPath) {
+        $toolName = $toolFullPath;
+    } else {
+            Warning("$dname. Tool not found: $toolName", "Searched:", ToolExtensionPaths());
+    }
+    #
+    #   Process options
+    #
+    foreach my $opt ( @opts )
+    {
+        if ( $opt =~ m/^--dir/i ) {
+            $toolName = StripFileExt($toolName);
+        } elsif ( $opt =~ m/^--file/i ) {
+            $toolName = StripDir($toolName);
+            $is_abs = 0;
+            $is_path = 0;
+        } elsif ( $opt =~ m/^--abspath/i ) {
+            $toolName = AbsPath($toolName);
+        } elsif ( $opt =~ m/^--absdrive/i ) {
+            $toolName = FullPath($toolName);
+        } else {
+            Error ("$dname: Unsupported option($opt) for --Tool(@_)");
+        }
+    }
+    Debug ("ExpandTool: $args --> $toolName");
+    return $toolName, $is_path ? 1 : 0, $is_abs;
+}
+#-------------------------------------------------------------------------------
 # Function        : isAnAlias
+#
 # Description     : Internal Helper
 #                   Determine if this platform is an alias for ...
+#
 #                   that also includes the toolset extension
+#
 # Inputs          : program             - Name of program
 #                   elist               - An array of possible program extensions
+#
-# Returns         : Full path the to program or an empty elelent (not undef)
+# Returns         : Full path the to program or an empty element (not undef)
+#
 sub ToolExtensionProgram
+{
     my ($program, @elist ) = @_;
 #                       --h, --headers
 #                       --asm
 #                       --FromPackage       - Search packages for the file
 #                       --List=xxx          - Append file to a named list
 #                       --Depends=xxx       - Manually name a dependency
+#                       --IgnoreDuplicates  - Ignore duplicates (mostly internal use)
+#
 #                   Options are processed before file elements
 #                   Thus options apply to all files in the list
+#
 # Returns         : Nothing
+#
 sub Src
+{
     my( $platforms, @elements ) = @_;
-    my( $type, @args, $source, $basename, $from_package, @lists );
+    my( $type, @args, $source, $basename, $from_package, @lists, $ignoreDups );
     my( @depends, @srcs );
     $platforms = '' unless ( $platforms );
     Debug2( "Src($platforms, @elements)" );
         elsif ( /^--asm$/ )
+        {
             Debug( "Src: --asm" );
             $type = ".asm";
+        }
+        elsif ( /^--IgnoreDup/ )
+        {
+            $ignoreDups = 1;
+        }
         elsif ( /^--FromPackage$/ )
+        {
             $from_package = 1;
+        }
         elsif ( /^--List=(.*)/ )
             $source = MakeSrcResolveExtended( $from_package, $_ );
             $basename = StripDir( $source );
             Debug( "Src: $_ -> $source=$basename (@args),(@depends)" );
             if ( $SRCS{ $basename } ) {
-                Warning( "Duplicate src ignored '$source'");
+                Warning( "Duplicate src ignored '$source'") unless $ignoreDups;
                 next;
+            }
             $SRCS{ $basename } = $source;
             HashJoin( \%SRC_ARGS, $;, $basename, @args )
             __AddSourceFile( 1, $source, "", $type );
+        }
+    }
+}
+#-------------------------------------------------------------------------------
+# Function        : AddToSrc
+#
+# Description     : Internal function
+#                   Used by plugins and tools
+#
+#                   Will test if specified file is known to JATS, before
+#                   adding to the the list of known (Src) files
+#
+# Inputs          : $platform
+#                   $file           - Only one file
+#                   @srcOpts        - Same as Src
+#
+# Returns         : True if any file can be found
+#                   Returns full path to the file
+#
+sub AddToSrc
+{
+    my( $platforms, $file, @args ) = @_;
+    Debug2( "AddToSrc($platforms, $file, @args)" );
+    #
+    #   Process files
+    #
+    my $basename = StripDir( $file );
+    unless (exists $SRCS{$file} || exists  $SRCS{$basename} ) {
+        Src ('*', $file, @args);
+    }
+    return $SRCS{$basename};
+}
 ###############################################################################
 #  sub LibNameSplit
 #      Just a little help to deal with major/minor stuff for shared libs -
 #      given the name of the library as the argument, split out major and minor
             my $ufn = $3 || $4 || $5;           # User filename + options
             my $mb = $-[0];                     # Match begin offset
             my $me = $+[0];                     # Match end
             my $flags = '';                     # Optional flags ( --dir or --file )
             my $raw_arg = $ufn;                 # Raw arguments
-            my $all = substr( $arg, $mb, $me ); # All of match. Avoid use of $&
+            my $all = substr( $arg, $mb, $me - $mb ); # All of match. Avoid use of $&
             my $is_abs;
             my $is_path = 1;
             Error ("RunTest. Empty element not allowed: $all")
                 unless ( defined($ufn) );
             elsif ( $cmd =~ /^Var/ )
+            {
                 ($fnp, $fn, $is_path, $is_abs) = ExpandGenVar( "RunTest", $raw_arg );
                 $flags = '';
+            }
+            elsif ( $cmd =~ /^Tool/ )
+            {
+                ($fn, $is_path, $is_abs) = ExpandTool( "RunTest", $raw_arg );
+                $flags = '';
+            }
             elsif ( $cmd =~ /^Local/ )
+            {
                 $fn = '$(LOCALDIR)/' . $ufn ;
                 UniquePush (\@preq_files, $fn);
+            }
+            elsif ( $cmd =~ /^Dir/ )
+            {
+                # Item is a directory.
+                # Must be massaged so that it will be correct within the context
+                # Modified path is simply added to the command line
+                #
+                $fn = $ufn;
+                unless (-d $fn) {
+                    if (-f $fn) {
+                        Warning ("Not a directory. Its a file: $arg") ;
+                    } else {
+                        Warning ("Directory not found: $arg");
+                    }
+                }
+            }
             else
+            {
                 Warning ("RunTest: Unknown replacement command: $cmd");
                 $fn = $ufn;
+            }
             push @tool_options, $_;
+        }
+    }
+    #
+    #   Validate some of the arguments
+    #   Ensure has not specified both --Prod and --Debug
+    #
+    Error ("Makeproject. Conflicting options --Debug and --Prod" )
+        if ( $PROJECTS{$proj}{'Debug'}  && $PROJECTS{$proj}{'Prod'} );
+    #   Ensure that global --OnlyProd/Debug don't prevent builds
+    $PROJECTS{$proj}{'Debug'} = 1 if ($ScmBuildType eq 'D');
+    $PROJECTS{$proj}{'Prod'} = 1 if ($ScmBuildType eq 'P');
+    Error ("Makeproject. Global and Local options --Debug and --Prod prevent project being built" )
+        if ( $PROJECTS{$proj}{'Debug'}  && $PROJECTS{$proj}{'Prod'} );
+    #
     #   Save the information
+    #
     $PROJECTS{$proj}{'options'} = \@tool_options;
     $PROJECTS{$proj}{'name'} = $proj;
     $PROJECTS{$proj}{'project'} = $project;
     $PROJECTS{$proj}{'basedir'} = $basedir;
     $PROJECTS{$proj}{'unittest'} = $unit_tests if ( $unit_tests );
     $PROJECTS{$proj}{'autotest'} = $auto_tests if ( $auto_tests );
     UniquePush (\@PROJECTS_ORDER, $proj);
-    #
-    #   Validate some of the arguments
-    #
-    Error ("Makeproject. Conflicting options --Debug and --Prod" )
-        if ( $PROJECTS{$proj}{'Debug'}  && $PROJECTS{$proj}{'Prod'} );
+}
 #-------------------------------------------------------------------------------
 # Function        : _PackageFromProject
+#
 #                                          --UnitTest=<name>
 #                                               Supports unit test
 #                                               by calling build target <name>
 #                                          --PackageBase
 #                                               Provides path to base of all packages
+#                                          --AllPackages
+#                                               Provide paths to both LinkPkgArchive and BuildPkgArchive
+#
 # Returns         :
+#
 our %JAR_FILES;
 sub MakeAnt
     my @tool_options;
     my @generated;
     my $unit_tests;
     my $auto_tests;
     my $package_base;
+    my $allPackages;
     foreach ( @elements )
+    {
         if ( m/^--Debug/ ) {
             $PROJECTS{$proj}{'Debug'} = 1;
             $auto_tests = $1
         } elsif ( m/^--PackageBase/ ) {
             $package_base = 1;
+        } elsif ( m/^--AllPackages/i ) {
+            $allPackages = 1;
         } elsif ( m/^--/ ) {
             Error("MakeAnt. Unknown option ignored: $_");
         } else {
+    #
     #   Extend option arguments to include the base dir of packages
     #   Create definitions of the form PACKAGE_<name>
+    #
-    for my $entry (@{$::ScmBuildPkgRules{$ScmPlatform} })
+    for my $entry (getPackageList())
+    {
+        my $pkgType = $entry->getType();
+        next if $pkgType eq 'interface'  ;
-        next unless ( $entry->{'TYPE'} eq 'link' );
+        next unless ( ( $pkgType eq 'link') || $allPackages);
-        my $dir = $entry->{'ROOT'};
+        my $dir = $entry->getBase(2);
-        my $name = $entry->{'NAME'};
+        my $name = $entry->getName();
         unless ( $package_base )
+        {
             $dir .= '/jar';
             next unless ( -d $dir );
+        }
-        push @tool_options, "-DPACKAGE_$name=$dir";
+        push @tool_options, "-DPACKAGE_$name=\$(call myabspath,$dir)";
+    }
+    #
     #   Extend options to include the base dir of the created package
     #   Allows careful use for direct packaging of artifacts
+    #
-    push @tool_options, '-DPACKAGEDIR=$(PWD)/$(PKGDIR)';
+    push @tool_options, '-DPACKAGEDIR=$(call myabspath,$(PKGDIR))';
+    #
     #   Save the information
+    #
     $PROJECTS{$proj}{'options'} = \@tool_options;
+        }
         if ($flags & $T_PKG) {
             $dir = __PkgDir( $udir );
         } else {
-            $dir = "\$(LOCALDIR)/$udir";
+            $dir = $base . "/" . $udir;
+        }
+    }
     return ($consumed) if ($dir eq "");
     $dir =~ s~//~/~g;
     my( $name, $stripCount) = @_;
     if ($stripCount)
+    {
         $name =~ s~\\~/~g;
-        $name =~ s~//~~g;
+        $name =~ s~//~/~g;
         my @items = split('/', $name);
         if ($stripCount > 0)
+        {
             my $len = scalar @items;
             if ( ! exists $PACKAGE_SETS{ $_ }{'TAG'} );
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : PackageDir
+#                   InstallDir
+#
+# Description     : Directive to package an entire directory tree
+#                   Will package the contents of the directory without regard as to there content
+#
+#                   Differs from PackageFile (... --DirTree ) in that the process is dynamic
+#                   It will support the packaging of files that are generated
+#
+#                   NOT intended to support the JATS BIN and LIB structure
+#                   It knows nothing of these types of files
+#
+# Inputs          : platforms   - Active platform list
+#                   Options:    - Many from PackageFile
+#                       --DirTree=xxx   Source Tree [Mandatory]
+#                       --Subdir=yyy    Target [ Mandatory]
+#
+sub PackageDir {
+    return if ( !$ScmPackage );                 # Packaging enabled ?
+    _PackageInstallDir('PackageDir', 'PBase', \@PACKAGE_DIRS, @_);
+    }
+sub InstallDir {
+    Warning ("InstallDir: Needs local directory specified in build.pl") unless ( $::ScmLocal );
+    _PackageInstallDir('InstallDir', 'IBase', \@INSTALL_DIRS, @_);
+    }
+sub _PackageInstallDir
+{
+    my( $cmdName, $tbase, $dirRef, $platforms, @elements ) = @_;
+    my( $base, $dir, $path, $type );
+    my %data;
+    Debug2( "$cmdName($platforms, @elements)" );
+    return if ( ! ActivePlatform($platforms) );
+#.. Arguments
+#
+    $base = $PackageInfo{'File'}{$tbase};           # Base of target
+    $dir = $base . $PackageInfo{'File'}{'Dir'};     # Installation path (default)
+    foreach ( @elements )
+    {
+        my $rv = __TargetDir($T_MACH|$T_GBE|$T_FILE, $base, $_, \$dir, \$type);
+        next if ( $rv == 1 );
+        return if ( $rv == 2 );
+        if (/^--Executable$/) {                  # Mark the file as executable
+            $data{exefile} = "X";
+        } elsif (/^--PreserveSymlink/i) {        # Preserve symlink to local file
+            delete $data{noPreserveSymlink};
+        } elsif (/^--NoPreserveSymlink/i) {      # Preserve symlink to local file
+            $data{noPreserveSymlink} = 1;
+        } elsif ( /^--DirTree=(.*)/ ) {
+            Error("DirTree. Multiple directories not allowed.") if ( $data{dirTree} );
+            $data{dirTree} =  $1;
+        } elsif ( /^--FilterOut=(.*)/ ) {
+            push @{$data{exclude}}, $1;
+        } elsif ( /^--FilterIn=(.*)/ ) {
+            push @{$data{include}}, $1;
+        } elsif ( /^--FilterOutRe=(.*)/ ) {
+            push @{$data{excludeRe}}, $1;
+        } elsif ( /^--FilterInRe=(.*)/ ) {
+            push @{$data{includeRe}}, $1;
+        } elsif ( /^--StripDir/ ) {
+            $data{strip_base} = 1;
+        } elsif ( m/^--Recurse/ ) {
+            delete $data{noRecurse};
+        } elsif ( m/^--NoRecurse/ ) {
+            $data{noRecurse} = 1;
+        } elsif (/^--(.*)/) {
+            Message( "$cmdName: unknown option $_ -- ignored\n" );
+        }
+    }
+    Error("DirTree. No path specified") unless ( defined($data{dirTree}) && $data{dirTree} ne "" );
+    Debug2( "$cmdName. Raw DirTree: $data{dirTree}" );
+    # Prevent the user from escaping from the current directory
+    Error("$cmdName. Absolute paths are not allowed",
+          "Directory: $data{dirTree}") if ( $data{dirTree} =~ m~^/~ || $data{dirTree} =~ m~^.\:~ );
+    #
+    #   Convert the relative path to one that is truely relative to the current
+    #   directory. This may occur when the user uses $ProjectBase
+    #
+    my $abs_dir_tree = AbsPath($data{dirTree});
+    $data{dirTree} = RelPath($abs_dir_tree);
+    #
+    #   Ensure that the user is not trying to escape the package
+    #   Don't allow the user to attempt to package the entire package either
+    #
+    #   Calculate the relative path from $ProjectBase to the target directory
+    #   It must not be above the $ProjectBase
+    #
+    if ( $data{dirTree} =~ m~^\.\.~)
+    {
+        my $dirFromBase = RelPath($abs_dir_tree, AbsPath($ProjectBase));
+        Error("$cmdName. DirTree cannot extend outside current package.",
+              "Directory: $dirFromBase") if ( $dirFromBase =~ m~\.\.~ );
+        Error("$cmdName. DirTree cannot package entire package.",
+            "Directory: $dirFromBase") if ( $dirFromBase eq '.' );
+    }
+    Debug( "$cmdName( $data{dirTree}");
+    $data{dir} = $dir;
+    $data{type} = $type if defined $type;
+    #DebugDumpData("$cmdName", \%data);
+    push @{$dirRef}, \%data;
+}
+#-------------------------------------------------------------------------------
 # Function        : PackageFile
+#
 # Description     : Directive to package files
 #                   Not to be used to package libraries, executables, headers
 #                   as this should be done by specialised directives
             $dist = "$1";
         } elsif (/^--Strip$/) {                 # Strip path from source files
             $strip = -1;
-        } elsif (/^--Strip=(\d+)$/) {                 # Strip path from source files
+        } elsif (/^--Strip=(\d+)$/) {           # Strip path from source files
             $strip = $1;
         } elsif (/^--Executable$/) {            # Mark the file as executable
             $exefile = "X";
         if ($strip_base){
             $strip_base = length( $dir_tree ) if ( $strip_base );
         } elsif ($strip_dots) {
             $strip_base = $strip_dots;
+        }
+    } else {
+        $strip_base = 0;
+    }
 #.. Files
+#
     foreach ( @elements )
+            #
             #   Sanity test the source filename
             #   User may have misused an option
+            #
-            if ( ( $srcfile =~ m/=/ ) || ( $srcfile =~ m/^-/ ) || ( $srcfile =~ m~/-~ )  )
+            if ( !$dir_tree && ( ( $srcfile =~ m/=/ ) || ( $srcfile =~ m/^-/ ) || ( $srcfile =~ m~/-~ ))  )
+            {
                Warning ("PackageFile: Suspect source filename: $srcfile");
+            }
             Debug( "PackageFile( $dir/$name, " .
     if (scalar @found > 1)
+    {
         Warning("Duplicates for '$source'. Using the first", @found);
+    }
-    return $found[0] || "";
+    return $found[0] || $source;
+}
 #-------------------------------------------------------------------------------
 # Function        : MakeSrcResolve
+#
     } elsif ( exists $SRCS{$name} ) {
         $file = $SRCS{$name};
     } else {
-        $file = MakeResolve( \@SRCDIRS, @_ )
+        $file = MakeResolve( \@SRCDIRS, @_ );
+    }
     return $file;
+}
     #   Auto package the 'descpkg' file
     #   If this makefile packages any files, then it can also package the descpkg file
     #   The descpkg will be piggybacked into all makefiles that do a package
+    #
     if ( %PACKAGE_FILES || %PACKAGE_HDRS || %PACKAGE_CLSS || %PACKAGE_LIBS
-                        || %PACKAGE_SHLIBS || %PACKAGE_PROGS )
+                        || %PACKAGE_SHLIBS || %PACKAGE_PROGS || @PACKAGE_DIRS )
+    {
         Src ('*', 'descpkg') unless ($SRCS{ descpkg });
         PackageFile ('*', 'descpkg');
+    }
 		clean unbuild clobber deploy
 default:
 all:		install package deploy
 build:		make_init generate install_hdr depend make_lib \\
-		install_lib make_install_shlib make_prog install_class
+		install_lib make_install_shlib make_prog install_class install_dirs
 install:	build install_prog
-package:	package_files package_hdr package_lib package_shlib package_prog \\
+package:	package_dirs package_files package_hdr package_lib package_shlib \\
-		package_class
+		package_prog package_class
 unpackage:	unpackage_class unpackage_prog unpackage_shlib \\
-		unpackage_lib unpackage_hdr unpackage_files
+		unpackage_lib unpackage_hdr unpackage_files unpackage_dirs
-uninstall:	uninstall_class uninstall_prog uninstall_shlib \\
+uninstall:	uninstall_dirs uninstall_class uninstall_prog uninstall_shlib \\
 		uninstall_lib uninstall_hdr
 clean:		make_clean unmake_prog unmake_test unmake_lib unobj \\
 		undepend ungenerate rmlitter unmake_dir
 unbuild:	clean uninstall
 clobber:	unpackage unbuild
     MakeHeader ("Tool Search Path",
                 "Extend the PATH seen by all the tools to include",
                 "The tools/bin directories discovered in Packages" );
     my $put_PATH;
     my $put_LD_LIBRARY_PATH;
+    MakePrint( "PATH := \$(BINDIR_LOCAL_PATH)$::ScmPathSep\$(PATH)\n" );
+    $put_PATH = 1;
     for my $path ( ToolExtensionPaths() )
+    {
         MakePrint( "PATH := $path$::ScmPathSep\$(PATH)\n" );
         $put_PATH = 1;
         #   Export GBE_UTF... for the duration of the test
+        #
         $me->AddDefn('export GBE_UTFNAME', $pEntry->{'utfname'});
         $me->AddDefn('export GBE_UTFUID', '$(MAKEFILEUID)' . '_' . $pEntry->{'index'});
         $me->AddDefn('export GBE_UTFFILE','$(UTFDIR_PKG)/$(GBE_PLATFORM)-$(GBE_TYPE)-$(GBE_UTFUID)' . '.xml');
+        $me->AddDefn('export GBE_UTFTEST','TEST-$(GBE_UTFNAME)-$(GBE_TYPE)-$(GBE_UTFUID)' );
+        #
+        #   A bit of a kludge for 'googletest'
+        #       If we have another kludge like then then consider placing this work into a module based on the filter name
+        #       with some sort of interface to allow the ENVvars and format and command line args to be massaged
+        #
+        #   For googletest
+        #       Set EnvVar and then prost process with junit
+        #
+        if ($pEntry->{'utfformat'})
+        {
+            if ($pEntry->{'utfformat'} eq 'gtest') {
+                $pEntry->{'utfformat'} = 'junit';
+                $me->AddDefn('export GTEST_OUTPUT ', 'xml:${GBE_UTFTEST}.xml');
+            }
+        }
         # Workaround for dirsep under windows when being wrapped in a timeout
         $me->AddDefn('dirsep', '$(dirsep)$(dirsep)') if ($timeout && ($::ScmHost ne "Unix"));
         $me->AddDependancy( "\$(GBE_$tdir_alias)" );
     MakePrint ("\n.PHONY: phony_generate\n\n" );
     foreach my $i ( @GENERATE_FILES )
+    {
         my $gen_tag = $i->{'index'};
+        #
+        #   Generate user-provided recipe names to allow the rule to be called by name.
+        #
+        my $recipeTag = $i->{'recipeTag'} || '';
+        my $recipeName = '';
+        my $recipeCleanName = '';
+        if ($recipeTag) {
+            $recipeName = $recipeTag;
+            $recipeCleanName = 'clean_' . $recipeTag;
+            # for 'jats make help'
+            $ScmRecipeTags{$recipeTag} = defined $i->{'clean'} ? 1 : 0;
+            MakePrint( ".PHONY: $recipeName $recipeCleanName\n");
+        }
+        #
         #   If predelete is enabled, then create a list of files to delete
+        #
         if ( $i->{'predelete'}  )
+        #
         #   Generate the basic generate rule and recipe
         #   together with the prerequisites
+        #
-        MakeEntry ( "", ":", "", " ", @{$i->{'gen'}} );
+        MakeEntry ( "", ":", "", " ", @{$i->{'gen'}}, $recipeName );
         unless ( $i->{'clean'} && $i->{'shell'} )
+        {
             MakeEntry ( "", "", " \\\n\t\t", "", @{$i->{'preq'}} );
             MakeEntry ( "", "", " \\\n\t\t", "", "phony_generate" ) if $i->{'preq_sus'};
         #   Generate 'clean' rules and recipes
+        #
         if ( $i->{'clean'} )
+        {
             MakePrint ("\n\nPHONY: clean_generate_$gen_tag" );
-            MakePrint ("\nclean_generate_$gen_tag:" );
+            MakePrint ("\nclean_generate_$gen_tag $recipeCleanName:" );
             MakePrint ("\n\t" . "\$(XX_PRE)-\$(call generate_$gen_tag,$i->{'clean'})" );
+        }
+        #
         #   Define a function to contain the body of the generation call
 #-------------------------------------------------------------------------------
 #   Installations
 MakeHeader ("Installations");
-PackageRule ( \&InstallCmd, \%INSTALL_HDRS  );
+PackageRule    ( \&InstallCmd, \%INSTALL_HDRS  );
-PackageRule ( \&InstallCmd, \%INSTALL_CLSS  );
+PackageRule    ( \&InstallCmd, \%INSTALL_CLSS  );
-PackageRule ( \&InstallCmd, \%INSTALL_LIBS  );
+PackageRule    ( \&InstallCmd, \%INSTALL_LIBS  );
-PackageRule ( \&InstallCmd, \%INSTALL_SHLIBS  );
+PackageRule    ( \&InstallCmd, \%INSTALL_SHLIBS  );
-PackageRule ( \&InstallCmd, \%INSTALL_PROGS  );
+PackageRule    ( \&InstallCmd, \%INSTALL_PROGS  );
+PackageDirRule ('install_dirs',    \@INSTALL_DIRS);
 #-------------------------------------------------------------------------------
 #   Packaging
+#
 MakeHeader ("Packaging");
-PackageRule ( \&PackageCmd, \%PACKAGE_FILES );
+PackageRule    ( \&PackageCmd, \%PACKAGE_FILES );
-PackageRule ( \&PackageCmd, \%PACKAGE_HDRS );
+PackageRule    ( \&PackageCmd, \%PACKAGE_HDRS );
-PackageRule ( \&PackageCmd, \%PACKAGE_CLSS );
+PackageRule    ( \&PackageCmd, \%PACKAGE_CLSS );
-PackageRule ( \&PackageCmd, \%PACKAGE_LIBS );
+PackageRule    ( \&PackageCmd, \%PACKAGE_LIBS );
-PackageRule ( \&PackageCmd, \%PACKAGE_SHLIBS );
+PackageRule    ( \&PackageCmd, \%PACKAGE_SHLIBS );
-PackageRule ( \&PackageCmd, \%PACKAGE_PROGS );
+PackageRule    ( \&PackageCmd, \%PACKAGE_PROGS );
+PackageDirRule ('package_dirs', \@PACKAGE_DIRS);
 #-------------------------------------------------------------------------------
 #   Uninstall/unpackaging
+#
 MakeHeader ("Uninstall/unpackaging");
-UnpackageRule( "uninstall_hdr",         \&UninstallCmd, \%INSTALL_HDRS );
+UnpackageRule  ( 'uninstall_hdr',         \&UninstallCmd, \%INSTALL_HDRS );
-UnpackageRule( "uninstall_lib",         \&UninstallCmd, \%INSTALL_LIBS );
+UnpackageRule  ( 'uninstall_lib',         \&UninstallCmd, \%INSTALL_LIBS );
-UnpackageRule( "uninstall_shlib",       \&UninstallCmd, \%INSTALL_SHLIBS );
+UnpackageRule  ( 'uninstall_shlib',       \&UninstallCmd, \%INSTALL_SHLIBS );
-UnpackageRule( "uninstall_prog",        \&UninstallCmd, \%INSTALL_PROGS );
+UnpackageRule  ( 'uninstall_prog',        \&UninstallCmd, \%INSTALL_PROGS );
-UnpackageRule( "uninstall_class",       \&UninstallCmd, \%INSTALL_CLSS );
+UnpackageRule  ( 'uninstall_class',       \&UninstallCmd, \%INSTALL_CLSS );
+PackageDirRule ( 'uninstall_dirs',        \@INSTALL_DIRS);
-UnpackageRule( "unpackage_files",       \&UnpackageCmd, \%PACKAGE_FILES );
+UnpackageRule  ( 'unpackage_files',       \&UnpackageCmd, \%PACKAGE_FILES );
-UnpackageRule( "unpackage_hdr",         \&UnpackageCmd, \%PACKAGE_HDRS );
+UnpackageRule  ( 'unpackage_hdr',         \&UnpackageCmd, \%PACKAGE_HDRS );
-UnpackageRule( "unpackage_lib",         \&UnpackageCmd, \%PACKAGE_LIBS );
+UnpackageRule  ( 'unpackage_lib',         \&UnpackageCmd, \%PACKAGE_LIBS );
-UnpackageRule( "unpackage_shlib",       \&UnpackageCmd, \%PACKAGE_SHLIBS );
+UnpackageRule  ( 'unpackage_shlib',       \&UnpackageCmd, \%PACKAGE_SHLIBS );
-UnpackageRule( "unpackage_prog",        \&UnpackageCmd, \%PACKAGE_PROGS );
+UnpackageRule  ( 'unpackage_prog',        \&UnpackageCmd, \%PACKAGE_PROGS );
-UnpackageRule( "unpackage_class",       \&UnpackageCmd, \%PACKAGE_CLSS );
+UnpackageRule  ( 'unpackage_class',       \&UnpackageCmd, \%PACKAGE_CLSS );
+PackageDirRule ( 'unpackage_dirs',        \@PACKAGE_DIRS);
 #-------------------------------------------------------------------------------
 #   Distribution Sets
+#
 MakeHeader ("Distribution Sets");
     Maketag( "process_tests",       @TOOLSET_UTF_PRE || @TOOLSET_UTF_POST || @TOOLSET_UTF_COLLATE);
     Maketag( "install_hdr",         %INSTALL_HDRS );
     Maketag( "install_class",       %INSTALL_CLSS );
     Maketag( "install_lib",         %INSTALL_LIBS );
     Maketag( "install_prog",        %INSTALL_PROGS );
+    Maketag( "install_dirs",        @INSTALL_DIRS );
     Maketag( "deploy",              %DEPLOYPACKAGE );
     Maketag( "package",             %PACKAGE_FILES || %PACKAGE_HDRS || %PACKAGE_CLSS ||
                                     %PACKAGE_LIBS || %PACKAGE_SHLIBS || %PACKAGE_PROGS );
+    #
 # Description     : Escape/Quote a pathname for make
 #                       Allow files with a $ in the name
 #                       Allow files with a space in the name
 #                       Allow files with a comma in the name
 #                       Allow for paths that have make-varible prefixes
-#                           $(GBE_...) or ${GBE_...} or $(OBJDIR)
+#                           $(GBE_...) or ${GBE_...} or $(OBJDIR) or $(BUILDVERNUM)
 #                           as these may be generated internally
 #                       Allow for files with a colon in the name
 #                           Mode dependent
 #                               0 - No effect
 #                               T - \\\:
+    #
     $uarg =~ m~^((\$\(.*?\)/)*)(.*)~;
     my $prefix = defined $1 ? $1 : '';
     my $arg    = defined $3 ? $3 : '';
-    $arg =~ s~\$(?!\(GBE_[A-Z]+\)|{GBE_[A-Z]+}|\(OBJDIR\))~\$\$~g;       # $, not followed by (GBE_ or ${GBE_ or (OBJDIR)- is not $(GBE_ AND not $(OBJDIR)
+    $arg =~ s~\$(?!\(GBE_[A-Z]+\)|{GBE_[A-Z]+}|\(OBJDIR\)|\(BUILDVERNUM\))~\$\$~g;       # $, not followed by (GBE_ or ${GBE_ or (OBJDIR)- is not $(GBE_ AND not $(OBJDIR)
     $arg =~ s~ ~\\ ~g;
     $arg =~ s~,~\$(comma)~g;
     $arg =~ s~%~\\%~g;
     $arg =~ s~:~\\\\\\:~g if ($mode eq 'T' &&  $::ScmHost eq "Unix");
     $arg =~ s~:~\\:~g     if ($mode eq 'S' &&  $::ScmHost eq "Unix");
+        }
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : PackageDirRule
+#
+# Description     : Generate special rules for dynamic packaging/installation of directories
+#
+# Inputs          : $mode        - package_dirs/unpackage_dirs/install_dirs/uninstall_dirs
+#                   $dataRef     - Ref to package/install list
+#
+#
+# Returns         :
+#
+sub PackageDirRule
+{
+    my ($mode, $dataRef) = @_;
+    my $me = MakeEntry::New( *MAKEFILE, $mode , '--Phony' );
+    my $modeText = 'packaging';
+    my $cmdText = 'PackageDir';
+    if ($mode =~ m~install~) {
+        $modeText = 'installing';
+        $cmdText = 'InstallDir';
+    }
+    my $cmd = 'copyDir';
+    if ($mode =~ m~^un~) {
+        $cmd = 'unCopyDir';
+        $modeText = 'un' . $modeText;
+        $cmdText = 'Un' . $cmdText;
+    }
+    foreach my $entry ( @{$dataRef}) {
+        $me->NewSection();
+        #
+        #   Conditional installation for DEBUG/PRODUCTION
+        #
+        my $type = $entry->{'type'};
+        if ( $type )
+        {
+           if ( $type eq "D" ) {
+               $me->SectionIfNeq('$(DEBUG)','0');
+           } elsif ( $type eq "P" ) {
+               $me->SectionIfEq('$(DEBUG)','0');
+           } else {
+               Error("INTERNAL: Unexpected packaging type: $type");
+           }
+        }
+        #
+        #   Quote the REs so that they can be passed to a command line
+        #       Replace $ with $$
+        #
+        my $QuoteRe = sub {
+            my ($arg) = @_;
+            $arg=~ s~\$~\$\$~g;
+            return $arg;
+            };
+        #
+        #   The body of the copy
+        #   Create a command line for run-time command
+        #
+        my @cmd;
+        push @cmd, '$(JatsRunTime)', $cmd, '--', '-$(VERBOSE_OPT)', '--Name='. $cmdText, '--';
+        push @cmd, '-mode=' . $modeText;
+        push @cmd, "'" . '-src=' . $entry->{dirTree} . "'";
+        push @cmd, "'" . '-dst=' . $entry->{dir} . "'";
+        push (@cmd, '-execute' ) if $entry->{exefile};
+        push (@cmd, '-noSymlink' ) if $entry->{noPreserveSymlink};
+        push (@cmd, '-noRecurse' ) if $entry->{noRecurse};
+        push (@cmd, '-stripBase' ) if $entry->{strip_base};
+        push (@cmd, "'" . '-exclude+=' . $QuoteRe->($_) . "'" ) foreach @{$entry->{exclude}};
+        push (@cmd, "'" . '-include+=' . $QuoteRe->($_) . "'" ) foreach @{$entry->{include}};
+        push (@cmd, "'" . '-excludeRe+=' . $QuoteRe->($_) . "'" ) foreach @{$entry->{excludeRe}};
+        push (@cmd, "'" . '-includeRe+=' . $QuoteRe->($_) . "'" ) foreach @{$entry->{includeRe}};
+        $me->AddRecipe(join(' ', @cmd ) );
+    }
+    $me->Print();
+}
+#-------------------------------------------------------------------------------
 # Function        : PackageSetRules
+#
 # Description     : Generate the packageset rules
 #                   These appear to be a now-defuct feature
+#

Subversion Repositories DevTools

(root)/core_devl/branches/gitBuilder/TOOLS/makelib.pl2 – Rev 7320 → 7322