Subversion Repositories DevTools

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

# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

#

# Module name   : JatsSignatureBuilder.pm

# Module type   : JATS Utility

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : Generate a PAckage signature

#

#

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

require 5.008_002;

use strict;

use warnings;

package JatsSignatureBuilder;

use JatsError;

use FileUtils;

use JatsVersionUtils;

use JatsEnv;

use JatsSystem;

use ArrayHashUtils;

use BuildName;

use Digest::SHA::PurePerl qw(sha1);

use IPC::Open3;

use File::Path;

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

# Function        : GeneratePackageSignature 

#

# Description     : Generate a package 'signature' for this package

#               

#                   The signature is used to bypass the entire Make processing in a sandbox

#                   If we can find a matching package in the package store then we don't 

#                   need to 'make' this package.

#

#                   There are two scenarios:

#                       In a GIT enabled sandbox

#                       Without GIT

#                       

#                   In a GIT enabled sandbox the signature allows the use of a pre-built 

#                   package - even if the package has been built on a different branch.

#                   

#                       The signature includes:

#                           The name of this package

#                           The GIT sha1 of the directory trees that contain this package

#                           The package signatures of all dependent packages

#                           

#                   In a Non-GIT enabled sandbox the package signature will be set such that

#                   the package will never be found in the package store and the package MUST

#                   be built within the sandbox.

#                   

#                   The hard part is determing the directory trees that contains this package

#                   Ideally this is a single dir-tree, but this cannot be enforced.

#                   

#                   Source directories have been gathered during makefile generation

#                   

#                   This suits most cases, but there are a few where the user needs

#                   to give JATS a hint. Use the AsdSrcDir directive to extend

#                   the signature paths to directories not under the build.pl

#                   or any makefile included by the build.pl

#                   

#                   The generated file will be held in the sandbox directory.

#

# Inputs          : $pkgBase        - Path to the package's build file

#                   $outPath        - Base of path to create signature files 

#

# Returns         : The package signature

#

sub GeneratePackageSignature

{

    my ($pkgBase, $outPath) = @_;

    my %sigExcludeDirs;

    my %sigExcludeFiles;

    my $BuildSignatureSha1;

    my $BuildSignature;

    my @sigList;

    my $sigText;

    Error ("No directory specified") unless $pkgBase;

    Debug("Build Directory: $pkgBase");

    Error ("Not a directory: $pkgBase") unless -d $pkgBase;

    my $parsedInfo = JatsParser::processBuild ($pkgBase);

    #DebugDumpData("GeneratePackageSignature::parsedInfo", $parsedInfo);

    Error ('BuildName not found') unless exists $parsedInfo->{BuildName};

    #

    #   Determine the saved locations for the output files

    #

    mkpath ( $outPath ) unless -d $outPath;

    my $signatureFile = CatPaths($outPath, 'Package.sig');

    my $sigDebugFile  = CatPaths($outPath, 'Package.dsig');

    #

    #   Determine if this is a GIT enabled sandbox build

    #   Need a .git directory or file in the root of the sandbox

    #

    my $gitEnabled;

    if ($::GBE_SANDBOX && -e CatPaths ($::GBE_SANDBOX, '.git') ) {

        $gitEnabled = 1;

    }

    #

    #   Start generating the signature

    #       Include the package Name, Version and Project

    #

    $BuildSignatureSha1 = Digest::SHA::PurePerl->new;

    $sigText = "PKGNAME: " . join (' ', @{$parsedInfo->{BuildName}} );

    $BuildSignatureSha1->add( $sigText );

    push @sigList, $sigText . ": " . $BuildSignatureSha1->clone->hexdigest;

    #

    #   Include the signature of ALL dependent packages

    #   Ie: The package signature is a function of the source and its dependents

    #   Assume that we are starting with a sorted list

    #

    foreach my $tag ( @{$parsedInfo->{PkgList}} )

    {

        my ($pname, $pversion) = split ($;, $tag);

        my $pkgSig = getPackageSignature($pname, $pversion);

        $BuildSignatureSha1->add("PKGSIGNATURE: $pkgSig");

        push @sigList, sprintf("PKGSIGNATURE: [%s %s] %s: %s", $pname, $pversion, $pkgSig , $BuildSignatureSha1->clone->hexdigest);

    }

    if ($gitEnabled)

    {

        #

        #   Include the sha1 of all 'git' tree items that form the complete source image

        #   Warn user if not all components are version controlled

        #

        my @relDirList = @{$parsedInfo->{DirList}}; 

        my @cmdList = map { 'HEAD:' . $_ . '/'  } @relDirList;

        Debug3(" GIT CMD: " . "git rev-parse", @cmdList );

#DebugDumpData("parsedInfo",$parsedInfo);

        #

        #   Generate a 'nice' array of display paths used

        #   The display path will be used simply to report the location in the debug of the package signature

        #   The display path is relative to the base of the sandbox

        #

        my @absDirList = map { RelPath(FullPath( $_ ),$::GBE_SANDBOX) } @relDirList;

        #

        #   Callback function to process the output of the Git parse

        #   Expect one line for each HEAD: item

        #

        my $index = 0;

        my @notControlled;

        my $callback = sub {

            my ($cdata, $gitShar) = @_;

            $gitShar =~ s~\s+$~~;

            Debug3(" GIT OUT: " . $gitShar  );

            if ($gitShar =~ m~^HEAD:(.*)~) {

                push @notControlled, $1;

                $gitShar = 'MSG: Not version controlled';

            }

            $BuildSignatureSha1->add($gitShar);

            push @sigList, "PKGSRC: $absDirList[$index++]: $gitShar: " . $BuildSignatureSha1->clone->hexdigest;

            return 0;

        };

        my $rv = GitCmd('rev-parse', @cmdList, { process => $callback } );

        Debug2("GitCmd Result: $rv");

        $BuildSignature =  $BuildSignatureSha1->hexdigest;

        if (@notControlled) {

            Warning('The following paths are not version controlled:', @notControlled);

        }

    }

    else

    {

        $BuildSignature = 'MSG: Sandbox is not git enabled';

    }

    Message("Signature: $BuildSignature");

    push @sigList, "Signature: $BuildSignature";

    FileCreate( $signatureFile, $BuildSignature );

    FileCreate( $sigDebugFile, @sigList );

Debug0("sigDebugFile: $sigDebugFile");

    return $BuildSignature;

}

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

# Function        : getPackageSignature 

#

# Description     : Helper routine 

#                   Given a package name and package version determine the package

#                   signature.

#                   

#                   Can used predetermined data or perform a package repo scan

#                   

#                   This version assumes that we are buildign within a jats sandbox

#                   Each packages signature file Package.sig is stored in the packages

#                   interface directory (at the moment).

#                   

#                   Process:

#                       Locate the packages interface directory - we have a link file to it

#                       Read in the PAckage Signature file

#

# Inputs          : $pname      - Package Name

#                   $pversion   - Package Version

#                   $mode       - Optional. true -> do not error if not found

#

# Returns         : The package signature. Undefined if the package canot be found

#                    

sub getPackageSignature

{

    my ($pname, $pversion, $mode ) = @_;

    my $prj = '';

    my $pkg;

    my $version;

    my $pkgSig;

    # 

    #   We are in a sandbox and expect to find a interface/Package.sig file

    #   This will allow us to locate the package in the package store

    #   

    #   If there is no interface/Package.sig, then the user must build (not make)

    #   the package in the sandbox.

    #   

    #   ie: the interface/Package.sig file allows us to use the package from package cache

    #       or indicates that the user has not yet built the package

    #       

    #   First locate the packages interface directory

    #   We have a nice link from the sandbox to assist in this

    #

    my ($pn, $pv, $ps ) = SplitPackage ($pname, $pversion );

    $version = 'sandbox';

    $prj = '.' . $ps if ( $ps ); 

    $version .= $prj;

    my $ifaceDir = CatPaths($::GBE_SANDBOX, 'sandbox_dpkg_archive', $pname, $version . '.int');

    $ifaceDir = TagFileRead($ifaceDir);

    $ifaceDir =~ s~\\~/~g;

    $ifaceDir =~ s~GBE_SANDBOX/~$::GBE_SANDBOX/~;

    my $pkgSigFile = CatPaths( $ifaceDir, 'Package.sig');

    if ( -f $pkgSigFile)

    {

#Debug0("$pname, $pversion --> $pkgSigFile");

        $pkgSig = TagFileRead($pkgSigFile);

        Error("Package signature invalid for $pname/$version", "Signature: $pkgSig") 

            if((length($pkgSig) != 40) && $pkgSig !~ m~^MSG:~) ;

    }

    else

    {

        Error("Package signature not found for $pname/$version", "You must 'build' the package before using it") unless $mode;

    }

    return $pkgSig;

}

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

# Function        : GitCmd

#

# Description     : Run a Git Command and capture/process the output

#

#                   Based on JatsSvnCore:SvnCmd

#

# Inputs          : Command

#                   Command arguments

#                   Last argument may be a hash of options.

#                       nosavedata  - Don't save the data

#                       process     - Callback function

#                       printdata   - Print data

#                       error       - Error Message

#                                     Used as first line of an Error call

#

# Returns         : non-zero on errors detected

#

sub GitCmd

{

    my $self;           # Local storage

    Debug ("GitCmd");

    #

    #   Locate essential tools

    #

    our $GBE_SVN_PATH;

    EnvImportOptional('GBE_GIT_PATH', '');

    Debug ("GBE_GIT_PATH", $::GBE_GIT_PATH);

    my $stdmux = LocateProgInPath ( 'stdmux');

    my $git    = LocateProgInPath ( 'git', '--All', '--Path=' . $::GBE_GIT_PATH );

    #

    #   Extract arguments and options

    #   If last argument is a hash, then its a hash of options

    #

    my $opt;

    $opt = pop @_

        if (@_ > 0 and UNIVERSAL::isa($_[-1],'HASH'));

    $self->{PRINTDATA} = $opt->{'printdata'} if ( exists $opt->{'printdata'} );

    Verbose2 "GitCmd $git @_";

    #

    # Useful debugging

    #

    # $self->{LAST_CMD} = [$svn, @_];

    #

    #   Reset command output data

    #

    $self->{ERROR_LIST} = [];

    $self->{RESULT_LIST} = [];

#    $self->{LAST_CMD} = \@_;

    #

    #   Make use of a wrapper program to mux the STDERR and STDOUT into

    #   one stream (STDOUT). #   This solves a lot of problems

    #

    #   Do not use IO redirection of STDERR because as this will cause a

    #   shell (sh or cmd.exe) to be invoked and this makes it much

    #   harder to kill on all platforms.

    #

    #   Use open3 as it allows the arguments to be passed

    #   directly without escaping and without any shell in the way

    #

    local (*CHLD_OUT, *CHLD_IN);

    my $pid = open3( \*CHLD_IN, \*CHLD_OUT, '>&STDERR', $stdmux, $git, @_);

    #

    #   Looks as though we always get a PID - even if the process dies

    #   straight away or can't be found. I suspect that open3 doesn't set

    #   $! anyway. I know it doesn't set $?

    #

    Debug ("Pid: $pid");

    Error ("Can't run command: $!") unless $pid;

    #

    #   Close the input handle

    #   We don't have anything to send to this program

    #

    close(CHLD_IN);

    #

    #   Monitor the output from the utility

    #   Have used stdmux to multiplex stdout and stderr

    #

    #   Note: IO::Select doesn't work on Windows :(

    #   Note: Open3 will cause blocking unless both streams are read

    #         Can't read both streams because IO::Select doesn't work

    #

    #   Observation:

    #       svn puts errors to STDERR

    #       svn puts status to STDOUT

    #

    while (<CHLD_OUT>)

    {

        s~\s+$~~;

        tr~\\/~/~;

        Verbose3 ( "GitCmd:" . $_);

        m~^STD(...):(.+)~;

        my $data = $1 ? $2 : $_;

        next unless ( $data );

        if ( $1 && $1 eq 'ERR' )

        {

            #

            #   Process STDERR output

            #

            push @{$self->{ERROR_LIST}}, $data;

        }

        else

        {

            #

            #   Process STDOUT data

            #

            push @{$self->{RESULT_LIST}}, $data unless ($opt->{'nosavedata'});

            #

            #   If the user has specified a processing function then pass each

            #   line to the specified function.  A non-zero return will

            #   be taken as a signal to kill the command.

            #

            if ( exists ($opt->{'process'}) && $opt->{'process'}($self, $data) )

            {

                kill 9, $pid;

                sleep(1);

                last;

            }

        }

    }

    close(CHLD_OUT);

    #

    #   MUST wait for the process

    #   Under Windows if this is not done then we eventually fill up some

    #   perl-internal structure and can't spawn anymore processes.

    #

    my $rv = waitpid ( $pid, 0);

    #

    #   If an error condition was detected and the user has provided

    #   an error message, then display the error

    #

    #   This simplifies the user error processing

    #

    if ( @{$self->{ERROR_LIST}} && $opt->{'error'}  )

    {

        Error ( $opt->{'error'}, @{$self->{ERROR_LIST}} );

    }

    #

    #   Exit status has no meaning since open3 has been used

    #   This is because perl does not treat the opened process as a child

    #   Not too sure it makes any difference anyway

    #

    #

    Debug ("Useless Exit Status: $rv");

    my $result = @{$self->{ERROR_LIST}} ? 1 : 0;

    Verbose3 ("Exit Code: $result");

    return $result;

}

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

#   Internal Package

#   Primarily to hide the use of the AUTOLOAD

#       Which still doesn't behave as expected

#       Have trouble with $self in AUTOLOAD. Its not appearig as an argument.

#   

package JatsParser;

use strict;

use warnings;

my $currentClass;

our $ProjectBase;

our $ScmRoot;

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

# Function        : JatsParser::processBuild 

#

# Description     : Process the build.pl file and associated makefile.pl's

#                   A static-ish method to do all of the hard work.

#

# Inputs          : $buildPath  - Path to the build file

#

# Returns         : A few globals 

#

sub processBuild

{

    my ($baseDir) = @_;

    my @AllSubDirs;

    #

    #   Process the build.pl file

    #

    my $filename = ::CatPaths($baseDir, 'build.pl');

    ::Error ("Build file not found : $filename") unless -f $filename;

    $baseDir = ::RelPath(::FullPath ($baseDir));

    my $buildParser = newJatsParser();

    $buildParser->parseFile($baseDir , 'build.pl');

    #DebugDumpData("parser", $parser);

    #

    #   If no source subdirs where specified in the build file then insert the  default one

    #   This is the same action as perform by jats build

    #

    if ( ! defined $buildParser->{SubDirs}) {

        push @{$buildParser->{SubDirs}}, ::CatPaths($baseDir, 'src');

    }

    #

    #   If the 'common' makefile exists then parse it as well

    #

    my $commonMakefile = ::CatPaths($baseDir, 'makefile.pl');

    unless ( -f $commonMakefile) {

        $commonMakefile = undef;

    }

    #

    #   Add the build path to the list of known subdirectories

    #

    @AllSubDirs = $baseDir;

    #

    #   Process all subdirs

    #       Order is not important - in this case

    #

    my @SubDirs = @{$buildParser->{SubDirs}};

    my $parser = newJatsParser($baseDir, $commonMakefile);

    while (@SubDirs)

    {

        my $makeDir = ::CleanDirName(pop @SubDirs);

        @{$parser->{SubDirs}} = ();

        $parser->parseFile($makeDir, 'makefile.pl');

        push @SubDirs, @{$parser->{SubDirs}} if (defined $parser->{SubDirs});

        ::UniquePush (\@AllSubDirs, $makeDir);

    }

    my @AllInclude = @{$parser->{Includes}} if defined $parser->{Includes};

    #

    #   Generate a list of root directories used by the package

    #   ie: want top level directories only and not subdirectories

    #

    my @PackageDirs = generateMinDirList(@AllSubDirs, @AllInclude);

    #

    #   Generate a list of all the external packages

    #   Don't sort the list. Order may be important

    #   

    my @AllPackages = ();

    push @AllPackages, @{$buildParser->{PkgList}} if (defined $buildParser->{PkgList});

    #

    #   Prepare a structure to be returned

    #   

    my $data;

    $data->{BuildName} = $buildParser->{BuildName};

    $data->{BaseDir} = $baseDir; 

    $data->{PkgList} = \@AllPackages;

    $data->{DirList} = \@PackageDirs;

    return $data;

}

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

# Function        : generateMinDirList 

#

# Description     : Generate a list of root directories used by the package

#                   ie: want top level directories onyl and not subdirectories

#  

#

# Inputs          : A list of paths to process

#

# Returns         : A list of processed paths 

#

sub generateMinDirList

{

    #

    #   Convert all to absolute paths

    #

    my @baseList;

    foreach  (@_) {

        push @baseList, ::FullPath($_);

    }

    #   Process the complete list to remove subdirectories

    #   Process is:

    #       Sort list. Will end up with shortest directories first, thus subdirs will follow parents

    #       Insert each item into a new list iff it is not a subdir of something already in the list

    #

    my @dirList = sort {uc($a) cmp uc($b)} @baseList;

    my @newlist; 

    foreach my $newItem ( @dirList ) {

        my $match = 0;

        foreach my $item ( @newlist ) {

            if (index ($newItem, $item) == 0) {

                $match = 1;

                last;

            }

        }

        push @newlist, $newItem if (! $match);

   }

   #

   #   Convert back to relative paths

   #

   @baseList = ();

   foreach ( @newlist ) {

       push @baseList, ::RelPath($_);

   }

   return @baseList;

}

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

# Function        : AUTOLOAD

#

# Description     : Intercept and process user directives

#                   It does not attempt to distinguish between user errors and

#                   programming errors. It assumes that the program has been

#                   tested. 

#

# Inputs          : Original function arguments (captured)

#

#

our $AUTOLOAD;

sub AUTOLOAD

{

    #

    #   Don't respond to class destruction

    #

    return if our $AUTOLOAD =~ /::DESTROY$/;

    my $self = $currentClass;

    my $type = ref ($self) || ::Error("$self is not an object");

    my $args = ::JatsError::ArgsToString( \@_);

    my $fname = $AUTOLOAD;

    $fname =~ s~^\w+::~~;

    my ($package, $filename, $line) = caller;

    #

    #   If directive is inlined

    #   Replace it with the raw text of the directive

    #       Really only for display purposes

    #

    if ($fname eq 'If')

    {

        return $fname . '(' . join( ',', map { qq/"$_"/ } @_ ) . ')' ;

    }

    #

    #   Capture  and process some directives

    #

    my %directives = ( AddIncDir => 1, 

                       AddSrcDir => 1, 

                       AddDir => 1, 

                       AddLibDir => 1,

                       LinkPkgArchive => 2, 

                       BuildPkgArchive => 2,

                       BuildName => 3,

                       SetProjectBase  => 4,

                       SubDir => 5,

                       BuildSubDir => 5,

                       );

    if ($directives{$fname})

    {

#        ::Debug0 ("Directive: $fname( $args );", "File: $filename, Line: $line, Mode: $directives{$fname}" );

        #   AddIncDir

        #   AddSrcDir

        #   AddLibDir

        #   AddDir

        #       Directives that specify directories that extend paths

        #

        if ($directives{$fname} == 1)

        {

            for (my $ii = 1; $ii < scalar @_; $ii++)

            {

                my $arg = $_[$ii];

                next if ( $arg =~ m~^--~);

#::Debug0("Processing: $arg");

#::DebugDumpData("Self", $self);

                #

                #   Skip if the path looks like it conatins keywords

                #   interface and local

                #   

                if ($arg =~ m~/interface/~ || $arg =~ m~/local/~ ) {

                    $arg = '.'

                }

                my $dirtyPath = $arg;

                $dirtyPath = join( '/', $self->{baseDir}, $arg) unless ($arg =~ m~^/~ || $arg =~ m~^\w:~) ;

#::Debug0("DirtyPath: $dirtyPath");

                my $path =  ::CleanPath($dirtyPath );

#::Debug0("CleanPath: $path");

                ::UniquePush (\@{$self->{Includes}}, $path);

                ::Error ("Included directory does not exist: $path") unless -d $path;

            }

        }

        #

        #   LinkPkgArchive

        #   BuildPkgArchive

        #       Directives that define external packages

        #

        if ($directives{$fname} == 2) {

            push @{$self->{PkgList}}, join($;, @_);

        }

        #

        #   BuildName

        #       Directive that specifies the Build Name

        #       Format into name, version, suffix

        #   

        if ($directives{$fname} == 3) {

            my $build_info = BuildName::parseBuildName( @_ );

            $build_info->{BUILDNAME_PROJECT}  = $build_info->{BUILDNAME_PROJECT} ? '.' . $build_info->{BUILDNAME_PROJECT} : '';

            my @data = ($build_info->{BUILDNAME_PACKAGE}, $build_info->{BUILDNAME_VERSION}, $build_info->{BUILDNAME_PROJECT}); 

            $self->{BuildName} = \@data;

        }

        #

        #   SetProjectBase

        #       Handle ProjectBase variable

        #       Only handle a subset as I want to deprecate this

        #       Handle ONLY one arg

        #       Must be either : --Up=nn, or a string ( ../.. );

        #

        if ($directives{$fname} == 4) {

            if (scalar @_ > 1 ) {

               :: Error ("Multiple arguments to SetProjectBase not supported");

            }

            my $dirString = $_[0];

            if ($dirString =~ m~--Up=(\d+)~) {

                my $count = $1;

                $dirString = '/..' x $count;

            }

            my $newProjectBase = $self->{ProjectBase} . $dirString;

            $newProjectBase = ::CleanPath($newProjectBase);

#::Debug0 ("SetProjectBase:" . $newProjectBase);

            no strict;

            no warnings 'all';

            $ProjectBase =  $newProjectBase;

#::Debug0 ("ProjectBase: $ProjectBase");

        }

        #

        #   SubDir

        #   BuildSubDir

        #       Directives that specify subdirectories to be included in the build

        #       Assume they are relative

        #

        if ($directives{$fname} == 5) {

            foreach ( @_ ) {

                push  @{$self->{SubDirs}}, ::CatPaths($self->{baseDir}, $_ );

            }

        }

    }

}

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

# Function        : newJatsParser 

#

# Description     : New instance of a JatsParser object

#

# Inputs          : $buildBase - Root of the build 

#                   $commonFile - Common makefile to be prefixed to all

#

# Returns         : 

#

sub newJatsParser

{

    my ($buildBase, $commonFile) = @_;

    my $class = 'JatsParser';

    my $self  = {};

    bless $self, $class;

    #

    #   Init Data

    #

    $self->{baseDir} = '';

    $self->{filename} = '';

    $self->{SubDirs} = ();

    $self->{PkgList} = ();

    $self->{Includes} = ();

    $self->{ScmRoot} = ::FullPath($buildBase) if defined $buildBase ;

    $self->{ProjectBase} = $self->{ScmRoot};

    $self->{Common} = $commonFile if defined $commonFile;

    #

    #   Return class

    #

    return $self;

}

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

# Function        : parseFile 

#

# Description     : Parse a build or makefile and return data

#

# Inputs          : $baseDir      - Base directory

#                   $filename     - File to process

#

# Returns         : stuff 

#

sub parseFile

{

    my ($self, $baseDir, $filename) = @_;

    $currentClass = $self;

    $self->{baseDir} = $baseDir;

    $self->{filename} = $filename;

    $filename =  ::CatPaths($baseDir,$filename);

    ::Error("parseFile. File not found: $filename") unless -f $filename;

    #

    #   Set Jats-global variables

    #       $ProjectBase

    #       $ScmRoot

    #

    no strict;

    $ProjectBase =  $self->{ProjectBase};

    $ScmRoot = ::RelPath( $self->{ScmRoot}, ::FullPath($self->{baseDir}) ) if defined( $self->{ScmRoot}); 

    local @ARGV;

    $ARGV[1] = 'Dummy';

    use strict;

    #

    #   Create the code to be processed

    #   Join the common-makefile and the user-makefile

    #       Set Line numbers and filenames

    #

    my $commonCode = "#No Common Code\n";

    $commonCode = slurpFile($self,$self->{Common}) if (exists $self->{Common});

    my $code =  slurpFile($self,$filename);

#    ::Debug0("code:\n", $commonCode . $code);

    #

    #   Evaluate the code

    #

    no strict;

    no warnings 'all';

    eval $commonCode . $code;

    if ($@) {

        ::Error('Bad eval of Code:', $@);

        ::Debug0("Code", $code);

    }

    use strict;

    use warnings;

#    ::DebugDumpData("ParsedData", $self);

}

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

# Function        : slurpFile 

#

# Description     : Read and entire (build / makefile ) into a string

#                   Clean it up a little bit

#

# Inputs          : $file   - File to process 

#

# Returns         : Entire file as a sinngle string

#

sub slurpFile

{

    my ($self, $file) = @_;

    local $/;

    open my $fh, '<', $file or ::Error("Cannot open $file. $!" );

    $/ = undef;

    my $data = <$fh>;

    close $fh;

    #

    #   Remove ugly directives

    #   Messes with line numbers

    #

    $data =~ s~^\s*require.*~_JatsRequire();~gm;

    $data =~ s~^\s*die.*~_JatsDie();~mg;

    $data =~ s~^\s*unless.*~_JatsUnless();~mg;

    $data =~ s~^\s*\$MAKELIB_PL\s+.*~_JatsDefine();~mg;

    $data =~ s~^\s*\$BUILDLIB_PL\s+.*~_JatsDefine();~mg;

    #

    #   Some old build files use some rubbish perl

    #

#    $data =~ s~^my~#my~mg;

    #

    #   Put a nice header on the file for error reporting

    #

    my $absName = ::FullPath($file);

    my $header = "#line 1 \"$absName\"\n" ;

    return $header . $data;

}

1;