# Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "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:
# General Path and File Utility Functions for use with Makmake
# Distinguish paths from filepaths by assuming paths end with "\"
# therefore ensure this is the case for all paths coming into programs using this module
# 
#

package Pathutl;

require Exporter;
@ISA=qw(Exporter);

@EXPORT=qw(
	Path_SetVerbose Path_Drive Path_WorkPath Path_RltToWork Path_AbsToWork
	Path_DelFiles Path_Split Path_Dirs Path_StepDirs Path_Strip 
	Path_MakePathL Path_UpToRoot Path_MakeRlt Path_MakeAbs Path_Chop
	Path_MakeEAbs Path_Quote Path_MakeRltToBase Path_Norm Path_PrefixWithDrive Path_PrefixWithDriveAndQuote
);

use Cwd;
use File::Path;                # for mkpath

my %Mode=(
	Verbose=>0
);
my $Drive;
my $WorkPath;
my @WorkPathList;

sub Path_SetVerbose () {
	$Mode{Verbose}=1;
}

sub Path_Drive () {
# return the current drive - programs shouldn't change directory if using this module
	$Drive;
}

sub Path_WorkPath () {
# return the current working directory - programs shouldn't change directory if using this module
	$WorkPath;
}

sub helper_MakeRlt ($@) {
# helper function for computing relative path(s) given a base path
	my ($BaseRef,@List)=@_;
	foreach my $p (@List) {
		my $filename=&Path_Split('File',$p);
		my @plist=&Path_Dirs($p);
		my $upcount=scalar @{$BaseRef};
		foreach (@{$BaseRef}) {
			if (uc $_ ne uc $plist[0]) {
				last;
			}
			$upcount -= 1;
			shift @plist;
		}
		$p="";
		while ($upcount-->0) {
			$p .= "..\\";
		}
		foreach (@plist) {
			$p .= "$_\\";
		}
		$p=".\\" if ($p eq "");		# ensure a well-formed result if path == work
		$p .= $filename;
	}
	return wantarray ? @List : $List[0];	
}

sub Path_RltToWork (@) {
# make a path or list of paths relative to the current working directory
	my @List=@_;
	@List=&helper_MakeRlt(\@WorkPathList,@List);
	return wantarray ? @List : $List[0];
}

sub Path_MakeRltToBase ($@) {	#args: $_[0] Base $_[1]... list of (Abs FilePath/Path)
# make a path, or list of paths, relative to a particular directory specified by the first
# path passed into the function
	return undef unless $_[0]=~m-(|\\$)-o;	# allow for null value passed in
	my ($Base,@List)=@_;
	my @BasePathList=&Path_Dirs($Base);
	@List=&helper_MakeRlt(\@BasePathList,@List);
	return wantarray ? @List : $List[0];	
}

sub Path_AbsToWork (@) {
# make a path or list of paths relative to the current working directory absolute
	my @List=@_;
	@List=&Path_MakeAbs($WorkPath,@List);
	return wantarray ? @List : $List[0];	
}

sub Path_DelFiles (@) {
# delete a list of files
	my @List=@_;
	my $File;
	foreach $File (@List) {
		if (unlink $File) {
			if ($Mode{Verbose}) {
				print "Deleted File: \"$File\"\n";
			}
			next;
		}
		if ($Mode{Verbose}) {
			print "Not Found: \"$File\"\n";
		}
	}
}

sub Path_Split ($$) {	#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
	my ($Sect,$P)=@_;

	return '' if !$P;
	
	$Sect= ucfirst lc $Sect;
	if ($Sect eq 'Path') {
		if ($P=~/^(.*\\)/o) {
			return $1;
		}
		return '';
	}
	if ($Sect eq 'Base') {
		if ($P=~/\\?([^\\]*?)(\.[^\\\.]*)?$/o) {
			return $1;
		}
		return '';
	}
	if ($Sect eq 'Ext') {
		if ($P=~/(\.[^\\\.]*)$/o) {
			return $1;
		}
		return '';
	}
	if ($Sect eq 'File') {
		if ($P=~/([^\\]*)$/o) {
			return $1;
		}
		return '';
	}
	undef;
}

sub Path_Dirs ($) {	#args: $_[0] Abs FilePath/Path
# return an ordered list of individual directories that make up a path
	return undef unless $_[0]=~m-^\\-o;
	my $P=&Path_Split('Path',$_[0]);
	return undef unless $P=~s-^(.*)\\$-$1-o;
	$P=~s-^\\(.*)-$1-o;
	split /\\/,$P;
}

sub Path_StepDirs ($) { #args: $_[0] Abs FilePath/Path
# return an ordered list of paths - starting with the directory in the root directory from the
# path passed into the function, each subsequent path contains the next directory from the path
# passed into the function, and the last path is the same as the path passed into the function
	return undef unless $_[0]=~m-^\\-o;
	my $P=$_[0];
	my @Dirs=&Path_Dirs($P);
	my @StepDirs;
	my $dir;
	my $stepDir="\\";
	foreach $dir (@Dirs) {
		$stepDir.="$dir\\";
		push @StepDirs, $stepDir;
	}
	@StepDirs;
}

sub Path_Strip ($) {	#args: $_[0] Abs FilePath/Path
# Remove excess occurrences of '..' and '.' from a path
	return undef unless $_[0]=~m-^\\-o;
	my $P=$_[0];
	while ($P=~s-\\\.\\-\\-go) { }
	while ($P=~s-\\(?!\.{2}\\)[^\\]*\\\.{2}(?=\\)--go) { }
	$P;
}

sub Path_MakePathL (@) {	#args: @_ list of Abs FilePath/Path
# make a directory or list of directories
	my @Paths=@_;
	my $P;
	foreach $P (@Paths) { 
		return undef unless $P=~m-^\\-o;
		$P=&Path_Split('Path',$P);
		$P=&Path_Strip($P);
		$P=~m-(.*)\\-o;
		if (-d $1) {
			if ($Mode{'Verbose'}) {
				print "Existing Path: \"$P\"\n";
			}
			next;
		}
		mkpath[$P];
		if ($Mode{'Verbose'}) {
			print "Created Path: \"$P\"\n";
		}
	}
	return wantarray ? @Paths : $Paths[0];
}

sub Path_UpToRoot ($) {	#args: $_[0] Abs FilePath/Path
# return the path that will lead from the directory the path passed into the function
# specifies back up to the root directory
	return undef unless $_[0]=~m-^\\-o;
	my $Path=$_[0];
	my $UpP;
	while ($Path=~m-\\-go) {
		$UpP.="..\\";
	}
	undef $Path;
	$UpP=~s-^(.*)\.\.\\-$1-o;
	$UpP=".\\" unless $UpP;
}

sub Path_MakeRlt ($@) {	#args: $_[0] Start UpPath $_[1]... list of (Abs FilePath/Path)
# make a path, or list of paths, relative to a particular directory specified by the first
# path passed into the function which leads upwards from a particular directory
	return undef unless $_[0]=~m-(|\\$)-o;	# allow for null value passed in
	my ($UpPath,@List)=@_;
	my $p;
	foreach $p (@List) {
		return undef unless $p=~m-^\\-o;
		$p=~s-^\\(.*)$-$1-o;
		$p=$UpPath.$p;
	}
	return wantarray ? @List : $List[0];	
}

sub Path_MakeAbs ($@) {	#args: $_[0] Start Abs FilePath/Path $_[1]... list of (Abs/Rel FilePath/Path)
# make a path, or list of paths, absolute given the directory specified by the first path
# passed into the function which the other paths passed into the function are assumed to be
# relative to
	return undef unless $_[0]=~m-^\\-o;
	my ($Path,@List)=@_;
	my $BasePath=&Path_Split("Path",$Path);
	undef $Path;
	my $p;
	foreach $p (@List) {
		if ($p=~m-^\.{2}-o) {
			$p=&Path_Strip($BasePath.$p);
			next;
		}
		if ($p=~m-^[^\.\\]-o) {
			$p=&Path_Strip($BasePath.$p);
			next;
		}
		if ($p=~m-^\\-o) {
			$p=&Path_Strip($p);
			next;
		}
		if ($p=~m-^\.\\(.*)$-o) {
			$p=&Path_Strip($BasePath.$1);
			next;
		}
		return undef;
	}
	return wantarray ? @List : $List[0];
}

sub Path_MakeEAbs ($@) {	#args: $_[0] Start EPOCPath Abs FilePath/Path $_[1]... list of (Abs/Rel FilePath/Path)
# Variant of MakAbs which also maps "+\\" to "${EPOCPath}"
	return undef unless $_[0]=~m-^\\-o;
	my ($EPOCPath,$Path,@List)=@_;
	my $BasePath=&Path_Split("Path",$Path);
	undef $Path;
	my $p;
	foreach $p (@List) {
		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=&Path_Strip($BasePath.$p);
			next;
		}
		if ($p=~m-^[^\.\\]-o) {
			$p=$BasePath.$p;
			next;
		}
		if ($p=~m-^\\-o) {
			next;
		}
		if ($p=~m-^\.\\(.*)$-o) {
			$p=&Path_Strip($BasePath.$1);
			next;
		}
		return undef;
	}
	return wantarray ? @List : $List[0];
}

sub Path_Chop (@) {
# remove the terminating backslash from a path, or list of paths, if there is one
	my @List=@_;
	my $Path;
	foreach $Path (@List) {
		$Path=~s-^(.*)\\$-$1-o;
	}
	return wantarray ? @List : $List[0];
}

sub Path_Quote ($) {
# Quote name for use in GNU makefiles
	my @List=@_;
	my $Path;
	foreach $Path (@List) {
		$Path=~s- -\\ -go if (defined($Path));
	}
	return wantarray ? @List : $List[0];
}

sub Path_Norm ($) {
# Normalise source specified paths for processing
	my ($Path) = @_;
	$Path =~ s/\//\\/g;
	return $Path;
}

sub Path_PrefixWithDrive ($) {
# Take a path, or list of paths, and prefix with drive based on CWD.
# Relative paths are just returned.
	my @List=@_;
	my $Path;
	my $Drive=$1 if (cwd =~ /^(.:)/); 

	foreach $Path (@List) {
		next if ($Path !~ /^\\/);
		$Path=$Drive.$Path;
	}
	
	return wantarray ? @List : $List[0];
}

sub Path_PrefixWithDriveAndQuote ($) {
# Take a path, or list of paths, and prefix with drive based on CWD.
# Relative paths are just quoted.
	my @List=@_;
	my $Path;
	my $Drive=$1 if (cwd =~ /^(.:)/); 

	foreach $Path (@List) {
		next if ($Path !~ /^\\/);
		$Path=$Drive.$Path;
	}

	foreach $Path (@List) {
		$Path="\"".$Path."\"";
	}
	
	return wantarray ? @List : $List[0];
}



BEGIN {
# get the current working directory
	$WorkPath=cwd;
	$WorkPath=~s-/-\\-go; # separator from Perl 5.005_02+ is forward slash
	$WorkPath=~s/^(.:)//o;    # remove drive letter
	$Drive=$1;
	$WorkPath=~s-^(.*[^\\])$-$1\\-o;        # ensure workpath ends with a backslash
	@WorkPathList=&Path_Dirs($WorkPath);
}

1;