Subversion Repositories DevTools

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

# COPYRIGHT - VIX IP PTY LTD ("VIX"). 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";

}