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

 require 5.006_001;
 use strict;
 use warnings;
 use Getopt::Long;
 use Data::Dumper;
+use JatsError;
 use JatsEnv;
 use MakeEntry;
 use JatsLocateFiles;
 use JatsDPackage;
+use MakeIf;
 our $ScmVersion             = "2.34";
 our $ScmGlobal              = 0;
 our $ScmExpert              = 0;
 #   Some toolset options that affect the generation of the makefile
+#
 our $UseAbsObjects          = 0;                # Default is relative paths to objects
 our $UseRelativeRoot        = 0;                # Default is absolute paths to build root
+#
+#   Arrays of hook functions
+#
+our %MF_RegisterSrcHooks;                       # Hook source file discovery
 ###############################################################################
+#
 #   Packaging and Installation Information
 #   Held in a structure as its used in a few places
 #   Items
     push( @ScmDepends, "$ScmMakelib" );         # parent
     $file = Require( "$::GBE_CONFIG", "Rules", "Common rules " );
     push( @ScmDepends, "$file" );
-    require "$::GBE_TOOLS/makeif.pl";           # plug-in interface
-    push( @ScmDepends, "$::GBE_TOOLS/makeif.pl" );
 #.. Platform (defines ScmToolset)
+#
     if ( defined( %::ScmBuildProducts ) &&      # interface/build.cfg
             $::ScmBuildProducts{ $ScmPlatform } )
+    {
             require $file;
+        }
+    }
+    #
+    #   Include local toolset extensions
+    #   These are rooted in the build directory and are not to be confused with
+    #   extensions that may be packaged
+    #
+    my $local_base_dir = "$ScmRoot/gbe/DIRECTIVES";
+    if ( -d $local_base_dir )
+    {
+        foreach my $file  ( glob ("$local_base_dir/*.pm") )
+        {
+            push( @ScmDepends, "$file" );
+            require $file;
+        }
+    }
+    #
     #   All makefile.pl's will include a makefile.pl found in the build
     #   root directory ( The same directory as build.pl ). This makefile.pl
     #   is a little bit different - It should not "require "$ARGV[1]", nor
     #   should it use a Platform directive.
+    #
     Debug2( "PlatformDefine(@_)" );
     $script = Exists( "PLATFORM", $script,      # locate image
                 "PlatformDefines", @ScmPlatformDirs );
+    push( @DEFINES, "# PlatformDefines from: $script" );
     open( SCRIPT, $script ) || Error( "Opening $script" );
     while (<SCRIPT>) {
         $_ =~ s/\s*(\n|$)//;                    # kill trailing whitespace & nl
         push( @DEFINES, $_ );
+    }
     my( $line );
     Debug2( "ToolsetRules(@_)" );
     $script = Exists( "$::GBE_CONFIG/TOOLSET", $script, "ToolsetRules" );
+    push( @TOOLSETRULES, "# ToolsetRules from: $script" );
     open( SCRIPT, $script ) || Error( "Opening $script" );
     while (<SCRIPT>) {
         $_ =~ s/\s*(\n|$)//;                    # kill trailing whitespace & newline
         push( @TOOLSETRULES, $_ );
+    }
 #                   False       - File is not a 'known' source file
+#
 sub __AddSourceFile
+{
     my( $push, $path, $obj, $type ) = @_;
-    my( $file, $ext, $srcfile, $is_obj, $ext_type, $result );
+    my( $filename, $ext, $srcfile, $is_obj, $ext_type, $result );
-    $file = StripExt($path);                    # file name
+    $filename = StripDir($path);                # file name
     $ext  = StripFile($path);                   # extension
     $ext = lc($ext)
         if ( $::ScmHost ne "Unix" );
-    if (! ($srcfile = $SRCS{ $path })) {
+    if (! ($srcfile = $SRCS{$filename})) {
         $srcfile = $path;                       # generated
+    }
-    $obj  = StripDir( $file )                   # Base name of object file
+    $obj  = StripExt( $filename )               # Base name of object file
         if ( ! defined($obj) || $obj eq "" );
     $type = ""                                  # optional type
         if ( ! defined( $type ) );
             use strict 'refs';
+        }
+    }
+    #
+    #   See if there is a hook function for this type of source file
+    #   Invoke user function to perform additional processing on the file
+    #
+    if ( %MF_RegisterSrcHooks )
+    {
+        my @listeners;
+        push @listeners, @{$MF_RegisterSrcHooks{$ext}} if ( exists $MF_RegisterSrcHooks{$ext} );
+        push @listeners, @{$MF_RegisterSrcHooks{'*'}}  if ( exists $MF_RegisterSrcHooks{'*'} );
+        while ( @listeners )
+        {
+            Debug( "RegisterSrcHook: Invoke SrcHook function" );
+            my ($fname, @args) = @{shift @listeners};
+            &$fname ( $srcfile ,$filename, $obj, $ext ,@args );
+        }
+    }
+    #
     #   Object files are saved in
     #       OBJSOURCE   - Generate a recipe to create the object
     #       OBJS        - A list of ALL non-shared object files
+    #
     if ( $is_obj && $::o )
     my( $line );
     Debug2( "Defines($path, $script)" );
     $script = Exists( $path, $script, "Defines" );
+    push( @DEFINES, "# Defines from: $script" );
     open( SCRIPT, $script ) || Error( "Opening $script" );
     while (<SCRIPT>) {
         $_ =~ s/\s*(\n|$)//;                    # kill trailing whitespace & nl
         push( @DEFINES, $_ );
+    }
     push( @ScmDepends, "$script" );             # makefile dependencies
     close( SCRIPT );
+}
+#-------------------------------------------------------------------------------
+# Function        : Rule
+#
+# Description     : Add a Rule and Recipe to the generated makefile
+#                   This is not encouraged as it has been misused to create
+#                   unreadable and unmaintainable makefiles.
+#
+#                   Rules will be added to the makefile after the rules and
+#                   recipes created by JATS directives
+#
+# Inputs          : $platform               - Platform predicate
+#                   @rule                   - Array of rules to add
+#
+# Returns         :
+#
 sub Rule
+{
     my( $platforms, @rule ) = @_;
     return if ( ! ActivePlatform($platforms) );
     push( @RULES, @rule );
     Message("Rule directive used. Consider replacing with GenerateFiles");
+}
+#-------------------------------------------------------------------------------
+# Function        : Rules
+#
+# Description     : Add a file of Rules and Recipes to the generated makefile
+#                   Used internally ONLY as there is no platform predicate
+#                   Similar to 'Rule()'
+#
+# Inputs          : $path                   - path to script
+#                   $script                 - File fo Rules
+#
+# Returns         :
+#
 sub Rules
+{
     my( $path, $script ) = @_;
     my( $line );
     $script = Exists( $path, $script, "Rules" );
+    push( @RULES, "# Rules from: $script" );
     open( SCRIPT, $script ) || Error( "Opening $script" );
     while (<SCRIPT>) {
         $_ =~ s/\s*(\n|$)//;                    # kill trailing whitespace & nl
         push( @RULES, $_ );
+    }
     push( @ScmDepends, "$script" );             # makefile dependencies
     close( SCRIPT );
+}
+#-------------------------------------------------------------------------------
+# Function        : AddRule
+#
+# Description     : Inernal function
+#                   Add a line to the Rules area
+#
+# Inputs          : @elements                   - Array of lines to add
+#
+# Returns         : Nothing
+#
+sub AddRule
+{
+    push( @RULES, @_ );
+}
+#-------------------------------------------------------------------------------
+# Function        : Src
+#
+# Description     : This directive is used to identify files to JATS
+#                   Once a file has been identified as a 'Source' file, then it
+#                   can be used by name, without the need to locate the file again.
+#                   This implies that filenames must be unique.
+#                   The directories cannot be used to make files of the same name
+#                   unqiue - this is not the JATS way
+#
+#                   Source files will be classified as one of:
+#                       c, c++, header, assembler or other
+#
+#
+# Inputs          : $platform               - Active Platform Predicate
+#                   @elements               - A list of files and options
+#
+#                   Valid options are:
+#                       --c                 - Specifies the type of file
+#                       --cpp
+#                       --h, --headers
+#                       --asm
+#                       --FromPackage       - Search packages for the file
+#                       --List=xxx          - Append file to a named list
+#                       --Depends=xxx       - Manually name a dependency
+#
+#                   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( @depends, @srcs );
 #                       --Defined=SomeValue
+#
 #                   Each can be prefxied with a '!' to negate the test
+#
 #                   Valid options are:
-#                       --Target        - indicates that the plaform is a 'target'
+#                       --Target        - indicates that the platform is a 'target'
+#
 # Returns         : TRUE if the platform spec is satisfied
+#
 sub ActivePlatform
+{
+   #
    push @MF_Generators, \@_;
+}
 #-------------------------------------------------------------------------------
+# Function        : RegisterSrcHook
+#
+# Description     : Register a function to be called when a source file is
+#                   declared
+#
+# Inputs          : $ext        - Extension of interest
+#                                 '*' will be used by all
+#                   $fname      - Name of the function
+#                   $args       - Function Arguments
+#
+# Returns         : Nothing
+#
+sub RegisterSrcHook
+{
+    my $ext = shift;
+    my ($fref) = @_;
+    my $rtype = ref($fref) || 'not a reference';
+    Error ("RegisterSrcHook called incorrectly",
+           "Second argument MUST be a code reference",
+           "It is a $rtype"
+           ) unless ( $rtype eq 'CODE' );
+    #
+    #    Save the arguments by reference in an array
+    #    The array will be processed later
+    #
+    push @{$MF_RegisterSrcHooks{$ext}}, \@_;
+}
+#-------------------------------------------------------------------------------
 # Function        : MakefileHeader
+#
 # Description:    : Generate a "standard" makefile header.
+#
 #..
                  "Dir: $::Cwd");
         return;
+    }
     $MakefileGenerate_once = 1;
+    #
     #   Invoke all registered Makefile Generator functions
     #   These allow clever directives to collect information to be
     #   processed before the makefiles are created
+    #
         MakePrint( "#---- (${i})\n\n" );
         if ( $ScmToolsetProgDependancies )
+        {
+            #
             #   Original style Prog Interface
-            #   Write some depnedency information here and some in the toolset
+            #   Write some dependency information here and some in the toolset
+            #   Problems:
+            #       1) Errors in library dependency generation will be
+            #          reported after all the object files have been created
+            #          Thus the error message and the make-stop are seperated
+            #          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 );
+        }
         else
+        {

Subversion Repositories DevTools

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