WebSVN – DevTools – Diff – /manifest-tool/trunk/src/gbe/DIRECTIVES/ManifestFiles.pm

 ########################################################################
-# Copyright (C) 2007 ERG Limited, All rights reserved
+# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
+#
-# Module name   : jats.sh
+# Module name   : ManifestFiles.pm
 # Module type   : Makefile system
-# Compiler(s)   : n/a
-# Environment(s): jats
+# Environment(s): JATS Build System
 # Documents     : MASS-00232 Format of the Linux App Upgrade Manifest File
+#
 # Description   : This package extends the JATS toolset at build time
 #                 It provides additional directives to the JATS makefiles
 #                 to simplify the directives.
 #                       --Name=Name             - Mandatory
 #                       --Tier=Name             - Mandatory
 #                       --Architecture=xxxx     - Default actitecture is the current target
 #                       --Product=yyyy          - Product Family
 #                       --Debian=BaseName[,--Prod,--Debug,--Arch=xxxx,--Product=yyyy]
+#                       --Apk=BaseName[,--Prod,--Debug,--Platform=pppp]
+#                                                   Default platform = ANDROID
+#                                                   Default type = Production
 #                       --MugPackage=Package[,--Subdir=subdir[,subdir]+]
 #                       --SrcFile=xxx
 #                       --SrcFileNoCopy=xxx
 #                       --Comment=xxx           - Add comment to Manifst
 #                       --NoManifestVersion     - Create unversioned Manifest File
     #   Collect user options
+    #
     foreach ( @elements )
+    {
         if ( m~^--Name=(.+)~ ) {
-            if ( $name )
+            if ( $name ) {
-            {
                 ReportError ("ManifestFiles:--Name option is only allowed once");
                 next;
+            }
             $name = $1;
         } elsif ( m~^--Tier=(.+)~ ) {
-            if ( $tier )
+            if ( $tier ) {
-            {
                 ReportError ("ManifestFiles:--Tier option is only allowed once");
                 next;
+            }
             $tier = $1;
             $cmt =~ s~.+=~~;
             $cmt =~ s~\s*\n\s*~\n~g;
             push @files, {'cmt' => $cmt };
         } elsif ( m~^--Debian=(.+)~ ) {
-            push @files, {'file' => LocateDebianFile($1, $default_arch, $default_prod)};
+            push @files, {'file' => _LocateDebianFile($1, $default_arch, $default_prod)};
+        } elsif ( m~^--Apk=(.+)~ ) {
+            push @files, {'file' => _LocateApkFile($1, $default_arch)};
         } elsif ( m~^--SrcFile=(.+)~ ) {
             push @files, {'file' => LocatePreReq($1)};
         } elsif ( m~^--SrcFileNoCopy=(.+)~ ) {
             push @files, {'filenocopy' => $1};
         } elsif ( m~^--MugPackage=(.+)~ ) {
-            if ( $mug_dir )
+            if ( $mug_dir ) {
-            {
                 ReportError ("ManifestFiles:--MugPackage option is only allowed once");
                 next;
+            }
-            $mug_dir = LocateMugDir($1);
+            $mug_dir = _LocateMugDir($1);
         } elsif ( m/^--Arch(.*)=(.+)/ ) {
             $default_arch = $2;
         } elsif ( m/^--Product=(.+)/ ) {
         } elsif ( m/^--NoManifestVersion/i ) {
             $Manifest_has_version = 0;
         } elsif ( m/^--PkgSubdir=(.+)/i ) {
-            if ( $pkg_subdir )
+            if ( $pkg_subdir ) {
-            {
                 ReportError ("ManifestFiles:--PkgSubdir option is only allowed once");
                 next;
+            }
             $pkg_subdir = $1;
         } elsif ( m/^--ImportManifest=(.+)/i ) {
-            my $import_info = ImportManifest($1, $tier, $name);
+            my $import_info = _ImportManifest($1, $tier, $name);
 #DebugDumpData("ImportInfo", $import_info );
             push @files, {'manifest' => $import_info };
+            #
             #   Fill in details unless already provided
+    #
     ReportError ("ManifestFiles: No name specified")
         unless $name;
     ReportError ("ManifestFiles: No tier specified")
         unless defined ($tier);
-    ReportError ("ManifestFiles: Cannot mix --Debian/--SrcFile with --MugPackage in one directive")
+    ReportError ("ManifestFiles: Cannot mix --Debian/-Apk/--SrcFile with --MugPackage in one directive")
         if ( $mug_dir && (@files || $imported_manifest) );
     ReportError ("ManifestFiles: Must specify files to add to Manifest")
         unless ( $mug_dir ||  @files || $imported_manifest);
     ErrorDoExit();
 #DebugDumpData("DirectiveData", \%data );
     push @Manifests, \%data;
     return;
+}
+#-------------------------------------------------------------------------------
+# Function        : _LocateDebianFile
+#
+# Description     : Locate a debian file
+#                   Internal Function
+#
+#                   Scan packages for the Debian package specified
+#                   The user provides the base name of the package
+#                   A Debian Package name has several fields
+#                   These are:
+#                       1) Base Name - Provided by the user
+#                       2) Version - Version will be wildcarded
+#                       3) Architecture - Wildcarded. Uses bin/arch directory
+#
+#                   Expect to find Debian Packages in the bin/PLATFORM subdir
+#
+# Inputs          : Debian base name, complete with suboptions
+#
+# Returns         : Full path of the file
+#
+sub _LocateDebianFile
+{
+    my ($arg, $arch, $product) = @_;
+    Verbose("LocateDebianFile: Processing: $arg");
+    my @type = qw( P D );
+    my @debian_file_path;
-    #-------------------------------------------------------------------------------
-    # Function        : LocateDebianFile
+    #
-    # Description     : Locate a debian file
+    #   Extract sub-options
-    #                   Internal Function
+    #       --Prod[uction]
+    #       --Debug
+    #       --Arch[itecture]=yyy
+    #       --Product=yyy
+    #
-    #                   Scan packages for the Debian package specified
+    my ($base_name, @opts) = split( ',', $arg );
+    foreach ( @opts )
+    {
-    #                   The user provides the base name of the package
+        if ( m/^--Arch(.*)=(.+)/ ) {
+            $arch=$2;
-    #                   A Debian Package name has several fields
+        } elsif ( m/^--Product=(.+)/ ) {
-    #                   These are:
+            $product=$1;
-    #                       1) Base Name - Provided by the user
+        } elsif ( m/^--Prod/ ) {
+            @type = 'P';
-    #                       2) Version - Version will be wildcarded
+        } elsif ( m/^--Debug/ ) {
+            @type = 'D';
+        } else {
-    #                       3) Architecture - Wildcarded. Uses bin/arch directory
+            Warning ('--Debian: Unknown Option: ' . $_);
+        }
+    }
+    #
-    #                   Expect to find Debian Packages in the bin/PLATFORM subdir
+    #   Create a list of products
+    #   ie: PRODUCT_ARCH
+    #
+    my @products;
-    # Inputs          : Debian base name, complete with suboptions
+    push @products, $product . '_' . $arch if ( $product );
+    push @products, $arch;
+    #
-    # Returns         : Full path of the file
+    #   Scan all packages for the specified debian package
+    #
-    sub LocateDebianFile
+    foreach my $package_dir ( getPackagePaths ('--All') )
+    {
-        my ($arg, $arch, $product) = @_;
-        Verbose("LocateDebianFile: Processing: $arg");
-        my @type = qw( P D );
-        my @debian_file_path;
-        #
-        #   Extract sub-options
-        #       --Prod[uction]
-        #       --Debug
-        #       --Arch[itecture]=yyy
-        #
-        my ($base_name, @opts) = split( ',', $arg );
-        foreach ( @opts )
+        foreach my $type ( @type )
+        {
-            if ( m/^--Arch(.*)=(.+)/ ) {
-                $arch=$2;
-            } elsif ( m/^--Product=(.+)/ ) {
-                $product=$1;
-            } elsif ( m/^--Prod/ ) {
-                @type = 'P';
-            } elsif ( m/^--Debug/ ) {
-                @type = 'D';
-            }
-        }
-        #
-        #   Create a list of products
-        #   ie: PRODUCT_ARCH
-        #
-        my @products;
-        push @products, $product . '_' . $arch if ( $product );
-        push @products, $arch;
-        #
-        #   Scan all packages for the specified debian package
-        #
-        foreach my $package_dir ( getPackagePaths ('--All') )
-        {
-            foreach my $type ( @type )
-            {
-                foreach my $prd ( @products )
+            foreach my $prd ( @products )
-                {
-                    foreach my $joiner ( qw(/ .) )
-                    {
-                        my $dir = "$package_dir/bin$joiner$prd$type";
-                        Verbose("ManifestFiles: Search in $dir");
-                        next unless ( -d $dir );
-                        my @files = glob ( "$dir/${base_name}_*.deb" );
-                        next unless ( @files );
-                        push @debian_file_path, @files;
-                        $package_dirs{$package_dir}{used} = 1;
-                    }
-                }
-            }
-            foreach my $type ( @type )
+            {
-                foreach my $prd ( @products )
+                foreach my $joiner ( qw(/ .) )
+                {
-                    my $dir = "$package_dir";
+                    my $dir = "$package_dir/bin$joiner$prd$type";
                     Verbose("ManifestFiles: Search in $dir");
                     next unless ( -d $dir );
-                    my @files = glob ( "$dir/${base_name}_*_${prd}_${type}.deb" );
+                    my @files = glob ( "$dir/${base_name}_*.deb" );
                     next unless ( @files );
                     push @debian_file_path, @files;
                     $package_dirs{$package_dir}{used} = 1;
+                }
+            }
+        }
+        foreach my $type ( @type )
+        {
+            foreach my $prd ( @products )
+            {
+                my $dir = "$package_dir";
-        ReportError ("Required Debian package not found: $base_name") unless @debian_file_path;
+                Verbose("ManifestFiles: Search in $dir");
+                next unless ( -d $dir );
-        ReportError ("Multiple matching Debian Packages located: $base_name", @debian_file_path ) if ( $#debian_file_path > 0 );
+                my @files = glob ( "$dir/${base_name}_*_${prd}_${type}.deb" );
+                next unless ( @files );
-        return $debian_file_path[0];
+                push @debian_file_path, @files;
+                $package_dirs{$package_dir}{used} = 1;
+            }
+        }
+    }
+    ReportError ("Required Debian package not found: $base_name") unless @debian_file_path;
+    ReportError ("Multiple matching Debian Packages located: $base_name", @debian_file_path ) if ( $#debian_file_path > 0 );
+    return $debian_file_path[0];
+}
-    #-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
-    # Function        : LocateMugDir
+# Function        : _LocateApkFile
-    #
+#
-    # Description     : Locate the directory containing the mugfiles
+# Description     : Locate a APK file
-    #                   Internal Function
+#                   Internal Function
+#
+#                   Scan packages for the APK package specified
+#                   The user provides the base name of the package
+#                   APK ( Android Packages )
+#                   Expect to have a '-release' or '-debug' suffix, except those provided via a
+#                   3rd party SDK.
+#                   Expect to find APK Packages in the bin/PLATFORM(P/D) subdir
+#                   Expect to find -debug in the <PLATFORM>D directory
+#                   Expect to find -release' in the <PLATFORM>P directory
+#
+#                   Allow for:
+#                       Full path to .apk file
+#                       .apk in package root directory
-    #
+#
-    # Inputs          : Mufile package, with embedded options
+# Inputs          : Apk base name, complete with suboptions
+#
+# Returns         : Full path of the file
+#
+sub _LocateApkFile
+{
+    my ($arg, $arch) = @_;
+    Verbose("LocateApkFile: Processing: $arg");
+    my @type = qw( P );
+    my @apk_file_path;
+    my %type = ('P' => '-release', 'D' => '-debug' );
+    #
+    #   Extract sub-options
-    # Returns         : Full path
+    #       --Prod[uction]
+    #       --Debug
+    #       --Architecture=yyy
+    #
+    my ($base_name, @opts) = split( ',', $arg );
-    sub LocateMugDir
+    foreach ( @opts )
+    {
-        my ($mug_package) = @_;
+        if ( m/^--Arch(.*)=(.+)/ ) {
-        #
+            $arch=$2;
-        #   Locate the mugfile subdir
+        } elsif ( m/^--Prod/ ) {
-        #
-        my $package_name = $mug_package;
-        my @dirs = 'mug';
+            @type = 'P';
-        my $mug_dir;
+        } elsif ( m/^--Debug/ ) {
-        #
-        #   Extract sub options
+            @type = 'D';
-        #       --Subdir=xxxx,yyyy,zzzz
-        #
-        if ( $package_name =~ m/(.*?),--Subdir=(.*)/ )
-        {
+        } else {
-            $package_name = $1;
-            @dirs = split( ',', $2 );
+            Warning ('--Apk: Unknown Option: ' . $_);
+        }
+    }
+    #
-        my $package = GetPackageEntry( $package_name );
+    #   Scan all packages for the specified APK package
+    #   Try:
+    #       Raw name - for apks from the SDK or 3rd parties
+    #       PLATFORM(P|D)/baseName-(release|debug) - Expected
-        unless ( $package )
+    #       baseName-(release|debug) - Repackaged badly
-        {
+    #
-            ReportError ("ManifestFiles: Package not known to build: $package_name");
+    foreach my $package_dir ( getPackagePaths ('--All') )
+    {
-            return undef;
+        my $testFile;
+        $testFile = "$package_dir/${base_name}.apk";
+        if ( -f $testFile ) {
+                push @apk_file_path, $testFile;
+        }
-        foreach my $subdir ( @dirs )
+        foreach my $type ( @type )
+        {
-            my $dir = "$package->{'ROOT'}/$subdir";
+            my $typeSuffix = $type{$type};
-            if ( -d $dir )
+            foreach my $joiner ( qw(/ .) )
+            {
-                Warning ("Multiple Mugfile directories located. Only the first will be used",
+                my $dir = "$package_dir/bin$joiner$arch$type";
-                         "Ignoring: $subdir" )if ( $mug_dir );
+                Verbose("ManifestFiles: Search in $dir");
-                $mug_dir = $dir;
+                next unless ( -d $dir );
+                $testFile = "$dir/${base_name}${typeSuffix}.apk";
+                if ( -f $testFile ) {
+                        push @apk_file_path, $testFile;
+                }
+            }
+        }
+        foreach my $type ( @type )
+        {
+            my $typeSuffix = $type{$type};
+            my $dir = "$package_dir";
-        ReportError ("Mugfile directory not found in package: $package_name")
+            Verbose("ManifestFiles: Search in $dir");
-            unless $mug_dir;
+            next unless ( -d $dir );
+            my $testFile = "$dir/${base_name}${typeSuffix}.apk";
-        return $mug_dir;
+            if ( -f $testFile ) {
+                    push @apk_file_path, $testFile;
+            }
+        }
+        $package_dirs{$package_dir}{used} = 1 if (@apk_file_path) ;
+    }
+    ReportError ("Required APK package not found: $base_name") unless @apk_file_path;
+    ReportError ("Multiple matching APK Packages located: $base_name", @apk_file_path ) if ( $#apk_file_path > 0 );
+    return $apk_file_path[0];
+}
-    #-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
-    # Function        : ImportManifest
+# Function        : _LocateMugDir
+#
+# Description     : Locate the directory containing the mugfiles
+#                   Internal Function
+#
+# Inputs          : Mufile package, with embedded options
+#
+# Returns         : Full path
+#
+sub _LocateMugDir
+{
+    my ($mug_package) = @_;
+    #
-    # Description     : Import an existing manifest
+    #   Locate the mugfile subdir
+    #
-    # Inputs          : Args    - PackageName[,Subdir=name,--ReWrite]
+    my $package_name = $mug_package;
-    #                   tier    - May be null
+    my @dirs = 'mug';
-    #                   name    - May be null
+    my $mug_dir;
+    #
+    #   Extract sub options
-    # Returns         : A hash of data to be used later
+    #       --Subdir=xxxx,yyyy,zzzz
+    #
-    sub ImportManifest
+    if ( $package_name =~ m/(.*?),--Subdir=(.*)/ )
+    {
-        my ($args, $tier, $name) = @_;
+        $package_name = $1;
-        my @file_contents;
+        @dirs = split( ',', $2 );
-        my @file_list;
+    }
-        #
-        #   Locate the mugfile subdir
-        #
-        my $package_name = $args;
+    my $package = GetPackageEntry( $package_name );
-        my @dirs = 'mug';
-        my $pkg_dir;
-        my $pkg_root;
+    unless ( $package )
-        my $manifest;
+    {
-        my $first_tier;
+        ReportError ("ManifestFiles: Package not known to build: $package_name");
-        my $first_name;
+        return undef;
-        my $rewrite;
+    }
+    foreach my $subdir ( @dirs )
-        #
+    {
-        #   Extract sub options
-        #       --Subdir=xxxx,yyyy,zzzz
+        my $dir = "$package->{'ROOT'}/$subdir";
-        #       --ReWrite
+        if ( -d $dir )
-        #
-        if ( $package_name =~ m/(.*?)(,.*)/ )
+        {
-            $package_name = $1;
+            Warning ("Multiple Mugfile directories located. Only the first will be used",
-            my @subargs = split(',--', $2);
+                     "Ignoring: $subdir" )if ( $mug_dir );
-            foreach ( @subargs)
+            $mug_dir = $dir;
-            {
+        }
+    }
-                next unless (length($_) > 0);
+    ReportError ("Mugfile directory not found in package: $package_name")
-                if (m~^Subdir=(.*)~i){
+        unless $mug_dir;
-                    @dirs = split( ',', $1 );
-                } elsif (m~^ReWrite~i) {
-                    $rewrite = 1;
+    return $mug_dir;
+}
-                } else {
-                    ReportError("ManifestFiles: Unknown suboption to ImportManifest:" . $_);
-                }
-            }
-        }
+#-------------------------------------------------------------------------------
+# Function        : _ImportManifest
+#
+# Description     : Import an existing manifest
+#
-        my $package = GetPackageEntry( $package_name );
+# Inputs          : Args    - PackageName[,Subdir=name,--ReWrite]
-        unless ( $package )
+#                   tier    - May be null
-        {
+#                   name    - May be null
+#
-            ReportError ("ManifestFiles: Package not known to build: $package_name");
+# Returns         : A hash of data to be used later
+#
+sub _ImportManifest
+{
+    my ($args, $tier, $name) = @_;
-            return undef;
+    my @file_contents;
-        }
+    my @file_list;
+    #
-        if (defined ($rewrite) && ( !defined($tier) || !defined($name)))
+    #   Locate the mugfile subdir
-        {
+    #
-            ReportError ("ManifestFiles: ImportManifest. --ReWrite cannot be used unless tier and name are specified");
+    my $package_name = $args;
+    my @dirs = 'mug';
+    my $pkg_dir;
+    my $pkg_root;
+    my $manifest;
+    my $first_tier;
-            return undef;
+    my $first_name;
-        }
+    my $rewrite;
+    #
-        foreach my $subdir ( @dirs )
+    #   Extract sub options
+    #       --Subdir=xxxx,yyyy,zzzz
+    #       --ReWrite
+    #
+    if ( $package_name =~ m/(.*?)(,.*)/ )
-        {
+    {
-            my $dir = "$package->{'ROOT'}/$subdir";
+        $package_name = $1;
-            my $root = $package->{'ROOT'};
+        my @subargs = split(',--', $2);
-            if ( -d $dir )
+        foreach ( @subargs)
-            {
+        {
-                Warning ("Multiple Package directories located. Only the first will be used",
+            next unless (length($_) > 0);
+            if (m~^Subdir=(.*)~i){
-                         "Ignoring: $subdir" )if ( $pkg_dir );
+                @dirs = split( ',', $1 );
-                $pkg_dir = $dir;
+            } elsif (m~^ReWrite~i) {
-                $pkg_root = $root;
+                $rewrite = 1;
+            } else {
+                ReportError("ManifestFiles: Unknown suboption to ImportManifest:" . $_);
+            }
+        }
+    }
+    my $package = GetPackageEntry( $package_name );
-        unless ($pkg_dir)
+    unless ( $package )
-        {
+    {
-            ReportError ("Package directory not found in package: $package_name");
+        ReportError ("ManifestFiles: Package not known to build: $package_name");
-            return undef;
+        return undef;
-        }
+    }
-        #
-        #   Determine Manifest File name
-        #
-        foreach my $file ( glob ($pkg_dir . '/Manifest*' ) )
+    if (defined ($rewrite) && ( !defined($tier) || !defined($name)))
-        {
+    {
-                next unless ( -f $file );
-                Warning ("Multiple Manifest Files find. Only the first will be used",
+        ReportError ("ManifestFiles: ImportManifest. --ReWrite cannot be used unless tier and name are specified");
-                         "Using: $manifest",
-                         "Ignoring: $file" ) if ( $manifest );
-                $manifest = $file;
+        return undef;
-        }
+    }
+    foreach my $subdir ( @dirs )
+    {
+        my $dir = "$package->{'ROOT'}/$subdir";
+        my $root = $package->{'ROOT'};
-        unless ($manifest)
+        if ( -d $dir )
         {
+            Warning ("Multiple Package directories located. Only the first will be used",
-            ReportError ("ImportManifest. No Manifest found: $package_name");
+                     "Ignoring: $subdir" )if ( $pkg_dir );
-            return undef;
+            $pkg_dir = $dir;
+            $pkg_root = $root;
+        }
+    }
+    unless ($pkg_dir)
+    {
+        ReportError ("Package directory not found in package: $package_name");
+        return undef;
+    }
+    #
+    #   Determine Manifest File name
+    #
+    foreach my $file ( glob ($pkg_dir . '/Manifest*' ) )
+    {
+            next unless ( -f $file );
+            Warning ("Multiple Manifest Files find. Only the first will be used",
+                     "Using: $manifest",
+                     "Ignoring: $file" ) if ( $manifest );
+            $manifest = $file;
+    }
+    unless ($manifest)
+    {
+        ReportError ("ImportManifest. No Manifest found: $package_name");
+        return undef;
+    }
+    #
+    #
+    #
+    open (MF, '<', $manifest ) || Error ("Cannot open the Manifest file: $manifest", $!);
+    while ( <MF> )
+    {
+        #
+        #   Clean trailing whitespace ( line-feed and new lines )
+        #   Comment out [Version] data
+        #
-        #
-        open (MF, '<', $manifest ) || Error ("Cannot open the Manifest file: $manifest", $!);
-        while ( <MF> )
-        {
-            #
-            #   Clean trailing whitespace ( line-feed and new lines )
-            #   Comment out [Version] data
-            #
-            s~\s+$~~;
+        s~\s+$~~;
-            s~(\s*\[Version])~#$1~;
+        s~(\s*\[Version])~#$1~;
-            #
+        #
-            #   Part lines and determine files
+        #   Part lines and determine files
-            #
+        #
-            next unless ( $_ );
+        next unless ( $_ );
-            next if ( m~\s*#~ );
+        next if ( m~\s*#~ );
-            next if ( m~\s*\[~ );
+        next if ( m~\s*\[~ );
-            my( $aname, $atier, $afile) = split(/\s*\,\s*/, $_);
+        my( $aname, $atier, $afile) = split(/\s*\,\s*/, $_);
 #            print "---------- $_\n";
 #            print "T: $atier, N:$aname, F:$afile\n";
-            push @file_list, $afile;
+        push @file_list, $afile;
-            #
+        #
-            #   Rewrite the name and tier
+        #   Rewrite the name and tier
-            #
+        #
-            if ($rewrite)
+        if ($rewrite)
-            {
+        {
-                $_ = join(',', $name, $tier, $afile);
+            $_ = join(',', $name, $tier, $afile);
-                $first_tier = $tier;
+            $first_tier = $tier;
-                $first_name = $name;
+            $first_name = $name;
-            }
-            else
-            {
-                #
-                #   Capture first tier and name
-                #
-                $first_tier = $atier unless ( defined $first_tier );
-                $first_name = $aname unless ( defined $first_name );
-            }
+        }
-        continue
+        else
+        {
+            #
-            push @file_contents, $_;
+            #   Capture first tier and name
+            #
+            $first_tier = $atier unless ( defined $first_tier );
+            $first_name = $aname unless ( defined $first_name );
+        }
-        close MF;
-        #
-        #   Create a hash of data that describes the manifest that has
-        #   just been read in.
-        #
-        $package_dirs{$pkg_root}{used} = 1;
-        $manifest =~ s~.*/~~;
-        return { 'contents' => \@file_contents,
-                  'files' => \@file_list,
-                  'file_base' => $pkg_dir,
-                  'manifest' => $manifest,
-                  'pkg_dir' => $pkg_root,
-                  'tier' => $first_tier,
-                  'name' => $first_name,
-                  'rewrite' => $rewrite,
-                };
+    }
+    continue
+    {
+        push @file_contents, $_;
+    }
+    close MF;
+    #
+    #   Create a hash of data that describes the manifest that has
+    #   just been read in.
+    #
+    $package_dirs{$pkg_root}{used} = 1;
+    $manifest =~ s~.*/~~;
+    return { 'contents' => \@file_contents,
+              'files' => \@file_list,
+              'file_base' => $pkg_dir,
+              'manifest' => $manifest,
+              'pkg_dir' => $pkg_root,
+              'tier' => $first_tier,
+              'name' => $first_name,
+              'rewrite' => $rewrite,
+            };
+}
 #-------------------------------------------------------------------------------
 # Function        : ManifestFiles_Generate
+#
         my $name = $entry->{name};
         my $include_md5 = $entry->{md5};
         if ( $entry->{dmf} )
+        {
-        	DmfGenerate($entry);
+            DmfGenerate($entry);
+        }
+        #
         #   Insert all the files that have been specified
         #   The user specified order is preserved
     my $i = 0;
     foreach my $fentry ( @files )
+    {
         if ( my $file = $fentry->{'file'} )
+        {
-        	my $order = $i + 1;
+            my $order = $i + 1;
             my $base_file = StripDir( $file );
             my $publish_file = $name . '_' . $version . '_' . $order . '.aup';
             my $aup_file = $work_dir . $publish_file;
             GenerateCesFile($file, $aup_file, 0x3, $gen_time, $publish_file);

Subversion Repositories DevTools

(root)/manifest-tool/trunk/src/gbe/DIRECTIVES/ManifestFiles.pm – Rev 5873 → 6302