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

 our @TOOLSETOBJS            = ();
 our @TOOLSETLIBS            = ();
 our @TOOLSETPROGS           = ();
 our %INSTALL_HDRS           = ();
 our %INSTALL_CLSS           = ();
+our @CLOBBERFILES           = ();
+our @CLOBBERDIRS            = ();
 our @TOOLSET_UTF_PRE        = ();       # Toolsets can extend rules run before all unit tests
 our @TOOLSET_UTF_POST       = ();       # Toolsets can extend rules run after all unit tests
 our @TOOLSET_UTF_COLLATE    = ();       # Toolsets can extend rules run to collate unit tests results
     Debug2( "ToolsetGenerate(@_)" );
     UniquePush( \@TOOLSETGENERATED, @_ );
+}
+sub ToolsetClobberFile
+{
+    Debug( "ToolsetClobberFile(@_)" );
+    UniquePush( \@CLOBBERFILES, @_ );
+}
+sub ToolsetClobberDir
+{
+    Debug( "ToolsetClobberDir(@_)" );
+    UniquePush( \@CLOBBERDIRS, @_ );
+}
 sub ToolsetObj
+{
     Debug2( "ToolsetObj(@_)" );
+#
 #                       --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
+#
+#                       --UtfFormat=name        - Flags the program as a 'test' to be run in the Test Phase
+#                                                 Intended to support thinks like Gradle that run tests in there own world
+#                                                 Enables support for (Must occur first)
+#                           --AutoUtf           - Non interactive unit test
+#                           --NoAutoUtf         - Interactive unit Test
+#                           --UtfArg=nnn        - Argument passed into the UTF formatter
+#                           --UtfDir=path       - SUbdir in which the Unit Tests will be run
+#
+#
 #               Eg: GenerateFiles ( '*', "--Tool=mod_if.pl",
 #                                        "-src --Prerequisite(udh_module.cfg)",
 #                                        "-direct -hdr --Generated(udp.h) -quiet" );
+#
     my @has_source;
     my @var_opts;
     my @genreq_seen;
     my $predelete;
     my $recipeTag;
+    my $utfAuto;
+    my $utfFormat;
+    my $utfDir;
+    my @utfArgs;
+    my $isaUtf;
+    my $noGenerate;
+    #
     #   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
             #   Delete generated files before running the generation process
             #   Some programs refuse to overwrite existing files
+            #
             $predelete = 1;
             next;
-        }
-        if ( $arg =~ /^--NoVarTag$/ )
+        } elsif ( $arg =~ /^--NoVarTag$/ ) {
-        {
+            #
             #   Modify the operation of --Var to supress the tags
             #   Should be used early as will only affect following --Var usage
+            #
             push @var_opts, "--notag";
             next;
-        }
-        if ( $arg =~ /^--NoWarn$/ )
+        } elsif ( $arg =~ /^--NoWarn$/ ) {
-        {
+            #
             #   Supress warnings - No prequisites found
             #   This is acceptable, but normally a tool should take an input
             #   and create some output from it.
+            #
             $no_warn = 1;
             next;
-        }
-        if ( $arg =~ /^--NoGenerate$/ )
+        } elsif ( $arg =~ /^--NoGenerate$/ ) {
-        {
+            #
             #   Tool does generate a definable output
-            #   Should only be used internally
+            #       Should only be used internally
+            #
-            #   Need to create a dummy name for the rule
-            #   Use a base name and a number
+            $noGenerate = 1;
-            #
-            my $dummy_target = 'generate_files_' . $NoGenIndex;
-            UniquePush (\@gen_files, $dummy_target );
-            UniquePush (\@GENERATED, $dummy_target);
             next;
-        }
-        if ( $arg =~ /^--UnknownPreq/ )
+        } elsif ( $arg =~ /^--UnknownPreq/ ) {
-        {
+            #
             #   Indicate that the prequisites are not known, or too complex to
             #   describe. ie: All files in a directory. May be used by packaging
             #   tools.
             #   The recipe will be run EVERY time we want to use the target.
+            #
             $preq_unknown = 1;
             $no_warn = 1;
             next;
-        }
-        if ( $arg =~ /^--AutoGenerate/ )
+        } elsif ( $arg =~ /^--AutoGenerate/ ) {
-        {
+            #
             #   Determine when to run the tool based on the types of files that
             #   are generated. Existance of a source file will force the tool
             #   to be run during the 'generate' phase, othewise the tool will be run
             #   when the generated components are required.
             $gtype = 2;
             Warning ("AutoGenerate MUST occur before options that declare generation of files",
                      "Have seen:", @genreq_seen)
                 if (@genreq_seen);
             next;
-        }
-        if ( $arg =~ /^--Prereq=(.*)/ )
+        } elsif ( $arg =~ /^--Prereq=(.*)/ ) {
-        {
+            #
             #   Specify a prerequisite file, that is not a part of the command line
             #   Simply add the files to the list of preq files
+            #
             my $fn = LocatePreReq ($1);
             UniquePush ( \@preq_files, $fn );
             Debug( "GenerateFiles: ExtraPrereq: $fn" );
             next;
-        }
-        if ( $arg =~ /^--Created(.*)=(.*)/ )
+        } elsif ( $arg =~ /^--Created(.*)=(.*)/ ) {
-        {
+            #
             #   Specify a generated file, that is not a part of the command line
             #   Add the files to the list of generated files
+            #
             my $type = $1;
                     push @has_source, $fn;
+                }
+            }
             Debug( "GenerateFiles: ExtraCreated: $fn" );
             next;
-        }
-        if ( $arg =~ /^--Clean($|=(.*))/ )
+        } elsif ( $arg =~ /^--Clean($|=(.*))/ ) {
-        {
+            #
             #   Detect Clean option
+            #
             $clean_tag = $2 ? $2 : '-clean';
             #   be run during a clean phase. They should not have any prereq
             #   and should not generate any files, so simplify the interface.
+            #
             push @args, '--NoWarn', '--NoGenerate'
                 if ( $shell_cmds );
             next;
-        }
-        if ( $arg =~ /^--Text=(.*)/ )
+        } elsif ( $arg =~ /^--Text=(.*)/ ) {
-        {
+            #
             #   Display this text when executing commands
+            #
             $text = $1;
             next;
-        }
-        if ( $arg =~ /^--RecipeTag=(.*)/ )
+        } elsif ( $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;
+        } elsif ( $arg =~ m/^--AutoUtf$/i) {
+            $utfAuto = 1;
+            $isaUtf = 1;
+            next;
+        } elsif ( $arg =~ m/^--NoAutoUtf$/i ) {
+            $utfAuto = 0;
+            $isaUtf = 1;
+            next;
+        } elsif ( $arg =~ m/^--UtfFormat=(.*)/i) {
+            $utfFormat = $1;
+            $isaUtf = 1;
+            next;
+        } elsif ( $arg =~ m/^--UtfDir=(.*)/i) {
+            $utfDir = $1;
+            $isaUtf = 1;
+            next;
+        } elsif ( $arg =~ m/^--UtfArg=(.*)/i) {
+            push @utfArgs, $1;
+            $isaUtf = 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])
         #           --xxxxx{yyyyyyy}
         #   Save the tool arguments in an array
+        #
         push @tool_args, $arg;
+    }
+    #
     #   Sanity test. Ensure that some file have been marked as generated
     #                Warn if no prerequisites found
+    #
+    ReportError("Mixed use of --NoGenerate and generated files") if (@gen_files && $noGenerate);
     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 );
+    Warning( "No Prerequisite files found in $tool",@tool_args) unless ( $isaUtf || $no_warn || $#preq_files >= 0 );
-    Error  ( "No generated files found in $tool",@tool_args) unless ($#gen_files >= 0);
+#    ReportError  ( "No generated files found in $tool",@tool_args) unless ($isaUtf || $noGenerate || $#gen_files > 0);
+    #
+    #   Sanity test. If a UTF then we shouldn't generate files
+    #
+    if ($isaUtf ) {
+        ReportError('In UTF mode generated files are not supported:', @gen_files) if @gen_files;
+    }
+    #   Invocation does not generate and files
+    #       Need to create a dummy name for the rule
+    #       Use a base name and a number
+    #
+    if ($noGenerate)
+    {
+        my $dummy_target = 'generate_files_' . $NoGenIndex;
+        UniquePush (\@gen_files, $dummy_target );
+        UniquePush (\@GENERATED, $dummy_target) unless $isaUtf;
+    }
+    ErrorDoExit();
+    #
     #   Determine the text to display while generating files
     #   Will be either user-text or the first target file (default)
     #   Suffix with RecipeTag, if provided
     $gen_data{'clean'}      = $clean_tag;
     $gen_data{'text'}       = $text;
     $gen_data{'preq_sus'}   = 1 if ( $preq_unknown );
     $gen_data{'predelete'}  = 1 if ( $predelete );
+    if ($isaUtf)
+    {
+        $gen_data{'isautf'}     = 1;
+        $gen_data{'utfauto'}    = $utfAuto if ( $utfAuto );
+        $gen_data{'utfformat'}  = $utfFormat if ( $utfFormat );
+        $gen_data{'utfdir'}     = $utfDir if ( $utfDir );
+        $gen_data{'utfargs'}    = \@utfArgs;
+        $TESTS_TO_RUN = 1;
+        $TESTS_TO_AUTORUN = 1 if ( $utfAuto );
+    }
     push(@GENERATE_FILES, \%gen_data);
 #DebugDumpData("GenerateFiles", \%gen_data);
     Debug2( "GenerateFiles: cmd: $tool @tool_args" );
+}
 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
+clobber:	unpackage unbuild clobberfiles clobberdirs
 deploy:		install run_deploy
 #--------- Macros --------------------------------------------------------------
 OBJDIR		= \$(GBE_PLATFORM)\$(GBE_TYPE).OBJ
         #   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
+        #       Set EnvVar and then post process with junit
+        #
         if ($pEntry->{'utfformat'})
+        {
             if ($pEntry->{'utfformat'} eq 'gtest') {
                 $pEntry->{'utfformat'} = 'junit';
         push @cmdline, "-dir=$tdir";
         push @cmdline, '-target=$(GBE_PLATFORM)';
         push @cmdline, '-pkgdir=$(PKGDIR)';
         push @cmdline, '-local=$(LOCALDIR)';
         push @cmdline, '-interface=$(INTERFACEDIR)';
-        foreach my $entry (@{$pEntry->{'utfargs' }})
+        push @cmdline, '-rcfile=utf.$${GBE_UTFUID}.rc';
-        {
-            push @cmdline, '-arg=' . $entry;
+        push @cmdline, map { '-arg='. $_ } @{$pEntry->{'utfargs' }};
-        }
+        #
         #   Insert commands to post process the test results according to the specified formatter
+        #
         $me->NewSection     ();
         $me->SectionIfDef   ('UTF_POSTPROCESS');
         $me->RecipePrefix   ('$(XX_PRE)');
-        $me->AddRecipe      ( "\$(GBE_PERL) -Mjats_runutf -e processUtf " . join(" \\\n\t\t\t", @cmdline)  );
+        $me->AddOneRecipe   ( "\$(GBE_PERL) -Mjats_runutf -e processUtf", @cmdline );
         $me->Print();
+        #
 #-------------------------------------------------------------------------------
 #   Generated Files
+#
     MakeHeader ("Generated Files");
     MakePrint ("\n.PHONY: phony_generate\n\n" );
+    my $generateMustAddTestPostProcess;
     foreach my $i ( @GENERATE_FILES )
+    {
         my $gen_tag = $i->{'index'};
+        my $genName = 'generate_' . $gen_tag;
+        my $me = MakeEntry::New( *MAKEFILE );
+        $me->AddComment    ('Generate Files');
+        $me->AddName(@{$i->{'gen'}});
+        #
         #   Generate user-provided recipe names to allow the rule to be called by name.
+        #
         my $recipeTag = $i->{'recipeTag'} || '';
         my $recipeName = '';
             $recipeCleanName = 'clean_' . $recipeTag;
             # for 'jats make help'
             $ScmRecipeTags{$recipeTag} = defined $i->{'clean'} ? 1 : 0;
+            $me->Phony() ;
-            MakePrint( ".PHONY: $recipeName $recipeCleanName\n");
+            $me->AddName($recipeName);
+        }
+        #
         #   If predelete is enabled, then create a list of files to delete
+        #
-        if ( $i->{'predelete'}  )
+        if ( $i->{'predelete'}  ) {
-        {
-            MakeDefEntry( "generate_gen_$gen_tag", "=",  $i->{'gen'} );
+            $me->AddDefn("generate_gen_$gen_tag", join(' ', @{$i->{'gen'}} )  );
-            MakePrint("\n")
+        }
+        my $target = join (' ', @{$i->{'gen'}}, $recipeName);
+        #
+        #   If a UnitTest then insert runtime defs
+        #
+        if ($i->{'isautf'})
+        {
+            my $test_name = $i->{'gen'}[0];
+            $generateMustAddTestPostProcess = 1;
+            push @TESTPROJECT_TO_URUN, $test_name;
+            push @TESTPROJECT_TO_ARUN, $test_name if ($i->{'utfauto'} );
+            $me->AddComment    ('  This is a Unit Test');
+            $me->AddDefn('export GBE_UTFNAME', $test_name );
+            $me->AddDefn('export GBE_UTFUID', 'G$(MAKEFILEUID)' . '_' . $i->{'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)' );
+        }
+        #
         #   Generate the basic generate rule and recipe
         #   together with the prerequisites
+        #
-        MakeEntry ( "", ":", "", " ", @{$i->{'gen'}}, $recipeName );
         unless ( $i->{'clean'} && $i->{'shell'} )
+        {
-            MakeEntry ( "", "", " \\\n\t\t", "", @{$i->{'preq'}} );
+            $me->AddDependancy(@{$i->{'preq'}});
-            MakeEntry ( "", "", " \\\n\t\t", "", "phony_generate" ) if $i->{'preq_sus'};
+            $me->AddDependancy("phony_generate") if $i->{'preq_sus'};
-            MakeEntry ( "", "", " \\\n\t\t", "", "\$(SCM_MAKEFILE)" );
+            $me->AddDependancy("\$(SCM_MAKEFILE)");
+            $me->RecipePrefix   ('$(AA_PRE)');
+            $me->AddRecipe("\$(echo) '[$i->{'text'}] generating..'");
+            $me->RecipePrefix   ('$(XX_PRE)');
+            $me->AddRecipe("\$(call RmFiles,generate_gen_$gen_tag)") if ( $i->{'predelete'}  );
+            if ($i->{'isautf'}) {
+                my $filter = $i->{'utfformat'} || 'internal';
+                my $uargs = join(' ', map { '-arg='. $_ } @{$i->{'utfargs' }});
+                my $tdir = $i->{'utfdir'} || '.';
+                $me->AddShellRecipe (  [
+                                       "PATH=.\\$::ScmPathSep\$(BINDIR_LOCAL_PATH)\\$::ScmPathSep\$\$PATH",
+                                       "\$(call $genName,)"
+                                       ] ,
+                                       'echo $$? > ${INTERFACEDIR}/utf.$${GBE_UTFUID}.rc',
+                                       "\$(call UtfPostProcess,$filter,$tdir,$uargs)" );
-            MakePrint ("\n\t" . "\@\$(echo) '[$i->{'text'}] generating..'" );
-            if ( $i->{'predelete'}  )
-            {
+            } else {
-                MakePrint ("\n\t" . "\$(XX_PRE)\$(call RmFiles,generate_gen_$gen_tag)" );
+                $me->AddRecipe("\$(call $genName,)");
+            }
-            MakePrint ("\n\t" . "\$(XX_PRE)\$(call generate_$gen_tag,)" );
+        }
+        $me->Print();
+        #
         #   Generate 'clean' rules and recipes
+        #
         if ( $i->{'clean'} )
+        {
-            MakePrint ("\n\nPHONY: clean_generate_$gen_tag" );
+            my $me = MakeEntry::New( *MAKEFILE, "clean_$genName", '--Phony' );
-            MakePrint ("\nclean_generate_$gen_tag $recipeCleanName:" );
+            $me->AddName($recipeCleanName) if $recipeCleanName;
+            $me->RecipePrefix('$(XX_PRE)');
-            MakePrint ("\n\t" . "\$(XX_PRE)-\$(call generate_$gen_tag,$i->{'clean'})" );
+            $me->AddRecipe("-\$(call $genName,$i->{'clean'})");
+            $me->Print();
+        }
+        #
         #   Define a function to contain the body of the generation call
         #   The first argument will be a 'clean' argument
+        #
-        MakePrint ("\n\ndefine generate_$gen_tag" );
+        my $md = MakeEntry::New( *MAKEFILE, $genName, '--Define' );
-        if ( $i->{'shell'} )
+        if ( $i->{'shell'} ) {
-        {
-            MakeEntry ("\n\t(" , "\\\n\t)\n", " \\\n\t", ";" , @{$i->{'toolargs'}} );
+            $md->AddShellRecipe( @{$i->{'toolargs'}} );
-        }
-        else
+        } else {
-        {
-            MakeEntry ("\n\t" . $i->{'tool'} . ' $1', "\n", " \\\n\t\t", "" , @{$i->{'toolargs'}} );
+            $md->AddOneRecipe( $i->{'tool'} . ' $1' ,@{$i->{'toolargs'}} );
+        }
+        $md->Print();
+    }
+    if ($generateMustAddTestPostProcess)
+    {
+        #
+        #   Define the UTF post processing
+        #   Define amacro thattakes two arguments
+        #       $1 - name of the filter
+        #       $2 - Directory to process
+        #       $3 - additional arguments
+        #
+        #
+        #   Create the basic command line for 'jats_runutf'
+        #       Use the simplistic 'internal' filter unless the user has provided one
+        #
+        my @cmdline;
+        push @cmdline, '--';
+        push @cmdline, '$(VERBOSE_OPT)';
+        push @cmdline, '-filter=$1';
+        push @cmdline, '-root=$(GBE_ROOT_ABS)' ;
+        push @cmdline, '-dir=$2';
+        push @cmdline, '-target=$(GBE_PLATFORM)';
+        push @cmdline, '-pkgdir=$(PKGDIR)';
+        push @cmdline, '-local=$(LOCALDIR)';
+        push @cmdline, '-interface=$(INTERFACEDIR)';
+        push @cmdline, '-rcfile=${INTERFACEDIR}/utf.$${GBE_UTFUID}.rc';
+        push @cmdline, '$3';
+        #
+        #   Insert commands to post process the test results according to the specified formatter
+        #
+        my $me = MakeEntry::New( *MAKEFILE, 'UtfPostProcess', '--Define' );
+        $me->AddComment    ('Post Process a UNIT TEST');
+        $me->AddComment    ('  arg1 - utffile name');
+        $me->AddComment    ('  arg2 - Directory to start scan for Unit Test Results');
+        $me->AddComment    ('  arg3 - Additional arguments to the filter');
+        $me->SectionIfDef  ('UTF_POSTPROCESS');
+        $me->AddOneRecipe  ("\$(GBE_PERL) -Mjats_runutf -e processUtf", @cmdline );
-        MakePrint ("endef\n\n" );
+        $me->Print();
+    }
 #-------------------------------------------------------------------------------
 #   Toolset Post Processing
 #   Allow the toolset to perform any post processing, before we finally write
 #   out any definitions.
+#
 MakeDefEntry( "TOOLSETOBJS",          "=", \@TOOLSETOBJS )      if ( @TOOLSETOBJS );
 MakeDefEntry( "TOOLSETLIBS",          "=", \@TOOLSETLIBS )      if ( @TOOLSETLIBS );
 MakeDefEntry( "TOOLSETPROGS",         "=", \@TOOLSETPROGS )     if ( @TOOLSETPROGS );
 MakeDefEntry( "TOOLSETDIRS",          "=", \@TOOLSETDIRS )      if ( @TOOLSETDIRS );
 MakeDefEntry( "TOOLSETDIRTREES",      "=", \@TOOLSETDIRTREES )  if ( @TOOLSETDIRTREES );
+MakeDefEntry( "TOOLSETCLOBFILES",      "=", \@CLOBBERFILES )    if ( @CLOBBERFILES );
+MakeDefEntry( "TOOLSETCLOBDIRS",       "=", \@CLOBBERDIRS )      if ( @CLOBBERDIRS );
 #--------- Determine compiler flag groups to use ----------------------------
+#
 #   Allows the compiler options to be controlled for both the debug and
 #   the production builds. Allows control over
 #   Dependencies for 'ungenerate'
+#
 my @ungeneratedep;
 push @ungeneratedep, '$(GENERATEDCLEAN)';
+#
+#   Actions for clobberfiles
+#
+my @clobberfiles;
+push @clobberfiles, RmFilesCmd('TOOLSETCLOBFILES') if (@CLOBBERFILES);
 #-------------------------------------------------------------------------------
 # Function        : PrintPhonyRule
+#
 # Description     : Helper function to print some internal phony makefile targets
 #                   These are used to hold the basic makefile together
 PrintPhonyRule ('make_test',            "make_script @testprogdep" );
 PrintPhonyRule ('unmake_test',          "unmake_script", \@untestprogact );
 PrintPhonyRule ('preprocess_tests',     '$(AUTOUNITTESTS_PRE)' );
 PrintPhonyRule ('postprocess_tests',    '$(AUTOUNITTESTS_POST)' );
 PrintPhonyRule ('collate_test_results', '$(AUTOUNITTESTS_COLLATE)' );
+PrintPhonyRule ('clobberfiles',         "",\@clobberfiles );
 #-------------------------------------------------------------------------------
 #   Package and Installation Summary
+#
     MakeHeader ("Package and Installation Summary");
         MkdirRule( $path, '', '--NoCreate' , '--RemoveAll');
+    }
     MakeHeader ("Subdir deletion");
     RmdirRules();
+    ClobberDirsRule();
     MakeNewLine();
 #--------- Toolset Rules -------------------------------------------------------
     MakeHeader ("Toolset Rules");
     MakePrintList ( \@TOOLSETRULES );
         $txt = '';
+    }
+}
 #-------------------------------------------------------------------------------
+# Function        : ClobberDirsRule
+#
+# Description     : Create the body of a recipe to delete the directories that
+#                   will be removed in a clobber
+#
+#                   Use JatsFileUtil rather than shell script
+#                       Faster under windows (and others)
+#                       Solved long pathname issues
+#                       Simpler to use and control
+#
+# Inputs          : @CLOBBERDIRS
+#
+# Returns         : Nothing.
+#                   Prints to the makefile
+#
+sub ClobberDirsRule
+{
+    MakeNewLine();
+    MakePrint( ".PHONY:\tclobberdirs\n" );
+    MakePrint( "clobberdirs:\n" );
+    #
+    #   Determine the list of directories to delete
+    #   Sort such that subdirs are deleted first
+    #
+    my $txt = 'Removing toolset directories';
+    foreach my $subdir ( reverse sort @CLOBBERDIRS )
+    {
+        my @args = $subdir;
+        MakePrint ("\t-\$(AA_PRE)JatsFileUtil ", QuoteArray( 'T0', $txt, @args ), "\n");
+        $txt = '';
+    }
+}
+#-------------------------------------------------------------------------------
 # Function        : CreateMkdirRules
+#
 # Description     : Create Rules to make dirs at runtime
 #                   This function is called to instantiate those entries
 #                   That have been requested before the makefile has has

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/makelib.pl2 – Rev 6798 → 6898