diff -r fa7a3cc6effd -r 6d08f4a05d93 imgtools/buildrom/tools/romutl.pm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imgtools/buildrom/tools/romutl.pm	Fri Jun 25 18:11:34 2010 +0800
@@ -0,0 +1,1697 @@
+# Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of the License "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+# Collection of utilitiy functions which is copied from Symbian OS perl modules. 
+# It provides platform related information to ROM Tools including buildrom, 
+# features.pl, etc.
+# 
+
+package romutl;
+
+require Exporter;
+@ISA=qw(Exporter);
+@EXPORT=qw(
+  init_plat
+  init_bsfs
+  init_platwithbpabi
+  
+  get_epocroot
+  get_drive
+  get_epocdrive
+  get_versionedname
+  get_bpabiplatlist
+  get_platlist
+  get_platcustomizes
+  get_platroot
+  get_makeeabspath
+  get_variantmacrolist  
+  get_variantmacroHRHfile
+  get_abiv2mode
+  get_variantfullpath
+  get_BVbinname
+  get_variant
+  
+  is_existinpath
+  
+  set_verbose
+  
+  check_varfile
+  split_path
+  append_driveandquote  
+  write_32bit
+);
+
+
+# EPOCROOT with proper format 
+my $epocroot;
+my $epocdrive = "";
+my $drive = "";
+
+BEGIN {
+    require 5.005_03;       # check user has a version of perl that will cope
+    
+    $epocroot = $ENV{EPOCROOT};
+    $epocroot = "\/" if (!$epocroot); # use "\" if EPOCROOT is not specified
+    $epocroot =~ s/\\/\//g;
+    $epocroot .= "\/" unless $epocroot =~ /\/$/;
+}
+
+use strict;
+use Cwd;
+use File::Spec;
+use romosvariant;
+
+my $verbose=0;
+
+########################
+#Init
+#
+
+#die "ERROR: EPOCROOT must specify an existing directory." if (!-d $epocroot);
+#die "ERROR: EPOCROOT must not be a UNC path\n" if ($epocroot =~ /^\\\\/);
+
+$drive=$1 if (cwd =~ /^(.:)/);
+
+if ($epocroot =~ /^(.:)/)
+{
+    $epocdrive=$1;
+}
+else
+{
+# current working directory is different to SDK's
+    $epocdrive=$drive
+}
+
+#####################################
+# General functions
+#
+
+sub get_epocroot
+{
+    return $epocroot;
+}
+
+sub get_epocdrive
+{
+    return $epocdrive;
+}
+
+sub get_drive
+{
+    return $drive;
+}
+
+sub set_verbose
+{
+    $verbose = shift;
+}
+
+use constant QUIET_NOT_FOUND => 0; #  return 0 if file not found in the PATH
+use constant DIE_NOT_FOUND => 1; #  issue error and die if file not found in the PATH
+use constant ERROR_NOT_FOUND => 2; #  issue error and return 0 if file not found in the PATH
+
+# Simulate shell to locate executable file in the PATH
+#
+# WARNING: don't use this func in a deep loop because of the
+#          less efficient implementation
+#
+# usage:  is_existinpath <filename> [<flag>]
+#
+#   flag == DIE_NOT_FOUND    die and display error when not found
+#   flag == ERROR_NOT_FOUND  display error and return 0 when not found
+#   else return 0 when not found
+#   return 1 when found     
+
+sub is_existinpath
+{
+    my ($filename, $flag)=@_;
+    return 0 unless defined $filename;
+    return 0 if ($filename =~ /\\/);
+    return 0 if ($filename =~ /\//); 
+    
+    my @paths;
+    my $delimiter = &env_delimiter;
+ 		@paths = split(/$delimiter/, $ENV{PATH});
+    unshift @paths, "\.";
+    
+    foreach my $path (@paths)
+    {
+        next if ($path =~ /^\s*$/);
+        chomp $path;
+        $path =~ s/\\/\//g;
+        $path .= "\/" unless ($path =~ /\/$/);
+        $path = $path.$filename;
+        foreach my $ext ("", ".bat", ".cmd", ".exe", ".com", ".pl", ".py")
+        {
+            return 1 if (-e $path.$ext);
+        }
+    }
+    die "Error: Cannot found \"$filename\" in the PATH.\n" if ($flag == DIE_NOT_FOUND);
+    print "Error: Cannot found \"$filename\" in the PATH.\n" if ($flag == ERROR_NOT_FOUND);
+    return 0;
+} 
+
+#########################################
+# Symbian variant functions and variables
+# 
+# copy from e32variant.pm
+#
+
+my $toolspath = $epocroot . "epoc32\/tools\/";
+# SPPR begin
+# enable includation of spp_variant.cfg if it exist
+my $spp_cfgFile = $toolspath . "variant\/spp_variant.cfg";
+my $cfgFile = $toolspath . "variant\/variant.cfg"; # default location
+$cfgFile = $spp_cfgFile if -e $spp_cfgFile; # use spp_variant.cfg
+# SPPR End
+
+my $variantABIV2Keyword = &get_abiv2mode;    # if variant ABIv2 mode enabled
+
+my $hrhdrive = $epocdrive;   # variant hrh drive
+my $hrhfile;    # variant hrh file
+my @macros;     # variant macros
+
+if ($cfgFile =~ /^(.:)/i)
+{
+   $hrhdrive = lc($1); 
+}
+
+# returns the variant specific macro definitions as a list
+sub get_variantmacrolist{
+    
+    return @macros if (@macros);
+    
+    my $vfile = get_variantmacroHRHfile();
+    
+    if($vfile)
+    {
+        my $VariantFilePath = split_path('Path',$vfile);
+        chop( $VariantFilePath );
+        $VariantFilePath = &append_driveandquote($VariantFilePath);
+        $vfile = &append_driveandquote($vfile);
+        my $e32Path = &append_driveandquote($epocroot."epoc32\/include");
+        
+        open CPPPIPE,"cpp -I $e32Path -I $VariantFilePath -undef -dM $vfile |" or die "ERROR: Can't invoke CPP.EXE\n";
+        while(<CPPPIPE>){
+            if($_ =~ /(\#define)(\s+)(.+)/){
+                push @macros, $3;
+            }
+        }
+        close CPPPIPE;
+    }
+    return @macros;
+}
+
+# return hrh filename defined in variant cfg file
+# notice: abort if hrh file located in different drive to cfg file
+sub get_variantmacroHRHfile{
+    
+    return $hrhfile if ($hrhfile);
+    if(-e $cfgFile){
+        open(FILE, $cfgFile) || die "\nCould not open: " . $cfgFile ."\n";
+        while (<FILE>) {
+            # strip comments
+            s/^([^#]*)#.*$/$1/o;
+            # skip blank lines
+            if (/^\s*$/o) {
+                next;
+            }
+            # get the hrh file
+            if($_ =~ /\.hrh/xi){
+                $hrhfile = $_; 
+                last;
+            }
+        }
+        close FILE;
+        die "\nERROR: No variant file specified in $cfgFile!\n" unless $hrhfile;
+        $hrhfile =~ s/\s+//g;
+        $hrhfile=~s/^(.:)//io;    # remove drive letter
+        my $paths_drive = lc($1);
+        
+        chomp $hrhfile;
+        $hrhfile = get_makeeabspath($epocroot."epoc32\/", $epocroot, $hrhfile); # assume relative to EPOCROOT
+        
+        
+        if($paths_drive){
+            die "\nERROR: Variant file specified in $cfgFile is not on the same drive as \/epoc32\/\n" 
+            unless ($paths_drive eq $hrhdrive);
+        }
+        die "\nERROR: $cfgFile specifies $hrhfile which doesn't exist!\n" unless (-e $hrhfile);
+        
+        # make sure it is in unix syntax
+        $hrhfile=~ s/\\/\//g;
+    }
+    return $hrhfile;
+}
+
+# get status of EANBLE_ABIV2_MODE
+# 1=enabled 0=disabled
+sub get_abiv2mode{
+
+    return $variantABIV2Keyword if (defined $variantABIV2Keyword);
+
+    $variantABIV2Keyword=0;
+    if(-e $cfgFile){
+        open(FILE, $cfgFile) || die "\nCould not open: " . $cfgFile ."\n";
+        while (<FILE>) {
+            # strip comments
+            s/^([^#]*)#.*$/$1/o;
+            # skip blank lines
+            if (/^\s*$/o) {
+            next;
+            }
+            # get the hrh file
+            if($_ =~ /^ENABLE_ABIV2_MODE$/xi){
+                $variantABIV2Keyword=1;
+                last;
+            }
+        }
+        close FILE;
+    }
+
+    return $variantABIV2Keyword;
+}
+
+#############################
+# Path utilities
+#
+# copy from pathutl.pm
+#
+
+#args: $_[0] Start EPOCPath Abs FilePath/Path $_[1]... list of (Abs/Rel FilePath/Path)
+# Variant of MakAbs which also maps "+\\" to "${EPOCPath}"
+sub get_makeeabspath ($@) {    
+    return undef unless $_[0]=~m-^(.:)?[\\\/]-o;
+    my ($EPOCPath,$Path,@List)=@_;
+    my $BasePath=&split_path("Path",$Path);
+    undef $Path;
+    my $p;
+    foreach $p (@List) {
+    		$p =~ s-\\-\/-g;
+        if ($p=~m-^\/?epoc32\/(.*)$-io) {    # change - special case for existing \\epoc32 references
+            $p=$EPOCPath.$1;
+            next;
+        }
+        if ($p=~m-^\s*\+\/(.*)$-o) {
+            $p=$EPOCPath.$1;
+            next;
+        }
+        if ($p=~m-^\.{2}-o) {
+            $p=&strip_path($BasePath.$p);
+            next;
+        }
+        if ($p=~m-^[^\.\/]-o) {
+            $p=$BasePath.$p unless ($p =~ m-^.:-o);
+            next;
+        }
+        if ($p=~m-^(.:)?\/-o) {
+            next;
+        }
+        if ($p=~m-^\.\/(.*)$-o) {
+            $p=&strip_path($BasePath.$1);
+            next;
+        }
+        return undef;
+    }
+    return wantarray ? @List : $List[0];
+}
+
+#args: $_[0] Abs FilePath/Path
+# Remove excess occurrences of '..' and '.' from a path
+sub strip_path ($) {   
+    return undef unless $_[0]=~m-^(.:)?[\/\\]-o;
+    my $P=$_[0];
+    while ($P=~s-([\/\\])\.[\/\\]-$1-go) { }
+    while ($P=~s-[\\](?!\.{2}\\)[^\\]*\\\.{2}(?=\\)--go) { }
+    $P;
+}
+
+#args: $_[0] 'Path' or 'Base' or 'Ext' $_[1] Abs/Rel FilePath/Path
+# return the section of a file path required - Path, Base, Ext or File
+sub split_path ($$) { 
+    my ($Sect,$P)=@_;
+    
+    return '' if !$P;    
+    $Sect= ucfirst lc $Sect;
+    if ($Sect eq 'Path') {
+        if ($P=~/^(.*[\\\/])/o) {
+            return $1;
+        }
+        return '';
+    }
+    undef;
+}
+
+sub append_driveandquote ($) {
+# Take a path, or list of paths, and prefix with drive based on 1. epocroot, 2.CWD.
+# Relative paths are just quoted.
+    my @List=@_;
+    my $Path;
+
+    
+    foreach $Path (@List) {
+        next if ($Path !~ /^[\/\\]/); # skip prefix with drive letter or relative path
+        $Path=$epocdrive.$Path;
+    }
+
+    foreach $Path (@List) {
+        chomp $Path;
+        $Path="\"".$Path."\"";
+    }
+    
+    return wantarray ? @List : $List[0];
+}
+
+
+###############################
+# General Utilities
+#
+# copy from genutl.pm
+#
+
+# return name with well formated version id in hex
+sub get_versionedname($) {
+    my ($name) = @_;
+    if ($name =~ /(.*)\{\s*(\d+)\s*\.\s*(\d+)\s*\}(.*?)$/i) {
+        my $a = $1;
+        my $b = $4;
+        my $major = $2;
+        my $minor = $3;
+        return $a.sprintf("{%04x%04x}",$major,$minor).$b if ($major<32768 and $minor<32768);
+    }
+    return $name;
+}
+
+
+###############################
+# BPABI Platform Utilities
+#
+# copy from bpabiutl.pm
+#
+
+my @BPABIPlats;
+
+
+# Identify the BPABI platforms to be supported based on the compiler configuration files
+# present in the location specified by the environment variable "SYMBIAN_COMPILATION_CONFIG_DIR"
+# and in the directory $EPOCROOT\epoc32\tools\compilation_config
+sub get_bpabiplatlist 
+{
+    return @BPABIPlats if (scalar(@BPABIPlats));
+    
+    my @CompilerConfigPath;
+
+    if (exists($ENV{'SYMBIAN_COMPILATION_CONFIG_DIR'})) 
+    {
+        my $Path = $ENV{SYMBIAN_COMPILATION_CONFIG_DIR};
+        @CompilerConfigPath = split(/;/, $Path);
+    }
+
+    push @CompilerConfigPath, "${epocroot}epoc32\/tools\/compilation_config";
+
+    my $ConfigDir;
+
+    foreach $ConfigDir (@CompilerConfigPath)
+    {
+        opendir DIR, "$ConfigDir";
+        my @Plats=grep /\.mk$/i, readdir DIR;
+        my $Plat;
+        foreach $Plat (@Plats) 
+        {
+# The platform name will be same as the name of the configuration file <config.mk>
+# with the suffix '.mk' removed
+            $Plat =~ s/\.mk//;
+            if ($variantABIV2Keyword) {
+                if ($Plat =~ /^armv5_abiv2$/i) {
+                    $Plat = "ARMV5";
+                }
+            }
+            else {
+                if ($Plat =~ /^armv5$/i) {
+                    $Plat = "ARMV5_ABIV2";
+                }
+            }
+            unless (grep /$Plat$/i, @BPABIPlats) {
+                $Plat = uc $Plat;
+                push @BPABIPlats, $Plat;
+            }
+        }
+    }
+    closedir DIR;
+    return @BPABIPlats;
+}
+
+#############################
+# Platform Utilities
+#
+# copy from e32plat.pm
+#
+my %Plat=(
+    ARM4=>{
+        ABI=>'ARM4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+    },
+    ARM4SMP=>{
+        ABI=>'ARM4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        SMP=>1,
+        StatLink=>'ARM4SMP',
+    },
+    ARM4T=>{
+        ABI=>'ARM4T',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+    },
+    ARMI=>{
+        ASSP=>'MARM',
+        Generic=>1,
+        ASSPABI=>'',
+    },
+    SARM4=>{
+        ABI=>'ARM4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        Single=>1,
+    },
+    SARMI=>{
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        Single=>1,
+    },
+    STHUMB=>{
+        ABI=>'THUMB',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        Single=>1,
+    },
+    THUMB=>{
+        ABI=>'THUMB',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+    },
+    TOOLS=>{
+        ABI=>'TOOLS',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'TOOLS',
+        OS=>'TOOLS',
+        MakeMod=>'Cl_win',
+        MakeCmd=>'nmake',
+    },
+    TOOLS2=>{
+        ABI=>'TOOLS2',
+        ASSPABI=>'',
+        Compiler=>'GCC32',
+        CPU=>'TOOLS2',
+        OS=>'TOOLS2',
+        MakeMod=>'Cl_mingw',
+        MakeCmd=>'make',
+    },
+    CWTOOLS=>{
+        ABI=>'TOOLS',
+        ASSPABI=>'',
+        Compiler=>'CW32',
+        CPU=>'TOOLS',
+        OS=>'TOOLS',
+        MakeMod=>'Cl_tools',
+        MakeCmd=>'make',
+    },
+    VC6TOOLS=>{
+        ABI=>'TOOLS',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'TOOLS',
+        Ext=>'.DSP',
+        MakeMod=>'Ide_vc6',
+        MakeCmd=>'nmake',
+        OS=>'TOOLS',
+        Real=>'TOOLS',
+        UsrHdrsOnly=>1,
+    },
+    WINS=>{
+        ABI=>'WINS',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'WINS',
+        MakeMod=>'Cl_win',
+        MakeCmd=>'nmake',
+        OS=>'WINS',
+    },
+    VC6=>{
+        ABI=>'WINS',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'WINS',
+        Ext=>'.DSP',
+        MakeMod=>'Ide_vc6',
+        MakeCmd=>'nmake',
+        OS=>'WINS',
+        Real=>'WINS',
+        UsrHdrsOnly=>1,
+    },
+    WINSCW=>{
+        ABI=>'WINSCW',
+        ASSPABI=>'',
+        Compiler=>'CW32',
+        CPU=>'WINS',
+        MakeMod=>'Cl_codewarrior',
+        OS=>'WINS',
+        DefFile=>'WINS',    # use the MSVC def files
+    },
+    CW_IDE=>{
+        ABI=>'WINSCW',
+        ASSPABI=>'',
+        Compiler=>'CW32',
+        CPU=>'WINS',
+        Ext=>'.xml',
+        MakeMod=>'Ide_cw',
+        MakeCmd=>'make',
+        OS=>'WINS',
+        Real=>'WINSCW',
+        DefFile=>'WINS',    # use the MSVC def files
+        UsrHdrsOnly=>1,
+        SupportsMultiplePlatforms=>1,   # supports more than one real platform
+    },
+    X86=>{
+        ABI=>'X86',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'X86',
+        MakeMod=>'Cl_x86',
+        MakeCmd=>'nmake',
+        OS=>'EPOC32',
+        DefFile=>'X86',
+        Generic=>1,
+    },
+    X86SMP=>{
+        ABI=>'X86',
+        ASSPABI=>'',
+        Compiler=>'VC32',
+        CPU=>'X86',
+        MakeMod=>'Cl_x86',
+        MakeCmd=>'nmake',
+        OS=>'EPOC32',
+        DefFile=>'X86',
+        Generic=>1,
+        SMP=>1,
+        StatLink=>'X86SMP',
+    },
+    X86GCC=>{
+        ABI=>'X86gcc',
+        ASSPABI=>'',
+        Compiler=>'X86GCC',
+        CPU=>'X86',
+        MakeMod=>'Cl_x86gcc',
+        OS=>'EPOC32',
+        DefFile=>'x86gcc',
+        Generic=>1,
+    },  
+    X86GMP=>{
+        ABI=>'X86gcc',
+        ASSPABI=>'',
+        Compiler=>'X86GCC',
+        CPU=>'X86',
+        MakeMod=>'Cl_x86gcc',
+        OS=>'EPOC32',
+        DefFile=>'x86gcc',
+        Generic=>1,
+        SMP=>1,
+        StatLink=>'X86GMP',
+    },  
+    ARMV4=>{
+        ABI=>'ARMV4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'Cl_arm',
+        Compiler=>'ARMCC',
+        DefFile=>'EABI',
+        EABI=>1,
+    },
+    ARMV4SMP=>{
+        ABI=>'ARMV4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'Cl_arm',
+        Compiler=>'ARMCC',
+        DefFile=>'EABI',
+        EABI=>1,
+        SMP=>1,
+        StatLink=>'ARMV4SMP',
+    },
+    ARMV5_ABIV1=>{
+        ABI=>'ARMV5',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'Cl_arm',
+        Compiler=>'ARMCC',
+        DefFile=>'EABI',
+        EABI=>1,
+        SupportsFeatureVariants=>1,
+    },
+    ABIV2=>{
+        ABI=>'ARMV5',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'Cl_bpabi',
+        DefFile=>'EABI',
+        EABI=>1,
+        SupportsFeatureVariants=>1,
+    },
+    GCCXML=>{
+        ABI=>'ARM4',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'cl_gccxml',
+    },
+    VS6=>{
+        ABI=>'WINSCW',
+        ASSPABI=>'',
+        Compiler=>'CW32',
+        CPU=>'WINS',
+        MakeMod=>'Cl_vscw',
+        OS=>'WINS',
+        Real=>'WINSCW',
+        DefFile=>'WINS',    # use the MSVC def files
+        Ext=>'.mak'     
+    },
+    VS2003=>{
+        ABI=>'WINSCW',
+        ASSPABI=>'',
+        Compiler=>'CW32',
+        CPU=>'WINS',
+        MakeMod=>'Cl_vscw',
+        OS=>'WINS',
+        Real=>'WINSCW',
+        DefFile=>'WINS',    # use the MSVC def files
+        Ext=>'.mak'
+    },
+    EDG=>{
+        ABI=>'ARMV5',
+        ASSP=>'MARM',
+        ASSPABI=>'',
+        Generic=>1,
+        MakeMod=>'cl_edg',
+    },
+
+    # ASSP platforms should be described using .ASSP files
+    # Do not add additional ASSP platforms to this file.
+);
+
+my $init_bsfs_done = 0;
+my $init_plat_done = 0;
+my @PlatList;       # Platlist returned by list_plat()
+
+# initialize BSF platforms into %Plat
+sub init_bsfs($) {
+    return $init_bsfs_done if ($init_bsfs_done);
+        
+    my ($Path)=@_;  
+#   get a list of modules
+    opendir DIR, $Path;
+    my @BSFs=grep s/^([^\.].*)\.BSF$/$1/, map { uc $_ } sort readdir DIR;
+    closedir DIR;
+
+    my $BSF;
+    foreach $BSF (@BSFs) {
+        my $File=$Path.lc($BSF).'.bsf';
+#       check whether the assp is already defined
+        if (defined %{$Plat{$BSF}}) {
+            warn(
+                "$File : warning: Platform \"$BSF\" already defined\n",
+                " ... skipping this spec\n"
+            );
+            delete $Plat{$BSF};
+            next;
+        }
+#       open the module
+        unless (open FILE, $File) {
+            delete $Plat{$BSF};
+            warn "warning: Can't open BSF specification \"$File\"\n";
+            next;
+        }
+        my $line1 = <FILE>;
+        $line1 = uc($line1);
+        unless ($line1 =~ /^\#\<BSF\>\#/) {
+            warn "warning: \"$File\" Invalid BSF specification - missing #<bsf>#\n";
+            delete $Plat{$BSF};
+            close FILE;
+                  next;
+        }
+        my $custom;
+        while ($custom = <FILE>) {
+            #skip blank lines and comments
+            delete $Plat{$BSF};
+            last unless ($custom =~ /^$|^\#/);
+        }
+        $custom = uc $custom;
+        unless ($custom =~ /^\s*CUSTOMIZES\s+(\S+)/) {
+            warn "warning: \"$File\" Invalid BSF specification - 'customizes' missing\n";
+            delete $Plat{$BSF};
+            close FILE;
+            next;
+        }
+        my $root = $1;
+        my $platname = '';
+        my $CustomizedPlatName = '';        
+
+        # In v1 mode, ARMV5 platform implies ARMV5_ABIV1 platform listed in the platlist        
+        my $Armv5Flag = 0;
+        if (!$variantABIV2Keyword && $root =~ /^ARMV5$/i) {
+            $Armv5Flag = 1;
+        }
+
+        # Support for Hierarchy of Customizations (BSF file customization of another BSF file)
+        # 1. Check whether the BSF file customizes another BSF file.
+        # 2. If so, check whether the root BSF file has already been read.
+        # 3. If not read, then defer the current BSF file reading until the root file is read.
+        my $rootPlatFound = 0;
+        if (defined %{$Plat{$root}} || $Armv5Flag) 
+        {
+            # BSF platform customizes another valid BSF platform
+            if (defined $Plat{$root}{'CUSTOMIZES'}) 
+            {
+                $rootPlatFound = 1;
+                $platname = $root;
+                $CustomizedPlatName = $root;
+
+                # Set the root platform name which is same as of customizes platform
+                $Plat{$BSF}{'ROOTPLATNAME'} = $Plat{$root}{'ROOTPLATNAME'};
+            }
+            # BSF platform customizes to one of the existing ABI platforms
+            else
+            {
+                # All BPABI platforms inherits from ABIV2 platform listed in the platlist
+                if (grep /^$root$/i, @BPABIPlats) {
+                    $platname = "ABIV2";
+                }
+                elsif ($Armv5Flag) {
+                # In v1 mode, ARMV5 platform implies ARMV5_ABIV1 platform listed in the platlist
+                    $platname = "ARMV5_ABIV1";  
+                }
+                else {
+                    $platname = $root;
+                }
+                
+                $CustomizedPlatName=$root;
+
+                # BSF File check Begins 
+                # The following check is included to handle the existing BSF files which has to behave in different manner
+                # in default v1 mode and v2 mode. The following code changes the BSF name and the custmoized platform name
+                # to the implied names. This is done to support switching between v1 and v2 modes by enabling the keyword in
+                # the variant configuration file.
+                # In v1 mode, the ARMV6_ABIV1 => ARMV6 platform and ARMV6 => ARMV6_ABIV2 platform.
+                if (!$variantABIV2Keyword) {
+                    if ($BSF =~ /^ARMV6_ABIV1$/i) {
+                        $BSF = "ARMV6"; 
+                        $CustomizedPlatName = "ARMV5";  
+                    }
+                    elsif ($BSF =~ /^ARMV6$/i) {
+                        $BSF = "ARMV6_ABIV2";   
+                        $CustomizedPlatName = "ARMV5_ABIV2";
+                        $platname = "ABIV2";
+                    }
+                }
+                # BSF File check Ends
+
+                # Set the root platform name
+                $Plat{$BSF}{'ROOTPLATNAME'} = $CustomizedPlatName;
+            }           
+        }
+        else
+        {
+            my $rootbsf = $Path.$root.".bsf";           
+            if ( -e $rootbsf ) {
+                # BSF file customizes another BSF file which has not been read yet.
+                # So defer current BSF file reading until the root BSF file is read.                
+                delete $Plat{$BSF};
+                push(@BSFs, $BSF);
+                next;       
+            }
+        }
+        # If the customizes platform is not a valid BSF platform or BPABI platorm or ARMV5 or ARMV5_ABIV1,
+        # then throw warning.
+        unless ($rootPlatFound || $root =~ /^ARMV5(_ABIV1)?$/ || (grep /^$root$/i, @BPABIPlats)) {
+            warn "warning: \"$File\" Invalid BSF specification - customization restricted to ARMV5, ABIv2 and valid BSF platforms\n";
+            close FILE;
+            delete $Plat{$BSF};
+            next;
+        }
+            
+        my ( $key, $value);
+        while (($key, $value) = each %{$Plat{$platname}}) {
+            $Plat{$BSF}{$key}=$value;
+        }
+        
+        push @{$Plat{$CustomizedPlatName}{'CUSTOMIZATIONS'}}, $BSF;
+        $Plat{$BSF}{'CUSTOMIZES'} = $CustomizedPlatName;
+        while (<FILE>) {
+            next if (/^$|^\#/);
+            if (/^\s*SMP\s*$/i) {
+                $Plat{$BSF}{'SMP'} = 1;
+                $Plat{$BSF}{'StatLink'} = lc $BSF;
+                next;
+            }
+            $Plat{$BSF}{'CUSTOMIZATION_DATA'} .= $_;
+        }
+        # BSF file statements will have newline character("\n") at the end, except for the last statement.
+        # So append "\n" for the last BSF file statement.
+        # "\n" will be used to split BSF statements to support hierarchy of customizations.
+        $Plat{$BSF}{'CUSTOMIZATION_DATA'} .= "\n";
+        close FILE;
+    }
+    $init_bsfs_done = 1;
+}
+
+# setup Plat with bpabi platforms
+sub init_platwithbpabi() 
+{
+    foreach my $Candidate (&get_bpabiplatlist)
+    {
+# All BPABI platforms inherit from ABIV2 properties as listed in the platlist
+# and Platlist is updated to include the BPABI platforms.
+        my ( $key, $value);
+        while (($key, $value) = each %{$Plat{ABIV2}}) {
+            $Plat{$Candidate}{$key}=$value;
+        }
+    }
+}
+
+# initialize %Plat with BSF/Bpabi/ASSP
+sub init_plat ($) { # takes path to ASSP modules
+    
+    return $init_plat_done if ($init_plat_done);
+    
+    my ($Path)=@_;
+
+    my %PlatHashKeys=(
+        ABI=>1,
+        ASSPABI=>1,
+        SINGLE=>1,
+        Compiler=>1,
+        CPU=>1,
+        MakeMod=>1,
+        MakeCmd=>1,
+        OS=>1,
+        DefFile=>1,
+        ASSP=>1,
+    );
+
+#   Include the list of BPABI platforms
+    &init_platwithbpabi;
+
+    init_bsfs($Path);
+
+#   get a list of modules
+    opendir DIR, $Path;
+    my @_ASSPs=grep s/^([^\.].*)\.ASSP$/$1/, map { uc $_ } readdir DIR;
+    closedir DIR;
+
+    my @ASSPs;
+    foreach (@_ASSPs) {
+        next if (!$ENV{USEARMCC} and /EDG$/i);
+        push @ASSPs, $_;
+    }
+
+#   open each module in turn, and add it to the array
+    my $ASSP;
+    foreach $ASSP (@ASSPs) {
+        my $File=$Path.$ASSP.'.assp';
+#       check whether the assp is already defined
+        if (defined %{$Plat{$ASSP}}) {
+            warn(
+                "$File : warning: ASSP \"$ASSP\" already defined\n",
+                " ... skipping this module\n"
+            );
+
+            next;
+        }
+#       open the module
+        unless (open FILE, $File) {
+            warn "warning: Can't open assp module \"$File\"\n";
+            next;
+        }
+        my %Data=();
+        my %SingleData=();
+        my $MatchingSingle="";
+        my @Errors=();
+        while (<FILE>) {
+#           strip comments
+            s/^([^#]*)#.*$/$1/o;
+#           skip blank lines
+            if (/^\s*$/o) {
+                next;
+            }
+#           get the key-value pair
+            unless (/^\s*(\w+)\s+(\w+)\s*$/o) {
+                push @Errors, "$File($.) : warning: syntax error - only key-value pairs allowed\n";
+                next;
+            }
+            my ($Key, $Val)=($1, $2);
+            if ($PlatHashKeys{$Key}!=1) {
+                push @Errors, "$File($.) : warning: unrecognized keyword - $Key\n";
+                next;
+            }
+            if ($Key eq "SINGLE") {
+                $SingleData{Single} = 1;
+                $SingleData{ASSP} = $ASSP;
+                $MatchingSingle = uc $2;
+            } else {
+                $Data{$Key}=$Val;
+                $SingleData{$Key}=$Val;
+            }
+        }
+        close FILE;
+        if (@Errors) {
+            warn(
+                @Errors,
+                " ... skipping this module\n"
+            );
+            next;
+        }
+# change -  Allow ASSPs to pick up all the options of the ABI they specify, 
+# in particular the compiler they need.
+            $Data{'ASSP'} = $ASSP unless $Data{'ASSP'};
+            if ($Plat{$Data{'ABI'}}) {
+            foreach (keys %{$Plat{$Data{'ABI'}}}) {
+            $Data{$_} = $Plat{$Data{'ABI'}}{$_} unless ($_ =~ /^GENERIC$/i) or $Data{$_};
+            }
+        }
+
+        %{$Plat{$ASSP}}=%Data;
+        if ($MatchingSingle ne "") {
+            foreach (keys %Data) {
+            $SingleData{$_} = $Data{$_} unless ($_ =~ /^GENERIC$/i) or $SingleData{$_};
+            }
+            %{$Plat{$MatchingSingle}}=%SingleData;
+        }           
+    }
+    $init_plat_done=1;
+}
+
+#   return list of supported platforms
+#   should be invoked atfer init_plat
+sub get_platlist () {
+
+    return @PlatList if (scalar(@PlatList));
+
+    &init_plat;
+
+    my $Key;
+    foreach $Key (keys %Plat) {
+        if (!$variantABIV2Keyword && $Key =~ /^armv5_abiv1$/i) {
+            $Key = 'ARMV5';
+        }
+        unless (grep /^$Key$/i, @PlatList) {
+            push @PlatList, $Key;
+        }
+    }
+    return @PlatList
+}
+
+# return customizes BSF plat if any
+sub get_platcustomizes($) {
+    my ($plat) = @_;
+    return $Plat{$plat}{'CUSTOMIZES'} ? $Plat{$plat}{'CUSTOMIZES'} : "";
+}
+
+# return root of a specific plat
+sub get_platroot($) {
+    my ($plat) = @_;
+
+    my $RootName = $Plat{$plat}{'ROOTPLATNAME'};
+
+    if ($RootName) {
+        return $RootName;
+    }
+    else {
+        # A non-BSF platform is its own root.
+        return $plat;
+    }
+}
+
+#################################
+# featurevariant map functions
+#
+# copy from featurevariantmap.pm
+
+my $featureListDir = "${epocroot}epoc32\/include\/variant\/featurelists";
+
+# Usage:    get_BVbinname("my.dll", "myvar")
+#
+# Look for a binary using its "final" name. We will use the feature
+# variant map and the feature variant name to deduce the "variant"
+# binary name and test for its existence.
+#
+# "my.dll"  - the final target (full path)
+# "myvar"   - the feature variant name
+#
+# returns the file name if found, or "" otherwise.
+
+sub get_BVbinname
+{
+    my $binName = shift;
+    my $varName = shift;
+
+    # look for the vmap file
+    my $vmapFile = "$binName.$varName.vmap";
+    
+    if (! -e $vmapFile)
+    {
+    	# compatible to old BV
+    	$vmapFile = "$binName.vmap";
+    }
+    
+    if (-e $vmapFile)
+    {
+        my $key = get_vmapkey($varName, $vmapFile);
+
+        if ($key)
+        {
+            $binName =~ /^(.*)\.([^\.]*)$/;
+            $binName = "$1.$key.$2";
+        }
+        else
+        {
+            print "ERROR: No \'$varName\' variant for $binName in $vmapFile\n";
+            return "";  # file not found
+        }
+    }
+
+    # check that the actual binary exists
+    if (-e $binName)
+    {
+        return $binName;
+    }
+    return "";  # file not found
+}
+
+# internal functions
+sub get_vmapkey
+{
+    my @res = get_vmapdata(@_);
+    return $res[0];
+}
+
+# Usage:    featurevariantmap->GetDataFromVMAP("myvar", "mydll.vmap")
+#
+# Opens the vmap file indicated and returns the data for the requested variant
+#
+# "myvar"   - the feature variant name
+# "my.vmap" - the final target vmap file (full path)
+#
+# Returns a list ( hash, features ) for the variant in the vmap or undef if not found
+
+sub get_vmapdata
+{
+    my $varName = shift;
+    my $fileName = shift;
+
+    if (!open(VMAP, $fileName))
+    {
+        print "ERROR: Could not read VMAP from $fileName\n";
+        return "";
+    }
+    while (<VMAP>)
+    {
+        chomp;
+        if (/(\w{32})\s+$varName\s+(.*)$/i or /(\w{32})\s+$varName$/i)
+        {
+            my ( $hash, $features ) = ( $1, $2 ? $2 : '' );
+            close(VMAP);
+            return ( $hash, $features );
+        }
+    }
+    close(VMAP);
+    return;
+}
+
+######################################
+# Feature variant parser
+#
+# copy from featurevariantparser.pm
+#
+
+
+# Parses .VAR files and returns key variables.
+# The following hashes can be used with this module:
+# NAME              -> Returns the name of the variant file (without the extension)
+# FULLPATH          -> Returns the full path of the variant file (including the extension)
+# VALID             -> Set to 1 if the variant file is valid, otherwise set to 0
+# VIRTUAL           -> Set to 1 if the variant is a grouping node, otherwise set to 0
+# ROM_INCLUDES      -> Returns a pointer to the list of ROM_INCLUDES (including Parent nodes).
+# VARIANT_HRH       -> Returns the full VARIANT_HRH file path used by the VAR file.
+
+
+my $defaultDir = "${epocroot}epoc32\/tools\/variant";
+my $pathregex = '.+[^\s]'  ;   # Regex to match all characters (including \ or /), excluding whitespaces.
+
+my @rominclude;
+my @parents;
+my @childNodes;
+my $virtual;
+my $childNodeStatus;
+my $varianthrh;
+
+my $dir;        #var directory
+my $fullpath;   #full path of var file
+my $fulldir;    #
+
+# Wrapper function to return all the correct variables
+# Arguments : (Variant Name, Variant Directory(optional))
+# Returns a Hash.
+sub get_variant
+{
+    @rominclude      = ();
+    @parents         = ();
+    @childNodes      = ();
+    $dir             = "";
+    $fullpath        = "";
+    $varianthrh      = "";
+    $virtual         = 0;
+    $childNodeStatus = 0;
+    
+    
+    my %data;
+    my $romincs   = "";
+    
+    $data{'VALID'} = 0;
+
+    my ( $varname, $dirname ) = @_;
+
+    my $fullvarpath = get_variantfullpath( $varname, $dirname );
+
+    if ( $dirname )
+    {
+        $fulldir = $dirname;
+    }
+    else
+    {
+        $fulldir = $defaultDir;
+    }
+
+    $data{'FULLPATH'} = "$fullvarpath";
+    $data{'NAME'}     = "$varname";
+
+    # If the variant file exists, check the syntax and setup variables.
+    if ( -e $fullvarpath )
+    {
+        if ( check_varfile( $fullvarpath, $varname ) )
+        {
+            $data{'VALID'} = 1;
+        }
+    }
+    else
+    {
+        print "ERROR: $fullvarpath" . " does not exist\n";
+    }
+
+    my $count = 0;
+
+    # If VAR file is valid, setup all other variables.
+    if ( $data{'VALID'} )
+    {
+
+        $romincs   = find_varrominc($fullvarpath);
+        
+        # Remove empty elements from the ROM_INCLUDE list
+        @$romincs = grep /\S/, @$romincs;
+
+        # Fix paths for all ROM_INCLUDES
+        for ( my $i = 0 ; $i < scalar(@$romincs) ; $i++ )
+        {
+            @$romincs[$i] = get_fixpath( @$romincs[$i] );
+        }
+
+        $data{'ROM_INCLUDES'}   = clone_list($romincs);
+        $data{'VARIANT_HRH'}    = $varianthrh;
+        $data{'VIRTUAL'}        = $virtual;
+    }
+
+    # If variant file is not valid, return reference to a blank array
+    else
+    {
+        $data{'ROM_INCLUDES'}   = [];
+        $data{'VARIANT_HRH'}    = "";
+    }
+
+    return %data;
+}
+
+# Method to construct a full variant path from the variant file and directory
+sub get_variantfullpath
+{
+
+    my $vardirectory = $_[1];
+    my $varname      = $_[0];
+    
+    my $dir;
+    
+    # Check if a directory is supplied
+    if ($vardirectory)
+    {
+        $dir = "$vardirectory";
+    }
+
+    else
+    {
+        $dir = $defaultDir;
+    }
+    my $filename = "$varname" . "\.var";
+    $fullpath = File::Spec->catfile( File::Spec->rel2abs($dir), $filename );
+
+    if ( !File::Spec->file_name_is_absolute($fullpath) )
+    {
+        $fullpath = File::Spec->rel2abs($fullpath);
+    }
+
+    return $fullpath;
+}
+
+# Checks the variant file for the correct syntax and reports any errors
+# Also sets up some variables(VIRTUAL ,VARIANT_HRH and VARIANT) whilst file is being parsed.
+
+# Usage: check_varfile(<fullpath>,<varfile>) . Note: <varfile> without .var
+sub check_varfile
+{
+
+    my $fullpath          = $_[0];
+    my $varname           = $_[1];
+    my $varianthrhpresent = 0;
+
+    open( READVAR, "<$fullpath" );
+    my $exp  = "#";
+    my $line = "";
+
+    while (<READVAR>)
+    {
+        s/\r\n/\n/g;
+
+        $line = $.;
+
+    # Checks for a valid argument supplied to EXTENDS keyword. Checks for one and only one argument supplied.
+        if (/^EXTENDS/)
+        {
+            if ( !m/^EXTENDS\s+./ )
+            {
+                print "\nERROR: Invalid format supplied to argument EXTENDS on line "
+                  . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+            my $str = get_extends($_);
+            if ( $str =~ /\s+/ )
+            {
+                print "\nERROR: Cannot extend from two nodes. Error in line "
+                  . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+
+            $childNodeStatus = 1;
+        }
+
+        # Checks for the grammar of BUILD_INCLUDE, i.e. KEYWORD MODIFIER VALUE
+        elsif (/^BUILD_INCLUDE/)
+        {
+            # skip build inc checking
+        }
+
+        # Checks for the grammar of ROM_INCLUDE, i.e. KEYWORD MODIFIER VALUE
+        elsif (/^ROM_INCLUDE/)
+        {
+
+            if (!m/^ROM_INCLUDE\s+(append|prepend|set)\s+$pathregex/)
+            {
+                print "\nERROR: Invalid syntax supplied to keyword ROM_INCLUDE on line "
+                  . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+
+            if (m/^ROM_INCLUDE\s+(append|prepend|set)\s+$pathregex\s+$pathregex/)
+            {
+                print "\nERROR: Too many arguments supplied to keyword ROM_INCLUDE on line "
+                  . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+        }
+
+        # Checks for a valid VARIANT name
+        elsif (/^VARIANT[^_HRH]/)
+        {
+            if ( !m/^VARIANT\s+\w+/ )
+            {
+                print "\nERROR: VARIANT name not specified on line " . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+            if ( uc("$varname") ne uc( get_variantname($_) ) )
+            {
+                print "\nERROR: VARIANT filename does not match variant name specified on line "
+                  . "$line"
+                  . " in file "
+                  . "$fullpath"
+                  . "\nVariant value extracted from the VAR file is " . "$_";
+            }
+
+        }
+
+        # Checks that keyword VIRTUAL is declared correctly
+        elsif (/^VIRTUAL/)
+        {
+            if (m/^VIRTUAL\s+\w+/)
+            {
+                print "\nERROR: Invalid declaration of VIRTUAL on line " . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+
+            $virtual = 1;
+        }
+
+        # Checks if VARIANT_HRH is declared correctly.
+        elsif (/^VARIANT_HRH/)
+        {
+            $varianthrhpresent = 1;
+            my $lineno = $.;
+            if ( !m/^VARIANT_HRH\s+./ )
+            {
+                print "\nERROR: Invalid format supplied to argument VARIANT_HRH on line "
+                  . "$lineno"
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+
+            my $str = get_hrhname($_);
+            if ( $str =~ /\s+/ )
+            {
+                print "\nERROR: Cannot have 2 or more hrh files. Error in line "
+                  . "$lineno"
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+
+            unless( -e get_fixpath($str) )
+            {
+                print "\nERROR: VARIANT HRH file : "
+                  . get_fixpath($str)
+                  . " specified on line "
+                  . "$lineno"
+                  . " does not exist";
+                return 0;
+            }
+
+            $varianthrh = get_fixpath( get_hrhname($_) );
+
+        }
+        
+        # If none of the valid keywords are found
+        else
+        {
+
+            # Do nothing if a comment or blank line is found
+            if ( (m/$exp\s+\S/) || (m/$exp\S/) || ( !m/./ ) || (m/^\n/) )
+            {
+            }
+
+            # Unsupported keyword
+            else
+            {
+
+                print "\nERROR: Invalid keyword " . '"' . "$_" . '"'
+                  . " found on line " . "$."
+                  . " in file "
+                  . "$fullpath";
+                return 0;
+            }
+        }
+    }
+
+    close(READVAR);
+
+    # If no HRH file defined, check if the default one exists
+    if ( !$varianthrhpresent )
+    {
+        print "\nINFO: No VARIANT_HRH defined in VAR file, using ${epocroot}epoc32\/include\/variant\/$varname\.hrh" if ($verbose);
+        my $str =
+          get_hrhname(
+            "VARIANT_HRH ${epocroot}epoc32\/include\/variant\/$varname\.hrh"
+          );
+
+        if ( ! -e $str )
+        {
+            print "\nERROR: VARIANT HRH file : " . "$str " . "does not exist\n";
+            return 0;
+        }
+        else
+        {
+            $varianthrh = $str;
+        }
+    }
+    return 1;
+}
+
+# Extract the value of the VARIANT keyword
+sub get_variantname
+{
+
+    $_[0] =~ m/^VARIANT\s+(\w+)/i;
+    return $1;
+}
+
+# Extracts the value of the HRH file from the VARIANT_HRH line supplied
+sub get_hrhname
+{
+
+    $_[0] =~ m/^VARIANT_HRH\s+($pathregex)/;
+    return $1;
+
+}
+
+# Method to find the immediate parent node of a child node
+sub get_extends
+{
+
+    $_[0] =~ m/^EXTENDS\s+(\w+)/;
+    return $1;
+}
+
+
+# Method to correct all the slashes, and also append EPOCROOT if the path begins with a \ or /
+# If path doesn't start with \ or /, returns an abosulte canonical path
+sub get_fixpath
+{
+
+    my $arr = $_[0];
+
+    if ( $arr =~ m/^\// )
+    {
+       $arr =~ s/^\/?//;
+        return File::Spec->canonpath( "$epocroot" . "$arr" );
+    }
+
+    elsif ( $arr =~ m/^\\/ )
+    {
+        $arr =~ s/^\\?//;
+        return File::Spec->canonpath( "$epocroot" . "$arr" );
+    }
+
+    else
+    {
+        return File::Spec->rel2abs( File::Spec->canonpath("$arr") );
+    }
+
+}
+
+# Method to find the ROMINCLUDE values of the VAR file.
+sub find_varrominc
+{
+
+    my $filename = $_[0];
+
+    my $parentNodes;
+
+    # Construct a list of parent nodes if node is a child
+    if ($childNodeStatus)
+    {
+        $parentNodes = find_varparentnode("$filename");
+    }
+
+    if ($parentNodes)
+    {
+
+        # Go through and build the list of all parent ROM_INCLUDES
+        for ( my $i = scalar(@$parentNodes) - 1 ; $i >= 0 ; $i-- )
+        {
+            my $t = get_variantfullpath( @$parentNodes[$i], $fulldir );
+            open( NEWHANDLE, "<$t" );
+
+            while (<NEWHANDLE>)
+            {
+                if (/ROM_INCLUDE/)
+                {
+                    get_varrominc($_);
+                }
+            }
+            close(NEWHANDLE);
+        }
+    }
+
+    # Append the ROM_INCLUDES of the VAR file in the end
+    open( NEWHANDLE, "<$filename" );
+
+    while (<NEWHANDLE>)
+    {
+        if (/ROM_INCLUDE/)
+        {
+            get_varrominc($_);
+        }
+    }
+
+    undef(@parents);    # Flush out parent array;
+    return \@rominclude;
+
+}
+
+# Constructs a list of Parent nodes for a given Child node.
+sub find_varparentnode
+{
+
+    my $filename   = $_[0];
+    my $hasparents = 0;
+
+    open( READHANDLE, "<$filename" );
+    while (<READHANDLE>)
+    {
+        if (/EXTENDS/)
+        {
+            $hasparents = 1;
+            push( @parents, get_extends($_) );
+
+        }
+    }
+
+    close(READHANDLE);
+
+    if ( $hasparents == 1 )
+    {
+        find_varparentnode(
+            get_variantfullpath( @parents[ scalar(@parents) - 1 ], $fulldir )
+        );
+    }
+    else
+    {
+        return \@parents;
+    }
+
+}
+
+# Method to extract the ROM_INCLUDE value of a node.
+sub get_varrominc
+{
+
+# If modifier append is found, push the rominclude to the end of the array list.
+    if (/^ROM_INCLUDE\s+append\s+($pathregex)/)
+    {
+        push( @rominclude, ($1) );
+    }
+
+# If modifier prepend is found, push the rominclude to the beginning of the array list.
+    if (/^ROM_INCLUDE\s+prepend\s+($pathregex)/)
+    {
+        unshift( @rominclude, ($1) );
+    }
+
+# If keyword set is found, then empty the rominclude variable and push the new value
+    if (/^ROM_INCLUDE\s+set\s+($pathregex)/)
+    {
+        undef(@rominclude);
+        push( @rominclude, ($1) );
+    }
+
+}
+
+# Helper method that clones a reference to a simple list
+sub clone_list
+    {
+    my $ref = shift;
+    
+    # Check the reference is a list
+    die "Not a list ref" if ref($ref) ne 'ARRAY';
+    
+    # Create a new list object
+    my @list;
+    foreach my $entry ( @$ref )
+        {
+        # Only clone lists of scalars
+        die "Not a scalar" if ref($entry);
+        
+        # Add the entry to the new list
+        push @list, $entry;
+        }
+    
+    # return a reference to the copy    
+    return \@list;
+    }
+    
+##############################
+#  write helper
+#
+# copy from writer.pm
+sub write_32bit # little-endian
+{
+    my $fileHandle=shift;
+    my $integer=shift;
+    &write_8bit($fileHandle, $integer&0x000000ff);
+    &write_8bit($fileHandle, ($integer>>8)&0x000000ff);
+    &write_8bit($fileHandle, ($integer>>16)&0x000000ff);
+    &write_8bit($fileHandle, ($integer>>24)&0x000000ff);
+}
+
+sub write_8bit
+{
+    my $fileHandle=shift;
+    my $integer=shift;
+    if ($integer&0xffffff00)
+    {
+        die("Error: the integer ".sprintf("0x%08x", $integer)." is too large to write into 8 bits\n");
+    }
+    printf $fileHandle "%c", $integer;
+}
+
+
+1;
+