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

 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;
+        }
         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;
+        }
             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) );
     $gen_data{'text'}       = $text || $gen_files[0];
     $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
 #                       --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 =~ /^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;
+            }
+        }
         if ($flags & $T_PKG) {
             $dir = __PkgDir( $udir );
         } else {
-            $dir = "\$(LOCALDIR)/$udir";
+            $dir = $base . "/" . $udir;
+        }
+    }
     return ($consumed) if ($dir eq "");
     $dir =~ s~//~/~g;
             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
+            #
             #   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, " .
     #   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
 #-------------------------------------------------------------------------------
 #   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 );
+    #
+        }
+    }
+}
 #-------------------------------------------------------------------------------
+# 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/trunk/TOOLS/makelib.pl2 – Rev 6353 → 6387