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

# Processes an mmp file and sets up subroutines to return the data

# 

#

package Mmp;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	Mmp_SetVerbose

	Mmp_ProcessL

	Mmp_ABI

	Mmp_AifStruct

	Mmp_AllowDllData

	Mmp_CompressTarget

	Mmp_ASSPExports

	Mmp_ASSPLibList

	Mmp_BuildAsARM

	Mmp_BitMapStruct 

	Mmp_CallDllEntryPoints

	Mmp_Capability

	Mmp_CapabilityFlags

	Mmp_DataLinkAddress

	Mmp_DebugLibList 

	Mmp_Def

	Mmp_DocHash

	Mmp_ExportUnfrozen

	Mmp_FirstLib

	Mmp_FixedProcess

	Mmp_HeapSize

	Mmp_LibList 

	Mmp_LinkAs

	Mmp_LinkAsBase

	Mmp_ExportLibrary

	Mmp_NewLib

	Mmp_NoExportLibrary

	Mmp_Macros

	Mmp_MmpFlag

	Mmp_PlatTxt2D

	Mmp_ProcessPriority

	Mmp_ResourceStruct 

	Mmp_SmpSafe

	Mmp_RamTargets

	Mmp_RomTargets

	Mmp_SourceStruct 

	Mmp_StackSize

	Mmp_StatLibList 

	Mmp_SysIncPaths

	Mmp_Trg

	Mmp_TrgType

	Mmp_UidList

	Mmp_UserIncPaths

	Mmp_SrcDbg

	Mmp_StdCpp

	Mmp_NoStdCpp

	Mmp_WarningLevel

	Mmp_LinkerOptions

	Mmp_Reset

	Mmp_Uids

	Mmp_Version

	Mmp_SecureId

	Mmp_VendorId

	Mmp_Replace

	Mmp_ARMFPU	

	Mmp_SetIgnoreMissingDef 

	Mmp_StringTable

	Mmp_CompressTargetMode

	Mmp_CodePagingTargetMode

	Mmp_DataPagingTargetMode

	Mmp_CheckSourceMMPMetaData

	Mmp_CheckSourceMMPIncludes

	Mmp_IsWideCharMain

	Mmp_IsDebuggable

	Mmp_IsFeatureVariant

	Mmp_TestedMacros

);

use strict;

use Genutl;

use Prepfile;

use Pathutl;

use Trgtype;

use CheckSource;

use Cwd;

my %ProcessPriorityNames = (

	LOW=>'Low',

	BACKGROUND=>'Background',

	FOREGROUND=>'Foreground',

	HIGH=>'High',

	WINDOWSERVER=>'WindowServer',

	FILESERVER=>'FileServer',

	REALTIMESERVER=>'RealTimeServer',

	SUPERVISOR=>'SuperVisor'

);

my %CapabilityNames;

my %Mode;

my $ABI;

my @AifStruct;

my $AllowDllData=0;

use constant COMPRESS => 0;

use constant NOCOMPRESS => 1;

my $CompressTarget=COMPRESS;	# compress the target binary (negative logic)

use constant NOCOMPRESSIONMETHOD => 0;

use constant INFLATECOMPRESSIONMETHOD => 1;

use constant BYTEPAIRCOMPRESSIONMETHOD => 2;

my $CompressTargetMethod=NOCOMPRESSIONMETHOD;   #NONE

my $ASSPABISwitch=0;

my $ASSPExports=0;

my @ASSPLibList;

my @BitMapStruct;

my $BuildAsARM=0;

my $CallDllEntryPoints=0;

my $Capability;

my @CapabilityFlags=(0,0);

my %CurSource;

my $DataLinkAddress='';

my @DebugLibList;

my %Def;

$Def{Path}='';

$Def{Base}='';

$Def{Ext}='';

my %DocHash;

my $ExportUnfrozen=0;

my $FirstLib;

my $FixedProcess=0;

my %HeapSize;

my @LangList;

my @LibList;

my $LinkAs;

my $LinkAsBase;

my $ExportLibrary;

my $NoExportLibrary;

my @Macros;

my %MmpFlag;

my $NewLib;

my @PlatTxt2D;

my $ProcessPriority='';

my @ResourceStruct;

my @RamTargets;

my @RomTargets=({}); # include default

my $SmpSafe = 0;

my @SourceStruct;

my $StackSize='';

my @StatLibList;

my $StdCpp = 0;

my $NoStdCpp = 0;

my @SysIncPaths;

my $Trg;

my %TrgType;

my @UidList;

my @UserIncPaths;

my $SrcDbg=0;

my %Compiler;

my %LinkerOptions;

my %Version;

my $SecureId;

my $VendorId;

my %Replace;

my $ARMFPU;

my $IgnoreMissingDef=0;

my @StringTableStruct;

my $CodePagingTargetMode;	# 0-N/A, 1-UNPAGED, 2-PAGED

my $DataPagingTargetMode;	# 0-N/A, 1-UNPAGED, 2-PAGED

my $WideCharMain=0;

my $IsDebuggable;	# 0-NON_DEBUGGABLE, 1-DEBUGGABLE,2-DEBUGGABLE_UDEBONLY

my $FeatureVariant=0;

use constant NOTPAGED => 0;

use constant UNPAGED => 1;

use constant PAGED => 2;

use constant NON_DEBUGGABLE => 0;

use constant DEBUGGABLE => 1;

use constant DEBUGGABLE_UDEBONLY => 2;

my %CheckSourceMMPMetaData;

my %CheckSourceMMPIncludes;

my %mmptestedMacrosHash;

# List of deprecated 2nd UIDs. These are checked in a Secure Platform

my %deprecatedUIDs=

    (

    "0x10005e32" => "Unmigrated FEP detected from use of UID 0x10005e32 ",

    "0x10004cc1" => "Unmigrated Application Initaliser (CEikLibrary deriver) detected from use of UID 0x10004cc1 ",

    "0x10003a30" => "Unmigrated Conarc plugin detected from use of UID 0x10003a30",

    "0x10003a19" => "Unmigrated Recogniser detected from use of UID 0x10003a19",

    "0x10003a37" => "Unmigrated Recogniser detected from use of UID 0x10003a37",

    "0x10003a34" => "Unmigrated CTL detected from use of UID 0x10003a34"

    );

sub Mmp_Reset() {

	undef $ABI;

	undef @AifStruct;

	$AllowDllData=0;

	$CompressTarget=COMPRESS;

    $CompressTargetMethod=NOCOMPRESSIONMETHOD;

	$ASSPABISwitch=0;

	$ASSPExports=0;

	$BuildAsARM=0;

	undef @ASSPLibList;

	undef @BitMapStruct;

	$CallDllEntryPoints=0;

	undef $Capability;

	@CapabilityFlags=(0,0);

	undef $VendorId;

	$DataLinkAddress='';

	undef @DebugLibList;

	undef %Def;

	$Def{Path}='';

	$Def{Base}='';

	$Def{Ext}='';

	undef %DocHash;

	$ExportUnfrozen=0;

	undef $FirstLib;

	$FixedProcess=0;

	undef %HeapSize;

	undef @LangList;

	undef @LibList;

	undef $LinkAs;

	undef $LinkAsBase;

	undef $ExportLibrary;

	undef @Macros;

	undef %MmpFlag;

	undef $NewLib;

	undef @PlatTxt2D;

	$ProcessPriority='';

	undef @ResourceStruct;

	undef @RamTargets;

	@RomTargets=({}); # include default

	undef @SourceStruct;   

	$StackSize='';

	undef @StatLibList;

	$SmpSafe = 0;

	$StdCpp = 0;

	$NoStdCpp = 0;

	undef @SysIncPaths;

	undef $Trg;

	undef %TrgType;

	undef @UidList;

	undef @UserIncPaths;

	$SrcDbg=0;

	undef %Compiler;

	undef %LinkerOptions;

    undef %Version;

    $IgnoreMissingDef=0;

    undef $ARMFPU;

	undef @StringTableStruct;

	$CodePagingTargetMode=0;	# default N/A

	$DataPagingTargetMode=0;	# default N/A

	$IsDebuggable=0; # Default = 0 (Not debuggable)

	undef %mmptestedMacrosHash;

}

BEGIN {

	$Mode{'Verbose'}=0;

	%CapabilityNames = (

		TCB =>					(1<<0),

		COMMDD =>				(1<<1),

		POWERMGMT =>			(1<<2),

		MULTIMEDIADD =>			(1<<3),

		READDEVICEDATA =>		(1<<4),

		WRITEDEVICEDATA =>		(1<<5),

		DRM =>					(1<<6),

		TRUSTEDUI =>			(1<<7),

		PROTSERV =>				(1<<8),

		DISKADMIN =>			(1<<9),

		NETWORKCONTROL =>		(1<<10),

		ALLFILES =>				(1<<11),

		SWEVENT =>				(1<<12),

		NETWORKSERVICES =>		(1<<13),

		LOCALSERVICES =>		(1<<14),

		READUSERDATA =>			(1<<15),

		WRITEUSERDATA =>		(1<<16),

		LOCATION =>				(1<<17),

		SURROUNDINGSDD =>		(1<<18),

		USERENVIRONMENT =>		(1<<19),

#old capability names have zero value

		ROOT =>				0,

		MEDIADD =>			0,

		READSYSTEMDATA =>	0,

		WRITESYSTEMDATA =>	0,

		SOUNDDD =>			0,

		UIDD =>				0,

		KILLANYPROCESS =>	0,

		DEVMAN =>			0,

		PHONENETWORK =>		0,

		LOCALNETWORK =>		0

	);

	my $all=0;

	foreach (keys %CapabilityNames)

		{

		$all = $all | $CapabilityNames{$_};

		}

	$CapabilityNames{"ALL"} = $all;

}

sub Mmp_SetVerbose () {

	$Mode{'Verbose'}=1;

}

sub Mmp_SetIgnoreMissingDef() {

    $IgnoreMissingDef = 1;

}

sub Mmp_ProcessL ($$$$) {

	my ($EPOCPath, $MMPFILE, $Plat_ref, $BuildIncList)=@_;

	my $emulator = $$Plat_ref{OS} ne 'EPOC32';

	if ($Mode{Verbose}) {

		&Prepfile_SetVerbose;

	}

	# Generate macro usage information and add variant build includes

	my $options = '-dU';

	foreach ( @$BuildIncList )

		{

		$options .= ' -I ' . &Path_PrefixWithDriveAndQuote($_);

		}

#	preprocess the project description file

	my @Mmp2D;

	Prepfile_SetCmdOptions($options);

	eval { &Prepfile_ProcessL(\@Mmp2D, $MMPFILE, &main::VariantFile(), @{$$Plat_ref{MmpMacros}}); };

	Prepfile_SetCmdOptions('');

	die $@ if $@;

	my @checkSourceMacros;

	foreach (@{$$Plat_ref{MmpMacros}}) {

		$_=uc $_;

		push @checkSourceMacros, " $_=_____$_";

	}

	my $current = cwd;

	$current =~ s/\//\\/g;

	$current =~ s/^[a-zA-Z]://;

	# Mimic what the current parsing routine does in terms of include paths and .mmp files

	my @checkSourceUserIncludePaths;

	push @checkSourceUserIncludePaths, "$ENV{EPOCROOT}epoc32\\include";

	push @checkSourceUserIncludePaths, "\.";

	push @checkSourceUserIncludePaths, $current;

	my @checkSourceSystemIncludePaths = ();

	CheckSource_Includes($MMPFILE, %CheckSourceMMPIncludes, &main::VariantFile(), @checkSourceMacros, @checkSourceUserIncludePaths, @checkSourceSystemIncludePaths, $CheckSource_NoUserSystemDistinction);

	my $NoStrictDef=0;

	my $TrgPath='';

	my $TrgType;

	my $MmpPath=&Path_Split('Path', $MMPFILE);

	my @MmpDie=();

	my @MmpWarn=();

	my @MmpDiagnostic=();

	my @MmpMigrationNote=();

	my (%CheckAif, %CheckASSPLib, %CheckDoc, %CheckLang, %CheckLib, %CheckMacro, %CheckResrc, %CheckSrc, %CheckStatLib, %CheckSysInc, %CheckSysResrc, %CheckUserInc);

	my ($CheckDef);

	my ($CheckRamTargets, $CheckRomTargets);

	my ($OtherPlatSwitch, $PlatTxtSwitch);

	my (%CurBitMap, $CurBitMapSrcPath);

	$CurBitMapSrcPath=$MmpPath;

	my (%CurResource, %ResourceCheckLang);

	my %CurStringTable;

	my ($CurSrcPath, $MmpMacro, $Line);

	$CurSrcPath=$MmpPath;

#	include the .MMP file as a document

	@{$DocHash{$MmpPath}}=(&Path_Split('File', $MMPFILE));

	$CheckDoc{$MMPFILE}='zero - specified by default';

# process the data structure

	my $CurFile=$MMPFILE;

	LINE: foreach $Line (@Mmp2D) {

		my $LineNum=shift @$Line;

		$_=shift @$Line;

		if ($LineNum eq '#') {

			$CurFile=$_;

			next LINE;

		}

		# Get details of tested macros affecting the MMP file

		# We get this from -dU preprocessor option

		if (/^#define$/ && "@$Line" =~ /^(\w+(?:\([^\)]*\))?)(?:\s(\S.*?))?\s*$/)

			{

			# Record macro details for defined tested macro

			$mmptestedMacrosHash{$1} = $2 ? "\'$2\'" : 'defined';

			next LINE;

			}

		elsif (/^#undef$/)

			{

			# Record macro details for undefined tested macro

			$mmptestedMacrosHash{"@$Line"} = 'undefined';

			next LINE;

			}

		$CurFile = &Path_Norm ($CurFile);

		$_=uc $_;

		my $mainElement = $_;

		if ($PlatTxtSwitch) {

			if (/^END$/o) {

				$PlatTxtSwitch=0;

				next LINE;

			}

			push @PlatTxt2D, [ "$CurFile($LineNum)", $_, @$Line ];

			next LINE;

		}

		if ($OtherPlatSwitch) {

			if (/^END$/o) {

				$OtherPlatSwitch=0;

				next LINE;

			}

			next LINE;

		}

		# ----------- handle body of START BITMAP ... END -------------

		if (%CurBitMap) {

			if (/^SOURCE$/o) {

				unless (@$Line>1) {

					push @MmpDie, "$CurFile($LineNum) : Not enough arguments for Bitmap keyword SOURCE\n";

				}

				my $cldepth = shift @$Line;

				my @ClDepths = split(/,/, $cldepth);

				foreach (@ClDepths) {

					$_ = lc $_; # bmconv can't handle upper-case 'C's

					unless (/^c?\d\d?a?$/o) {

						push @MmpDie, "$CurFile($LineNum) : BITMAP color depth \"$_\" - unexpected format\n";

					}

				}

				@ClDepths = (@ClDepths) x @$Line;	# make a sufficiently long list of color depths

				foreach (@$Line) {

					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "BITMAP SOURCE", $_, $LineNum, $CheckSource_PhysicalCheck, $CurBitMapSrcPath);

					$_ = &Path_Norm($_);

					$_=lc $_;	# bmconv generates a header with case-sensitive enums

					my $bitmap = "$CurBitMapSrcPath$_";

					push @{$CurBitMap{Source}}, { # sources must be kept in order

						Src=>$bitmap,

						ClDepth=>shift @ClDepths	# take next color depth from the list

					};

					unless (-e $bitmap) {

						push @MmpWarn, "$CurFile($LineNum) : BITMAP source \"$CurBitMapSrcPath$_\" not found\n";

					}

				}

				next LINE;

			}

			if (/^END$/o) {

				$CurBitMapSrcPath=$MmpPath;

				my %BitMap=%CurBitMap;

				undef %CurBitMap;

				push @BitMapStruct, \%BitMap;

				next LINE;

			}

			if (/^SOURCEPATH$/o) {

				unless ($CurBitMapSrcPath=shift @$Line) {

					push @MmpDie, "$CurFile($LineNum) : No path specified with Bitmap keyword SOURCEPATH\n";

					next LINE;

				}

				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "BITMAP SOURCEPATH", $CurBitMapSrcPath, $LineNum, $CheckSource_PhysicalCheck);

				$CurBitMapSrcPath = &Path_Norm($CurBitMapSrcPath);

				$CurBitMapSrcPath=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash

				$CurBitMapSrcPath=&Path_MakeAbs($CurFile,$CurBitMapSrcPath);

				if (@$Line) {

					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for Bitmap keyword SOURCEPATH\n";

				}

				next LINE;

			}

			if (/^HEADER$/o) {

				if ($CurBitMap{Hdr}) {

					push @MmpWarn, "$CurFile($LineNum) : Bitmap HEADER already specified at line $CurBitMap{Hdr}\n";

					next LINE;

				}

				$CurBitMap{Hdr}="$CurFile($LineNum)";

				if (@$Line) {

					push @MmpWarn, "$CurFile($LineNum) : Bitmap keyword HEADER takes no arguments\n";

				}

				next LINE;

			}

			if (/^TARGETPATH$/o) {

				if ($CurBitMap{TrgPath}) {

					push @MmpWarn, "$CurFile($LineNum) : Bitmap TARGETPATH already specified\n";

					next LINE;

				}

				unless ($CurBitMap{TrgPath}=shift @$Line) {

					push @MmpDie, "$CurFile($LineNum) : No path specified with Bitmap keyword TARGETPATH\n";

					next LINE;

				}

				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "BITMAP TARGETPATH", $CurBitMap{TrgPath}, $LineNum);

				$CurBitMap{TrgPath} = &Path_Norm($CurBitMap{TrgPath});

				$CurBitMap{TrgPath}=~s-^\\(.*)$-$1-o;        # remove leading backslash, if any

				$CurBitMap{TrgPath}=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash

				$CurBitMap{TrgPath}="z\\$CurBitMap{TrgPath}";

				if (@$Line) {

					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for Bitmap keyword TARGETPATH\n";