########################################################################
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
#
# Module name   : PLATFORM_CFG.PM
# Module type   : Makefile system
# Compiler(s)   : Perl
# Environment(s): jats
#
# Description   : Provides platform configuration information
#
#                 The main pupose of this configuration information is to
#                 prevent JATS from attempting to build software on
#                 a platform that does not support the required compilers
#
#                 ie: Its not possible to build PPC_302E on a windows
#                     Nor is it possbile to build WIN32 on a Sun Sparc
#
#                 This can be done via GBE_BUILDFILTER, but results in
#                 an unwieldy GBE_BUILDFILTER. Better to prune the
#                 targets at the start
#
#......................................................................#

require 5.008_002;
use strict;
use warnings;

package PlatformConfig;
use JatsError;

#
#   An array of known Keywords and Aliases
#       Keywords should not be used for platform names
#       Aliases are set up for the user
# 
our @BuildAliases = qw (NATIVE INSTRUMENT PKG_WIN PKG_RPM PKG_DEB SK);
our @BuildKeywords = ( qw (TOOLSET GENERIC GENERIC_MACHTYPE BASE_TARGET), @BuildAliases );

#
#   An array of platform aliases that will be expanded into multiple platforms
#
our @BuildFamilies = qw (ANDROIDNDK DEVLINUX GENERICS LINUX LMOS LMOS_DEVLINUX MSWIN32 MSWIN64 SOLARIS WINCE WINCE6 WINCE7 SK);

#
#   The following structure is a hash of arrays
#   The hash key is a supported machine type - one per machine
#   The data is an array of supported PLATFORMS
#   Each platform may have a : seperated list of tags
#   Known tags include:
#       TOOLSET - Suitable for building JATS tools
#       NATIVE  - Can be expected to run on the build machine
#       KNOWN - Indicated platform is known to this machine type. Used to test existence 
#       GENERIC - Can be built on any machine
#       GENERIC_MACHTYPE - Can be built on a specific machine type (Auto generated)
#       DEVLINUX - Part of the DEVLINUX alias
#       LINUX - Part of the LINUX alias 
#       LMOS - Bastard Platforms from Hell
#       PKG_DEB - Install Debian Packages   
#       PKG_RPM - Install RPM Packages
#       PKG_WIN - Install Windows Installers
#       SK - The SK familty of platforms
#       SOLARIS - Part of the SOLARIS alias
#       MACHTYPE - Machine Type to build on (Auto generated)
#       BASE_TARGET - Underling platform
#       NOTABT - Not available on a sanctioned build machine (GBE_ABT defined)
#
#
#   Platforms that are nolonger supported. We have no compilers for them and they have never been in the build system. 
#       ACEX AMX CMOS386 CMOS68K DF4OBE DOS16 DOS32 EEPP386 EETP386 EOS EOSM68K EOSP386 GMPCA GO32 
#       HK386PC HKAVM HKAVM2 HKBCP HKDDU HKGAK HKMPR HKPCA LINUX86 LINUX_ARMV4 MERG NGBCP NGDDU PHARLAP
#
#
our %BuildAvailability = (
    'linux_i386' => [
        'ANDROIDARM:ANDROIDNDK',
        'ANDROIDMIPS:ANDROIDNDK',
        'ANDROIDX86:ANDROIDNDK',
        'ANDROID',
        'ARM9TDMI:DEVLINUX:LMOS:PKG_DEB',
        'COBRA:DEVLINUX:LMOS:PKG_DEB',
        'COBRA2:DEVLINUX:LMOS:PKG_DEB',
        'HAMMERHEAD:PKG_DEB',
        'JAVA:NATIVE',
        'LINUX_EMU:LMOS',
        'LINUX_ETX:DEVLINUX:LMOS',
        'LINUX_I386:LMOS:NATIVE:TOOLSET',
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
        'SK20:DEVLINUX:PKG_DEB:SK',
        'SK20V41:DEVLINUX:PKG_DEB:SK',
        'UBUNTU12:NATIVE:TOOLSET:DEVLINUX:LMOS:PKG_DEB',
        'UBUNTU12_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
        'UBUNTU12C11:NATIVE:TOOLSET:DEVLINUX:PKG_DEB',
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
        'VIPER2:DEVLINUX:PKG_DEB',
        ],

    'linux_x64' => [
        'ANDROID:NOTABT',
        'LINUX_I386:LMOS:NATIVE:PKG_DEB',
        'JAVA:NATIVE',
        'UBUNTU14:NATIVE:TOOLSET:LINUX:PKG_DEB',
        'UBUNTU14_INSTRUMENT:NATIVE:LINUX:INSTRUMENT',
        'UBUNTU16:NATIVE:TOOLSET:LINUX:PKG_DEB',
        'UBUNTU16_INSTRUMENT:NATIVE:LINUX:INSTRUMENT',
        'ANDROIDARM:ANDROIDNDK',
        'ANDROIDARMV7:ANDROIDNDK',
        'ANDROIDMIPS:ANDROIDNDK',
        'ANDROIDX86:ANDROIDNDK',
        'ANDROIDARM64:ANDROIDNDK',
        'ANDROIDMIPS64:ANDROIDNDK',
        'ANDROIDX86_64:ANDROIDNDK',
        'ANDROID',
        'ARM9TDMI:DEVLINUX:LMOS',
        'COBRA:DEVLINUX:LMOS:PKG_DEB',
        'COBRA2:DEVLINUX:LMOS:PKG_DEB',
        'HAMMERHEAD:PKG_DEB',
        'LINUX_ETX:DEVLINUX:LMOS',
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
        'SK20:DEVLINUX:PKG_DEB:SK',
        'SK20V41:DEVLINUX:PKG_DEB:SK',
        'STIBAXIO:DEVLINUX:PKG_DEB',
        'SK100:DEVLINUX:PKG_DEB:SK',
        'UBUNTU12C11:NATIVE:DEVLINUX:PKG_DEB',
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
        'VIPER2:DEVLINUX:PKG_DEB',
        'MANSIG',
        ],

    'linux_el7_x64' => [
        'RHEL7:TOOLSET:NATIVE:PKG_RPM',
        'RHEL7_INSTRUMENT:NATIVE:INSTRUMENT',
        ],

    'solaris10_sparc32' => [
        'SOLARIS10_SPARC32:SOLARIS:NATIVE:TOOLSET',
        'SOLARIS10_SPARC64:SOLARIS:NATIVE',
        'JAVA:NATIVE',
        ],

    'solaris10_x86' => [
        'SOLARIS10_X86:SOLARIS:NATIVE:TOOLSET',
        'SOLARIS10_X64:SOLARIS:NATIVE',
        'JAVA:NATIVE',
        ],

    'sparc' => [
        'SOLARIS8_SPARC32:SOLARIS:NATIVE:TOOLSET',
        'JAVA:NATIVE',
        ],

    'win32' => [
        'ANDROID',
        'ARM_I5100',
        'AVR_IAR',
        'BORLAND',
        'CORTEXM3_IAR',
        'CSHARP:NATIVE',
        'CSHARP2005:NATIVE',
        'CSHARP2008:NATIVE',
        'CSHARP2010:NATIVE',
        'CSHARP2012:NATIVE',
        'CSHARP2015:NATIVE',
        'DAFBR_MOS',
        'DAFBR_WIN',
        'DELPHI7',
        'H8S',
        'H400',
        'INGEN',
        'INTELLECT',
        'JAVA:NATIVE',
        'MCR',
        'MOS68K',
        'MOS68KRM',
        'MOSCF',
        'MPT',
        'VSDEVRC',
        'PHP',
        'RIORDS',
        'THYRON',
        'VB6',
        'VERIX',
        'VIXITP',
        'VS2003:NATIVE',
        'VS2005:NATIVE:MSWIN32',
        'VS2008:NATIVE',
        'VS2010:NATIVE',
        'VS2012:NATIVE:TOOLSET:MSWIN32:PKG_WIN',
        'VS2015:NATIVE:TOOLSET:MSWIN32:PKG_WIN',
        'WCEIPA280:WINCE',
        'WCEIT3000:WINCE',
        'WCENAUTIZX5',
        'WCEPA961:WINCE',
        'WCEPA962:WINCE',
        'WCEPA962_500:WINCE',
        'WCEPCM7220:WINCE',
        'WCEPSION_420',
        'WCEPSION_500:WINCE',
        'WCEPSION_500_emu:WINCE',
        'WCEPSION_500_VS2005:WINCE',
        'WCEPSPC_arm:WINCE',
        'WCEPSPC_emu:WINCE',
        'WCEX86A420:WINCE',
        'WCEX86A500:WINCE',
        'WCEX86A500_SOM4455:WINCE',
        'WCEX86A700_SOM4466:WINCE7:WINCE',
        'WCE6ARMV4I:WINCE6',
        'WIN32:NATIVE:TOOLSET:MSWIN32:LMOS:PKG_WIN',
        'VS2012_X64:NATIVE:MSWIN64:PKG_WIN',
        'VS2015_X64:NATIVE:MSWIN64:PKG_WIN',
        ],

);

#
#   The above data will be reorganised and placed into the following
#   hashes to simplify data access
#
my %TargetByTag;
my %TagByTarget;

#-------------------------------------------------------------------------------
# Function        : InitData
#
# Description     : Init data structures
#                   Done once
#
#                   Convert the $BuildAvailability entry array into a hash to 
#                   simplify lookup. 
#                       Add in the GENERIC target
#                       Add in the GENERIC_MACHTYPE target
#                       Add in LMOS targets
#
# Inputs          : None
#
# Returns         : Nothing
#
sub InitData
{
    #
    #   Only do this work once
    #
    return if exists $TagByTarget{'GENERIC'};
    
    #
    #   Process all machine types
    #       Processes myself first
    #       Process linux_x64 before linux_i386
    #
    Error("GBE_MACHTYPE has not been defined ") unless defined $::GBE_MACHTYPE;
    foreach my $machType ( $::GBE_MACHTYPE, qw(linux_x64  linux_i386 linux_el7_x64 solaris10_sparc32 solaris10_x86 sparc win32 ))
    {
        #
        #   Validate build machine
        #
        Error("GBE_MACHTYPE has not been defined ") unless defined $machType;
        Error (__PACKAGE__ . " : Unknown build machine type: $machType")
            unless ( exists $BuildAvailability{$machType} );

        #
        #   Convert the array into a hash to speed up access later
        #   Create GENERIC platform
        #
        push @{$BuildAvailability{$machType}}, 'GENERIC:GENERIC';

        #
        #   Create Machine Type specific Generic
        #       GENERIC_XXXX:GENERIC_MACHTYPE:TOOLSET
        #   
        my $genericMachTypes = 'GENERIC_' . uc ($machType);
        push @{$BuildAvailability{$machType}}, join (':', $genericMachTypes, 'GENERIC_MACHTYPE', 'TOOLSET', 'GENERICS' );

        foreach ( @{$BuildAvailability{$machType}}  )
        {
            my @data = split(':', $_ );
            my $target = uc shift @data;
            my $hasLMOS;

            #
            #   Add in MACHTYPE, only the first machine is processed
            #
            next if exists $TagByTarget{$target}{'MACHTYPE'};
            $TagByTarget{$target}{'MACHTYPE'} = $machType;

            #
            #   If tagged as NOTABT and we are working on a sanctioned build machine
            #   with GBE_ABT set, then ignore this target. It cannot be built on a build
            #   machine. Used where we can develop on multiple machines but perform sanctioned builds
            #   only on one machine type.
            #
            if (defined $::GBE_ABT) {
                my $hasNotAbt = (grep $_ eq 'NOTABT', @data);
                if ($hasNotAbt) {
                    Warning("NotAbt. $target is not supported in a build system under $machType" );
                    next;
                }
            }


            #
            #   Add items into data structures
            #   Allow for AAAAA=Value
            #
            foreach my $item ( @data )
            {
                if ($item eq 'LMOS') {
                    $hasLMOS = 1;
                    next;
                }

                ($item, my $value) = split (/=/, $item,2);
                $value = 1 unless defined $value;
                $TagByTarget{$target}{uc($item)} = $value;
                push @{$TargetByTag{uc($item)}}, $target;
            }

            #
            #   Generate LMOS platforms entries from the base platform entry
            #   Similar to above, but it has LMOS prefix
            #   Some tags are not applicable to LMOS
            #       TOOLSET - Will never have an LMOS based toolset
            #   Some tags will not have LMOS_ prefixes
            #       NATIVE PKG_WIN PKG_RPM PKG_DEB SK
            #       ie: Those in @BuildAliases    
            #
            if ($hasLMOS)
            {
                my $lmosTarget = 'LMOS_' . $target;
                next if exists $TagByTarget{$lmosTarget}{'MACHTYPE'};
                $TagByTarget{$lmosTarget}{'MACHTYPE'} = $machType;

                $TagByTarget{$lmosTarget}{'BASE_TARGET'} = $target;
                push @{$TargetByTag{uc('LMOS')}}, $lmosTarget;

                foreach my $item ( @data )
                {
                    next if ($item eq 'LMOS');
                    next if ($item eq 'TOOLSET');

                    ($item, my $value) = split (/=/, $item,2);
                    $value = 1 unless defined $value;
                    unless (grep /^$item$/, @BuildAliases) {
                        $item = 'LMOS_' . $item;
                    }
                    $TagByTarget{$lmosTarget}{uc($item)} = $value;
                    push @{$TargetByTag{uc($item)}}, $lmosTarget;
                }

            }
        }
    }

    #DebugDumpData("TagByTarget", \%TagByTarget);
    #DebugDumpData("TargetByTag", \%TargetByTag);
    #DebugDumpData("BuildAvailability", \%BuildAvailability);
}

#-------------------------------------------------------------------------------
# Function        : getTargetsByTag 
#
# Description     : Fetch an array of build platforms that are tagged
#
# Inputs          : $tag    - Tag to process
#
# Returns         : An array of targets. May be empty
#

sub getTargetsByTag
{
    my ($tag) = @_;
    Error("Internal: getTargetsByTag. No tag specified") unless ($tag);
    InitData();

    if (exists ($TargetByTag{uc($tag)}) )
    {
        return @{$TargetByTag{uc($tag)}};
    }

    my @empty;
    return @empty;
}

#-------------------------------------------------------------------------------
# Function        : targetHasTag 
#
# Description     : Determine if the named target has the specified tag
#
# Inputs          : $target
#                   $tag 
#
# Returns         : Value of the Tag. May be 1
#                   Tags of the form NAME=VALUE wull return 'VALUE'
#
sub targetHasTag
{
    my ($target, $tag) = @_;
    my $value = 0;
    Error("Internal: targetHasTag. No target specified") unless ($target);
    Error("Internal: targetHasTag. No tag specified") unless ($tag);

    InitData();
    $target = uc ($target);
    if (exists ($TagByTarget{$target}) && exists ($TagByTarget{$target}{$tag}))
    {
        $value = $TagByTarget{$target}{$tag};
    }
    Debug3("targetHasTag: @_ -> $value");
    return $value;
}

#-------------------------------------------------------------------------------
# Function        : validMachType 
#
# Description     : Determine if a given machType is known to the system 
#
# Inputs          : machType - to be tested 
#
# Returns         : true - known to the system
#                   false - no known. 
#
sub validMachType {
    my ($machType) = @_;
    return exists $BuildAvailability{lc $machType};
}

#-------------------------------------------------------------------------------
# Function        : getGenericMachType 
#
# Description     : Calculate the generic machine type(s) for a specified target(s)    
#
# Inputs          : A target to process
#
# Returns         : An array of machine types 
#
sub getGenericMachType {
    my ($target) = @_;
    my $machType;

    if (exists $TagByTarget{$target}) {
        $machType =  'GENERIC_' . uc ($TagByTarget{$target}{MACHTYPE});
    }

    return $machType; 
}


1;