Subversion Repositories DevTools

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

# 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;