Subversion Repositories DevTools

Rev

Rev 6198 | Rev 6285 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 6198 Rev 6276
Line 31... Line 31...
31 
#
 31 
#
32 
#   An array of known Keywords and Aliases
 32 
#   An array of known Keywords and Aliases
33 
#       Keywords should not be used for platform names
 33 
#       Keywords should not be used for platform names
34 
#       Aliases are set up for the user
 34 
#       Aliases are set up for the user
35 
#
35 
#
36 
our @BuildAliases = qw (NATIVE INSTRUMENT PKG_WIN PKG_RPM PKG_DEB SK );
 36 
our @BuildAliases = qw (NATIVE INSTRUMENT PKG_WIN PKG_RPM PKG_DEB SK);
37 
our @BuildKeywords = ( qw (TOOLSET GENERIC GENERIC_MACHTYPE), @BuildAliases );
 37 
our @BuildKeywords = ( qw (TOOLSET GENERIC GENERIC_MACHTYPE BASE_TARGET), @BuildAliases );
- 
 
 38 
 
- 
 
 39 
#
- 
 
 40 
#   An array of platform aliases that will be expanded into multiple platforms
- 
 
 41 
#
- 
 
 42 
our @BuildFamilies = qw (ANDROIDNDK DEVLINUX GENERICS LINUX LMOS LMOS_DEVLINUX MSWIN32 MSWIN64 SOLARIS WINCE SK);
38 
 
 43 
 
39 
#
 44 
#
40 
#   The following structure is a hash of arrays
 45 
#   The following structure is a hash of arrays
41 
#   The hash key is a supported machine type - one per machine
 46 
#   The hash key is a supported machine type - one per machine
42 
#   The data is an array of supported PLATFORMS
 47 
#   The data is an array of supported PLATFORMS
Line 44... Line 49...
44 
#   Known tags include:
 49 
#   Known tags include:
45 
#       TOOLSET - Sutable for building JATS tools
 50 
#       TOOLSET - Sutable for building JATS tools
46 
#       NATIVE  - Can be expected to run on the build machine
 51 
#       NATIVE  - Can be expected to run on the build machine
47 
#       KNOWN - Indicated platform is known to this machine type. Used to test existence
52 
#       KNOWN - Indicated platform is known to this machine type. Used to test existence
48 
#       GENERIC - Can be built on any machine
 53 
#       GENERIC - Can be built on any machine
- 
 
 54 
#       GENERIC_MACHTYPE - Can be built on a specific machine type (Auto generated)
49 
#       DEVLINUX - Part of the DEVLINUX alias
 55 
#       DEVLINUX - Part of the DEVLINUX alias
50 
#       LINUX - Part of the LINUX alias
56 
#       LINUX - Part of the LINUX alias
51 
#       LMOS - Bastard Platforms from Hell
 57 
#       LMOS - Bastard Platforms from Hell
52 
#       PKG_DEB - Install Debian Packages
58 
#       PKG_DEB - Install Debian Packages
53 
#       PKG_RPM - Install RPM Packages
 59 
#       PKG_RPM - Install RPM Packages
54 
#       PKG_WIN - Install Windows Installers
 60 
#       PKG_WIN - Install Windows Installers
55 
#       SK - The SK familty of platforms
 61 
#       SK - The SK familty of platforms
- 
 
 62 
#       SOLARIS - Part of the SOLARIS alias
- 
 
 63 
#       MACHTYPE - Machine Type to build on (Auto generated)
- 
 
 64 
#       BASE_TARGET - Underling platform
56 
#
 65 
#
57 
our %BuildAvailability = (
 66 
our %BuildAvailability = (
58 
    'linux_i386' => [
 67 
    'linux_i386' => [
59 
        'ANDROIDARM:ANDROIDNDK',
 68 
        'ANDROIDARM:ANDROIDNDK',
60 
        'ANDROIDMIPS:ANDROIDNDK',
 69 
        'ANDROIDMIPS:ANDROIDNDK',
Line 73... Line 82...
73 
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
 82 
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
74 
        'SK20:DEVLINUX:PKG_DEB:SK',
 83 
        'SK20:DEVLINUX:PKG_DEB:SK',
75 
        'SK20V41:DEVLINUX:PKG_DEB:SK',
 84 
        'SK20V41:DEVLINUX:PKG_DEB:SK',
76 
        'UBUNTU12:NATIVE:TOOLSET:DEVLINUX:LMOS:PKG_DEB',
 85 
        'UBUNTU12:NATIVE:TOOLSET:DEVLINUX:LMOS:PKG_DEB',
77 
        'UBUNTU12_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
 86 
        'UBUNTU12_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
78 
        'UBUNTU12C11:NATIVE:TOOLSET:DEVLINUX:LMOS:PKG_DEB',
 87 
        'UBUNTU12C11:NATIVE:TOOLSET:DEVLINUX:PKG_DEB',
79 
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
 88 
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
80 
        'VIPER2:DEVLINUX:PKG_DEB',
 89 
        'VIPER2:DEVLINUX:PKG_DEB',
81 
        ],
 90 
        ],
82 
 
 91 
 
83 
    'linux_x64' => [
 92 
    'linux_x64' => [
Line 98... Line 107...
98 
        'LINUX_ETX:DEVLINUX:LMOS',
 107 
        'LINUX_ETX:DEVLINUX:LMOS',
99 
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
 108 
        'PPC_603E:DEVLINUX:LMOS:PKG_DEB',
100 
        'SK20:DEVLINUX:PKG_DEB:SK',
 109 
        'SK20:DEVLINUX:PKG_DEB:SK',
101 
        'SK20V41:DEVLINUX:PKG_DEB:SK',
 110 
        'SK20V41:DEVLINUX:PKG_DEB:SK',
102 
        'SK100:DEVLINUX:PKG_DEB:SK',
 111 
        'SK100:DEVLINUX:PKG_DEB:SK',
103 
        'UBUNTU12C11:NATIVE:DEVLINUX:LMOS:PKG_DEB',
 112 
        'UBUNTU12C11:NATIVE:DEVLINUX:PKG_DEB',
104 
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
 113 
        'UBUNTU12C11_INSTRUMENT:NATIVE:DEVLINUX:INSTRUMENT',
105 
        'VIPER2:DEVLINUX:PKG_DEB',
 114 
        'VIPER2:DEVLINUX:PKG_DEB',
106 
        ],
 115 
        ],
107 
 
 116 
 
108 
    'linux_el7_x64' => [
 117 
    'linux_el7_x64' => [
109 
        'RHEL7:LINUX:TOOLSET:NATIVE:PKG_RPM',
 118 
        'RHEL7:LINUX:TOOLSET:NATIVE:PKG_RPM',
110 
        'RHEL7_INSTRUMENT:NATIVE:LINUX:INSTRUMENT',
 119 
        'RHEL7_INSTRUMENT:NATIVE:LINUX:INSTRUMENT',
111 
        ],
 120 
        ],
112 
 
 121 
 
113 
    'solaris10_sparc32' => [
 122 
    'solaris10_sparc32' => [
114 
        'SOLARIS10_SPARC32:NATIVE:TOOLSET',
 123 
        'SOLARIS10_SPARC32:SOLARIS:NATIVE:TOOLSET',
115 
        'SOLARIS10_SPARC64:NATIVE',
 124 
        'SOLARIS10_SPARC64:SOLARIS:NATIVE',
116 
        'JAVA:NATIVE',
 125 
        'JAVA:NATIVE',
117 
        ],
 126 
        ],
118 
 
 127 
 
119 
    'solaris10_x86' => [
 128 
    'solaris10_x86' => [
120 
        'SOLARIS10_X86:NATIVE:TOOLSET',
 129 
        'SOLARIS10_X86:SOLARIS:NATIVE:TOOLSET',
121 
        'SOLARIS10_X64:NATIVE',
 130 
        'SOLARIS10_X64:SOLARIS:NATIVE',
122 
        'JAVA',
 131 
        'JAVA:NATIVE',
123 
        ],
 132 
        ],
124 
 
 133 
 
125 
    'sparc' => [
 134 
    'sparc' => [
126 
        'SOLARIS:NATIVE:TOOLSET:TARGET_CFG=SOLARIS8_SPARC32',
 135 
        'SOLARIS8_SPARC32:SOLARIS:NATIVE:TOOLSET',
127 
        'SOLARIS_I386',
 - 
 
128 
        'SOLARIS_SPARC',
 - 
 
129 
        'JAVA:NATIVE',
 136 
        'JAVA:NATIVE',
130 
        ],
 137 
        ],
131 
 
 138 
 
132 
    'win32' => [
 139 
    'win32' => [
133 
        'ANDROID',
 140 
        'ANDROID',
Line 207... Line 214...
207 
        'WCEPSPC_arm:WINCE',
 214 
        'WCEPSPC_arm:WINCE',
208 
        'WCEPSPC_emu:WINCE',
 215 
        'WCEPSPC_emu:WINCE',
209 
        'WCEX86A420:WINCE',
 216 
        'WCEX86A420:WINCE',
210 
        'WCEX86A500:WINCE',
 217 
        'WCEX86A500:WINCE',
211 
        'WCEX86A500_SOM4455:WINCE',
 218 
        'WCEX86A500_SOM4455:WINCE',
- 
 
 219 
        'WCEMOBILE6:WINCE',
212 
        'WIN32:NATIVE:TOOLSET:MSWIN32:LMOS:PKG_WIN',
 220 
        'WIN32:NATIVE:TOOLSET:MSWIN32:LMOS:PKG_WIN',
213 
        'VS2012_X64:NATIVE:MSWIN64:PKG_WIN',
 221 
        'VS2012_X64:NATIVE:MSWIN64:PKG_WIN',
214 
        'VS2015_X64:NATIVE:MSWIN64:PKG_WIN',
 222 
        'VS2015_X64:NATIVE:MSWIN64:PKG_WIN',
215 
        ],
 223 
        ],
216 
 
 224 
 
Line 228... Line 236...
228 
#
 236 
#
229 
# Description     : Init data structures
 237 
# Description     : Init data structures
230 
#                   Done once
 238 
#                   Done once
231 
#
 239 
#
232 
#                   Convert the $BuildAvailability entry array into a hash to
240 
#                   Convert the $BuildAvailability entry array into a hash to
- 
 
 241 
#                   simplify lookup.
233 
#                   simplify lookup. Add in the GENERIC target:
 242 
#                       Add in the GENERIC target
234 
#                       GENERIC         - can be built on ANY machine
 243 
#                       Add in the GENERIC_MACHTYPE target
- 
 
 244 
#                       Add in LMOS targets
235 
#
 245 
#
236 
# Inputs          : None
 246 
# Inputs          : None
237 
#
 247 
#
238 
# Returns         : Nothing
 248 
# Returns         : Nothing
239 
#
 249 
#
Line 241... Line 251...
241 
{
 251 
{
242 
    #
 252 
    #
243 
    #   Only do this work once
 253 
    #   Only do this work once
244 
    #
 254 
    #
245 
    return if exists $TagByTarget{'GENERIC'};
 255 
    return if exists $TagByTarget{'GENERIC'};
- 
 
 256
246 
    #
 257 
    #
247 
    #   Validate build machine
 258 
    #   Process all machine types
- 
 
 259 
    #       Processes myself first
- 
 
 260 
    #       Process linux_x64 before linux_i386
248 
    #
 261 
    #
249 
    Error("GBE_MACHTYPE has not been defined ") unless defined $::GBE_MACHTYPE;
 262 
    Error("GBE_MACHTYPE has not been defined ") unless defined $::GBE_MACHTYPE;
250 
    Error (__PACKAGE__ . " : Unknown build machine type: $::GBE_MACHTYPE")
 - 
 
251 
        unless ( exists $BuildAvailability{$::GBE_MACHTYPE} );
 - 
 
252 
 
 - 
 
253 
    #
 - 
 
254 
    #   Convert the array into a hash to speed up access later
 - 
 
255 
    #   Create GENERIC platform
 - 
 
256 
    #
 - 
 
257 
    push @{$BuildAvailability{$::GBE_MACHTYPE}}, 'GENERIC:GENERIC';
 - 
 
258 
 
 - 
 
259 
    #
 - 
 
260 
    #   Create Machine Type specific Generic
 - 
 
261 
    #       GENERIC_XXXX:GENERIC_MACHTYPE:TOOLSET
 - 
 
262 
    #
- 
 
263 
    my $genericMachTypes = 'GENERIC_' . uc ($::GBE_MACHTYPE);
 - 
 
264 
    push @{$BuildAvailability{$::GBE_MACHTYPE}}, join (':', $genericMachTypes, 'GENERIC_MACHTYPE', 'TOOLSET' );
 263 
    foreach my $machType ( $::GBE_MACHTYPE, qw(linux_x64  linux_i386 linux_el7_x64 solaris10_sparc32 solaris10_x86 sparc win32 ))
265 
 
 - 
 
266 
    foreach ( @{$BuildAvailability{$::GBE_MACHTYPE}}  )
 - 
 
267 
    {
 264 
    {
- 
 
 265 
        #
268 
        my @data = split(':', $_ );
 266 
        #   Validate build machine
- 
 
 267 
        #
- 
 
 268 
        Error("GBE_MACHTYPE has not been defined ") unless defined $machType;
- 
 
 269 
        Error (__PACKAGE__ . " : Unknown build machine type: $machType")
- 
 
 270 
            unless ( exists $BuildAvailability{$machType} );
- 
 
 271 
 
- 
 
 272 
        #
- 
 
 273 
        #   Convert the array into a hash to speed up access later
269 
        my $target = shift @data;
 274 
        #   Create GENERIC platform
- 
 
 275 
        #
- 
 
 276 
        push @{$BuildAvailability{$machType}}, 'GENERIC:GENERIC';
- 
 
 277 
 
- 
 
 278 
        #
- 
 
 279 
        #   Create Machine Type specific Generic
- 
 
 280 
        #       GENERIC_XXXX:GENERIC_MACHTYPE:TOOLSET
- 
 
 281 
        #
- 
 
 282 
        my $genericMachTypes = 'GENERIC_' . uc ($machType);
- 
 
 283 
        push @{$BuildAvailability{$machType}}, join (':', $genericMachTypes, 'GENERIC_MACHTYPE', 'TOOLSET', 'GENERICS' );
270 
 
 284 
 
271 
        $TagByTarget{$target}{'KNOWN'} = 1;
 - 
 
272 
        foreach my $item ( @data )
 285 
        foreach ( @{$BuildAvailability{$machType}}  )
273 
        {
 286 
        {
- 
 
 287 
            my @data = split(':', $_ );
- 
 
 288 
            my $target = uc shift @data;
- 
 
 289 
            my $hasLMOS;
- 
 
 290 
 
- 
 
 291 
            #
- 
 
 292 
            #   Add in MACHTYPE, only the first machine is processed
- 
 
 293 
            #
- 
 
 294 
            next if exists $TagByTarget{$target}{'MACHTYPE'};
- 
 
 295 
            $TagByTarget{$target}{'MACHTYPE'} = $machType;
- 
 
 296 
 
- 
 
 297 
            #
- 
 
 298 
            #   Add items into data structures
- 
 
 299 
            #   Allow for AAAAA=Value
- 
 
 300 
            #
- 
 
 301 
            foreach my $item ( @data )
- 
 
 302 
            {
- 
 
 303 
                if ($item eq 'LMOS') {
- 
 
 304 
                    $hasLMOS = 1;
- 
 
 305 
                    next;
- 
 
 306 
                }
- 
 
 307 
 
274 
            ($item, my $value) = split (/=/, $item,2);
 308 
                ($item, my $value) = split (/=/, $item,2);
275 
            $value = 1 unless defined $value;
 309 
                $value = 1 unless defined $value;
276 
            $TagByTarget{$target}{uc($item)} = $value;
 310 
                $TagByTarget{$target}{uc($item)} = $value;
277 
            push @{$TargetByTag{uc($item)}}, $target;
 311 
                push @{$TargetByTag{uc($item)}}, $target;
- 
 
 312 
            }
- 
 
 313 
 
- 
 
 314 
            #
- 
 
 315 
            #   Generate LMOS platforms entries from the base platform entry
- 
 
 316 
            #   Similar to above, but it has LMOS prefix
- 
 
 317 
            #
- 
 
 318 
            if ($hasLMOS)
- 
 
 319 
            {
- 
 
 320 
                my $lmosTarget = 'LMOS_' . $target;
- 
 
 321 
                next if exists $TagByTarget{$lmosTarget}{'MACHTYPE'};
- 
 
 322 
                $TagByTarget{$lmosTarget}{'MACHTYPE'} = $machType;
- 
 
 323 
 
- 
 
 324 
                $TagByTarget{$lmosTarget}{'BASE_TARGET'} = $target;
- 
 
 325 
                push @{$TargetByTag{uc('LMOS')}}, $lmosTarget;
- 
 
 326 
 
- 
 
 327 
                foreach my $item ( @data )
- 
 
 328 
                {
- 
 
 329 
                    next if ($item eq 'LMOS');
- 
 
 330 
                    ($item, my $value) = split (/=/, $item,2);
- 
 
 331 
                    $value = 1 unless defined $value;
- 
 
 332 
                    $item = 'LMOS_' . $item;
- 
 
 333 
                    $TagByTarget{$lmosTarget}{uc($item)} = $value;
- 
 
 334 
                    push @{$TargetByTag{uc($item)}}, $lmosTarget;
- 
 
 335 
                }
- 
 
 336 
 
- 
 
 337 
            }
278 
        }
 338 
        }
279 
    }
 339 
    }
280 
 
 340 
 
281 
    #DebugDumpData("TagByTarget", \%TagByTarget);
 341 
    #DebugDumpData("TagByTarget", \%TagByTarget);
282 
    #DebugDumpData("TargetByTag", \%TargetByTag);
 342 
    #DebugDumpData("TargetByTag", \%TargetByTag);
- 
 
 343 
    #DebugDumpData("BuildAvailability", \%BuildAvailability);
283 
}
 344 
}
284 
 
 345 
 
285 
#-------------------------------------------------------------------------------
 346 
#-------------------------------------------------------------------------------
286 
# Function        : getTargetsByTag
347 
# Function        : getTargetsByTag
287 
#
 348 
#
Line 308... Line 369...
308 
}
 369 
}
309 
 
 370 
 
310 
#-------------------------------------------------------------------------------
 371 
#-------------------------------------------------------------------------------
311 
# Function        : targetHasTag
372 
# Function        : targetHasTag
312 
#
 373 
#
313 
# Description     : Determineif the named target has the specified tag
 374 
# Description     : Determine if the named target has the specified tag
314 
#
 375 
#
315 
# Inputs          : $target
 376 
# Inputs          : $target
316 
#                   $tag
377 
#                   $tag
317 
#
 378 
#
318 
# Returns         : Value of the Tag. May be 1
 379 
# Returns         : Value of the Tag. May be 1
319 
#                   Tags of the form NAME=VALUE wull return 'VALUE'
 380 
#                   Tags of the form NAME=VALUE wull return 'VALUE'
320 
#
 381 
#
321 
sub targetHasTag
 382 
sub targetHasTag
322 
{
 383 
{
323 
    my ($target, $tag) = @_;
 384 
    my ($target, $tag) = @_;
- 
 
 385 
    my $value = 0;
324 
    Error("Internal: targetHasTag. No target specified") unless ($target);
 386 
    Error("Internal: targetHasTag. No target specified") unless ($target);
325 
    Error("Internal: targetHasTag. No tag specified") unless ($tag);
 387 
    Error("Internal: targetHasTag. No tag specified") unless ($tag);
326 
 
 388 
 
327 
    InitData();
 389 
    InitData();
- 
 
 390 
    $target = uc ($target);
328 
    if (exists ($TagByTarget{$target}) && exists ($TagByTarget{$target}{$tag}))
 391 
    if (exists ($TagByTarget{$target}) && exists ($TagByTarget{$target}{$tag}))
329 
    {
 392 
    {
330 
        return $TagByTarget{$target}{$tag};
 393 
        $value = $TagByTarget{$target}{$tag};
331 
    }
 394 
    }
- 
 
 395 
    Debug3("targetHasTag: @_ -> $value");
332 
    return 0;
 396 
    return $value;
333 
}
 397 
}
334 
 
 398 
 
335 
1;
 399 
1;
336 
 
 400