#!\bin\perl -w

# Copyright (c) 2003-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:

# CConfig

# 

package CConfig;

use strict;

use IO::File;

use COutputHandler;

# Added for scanlog compatibility

use Time::localtime;

# CConfig New(scalar aFilename) : constructor

sub New($)

	{

	my $proto = shift;

	my ($aFilename) = @_;

	my $class = ref($proto) || $proto;

	my $self = { RELTOOLS_REQUIRED => "",

                     outputHandler => COutputHandler->new()};

	bless($self, $class);

  # undef the logfile here so that the folowing warning goes to stdout

  $self->{iLOGFILE} = undef;

	# Load in options

	if (defined($aFilename))

		{

		if (!$self->Reload($aFilename))

			{

			$self->Warning("Option file could not be loaded.\n");

			}

		}

  # Added support for scanlog and Die() control.

  $self->{iPhaseErrorCount} = 0;

	$self->{iPhase} = undef;

	return $self;

	}

# boolean Set(scalar aOptionName, scalar aValue)

sub Set($$)

	{

	my $self = shift;

	my ($aOptionName, $aValue) = @_;

	if (!defined($aOptionName))

		{

		$self->Warning("Cannot set undefined option");

		return 0;

		}

	if (!defined($aValue))

		{

		$self->Warning("Cannot set option '$aOptionName' to undefined value.");

		return 0;

		}

	if ((ref($aValue) ne "") && (ref($aValue) ne "ARRAY"))

		{

		$self->Warning("Value of '$aOptionName' must be either a string or list.");

		return 0;

		}

	$self->{iOptions}->{lc($aOptionName)} = [$aOptionName, $aValue];

	return 1;

	}

# scalar Get(scalar aOptionName)

sub Get($)

	{

	my $self = shift;

	my ($aOptionName) = @_;

	if (defined($self->{iOptions}->{lc($aOptionName)}))

		{

		return ($self->{iOptions}->{lc($aOptionName)})->[1];

		}

	else

		{

		return undef;

		}

	}

# boolean Reload(scalar aFilename)

sub Reload($)

	{

	my $self = shift;

	my ($aFilename) = @_;

	my $okay = 1;

	$self->{iOptions}={}; # Blank existing options

	if (!open(FILE, $aFilename))

		{

		$self->Warning("Option file '$aFilename' could not be opened.");

		$okay = 0;

		}

	else

		{

		foreach my $line (<FILE>)

			{

			chomp ($line);

			# Split on colon

			my $parms = $line;

			$parms =~ s/([^\\]):/$1\x08/g; # Turn unescaped colons into 0x08 chars

			$parms =~ s/\\:/:/g; # Unescape escaped colons

			my @parms = split(/\x08/,$parms); # Split on 0x08

			if (scalar(@parms) != 0)

				{

				if (scalar(@parms) == 2)

					{

					my $key = $parms[0];

					$key =~ s/^\s+//; # Remove preceding spaces

					$key =~ s/([^\\])\s$/$1/g; # Remove unescaped trailing spaces

					$key =~ s/\\(\s)/$1/g; # Unescape space characters

					my $value = $parms[1];

					if ($value =~ /\s*\[.*\]\s*$/)

						{

						# Value is a [list]

						# Remove square brackets

						$value =~ s/^\s*\[//;

						$value =~ s/\]\s*$//;

						# Split on comma

						$value =~ s/([^\\]),/$1\x08/g; # Turn unescaped commas into 0x08 chars

						$value =~ s/\\,/,/g; # Unescape escaped commas

						my @values = split(/\x08/,$value); # Split on 0x08

						map(s/^\s+//, @values); # Remove preceding spaces

						map(s/([^\\])\s$/$1/g, @values); # Remove unescaped trailing spaces

						map(s/\\(\s)/$1/g, @values); # Unescape space characters

						$value = [@values];

						}

					else

						{

						# Value is a scalar

						$value =~ s/^\s+//; # Remove preceding spaces

						$value =~ s/([^\\])\s$/$1/g; # Remove unescaped trailing spaces

						$value =~ s/\\(\s)/$1/g; # Unescape space characters

						}

					if (!($self->Set($key, $value)))

						{

						$okay = 0;

						}

					}

				else

					{

					$self->Warning("In file '$aFilename', ".scalar(@parms)." parameters found on a line.\nOnly two parameters, colon separated, are supported.\nLine: '$line'");

					$okay = 0;

					}

				}

			}

		close(FILE);

		}

	return ($okay);

	}

# boolean Save(scalar aFilename)

sub Save($)

	{

	my $self = shift;

	my ($aFilename) = @_;

	my $okay = 1;

	if (!open(FILE, ">$aFilename"))

		{

		$self->Warning("Could not open option file '$aFilename' to save to.");

		$okay = 0;

		}

	else

		{

		foreach my $pair (values(%{$self->{iOptions}}))

			{

			my $key = $pair->[0];

			my $value = $pair->[1];

			if (!defined($value))

				{

				$self->Error("Cannot write undefined value for key '$key' when saving options.");

				$okay = 0;

				}

			else

				{

				if (ref($value))

					{

					if (ref($value) ne "ARRAY")

						{

						$self->Error("Cannot write ".ref($value)." for key '$key' when saving options.");

						$okay = 0;

						}

					else

						{

						# It's a list: [value,value,value] and escape any commas or opening spaces

						my @values = @{$value};

						map(s/^(\s)/\\$1/,@values);

						map(s/,/\\,/g,@values);

						$value = "[".join(",",@values)."]";

						}

					}

				else

					{

					# It's a scalar string

					# Escape opening space

					$key =~ s/^(\s)/\\$1/;

					# Escape square brackets;

					}

				# Escape colons

				$key =~ s/:/\\:/g;

				$value =~ s/:/\\:/g;

				print FILE $key.":".$value."\n";

				}

			}

		close (FILE)

		}

	return $okay;

	}

# boolean SetLog(scalar aFilename)

sub SetLog($)

	{

	my $self = shift;

	my ($aLogFile) = @_;

	if (defined($self->{iLOGFILE}))

		{

		$self->{iLOGFILE}->close();

    # This forces any subsequent error message to go to stdout

    $self->{iLOGFILE} = undef;

		}

	if (-e $aLogFile)

		{

		if (-e $aLogFile."~")

			{

			if (!unlink $aLogFile."~")

				{

				$self->Error("Couldn't delete backup log file\n");

				return 0;

				}

			}

		if (system("copy $aLogFile $aLogFile~ > nul 2>&1"))

			{

			$self->Error("Couldn't back-up existing log file\n");

			return 0;

			}

		}

	$self->{iLOGFILE}=new IO::File("> $aLogFile");

	if (defined($self->{iLOGFILE}))

		{

		return 1;

		}

	else

		{

		$self->Error("Couldn't open logfile $aLogFile\n");

		return 0;

		}

	}

# void Print(scalar aLogLine)

sub Print($)

	{

	my $self = shift;

	my ($aLogLine) = @_;

	my $logfile = $self->{iLOGFILE};

	if ($aLogLine !~ /\n$/)

		{

		$aLogLine = $aLogLine."\n";

		}

        $aLogLine = $self->{outputHandler}->CheckOutput($aLogLine);      

	if (!defined($logfile))

		{

		print $aLogLine;

		}

	else

		{

		print $logfile $aLogLine;

		}

	}

# void Die(scalar aError)

sub Die($)

	{

	my $self = shift;

	my ($aError) = @_;

	my $logfile = $self->{iLOGFILE};

	if ($aError !~ /\n$/)

		{

		$aError = $aError."\n";

		}

	if (!defined($logfile))

		{

		die $aError;

		}

	else

		{

		print $logfile $aError;

		die "ERROR: System experienced a fatal error; check the log file.\n";

		}

	}

# void Status(scalar aMessage)

sub Status($)

	{

	my $self = shift;

	my ($aMessage) = @_;

	if (defined($self->{iLOGFILE}))

		{

		print STDOUT $aMessage."\n"; # Only display status (to STDOUT) if everything else is going to the logfile

		}

	}

# Returns the number of errors encountered in a phase

sub GetErrorCount()

  {

  my $self = shift;

  return $self->{iPhaseErrorCount};

  }

###########################################

# Utility functions

###########################################

# boolean CheckRelTools()

sub CheckRelTools()

	{

	# Search for reldata API

	my $found = 0;

	foreach my $path (split(/;/,$ENV{PATH}))

		{

		if (-e $path."\\reldata\.pm")

			{

			$found = 1;

			last;

			}

		}

	return $found

	}

# void RequireRelTools() - Requires RelData and IniData. Dies if tools can't be located, or die when being required.

sub RequireRelTools()

	{

	my $self = shift;

	if ($self->{RELTOOLS_REQUIRED} ne "required")

		{

		# Locate reldata API

		my $found = 0;

		foreach my $path (split(/;/,$ENV{PATH}))

			{

			if (-e $path."\\reldata\.pm")

				{

				push @INC, $path;

				$found = 1;

				last;

				}

			}

		if (!$found)

			{

			$self->Error("Couldn't find release tools in path");

			}

		# Require core modules

		require RelData;

		require IniData;

		$self->{RELTOOLS_REQUIRED}="required";

		}

	}

###########################################

# Handling Commands, Phases and components.

###########################################

# void Command(scalar aMessage)

# Prints out a command in scanlog format to the log file or stdout

sub Command($)

  {

  my $self = shift;

	my ($aCommand) = @_;

  my $message = "===-------------------------------------------------\n=== Stage=$self->{stageNumber}.$aCommand\n===-------------------------------------------------\n";	my $logfile = $self->{iLOGFILE};

  $self->Print($message);

	}

# void PhaseStart(scalar aPhaseName)

# If a current phase is active then this is closed, if when doing so a

# non-zero error count is returned by PhaseEnd() then Die is called. This

# is regarded as a logic error as the stage runner should normally call PhaseEnd()

# itself and decide what to do about any errors that occured in that phase.

sub PhaseStart($)

  {

  my $self = shift;

  my $phase = shift;

  if (defined $self->{iPhase})

    {

    my $numErrs = $self->PhaseEnd();

    # If there are errors returned by PhaseEnd then Die()

    if ($numErrs != 0)

      {

        $self->Die("Fatal logic error detected, CConfig::PhaseStart() called without PhaseEnd() when phase has $numErrs errors.\n");

      }

    }

    $self->{stageNumber}++; # For scanlog compatibility

    $self->Command($phase);

    $self->{iPhase} = $phase;

    my $localTime = ctime(); 

    my $message = "=== Stage=$self->{stageNumber}.$self->{iPhase} started $localTime\n";

    $message .= "=== Stage=$self->{stageNumber}.$self->{iPhase} == $self->{iPhase}\n"; # For Scanlog compatibility

    $message .= "+++ HiRes Start " . time() . "\n"; # For Scanlog compatibility

    $message .= "--  $self->{iPhase}: Miscellaneous\n"; # For Scanlog compatibility

    $self->Print($message);

    $self->{iPhaseErrorCount} = 0;

  }

# scalar PhaseEnd(void)

# Closes the current phase and returns a count of the number of errors encountered.

# This will die if a PhaseStart() has not been declared.

sub PhaseEnd()

  {

  my $self = shift;

  my $localTime = ctime();

  if (defined $self->{iPhase})

    {   

    my $message = "+++ HiRes End " . time() . "\n"; # For Scanlog compatibility

    $message .= "=== Stage=$self->{stageNumber}.$self->{iPhase} finished $localTime\n";

    $self->Print($message);

    }

  else

    {

    $self->Die("Error: CConfig::PhaseEnd() called without corresponding PhaseStart()\n");

    }

	$self->{iPhase} = undef;

  return $self->{iPhaseErrorCount};

  }

# void Component(scalar aComponent)

# Prints out a component for this phase in scanlog format to the log file or stdout

sub Component($)

  {

  my $self = shift;

	my ($aComponent) = @_;

  if (!defined $self->{iPhase})

    {

    $self->Die("Logger: Undefined phase for component \"$aComponent\"\n");

    }

  else

    {

    my $message = "+++ HiRes End " . time() . "\n-- $aComponent\n+++ HiRes Start " . time();

    $self->Print($message);

    }

  }

###############################

# Handling errors and warnings.

###############################

# void Error(scalar aMessage)

# Writes an error message to the logfile (if defined) or stdout

# and will increment the error count for this phase.

sub Error($)

  {

	my $self = shift;

	my ($aMessage) = @_;

  $self->{iPhaseErrorCount} += 1;

  my $message = "ERROR: $aMessage";

  $self->Print($message);

  }

# void Warning(scalar aMessage)

# Writes an warning message to the logfile (if defined) or stdout

sub Warning($)

  {

	my $self = shift;

	my ($aMessage) = @_;

  my $message = "WARNING: $aMessage";

  $self->Print($message);

  }

sub DESTROY

	{

	my $self = shift;

	# Avoid "unreferenced scalar" error in Perl 5.6 by not calling