# 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=>{