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