Subversion Repositories DevTools

########################################################################
# Copyright (C) 2008 ERG Limited, All rights reserved
#
# Module name   : new_toolset_def.pl
# Module type   : JATS Utility
# Compiler(s)   : Perl
# Environment(s): JATS
#
# Description   :
#
# Usage:
#
#
#......................................................................#

require 5.008_002;
use strict;
use warnings;

use JatsError;

my %ToolsetData;

sub ToolsetName
{
    ( $ToolsetData{name},$ToolsetData{long}, $ToolsetData{tag} ) = @_;
}

sub ToolsetSuffix
{
    foreach  ( @_ )
    {
        my ($tag,$value) = split( /\s*=\s*/, $_ );
        $ToolsetData{suffix}{$tag} = $value;
    }
}

sub ToolsetVar
{
    my $name = shift;
    Error ("ToolsetVar. No variable name") unless $name;
    foreach  ( @_ )
    {
        if ( m~^--Default=(.+)~i ) {
            $ToolsetData{ENV}{$name}{default} = $1;
        } elsif ( m~^--Value=(.+)~i ) {
            $ToolsetData{ENV}{$name}{value} = $1;
        } else {
            Error ("ToolsetVar. Unknown option: $_");
        }
    }
}

sub ToolsetPath
{
    push @{$ToolsetData{PATH}}, @_;
}

sub ToolsetInclude
{
    push @{$ToolsetData{INCLUDE}}, @_;
}

sub ToolsetLib
{
    push @{$ToolsetData{LIB}}, @_;
}

sub ToolsetRpcGen
{
    foreach ( @_)
    {
        if ( m~^--cpp=(.+)~i ) {
            $ToolsetData{RPCGEN}{CPP} = $1;

        } elsif ( m~^--flags=(.+)~i ) {
            $ToolsetData{RPCGEN}{FLAGS} = $1;

        } else {
            Error ("ToolsetRpcGen. Unknown option: $_");
        }
    }
}

sub ToolsetDef
{
    my ($name, $value ) = @_;
    push @{$ToolsetData{DEF}}, [ $name, $value ];

    push @{$ToolsetData{DEFORDER}}, $name;
    $ToolsetData{DEFDATA}{$name} = $value;

}


ToolsetName ( 'PHARLAP', 'Phar Lap ETS 10.1', 'vcwin32' );

ToolsetSuffix ( 'object=obj', 'assembler=asm', 'library=lib', 'program=.exe' );

ToolsetVar  ('PROGRAMFILES', '--Default=C:/Program Files' );
ToolsetVar  ('VSCommonDir',  '--Default=$(PROGRAMFILES)\Microsoft Visual Studio\Common' );
ToolsetVar  ('MSDevDir',     '--Default=$(PROGRAMFILES)\Microsoft Visual Studio\Common\MSDev98' );
ToolsetVar  ('MSVCDir',      '--Default=$(PROGRAMFILES)\Microsoft Visual Studio\VC98' );
ToolsetVar  ('VcOsDir',      '--Default=WINNT' );
ToolsetVar  ('PHARLAP_HOME', '--Default=c:/pharemb' );
#ToolsetVar  ('TEST', '--Default=c:/pharemb/$(JILL)' );
#ToolsetVar  ('TEST2', '--Default=c:/pharemb/$(JILL)/aaaa/$(JILL)' );
#ToolsetVar  ('TEST3', '--Default=c:/pharemb/$(TEST4)/aaaa/$(JILL)' );
#ToolsetVar  ('TEST4', '--Default=c:/pharemb/$(TEST3)/aaaa/$(JILL)' );
#ToolsetVar  ('JILL', '--Default=ThisIsJill' );
ToolsetVar  ('JILL', '--Value=ThisIsJill' );

ToolsetPath ( '$(PHARLAP_HOME)\bin' );
ToolsetPath ( '$(MSDevDir)\BIN' );
ToolsetPath ( '$(MSVCDir)\BIN' );
ToolsetPath ( '$(VSCommonDir)\TOOLS\$(VcOsDir)' );
ToolsetPath ( '$(VSCommonDir)\TOOLS' );

ToolsetInclude ('$(PHARLAP_HOME)\include' );
ToolsetInclude ('$(MSVCDir)\ATL\INCLUDE' );
ToolsetInclude ('$(MSVCDir)\INCLUDE' );
ToolsetInclude ('$(MSVCDir)\MFC\INCLUDE' );

ToolsetLib ('$(PHARLAP_HOME)\lib' );
ToolsetLib ('$(PHARLAP_HOME)\lib\vclib' );
ToolsetLib ('$(MSVCDir)\LIB' );
ToolsetLib ('$(MSVCDir)\MFC\LIB' );

ToolsetRpcGen ('--Cpp=c1','--Flags=-EP');

ToolsetDef ('VISUALC', '$(subst \,/,$(strip $(MSVCDir)))');
ToolsetDef ('visualc', '$(subst $(space),$(spacealt),$(subst \,/,$(strip $(MSVCDir))))');


DebugDumpData("Toolset BASE", \%ToolsetData );

#
#   Post process the ENV data
#       Extract real values from the environment
#       Determine real values
#           Keep symbolic values as well as physical values
#
foreach  ( keys %{$ToolsetData{ENV}} )
{
    next unless (  exists($ToolsetData{ENV}{$_}{default}) );
    if ( exists ($ENV{$_}) )
    {
        $ToolsetData{ENV}{$_}{value} = $ENV{$_};
    }
    else
    {
        $ToolsetData{ENV}{$_}{value} = $ToolsetData{ENV}{$_}{default};
    }
}

my $more = 1;
my %need;
while ( $more )
{
    $more = 0;
    %need = ();
    foreach  ( keys %{$ToolsetData{ENV}} )
    {
        next if ( exists $ToolsetData{ENV}{$_}{eval} );
        my $data = $ToolsetData{ENV}{$_}{value};
        if ( $data =~ m~\$\(([^\)]+)\)~ )
        {
            my $tag = $1;
            if ( exists $ToolsetData{ENV}{$tag} && exists $ToolsetData{ENV}{$tag}{eval} )
            {
                $data =~ s~\$\($tag\)~$ToolsetData{ENV}{$tag}{eval}~g;
                $ToolsetData{ENV}{$_}{value} = $data;
                $more = 1;
            }
            else
            {
                $need{$tag} = 1;
            }
        }
        else
        {
            $ToolsetData{ENV}{$_}{eval} = $data;
            push @{$ToolsetData{ENVORDER}}, $_;

        }
    }

}

if ( keys %need )
{
    Error ("Cannot resolve symbolic variables: ", sort keys %need );
}

sub expand
{
    my ($var) = @_;
    my $orginal = $var;

    while ( $var =~ m~\$\(([^\)]+)\)~ )
    {
        my $tag = $1;
        Error ("Cannot expand: $orginal. Unknown tag: $tag")
            unless ( exists $ToolsetData{ENV}{$tag} );

        $var =~ s~\$\($tag\)~$ToolsetData{ENV}{$tag}{eval}~g;
    }

   return $var;
}

DebugDumpData("Toolset", \%ToolsetData );

foreach  ( @{$ToolsetData{PATH}}, @{$ToolsetData{LIB}}, @{$ToolsetData{INCLUDE}}  )
{
    my $data = expand ($_);
    print "$_ => $data\n";
    Warning ("$_ does not exist") unless ( -d $data );
}

################################################################################
#   Create the makefile DEF file for this toolset
#
print "toolset = $ToolsetData{tag}\n";

foreach  ('object', 'library' ,'program', 'assembler' )
{
    my $data = '';
    $data = $ToolsetData{suffix}{$_} if ( exists $ToolsetData{suffix}{$_}  );

    print "$_ = $data\n" if $data;
}

#
#   Setup the environment defaults
#
foreach  ( @{$ToolsetData{ENVORDER}} )
{
    if ( exists $ToolsetData{ENV}{$_}{default} )
    {
        print "$_ ?= $ToolsetData{ENV}{$_}{default}\n";
    }
    else
    {
        print "$_  = $ToolsetData{ENV}{$_}{value}\n";
    }
}

#
#   Create a recipe to test the vality of the toolsets directories
#
print ".PHONY: $ToolsetData{tag}\n";
print "$ToolsetData{tag}:\n";
print "  ifndef GBE_NOTOOLSTEST\n";
print "\@\$(echo) [Toolset $ToolsetData{name} - $ToolsetData{long}];";
foreach my $dir ( @{$ToolsetData{ENVORDER}} )
{
    print " \\\n";
    print "\t\tif [ -z \"\$\$$dir\" ]; then echo \"$dir env var not set\"; exit 2; fi;";
    print " \\\n";
    print "\t\tif [ ! -d \"\$($dir)\" ]; then echo \"Directory $dir does not exist: \$($dir)\"; exit 2; fi;";
}
print "\n";
print "  endif\n";

#
#   Set up the PATH
#
foreach  ( @{$ToolsetData{PATH}} )
{
    print "PATH := \$(PATH);$_\n";
}
print "Path := \$(PATH)\n";
print "export PATH Path\n";

#
#   Set up the INCLUDE variable
#
print "INCLUDE :=\n";
foreach  ( @{$ToolsetData{INCLUDE}} )
{
    print "INCLUDE := \$(INCLUDE);$_\n";
}
print "export INCLUDE\n";

#
#   Set up the LIB variable
#
print "LIB :=\n";
foreach  ( @{$ToolsetData{LIB}} )
{
    print "LIB := \$(LIB);$_\n";
}
print "export LIB\n";

#
#   Setup the RPC exports
#
print "RPCGEN_CPP       := $ToolsetData{RPCGEN}{CPP}\n";
print "RPCGEN_CFLAGS    := $ToolsetData{RPCGEN}{FLAGS}\n";
print "export RPCGEN_CPP RPCGEN_CFLAGS\n";

#
#   Any ad-hoc definitions
#
foreach my $name ( @{$ToolsetData{DEFORDER}} )
{
    print "$name := $ToolsetData{DEFDATA}{$name}\n";
}