Subversion Repositories DevTools

########################################################################

# Copyright (C) 2007 ERG Limited, All rights reserved

#

# Module name   : jats.sh

# Module type   : Makefile system

# Compiler(s)   : n/a

# Environment(s): jats

#

# Description   : Top level Makefile supervisor

#                 The function of this program is to call the target makefiles

#                 in a sutable manner.

#

# History       : Once upon a time this was done with another makefile and

#                 some really ugle shell, embedded within the makefile

#                 This had a number of limitations, including

#                   - Limited to makefile command line syntax

#                   - Overly complex makefile

#                   - Slow execution

#

# Usage:

#

#......................................................................#

require 5.6.1;

use strict;

use warnings;

use Pod::Usage;                             # For help support

use JatsError;

use JatsSystem;

use JatsEnv;

use JatsMakeInfo;

use ReadBuildConfig qw(:All);

use Getopt::Long;

use FileUtils;

use ArrayHashUtils;

use JatsDPackage;

my $VERSION = "1.0.0";                      # Update this

#

#   Options

#

my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug

my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose

my $opt_help = 0;

my $opt_manual = 0;

my $opt_silent = 1;

my $opt_default;

#

#   Global variables

#

our %cf_info;

our $GBE_TOOLS;                             # Base of tools

our $GBE_ABT;                               # Optional ABT indication

our $GBE_PLATFORM;                          # Optional GBE_PLATFORM

our $ScmInterface;                          # Current interface directory

our $ScmRoot;                               # Build root

my $Tags;                                   # Reference to hash of tags

my %defs;                                   # Make definitions

my @defs;                                   # Make definitions

my @targets;                                # Make targets

my $makelib;                                # Path to makelib.pl

my $update = 0;                             # Makefiles updated

my $build_error = 0;                        # Build Error encountered

my $tlen = 4;                               # Max length of targets

my %common_cmd;                             # Short circuit some commands

my %gbe_platform;                           # Nice form of GBE_PLATFORM

#

#   Known commands

#   A hash of known commands an information about the commands

#       common      - Command is not executed for Debug and Production

#                     Flags: 1 - Command not executed for debug+prod

#                     Flags: 2 - Command is only executed ONCE per platform

#       local       - The command is handled locally.

#       nomakecheck - Don't check for makefile being out of date

#       IFLAG       - iteration flag,

#                       0   No external dependencies.

#                       1   Source dependency list.

#                       2   Shared library dependency list.

#                       3   Application dependency list.

#   Note:   gmake attempts to build includes prior to invoking other

#   rules when the source is non-existent, which can/do fail as a

#   result of the prereq rules not being executed, the IFLAG inhabits

#   includes during these prereq rules.

#

my %composite_commands = (

    #

    #   Composite commands

    #

    'all'                   => [ 'install', 'package', 'deploy' ] ,

    'install'               => [ 'build' ] ,

    'build'                 => [ 'mkdepends', 'generate', 'install_hdr', 'depend',

                                 'make_lib', 'install_lib', 'make_install_shlib',

                                 'make_prog', 'make_test', 'install_prog', 'install_class' ] ,

    'lint'                  => [ 'mkdepends', 'generate_debug', 'install_hdr_debug',

                                 'lint_lib', 'lint_shlib', 'lint_prog' ] ,

    'ctags'                 => [ 'mkdepends', 'generate_debug', 'ctags_debug' ] ,

    'test'                  => [ 'make_test' ] ,

    'mkdepends'             => [ 'makefiles', 'make_init'] ,

    );

my %commands = (

    #

    #   Basic commands / phases of the build process

    #   This should be a list of all known makefile commands

    #

    'make_usage'            => { 'tag' => 0, 'local' => \&DoHelp },

    'help'                  => { 'tag' => 0, 'local' => \&DoHelp },

    'rebuild'               => { 'tag' => 0, 'local' => \&TestMakeFiles },

    'makefiles'             => { 'tag' => 0, 'local' => \&TestMakeFiles },

    'unmakefiles'           => { 'tag' => 0, 'local' => \&UnMakeFiles },

    'make_init'             => { 'tag' => 1, 'nomakecheck' => 1, 'common' => 3, },

    'make_dir'              => { 'tag' => 1, 'nomakecheck' => 1 },

    'generate'              => { 'tag' => 1 },

    'install_hdr'           => { 'tag' => 1 },

    'depend'                => { 'tag' => 1, 'unless' => 'NODEPEND' },

    'make_lib'              => { 'tag' => 1, 'IFLAG' => 1 },

    'install_lib'           => { 'tag' => 1, 'IFLAG' => 1 },

    'make_install_shlib'    => { 'tag' => 1, 'IFLAG' => 2 },

    'make_prog'             => { 'tag' => 1, 'IFLAG' => 3 },

    'make_test'             => { 'tag' => 1, 'IFLAG' => 3 },

    'install_prog'          => { 'tag' => 1, 'IFLAG' => 3 },

    'install_class'         => { 'tag' => 1 },

    'package'               => { 'tag' => 1, 'IFLAG' => 3 },

    'deploy'                => { 'tag' => 1, 'IFLAG' => 1 },

    #

    #   Basic commands, that appear to be unused in composite commands

    #   Not too sure why

    #

    'make_script'           => { 'commands' => [], 'tag' => 1 },

    #

    #   Lint related targets

    #

    'lint_lib',             => { 'tag' => 'make_lib'            , 'IFLAG' => 1 },

    'lint_shlib',           => { 'tag' => 'make_install_shlib'  , 'IFLAG' => 2 },

    'lint_prog'             => { 'tag' => 'make_prog'           , 'IFLAG' => 3 },

    #

    #   Following commands should NOT be a part of a composite command

    #

    'run_tests'             => { 'nomakecheck' => 1, 'tag' => 1, 'IFLAG' => 3},

    'run_unit_tests'        => { 'nomakecheck' => 1, 'tag' => 1, 'IFLAG' => 3},

    'clean'                 => { 'nomakecheck' => 1},

    'clobber'               => { 'nomakecheck' => 1},

    'rmlitter'              => { 'nomakecheck' => 1},

    'unbuild'               => { 'nomakecheck' => 1},

    'undepend'              => { 'nomakecheck' => 1},

    'ungenerate'            => { 'nomakecheck' => 1},

    'uninstall'             => { 'nomakecheck' => 1},

    'uninstall_class'       => { 'nomakecheck' => 1},

    'uninstall_hdr'         => { 'nomakecheck' => 1},

    'uninstall_lib'         => { 'nomakecheck' => 1},

    'uninstall_prog'        => { 'nomakecheck' => 1},

    'unmake_lib'            => { 'nomakecheck' => 1},

    'unmake_prog'           => { 'nomakecheck' => 1},

    'unmake_script'         => { 'nomakecheck' => 1},

    'unmake_test'           => { 'nomakecheck' => 1},

    'unobj'                 => { 'nomakecheck' => 1},

    'unpackage'             => { 'nomakecheck' => 1},

    'make_undir'            => { 'nomakecheck' => 1},

    );

#    DebugDumpData ("Commands", \%commands);

#-------------------------------------------------------------------------------

# Function        : Mainline Entry Point

#

# Description     :

#

# Inputs          :

#

#

#   Parse the user options

#

my $result = GetOptions (

                "help+"         => \$opt_help,              # flag, multiple use allowed

                "manual"        => \$opt_manual,            # flag, multiple use allowed

                "verbose+"      => \$opt_verbose,           # flag, multiple use allowed

                "d|debug+"      => \$opt_debug,             # flag, multiple use allowed

                "default=s"     => \$opt_default,           # string

                );

                #

                #   UPDATE THE DOCUMENTATION AT THE END OF THIS FILE !!!

                #

#

#   Process help and manual options

#

pod2usage(-verbose => 0, -message => "Version: $VERSION")  if ($opt_help == 1  || ! $result);

pod2usage(-verbose => 1)  if ($opt_help == 2 );

pod2usage(-verbose => 2)  if ($opt_manual || ($opt_help > 2));

#

#   Configure the error reporting process now that we have the user options

#

ErrorConfig( 'name'    => 'Make',

             'verbose' => $opt_verbose,

             'debug'   => $opt_debug );

#

#   Configure the 'System' process so that it will terminate on any error

#   and not report the complete command line

#

SystemConfig ( 'ExitOnError' => 2);

#

#   Extract non-option commands

#   Much of this is for backward compatability

#   Support the following arguments

#       XXXXX=yyyy      Makefile Definition

#       -XXXX           Flags passed to make

#       XXXX            Raw target name

#

foreach my $arg ( @ARGV )

{

    Verbose2 ("Arg: $arg");

    if ( $arg =~ m~(\w+)=(.+)~ ) {

        $defs{uc($1)} = $2;

    } elsif ( $arg =~ m/^-/ ) {

        push @defs, $arg;

    } else {

        push @targets, $arg;

    }

}

#

#   Misc. Initialisation

#

InitFileUtils();

EnvImport( 'GBE_TOOLS' );

$makelib = "$GBE_TOOLS/makelib.pl";

Error ("Cannot locate JATS file: $makelib") unless ( -f $makelib );

EnvImportOptional ( 'GBE_ABT' );

EnvImportOptional ( 'GBE_PLATFORM' );

#

#   Validate user options

#

@targets = ($opt_default)

    if ( $opt_default && ! @targets);

Error ("No make targets specified" ) unless ( @targets );

#

#   Build the @defs array

#   This is a set of definitions passed to the makefiles

#   It is created on the fly to allow command line options to modify the definitions

#

foreach  ( sort keys %defs )

{

    next if ( m~^DEBUG$~i );                    # Naughty user

    push @defs, "$_=$defs{$_}";                 # Makefile defs are XXXX=aaaa

}

#

#   Look for OPTIONS=*args* and disable the silent make operation

#   This will allow the make to output messages

#

if (( exists $defs{OPTIONS} && $defs{OPTIONS} =~ m/args/ ) || $opt_verbose || $opt_debug )

{

    $opt_silent = 0;

}

#

#   Process GBE_PLATFORM and create a usable hash

#

if ( $GBE_PLATFORM )

{

    Verbose2 ("GBE_PLATFORM: $GBE_PLATFORM");

    $gbe_platform{$_} = 1 foreach ( split( / /, $GBE_PLATFORM ) );

}

#

#   Read in the local Makefile.gbe file

#   This will provide a path to the interface directory

#

ReadMakeInfo();

#

#   Read in the global build variables

#

ReadBuildConfig( "$::ScmRoot/$::ScmInterface" );

#

#   Determine the max size of the target name

#   Makes a nice display

#

foreach ( @BUILDPLATFORMS )

{

    my $len = length ($_);

    $tlen = $len if ( $len > $tlen );

}

#-------------------------------------------------------------------------------

#   Scan the list of targets and perform 'alias' expansion

#   targets are of the form

#       platform_command_type

#       Where:

#           type        may be _prod or _debug or not present

#           command     may be either a composite command or a simple command

#           platform    may be a platform or an alias

#

#

foreach my $arg ( @targets )

{

    my $suffix = '';

    my @commands;

    my @platforms;

    #

    #   Remove the only available suffix ( _debug | _prod )

    #   Also detect commnads of debug or prod

    #

    if ( $arg =~ m~(.+)_(debug)$~ ) {

        $suffix = $2;

        $arg = $1;

    } elsif ( $arg =~ m~(.+)_(prod)$~ ) {

        $suffix = $2;

        $arg = $1;

    } elsif ( $arg eq 'debug' ) {

        $suffix = $arg;

        $arg = '';

    } elsif ( $arg eq 'prod' ) {

        $suffix = $arg;

        $arg = '';

    }

    #

    #   Remove valid make commands from the remaining argument

    #   Have a hash of all known makefile commands

    #

    foreach my $cmd ( keys %composite_commands, keys %commands )

    {

        if ( $arg eq $cmd )

        {

            @commands = ExpandComposite($cmd);

            $arg = '';

        }

        elsif ( $arg =~ m~(.+)_($cmd)$~ )

        {

            $arg = $1;

            @commands = ExpandComposite($2);

            last;

        }

    }

    #

    #   See of we can extract an platform alias from the command

    #   Rip into target + command

    #

    if ( $arg )

    {

        if ( exists $ScmBuildAliases{$arg}  )

        {

            @platforms =  split (/ /, $ScmBuildAliases{$arg} );

        }

        elsif ( exists $ScmBuildPlatforms{$arg} )

        {

            @platforms = ($arg);

        }

        else

        {

            if ( @commands )

            {

                Error ("Unknown target: $arg");

            }

            else

            {

                Message ("Unknown command. Passed to make: $arg");

                @commands = $arg;

            }

        }

    }

    #

    #   Insert defaults

    #

    @platforms = @DEFBUILDPLATFORMS

        unless ( @platforms );

    @commands = ExpandComposite('all')

        unless ( @commands);

    #

    #   Perform GBE_PLATFORM filtering

    #

    if ( %gbe_platform )

    {

        my @filter;

        foreach ( @platforms )

        {

            push @filter, $_ if ( exists $gbe_platform{$_} );

        }

        @platforms = @filter;

    }

    Error ("No platforms to be processed. Check GBE_PLATFORM")

        unless ( @platforms );

    #

    #   Iterate commands over platforms

    #

    foreach my $cmd ( @commands )

    {

        PerformCommand (\@platforms, $cmd, $suffix );

    }

}

#

#   All done

#

exit (0);

#-------------------------------------------------------------------------------

# Function        : PerformCommand

#

# Description     : Perform the make on a platform command

#

# Inputs          : $platform_ref   - platforms to process

#                   $cmd            - simple make command

#                   $suffix         - debug,prod,none

#

# Returns         : 

#

sub PerformCommand

{

    my ($platform_ref, $cmd, $suffix) = @_;

    my $do_prod = 1;

    my $do_debug = 1;

    #

    #   Clean up some ugly commands from lint and ctags

    #

    if ( $cmd =~ m~(.+)_(debug)$~ )

    {

        $cmd = $1;

        $suffix = $2;

    }

    Verbose2 ("Processing Target: $cmd, $suffix");

    #

    #   Limit command to production or debug

    #

    if ( $suffix eq 'debug' ) {

        $do_prod  = 0;

    } elsif ( $suffix eq 'prod' ) {

        $do_debug  = 0;

    }

    #

    #   Some commands can be suppressed by options

    #

    if ( exists $commands{$cmd}{'unless'}  )

    {

        my $check = $commands{$cmd}{'unless'};

        if ( exists $defs{$check} && $defs{$check} )

        {

            Verbose2 ("Skipping: $cmd because $check");

            return;

        }

    }

    #

    #   Interecpt commands that are handled locally

    #

    if ( exists $commands{$cmd}{'local'} )

    {

        $commands{$cmd}{'local'}( $cmd, $platform_ref );

        return;

    }

    #

    #   Process and recurse directory tree

    #

    Verbose ("Processing: $cmd, @{$platform_ref}");

    #

    #   Determine the local tag name and state

    #   The tag is used to short circuit makefile commands in recursive makes

    #   It greatly reduces the work required

    #

    #   Many commands have a tag that is the same as the command, but a few don't

    #

    my $tag = 0;

    if ( exists $commands{$cmd}{tag}  )

    {

        $tag = $commands{$cmd}{tag};

        $tag = $cmd if ( $tag eq '1' );

    }

    if ( $commands{$cmd}{'common'} )

    {

        InvokeSubMake( $::Cwd, $platform_ref ,$cmd, $tag, 1 );

    }

    else

    {

        InvokeSubMake( $::Cwd, $platform_ref ,$cmd, $tag, 1 ) if $do_debug;

        InvokeSubMake( $::Cwd, $platform_ref ,$cmd, $tag, 0 ) if $do_prod;

    }

}

#-------------------------------------------------------------------------------

# Function        : InvokeSubMake

#

# Description     : Build recursion

#                   Determine if there is anything to be done for the current

#                   target within a specified directory

#

# Inputs          : $dir

#                   $pref                   - Ref to an array of platforms

#                   $cmd

#                   $tag

#                   $do_prod

#

# Returns         : 

#

sub InvokeSubMake

{

    my ( $dir, $pref, $cmd, $tag, $do_debug) = @_;

    #

    #   Ensure the current directory is known to the Tags database

    #

    $Tags = ReadMaketags( $dir );

    Error ("Directory not in tag database", $dir ) unless ( $Tags );

    #

    #   Process commands in the current directory

    #   If the command is tagged, then we may be able to skip it

    #   Otherwise we need to do it

    #

    InvokeMake( $dir, $pref, $cmd, $tag, $do_debug );

    #

    #   Recurse into any subdirectories that may be a part of the build

    #

    unless ( exists $defs{NORECURSE} && $defs{NORECURSE}  )

    {

        #

        #   Process subdirectories for the current command

        #   If the command is tagged, then we may be able to skip it

        #   Otherwise we need to do it

        #

        foreach my $subdir (@{$Tags->{$dir}{subdirs}} )

        {

            InvokeSubMake( CleanDirName( "$dir/$subdir"), $pref, $cmd, $tag, $do_debug );

        }

    }

}

#-------------------------------------------------------------------------------

# Function        : InvokeMake

#

# Description     : Actually invoke the make for debug and production as required

#

# Inputs          : $dir

#                   $pref

#                   $cmd

#                   $tag

#                   $do_debug

#

#

# Returns         : 

#

sub InvokeMake

{

    my ( $dir, $pref, $cmd, $tag, $do_debug ) = @_;

    my $text = 'C';

    #

    #   Ensure that the current directory actually has makefile targets

    #   Not all makefile.pl create .mk files

    #       1) Top-level makefile.pl

    #       2) Makefiles that use --NoPlatformBuilds

    #

    if ( $Tags->{$dir}{root} )

    {

        Verbose2 "Root directory has no makefiles: $dir";

        return;

    }

    if ( $Tags->{$dir}{noplatforms} )

    {

        Verbose2 "No make targets in $dir";

        return;

    }

    #

    #   Process each platform

    #

    foreach my $target ( @{$pref} )

    {

        unless ( exists $Tags->{$dir}{platforms}{$target} )

        {

            Verbose2 "No make targets in $dir, for $target";

            next;

        }

        #

        #   Do we need to do any thing for this target / tag

        #

        if ( $tag )

        {

            unless ( exists $Tags->{$dir}{full}{$target}{'%MakeTags'}{$tag} )

            {

                Verbose2 ("Skipping $cmd in $dir");

                next;

            }

        }

        #

        #   common mode == 2

        #   Only process target ONCE for each platform

        #   Don't care when its used

        #

        if ( exists $commands{$cmd}{common} && $commands{$cmd}{common} & 2 )

        {

            if ( $common_cmd{$cmd}{$target} )

            {

                Verbose2 "Already performed $cmd for $target";

                next;

            }

            $common_cmd{$cmd}{$target} = 1;

        }

        #

        #   Is the build limited to only debug or production

        #

        unless ( exists $commands{$cmd}{common} )

        {

            if ( $do_debug == 0 ) {

                next unless ( $Tags->{$dir}{platforms}{$target}{prod} );

                $text = 'P';

            } elsif  ( $do_debug == 1 ) {

                next unless ( $Tags->{$dir}{platforms}{$target}{debug} );

                $text = 'D';

            }

        }

        #

        #   Final sanity test

        #   Must have the makefile. We should have detected this error before now

        #

        Error ("Makefile not found - $target") unless ( -f "$dir/$target.mk" );

        #

        #   Build up the make command line

        #   Examine command specfic flags

        #

        my @args = @defs;

        push @args, "IFLAG=$commands{$cmd}{IFLAG}" if ( exists $commands{$cmd}{IFLAG} );

        push @args, "NOSCMDEPEND=1" if ( exists $commands{$cmd}{nomakecheck} );

        my $cdir = CleanDirName ($dir);

        my @make_command;

        push @make_command, "$ENV{GBE_BIN}/xmake";

        push @make_command, "-s" if $opt_silent;

        push @make_command, "--no-print-directory";

        push @make_command, "-C", $cdir unless ( $cdir eq $::Cwd );

        push @make_command, "-f", "$target.mk";

        push @make_command, @args;

        push @make_command, 'make_dir' unless exists $commands{$cmd}{nomakecheck} ;

        push @make_command, $cmd;

        Message ( sprintf ("[$text] %-${tlen}s, $cmd, $cdir", $target ));

        System (@make_command, "DEBUG=$do_debug" );

    }

}

#-------------------------------------------------------------------------------

# Function        : TestMakeFiles

#

# Description     : Test all the makefile dependent files to see if any of the

#                   makefiles need to be rebuilt.

#

#                   Walk the directory tree looking for makefiles to be

#                   rebuilt.

#

# Inputs          : $cmd            - Current command

#                   $pref           - Ref to an array of platforms

#

# Returns         : 

#

sub TestMakeFiles

{

    my ( $cmd, $pref ) = @_;

    Verbose ("Test makefile dependencies");

    #

    #   Read in the Tag file for the current directory

    #   This will provide the current list of subdirectories

    #

    #   Process Test the current makefiles, then test any subdirs

    #

    TestSubMake( $cmd, $Cwd, $pref );

    #

    #   Report build errors

    #   Done after all makefiles have been processed

    #

    if ( $build_error )

    {

        Error ("Error creating makefiles. Errors previously reported");

    }

    #

    #   Post makefile build processing

    #   Only required if a files have been re-built

    #

    if ( $update )

    {

        #

        #   Sanity test the makefile structure

        #   Ensure that makefiles have only one parent.

        #

        TestParents();

        #

        #   Sanity test the installed and packaged files

        #   Generate warnings and errors if a file if packaged from two

        #   locations

        #

        TestPackages();

        #

        #   Generate DPACKAGE file if required

        #

        JatsDPackage::DPackageGenerate( $::ScmRoot, $::ScmInterface  );

    }

    #

    #

    #   Check that the build.pl file is not newer that the tags file

    #   This will not be an error, but it will be a nagging warning

    #

    my @build_warn;

    my $bstamp = -M "$::ScmRoot/$ScmBuildSrc";

    my $tstamp = -M "$::ScmRoot/Makefile.gbe";

    push @build_warn, "Missing: Makefile.gbe" unless ( defined $tstamp );

    push @build_warn, "Modified build file ($ScmBuildSrc)" if ( $tstamp && $bstamp < $tstamp );

    if ( @build_warn )

    {

        Warning ("The build file is newer than the generated files",

                 "The project needs to be built for these changes to be included",

                 @build_warn );

    }

}

#-------------------------------------------------------------------------------

# Function        : TestSubMake

#

# Description     : Test the makefiles in the current directory

#                   Recurse into subdirectories

#

# Inputs          : $cmd            - Current command

#                   $dir            - Directory to test

#                   $pref           - Ref to an array of platforms

#

# Returns         : 

#

sub TestSubMake

{

    my ($cmd, $dir, $pref ) = @_;

    $Tags = ReadMaketags( $dir, 1 );

    unless ( $Tags )

    {

        Verbose2 ("TestSubMake :Directory not in tag database", $dir );

        MakeBuild( $dir);

    }

    else

    {

        TestMake( $cmd, $dir, $pref );

    }

    #

    #   Recurse into any subdirectories that may be a part of the build

    #

    unless ( exists $defs{NORECURSE} && $defs{NORECURSE}  )

    {

        foreach my $subdir (@{$Tags->{$dir}{subdirs}} )

        {

            TestSubMake( $cmd, CleanDirName( "$dir/$subdir"), $pref );

        }

    }

}

#-------------------------------------------------------------------------------

# Function        : TestMake

#

# Description     : Test the makefiles component files

#                   and determine if the makefile(s) need to be rebuilt

#

# Inputs          : $cmd            - Current command

#                   $dir            - Directory to test

#                   $pref           - Ref to an array of platforms

#

# Returns         : 

#

sub TestMake

{

    my ( $cmd, $dir, $pref ) = @_;

    my @must_rebuild;

    if ( $cmd eq 'rebuild' )

    {

        MakeBuild( $dir);

        return;

    }

    #

    #   Check that the local makefile.pl is not newer than

    #   the Tags file. Not all makefile.pl's create .mk files

    #

    my $mstamp = -M "$dir/makefile.pl";

    my $tstamp = -M "$dir/Makefile.gbe";

    unless ( defined $tstamp )

    {

        UniquePush (\@must_rebuild, "Missing: $dir/Makefile.gbe");

    }

    if ( $mstamp && $mstamp < $tstamp  )

    {

        UniquePush (\@must_rebuild, "Updated: $dir/makefile.pl");

    }

    else

    {

        if ( $Tags->{$dir}{root} )

        {

            Verbose2 "TestMake: Root directory has no makefiles: $dir";

            return;

        }

        if ( $Tags->{$dir}{noplatforms} )

        {

            Verbose2 "TestMake: No make targets in $dir";

            return;

        }

        #

        #   Process only the required build targets

        #

        foreach my $tgt ( keys %{$Tags->{$dir}{platforms}}   )

        {

            next if ( %gbe_platform && not exists $gbe_platform{$tgt} );

            #

            #   Locate all the makefile dependent files

            #

            my $data = $Tags->{$dir}{full}{$tgt}{'@ScmDepends'};

            if ( $data )

            {

                Verbose2 ("Processing: $dir : $tgt");

                my $base_stamp = -M "$dir/$tgt.mk";

                unless ( defined $base_stamp )

                {

                    UniquePush (\@must_rebuild, "Missing: $dir/$tgt.mk");

                }

                else

                {

                    foreach my $file ( "$dir/makefile.pl" ,@$data )

                    {

                        $file = "$dir/$file" if ( $file =~ m~^\.~ );

                        my $stamp = -M $file;

                        if ( defined $stamp )

                        {

                            Verbose3 ("Timestamp: $stamp, $file");

                            if ( $stamp < $base_stamp  )

                            {

                                UniquePush (\@must_rebuild, $file);

                            }

                        }

                        else

                        {

                            UniquePush (\@must_rebuild, "Missing: $file");

                        }

                    }

                }

            }

            else

            {

                Warning ("No dependency information for: $tgt in $dir");

            }

        }

    }

    if ( @must_rebuild )

    {

        my @display;

        push (@display, CleanDirName($_) ) foreach ( @must_rebuild );

        Message ("One or more JATS source or internal files have changed, Makefiles will be rebuilt",

                  "Target is: $dir",

                  @display );

        MakeBuild ($dir);

    }

    return;

}

#-------------------------------------------------------------------------------

# Function        : MakeBuild

#

# Description     : Rebuild the makefiles in the specified directory

#                   This does not involve recursion - thats already been

#                   done.

#

#                   Once the makefiles have been re-built the tags database

#                   must be read in again as it may have changed.

#

# Inputs          : 

#

# Returns         : 

#

sub MakeBuild

{

    my ($dir) = @_;

    #

    #   No makefiles to build in the root directory

    #   Can't rebuild the top-level Makefile.gbe file

    #

    return if ( $Tags->{$dir}{root} );

    #

    #   Try to rebuild the makefile

    #

    my @args;

    push @args, '--expert' if ($ScmExpert);

    push @args, "--interface=$::ScmInterface";

    push @args, '-F';

    chdir $dir || Error ("Cannot change directory to $dir");

    my $result = System ('--NoExit',$ENV{GBE_PERL}, 'makefile.pl', $::ScmRoot, $makelib, @args );

    chdir $::Cwd || Error ("Cannot change directory to $::Cwd");

    #

    #   Re-read the tags database

    #

    $Tags = ReadMaketags( $dir, 2 );

    #

    #   Flag that makefiles have been modified

    #

    $update = 1;

    $build_error = 1 if ( $result && $result != 10 );

}

#-------------------------------------------------------------------------------

# Function        : UnMakeFiles

#

# Description     : Delete generated makefiles and control files

#

# Inputs          : $cmd            - Current command

#                   $pref           - Ref to an array of platforms

#

# Returns         : 

#

sub UnMakeFiles

{

    #

    #   Recurse down the tree

    #   Recurse, then performs operations in the current directory

    #

    sub UnSubMakeFiles

    {

        my ($dir) = @_;

        $Tags = ReadMaketags( $dir, 1 );

        foreach my $subdir (@{$Tags->{$dir}{subdirs}} )

        {

            UnSubMakeFiles( CleanDirName( "$dir/$subdir") );

        }

        UnMake( $dir );

    }

    #

    #   Delete makefiles in the current directory

    #

    sub UnMake

    {

        my ($dir) = @_;

        Verbose("Unmake in $dir");

        foreach my $tgt ( keys %{$Tags->{$dir}{platforms}}   )

        {

            Verbose2("Unmake. Delete ${tgt}.mk");