Subversion Repositories DevTools

our @LINKPKGEXLUDES         = ();               # LinkPkgExclude arguments

# Function        : LinkPkgExclude 

#

# Description     : Mark a package to be excluded / included for a specific build

#                   Intended use:

#                       Recover from really (reaaly) badly constructed packages

#                       

#                   Essentially this directive will 'Exclude' packages from the

#                   a specific build target (platform) by removing it from data

#                   structures that are exported to the make stage

#                   

#                   Process ONLY works for LinkPkgArchive packages

#

# Inputs          : platform-selector   - A JATS style platform specifier

#                   package-list        - one or or packages to process

#                   

# Example         : LinkPkgExclude('!SK100', 'PulseSdk');

#                   LinkPkgExclude('SK100' , 'crypto');

#

sub LinkPkgExclude

{

    DataDirective('LinkPkgExclude');

    Error("LinkPkgExclude(@_) requires at least two arguments") unless ((scalar @_) >= 2);

    #

    #   Simply save the arguments for later processing

    #

    push @LINKPKGEXLUDES, join($;, @_);

}

#-------------------------------------------------------------------------------

# Function        : ProcessLinkPkgExclude 

#

# Description     : INTERNAL Function

#                   Process the data collected by the LinkPkgExclude directives  

#

# Inputs          : None

#                   Uses: LINKPKGEXLUDES    

#

# Returns         : Will modify interal classes and data structures

#

sub ProcessLinkPkgExclude

{

    my @unknownPlatforms;

    my @unknownPkg;

    my @notLinkPkg;

    #

    #   Create a hash of known platforms - detect and report bad user input

    #

    my %fullPlatformList =  map { $_ => 1 } @BUILDPLATFORMS;

    #

    #   Process each directive

    #

    foreach ( @LINKPKGEXLUDES )

    {

        my (@add, @remove);

        my ($pSel, @pkgList) = split($;, $_);

        Log("LinkPkgExclude $pSel, @pkgList");

        #

        #   Process the selector in the same manor as makefiles

        #       Need the selector to be active

        #       Selector may be an alias or a platform

        #       Selector may be negated

        #       Selectors are comma seperated

        #       Additive elements are processed before subtactive elements

        #           

        my @pItems = split(/\s*,\s*/, $pSel);

        @pItems = ExpandPlatforms( @pItems );

         foreach my $platform ( @pItems) {

             my $pname = $platform;

             my $invert;

             if (substr($platform, 0, 1) eq '!') {

                 $invert = 1;

                 $pname = substr($platform, 1)

                 }

             unless (exists($fullPlatformList{$pname})) {

                 UniquePush(\@unknownPlatforms, $pname);

                 next;

                 }

             if ( $invert )  {

                 push @remove, $pname; 

             } else {

                 push @add, $pname; 

             }

         }

         #

         #   Build complete list of allowed platforms

         #       Process additive rules before removal rules

         #       If there are no additive rules, then assume all protaforms

         #

         my %calcList;

         @add = @BUILDPLATFORMS unless @add;

         $calcList{uc $_} = 1 foreach (@add);

         delete $calcList{uc $_} foreach (@remove);

         Verbose2("LinkPkgExclude ", keys %calcList,",", @pkgList);

         #

         #  Now have a list of platforms to process (exclude)

         #  Now have a list of packages to exclude

         #

         #  Iterate over the package rules and mark those to be excluded

         #

         foreach my $platform ( keys %calcList )

         {

             unless (exists($PKGRULES{$platform})) {

                 next;

             }

             foreach my $ePackage (@pkgList) {

                 my $pkgFound;

                 foreach my $package ( @{$PKGRULES{$platform}} )

                 {

                     my $fname = $package->{'dname'};

                     if ( $package->{'dproj'}) {

                         $fname .= '.' . $package->{'dproj'};

                     }

                     if ( $ePackage eq $package->{'dname'}  || $ePackage eq $fname) {

                         $pkgFound = 1;

                         if ($package->{'type'} ne 'link') {

                             UniquePush(\@notLinkPkg, $ePackage);

                             last;

                         }

                         $package->{'EXCLUDE'} = 1;

                         Debug("Exclude", $platform, $fname );

                         last;

                     }

                 }

                 UniquePush(\@unknownPkg, $ePackage) unless $pkgFound;

             }

         }

   }

    ReportError("LinkPkgExclude. Unknown platforms:", @unknownPlatforms) if @unknownPlatforms;

    ReportError("LinkPkgExclude. Unknown packages:", @unknownPkg) if @unknownPkg;

    ReportError("LinkPkgExclude. BuildPkgArchive not allowed for:", @notLinkPkg) if @notLinkPkg;

    ErrorDoExit();

}

#-------------------------------------------------------------------------------

    ProcessLinkPkgExclude();

            next if exists $package->{'EXCLUDE'};