# 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 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";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Unrecognised Bitmap Keyword \"$_\"\n";
		}
		
		# ----------- handle body of START RESOURCE ... END -------------
		if (%CurResource) {
			if (/^END$/o) {
				$CurResource{SrcPath}=$CurSrcPath;
				my %Resource=%CurResource;
				undef %CurResource;
				push @ResourceStruct, \%Resource;
				undef %ResourceCheckLang;
				next LINE;
			}
			if (/^HEADER$/o) {
				if ($CurResource{Hdr}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource HEADER already specified at line $CurResource{Hdr}\n";
					next LINE;
				}
				elsif ($CurResource{Hdronly}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource HEADERONLY already specified at line $CurResource{Hdr}\n";
					next LINE;
				}
				$CurResource{Hdr}="$CurFile($LineNum)";
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Resource keyword HEADER takes no arguments\n";
				}
				next LINE;
			}
			if (/^HEADERONLY$/o) {
				if ($CurResource{Hdronly}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource HEADERONLY already specified at line $CurResource{Hdr}\n";
					next LINE;
				}
				elsif ($CurResource{Hdr}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource HEADER already specified at line $CurResource{Hdr}\n";
					next LINE;
				}
				$CurResource{Hdronly}="$CurFile($LineNum)";
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Resource keyword HEADERONLY takes no arguments\n";
				}
				next LINE;
			}

			if (/^LANG$/o) {
				if (@$Line) {
					my $Candidate;
					foreach $Candidate (@$Line) {
						if ($ResourceCheckLang{$Candidate}) {
							push @MmpWarn, "$CurFile($LineNum) : Duplicate Language \"$Candidate\" at line $ResourceCheckLang{$Candidate}\n";
							next; 
						}
						push @{$CurResource{Lang}}, $Candidate;
						$ResourceCheckLang{$Candidate}="$CurFile($LineNum)";
					}
					next LINE;
				}
				push @MmpWarn, "$CurFile($LineNum) : No Languages specified for keyword LANG\n";
				next LINE;
			}
			if (/^TARGET$/o) {
				if ($CurResource{BaseTrg}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource TARGET already specified\n";
					next LINE;
				}
			    my $src=shift @$Line;
			    CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "RESOURCE TARGET", $src, $LineNum);
			    
			    $src = &Path_Norm($src);
				$CurResource{BaseTrg}=&Path_Split('Base',$src);
				unless ($CurResource{BaseTrg}) {
					push @MmpDie, "$CurFile($LineNum) : No name specified with Resource keyword TARGET\n";
					next LINE;
				}
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for Resource keyword TARGET\n";
				}
				next LINE;
			}
			if (/^TARGETPATH$/o) {
				if ($CurResource{TrgPath}) {
					push @MmpWarn, "$CurFile($LineNum) : Resource TARGETPATH already specified\n";
					next LINE;
				}
				unless ($CurResource{TrgPath}=shift @$Line) {
					push @MmpDie, "$CurFile($LineNum) : No path specified with Resource keyword TARGETPATH\n";
					next LINE;
				}
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "RESOURCE TARGETPATH", $CurResource{TrgPath}, $LineNum);
				$CurResource{TrgPath} = &Path_Norm($CurResource{TrgPath});
				
				$CurResource{TrgPath}=~s-^\\(.*)$-$1-o;        # remove leading backslash, if any
				$CurResource{TrgPath}=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash
				$CurResource{TrgPath}="z\\$CurResource{TrgPath}";
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for Resource keyword TARGETPATH\n";
				}
				next LINE;
			}
			if (/^UID$/o) {
				if (@$Line) {
					if (scalar @$Line>2) {
						push @MmpWarn, "$CurFile($LineNum) : Can't specify more than 2 Uids\n";
						next LINE;
					}
					foreach (@$Line) {
						$_=&Genutl_AnyToHex($_);
						if (defined $_) {
							push @{$CurResource{Uids}}, $_;
							next;
						}
						push @MmpDie, "$CurFile($LineNum) : Uid doesn't fit expected number format\n";
						next LINE;
					}
					next LINE;
				}
				push @MmpWarn, "$CurFile($LineNum) : No Uids specified for Resource keyword UID\n";
				next LINE;
			}
			if (/^DEPENDS$/o) {
				# Note that DEPENDS lines are tolerated, but ignored - these are only relevant to build systems
				# other than ABLD
				next LINE;
			}
			
			push @MmpWarn, "$CurFile($LineNum) : Unrecognised Resource Keyword \"$_\"\n";
		}
		if (/^WCHARENTRYPOINT$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			if ($TrgType=~/^STDEXE$/io) {
				$WideCharMain=1;	
			}
			else{
				push @MmpWarn, "$CurFile($LineNum) : WCHARENTRYPOINT is supported only for Target Type STDEXE\n";
			}
			next LINE;
		}
		# ----------- handle body of START STRINGTABLE ... END -------------
		if(%CurStringTable)
		{	
			if (/^END$/o) {
				my %stringtable = %CurStringTable;
				push @StringTableStruct, \%stringtable;
				undef %CurStringTable;
				next LINE;
			}
			if (/^EXPORTPATH/o) {
				if (scalar @$Line != 1) {
					push @MmpDie, "$CurFile($LineNum) : Wrong number of arguments for EXPORTPATH\n";
				} 
				if(defined $CurStringTable{ExportPath})	{
					push @MmpDie, "$CurFile($LineNum) : Redefinition of EXPORTPATH\n";
				}
				else {
				    my $src=shift @$Line;
					$CurStringTable{ExportPath} = $src;

					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "STRINGTABLE EXPORTPATH", $CurStringTable{ExportPath}, $LineNum);
					
					$CurStringTable{ExportPath} = &Path_Norm($CurStringTable{ExportPath});					

					$CurStringTable{ExportPath} =~ s/\\$//o;   # ensure path doesn't end with a backslash (cl_generic.pm will add one)
					$CurStringTable{ExportPath} = &Path_MakeEAbs($EPOCPath,$CurFile,$CurStringTable{ExportPath});

				}
				next LINE;
			}
			if (/^HEADERONLY$/o) {
				if ($CurStringTable{Hdronly}) {
					push @MmpWarn, "$CurFile($LineNum) : Stringtable HEADERONLY already specified\n";
					next LINE;
				}
				$CurStringTable{Hdronly}="$CurFile($LineNum)";
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Stringtable keyword HEADERONLY takes no arguments\n";
				}
				next LINE;
			}
		}
		# ----------- handle top-level MMP file -------------------	
		if (/^START$/) {
			unless ($_=uc shift @$Line) {
				push @MmpWarn, "$CurFile($LineNum) : No Argument specified for START block\n";
				next LINE;
			}
			foreach $MmpMacro (@{$$Plat_ref{MmpMacros}}) {
				if ($_ eq $MmpMacro) {
					$PlatTxtSwitch="$CurFile($LineNum)";
					next LINE;
				}
			}
			if ($_ eq 'BITMAP') {
				unless ($CurBitMap{Trg}=shift @$Line) {
					push @MmpWarn, "$CurFile($LineNum) : No Bitmap Target specified\n";
					$CurBitMap{Trg}='NoTargetSpecified';
				}
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for START BITMAP clause\n";
				}

				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "START BITMAP", $CurBitMap{Trg}, $LineNum);
				$CurBitMap{Trg} = &Path_Norm($CurBitMap{Trg});
				next LINE;
			}
			if ($_ eq 'RESOURCE') {
				if (scalar @$Line != 1) {
					push @MmpWarn, "$CurFile($LineNum) : Wrong number of arguments for START RESOURCE clause\n";
				} 
				else {
				    my $src=shift @$Line;
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "START RESOURCE", $src, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$src = &Path_Norm($src);
				    
					$CurResource{Source}="$CurSrcPath$src";
				}

				
				next LINE;
			}
			if ($_ eq 'STRINGTABLE') {
				if (scalar @$Line != 1) {
					push @MmpWarn, "$CurFile($LineNum) : Wrong number of arguments for START STRINGTABLE clause\n";
				} 
				else {
				    my $Candidate = shift @$Line;
				    CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, "START STRINGTABLE", $Candidate, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$Candidate = &Path_Norm($Candidate);
				    
					$Candidate =~ s/^\\//;	# remove leading \, if any	
					$CurStringTable{BaseTrg}=&Path_Split('Base',$Candidate);
					my $path=&Path_Split('Path',$Candidate);
					if($path){
					  $CurStringTable{STPath}=&Path_MakeAbs($CurSrcPath,&Path_Split('Path',$Candidate));
					}
					else {
					  $CurStringTable{STPath}=$CurSrcPath;
					}
					$CurStringTable{STFile}=&Path_Split('File',$Candidate);

				}
				next LINE;
			}
			$OtherPlatSwitch="$CurFile($LineNum)";
			next LINE;
		}

		if (/^AIF$/o) {
			my ($trg, $dir, $file, $clDepth, @bitmaps)=@$Line;
			unless ($file) { # bitmaps aren't essential
				push @MmpDie, "$CurFile($LineNum) : Not enough arguments for keyword AIF\n";
				next LINE;
			}
			my %Data;
			$Data{Trg} = $trg;	# Defect: may include directory
			$dir=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash
			$Data{Source}=&Path_MakeAbs($CurFile, "$dir$file");
			unless (-e "$Data{Source}") {
				push @MmpWarn, "$CurFile($LineNum) : AIF source \"$Data{Source}\" not found\n";
			}
			if ($CheckAif{$Data{Trg}}) {
				push @MmpDie, "$CurFile($LineNum) : Duplicate Aif \"$Data{Trg}\" at line $CheckAif{$Data{Trg}}\n";
				next LINE;
			}
			$CheckAif{$Data{Trg}}="$CurFile($LineNum)";
			push @AifStruct, \%Data;
			next LINE unless (@bitmaps);
			# handle bitmaps
			my @ClDepths = split(/,/, $clDepth);
			foreach (@ClDepths) {
				$_ = lc $_; # bmconv can't handle upper-case 'C's
				unless (/^c?\d\d?$/o) {
					push @MmpDie, "$CurFile($LineNum) : AIF color depth \"$_\" - unexpected format\n";
				}
			}
			@ClDepths = (@ClDepths) x @bitmaps;	# make a sufficiently long list of color depths
			foreach $file (@bitmaps) {
				if ($file !~ /^\\/) {
					$file = &Path_MakeAbs($CurFile, "$dir$file");
				}
				push @{$Data{BitMaps}}, { # sources must be kept in order
					Src=>$file,
					ClDepth=>shift @ClDepths	# take next color depth from the list
				};
				unless (-e $file) {
					push @MmpWarn, "$CurFile($LineNum) : AIF source \"$file\" not found\n";
				}
			}
			next LINE;
		}
		if (/^ASSPABI$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$ASSPABISwitch=1;
			next LINE;
		}
		if (/^ASSPEXPORTS$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$ASSPExports=1;
			next LINE;
		}
		if (/^ASSPLIBRARY$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum);
					$Candidate = &Path_Norm($Candidate);
					
					unless ($emulator or &Genutl_ParseVersionedName(\$Candidate)) {
						push @MmpWarn, "$CurFile($LineNum) : Bad version in ASSPLIBRARY\n";
					}
					if ($CheckASSPLib{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Library \"$Candidate\" at line $CheckASSPLib{$Candidate}\n";
						next; 
					}
					
					push @ASSPLibList, $Candidate;
					$CheckASSPLib{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Libraries specified for keyword ASSPLIBRARY\n";
			next LINE;
		}
		if (/^CAPABILITY$/o) {
			if (defined($Capability)) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine CAPABILITY\n";
				next LINE;
			}
			if (scalar @$Line == 0) {
				push @MmpWarn, "$CurFile($LineNum) : Wrong number of arguments for CAPABILITY\n";
				next LINE;
			}
			foreach my $capname (@$Line) {
				my $invert = 0;
				if ($capname =~ /^-(\w*)/) {
					$invert = 0xffffffff;
					$capname = $1;
				}
				my $capFlag = 0;
				if (defined($CapabilityNames{uc $capname})) {
					$capFlag = $CapabilityNames{uc $capname};
					if (not $capFlag) {
						push @MmpDiagnostic, "$CurFile($LineNum) : Use of old capability name, \"$capname\" ignored\n";
						next;
					}
					if ("ALL" eq uc $capname and $invert) {
						push @MmpWarn, "Capability '-ALL' not allowed";
						next;
					}
				}
				elsif ("NONE" eq uc $capname) {
					if($invert) {
						push @MmpWarn, "Capability '-NONE' not allowed";
						next;
					}
				}
				else {
					push @MmpWarn, "$CurFile($LineNum) : Unknown capability \"$capname\" ignored\n";
					next;
				}
				# append name to capability string
				if (defined($Capability) and not $invert) { $Capability .= "+"; }
				if($invert) { $Capability .= "-"; }
				$Capability .= $capname;

				# add capability mask to flags
				$CapabilityFlags[0] = $CapabilityFlags[0] ^ $invert;
				$CapabilityFlags[0] = $CapabilityFlags[0] | $capFlag;
				$CapabilityFlags[0] = $CapabilityFlags[0] ^ $invert;
				$CapabilityFlags[1] = 0;
				next;
			}
			next LINE;
		}
		if (/^DEBUGLIBRARY$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum);
					$Candidate = &Path_Norm($Candidate);
					
					unless ($emulator or &Genutl_ParseVersionedName(\$Candidate)) {
						push @MmpWarn, "$CurFile($LineNum) : Bad version in DEBUGLIBRARY\n";
					}
					if ($CheckLib{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Library \"$Candidate\" at line $CheckLib{$Candidate}\n";
						next; 
					}
					
					push @DebugLibList, $Candidate;
					$CheckLib{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Libraries specified for keyword DEBUGLIBRARY\n";
			next LINE;
		}
		if (/^DEFFILE$/o)  {
			if ($CheckDef) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine DEFFILE\n";
				next LINE;
			}
			$CheckDef=1;
			unless ($_=shift @$Line) {
				push @MmpWarn, "$CurFile($LineNum) : No file specified for keyword DEFFILE\n";
				next LINE;
			}

			$Def{CheckSource_MMPEntry} = $_;		
			$Def{CheckSource_LineNumber} = $LineNum;
			$Def{CheckSource_MMPFile} = $CurFile;
			
			$_ = &Path_Norm($_);
			
			$Def{Base}=&Path_Split('Base',$_);
			$Def{Ext}=&Path_Split('Ext',$_);
			$Def{Path}=&Path_Split('Path',$_);
			
			if ($Def{Path}) {
				$Def{Path}=&Path_MakeEAbs($EPOCPath,$CurFile,$Def{Path});
			}

			if ($Def{Base} =~ /\{|\}/) {
				push @MmpDie, "$CurFile($LineNum) : Bad DEFFILE name\n";
			}
			next LINE;
		}
		if (/^DOCUMENT$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$Candidate = &Path_Norm($Candidate);
					
					if ($CheckDoc{"$CurSrcPath$Candidate"}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Document \"$CurSrcPath$Candidate\" at line ", $CheckDoc{"$CurSrcPath$Candidate"}, "\n";
						next; 
					}
					unless (-e "$CurSrcPath$Candidate") {
						push @MmpWarn, "$CurFile($LineNum) : DOCUMENT \"$CurSrcPath$Candidate\" not found\n";
					}
					
					push @{$DocHash{$CurSrcPath}}, $Candidate;
					$CheckDoc{"$CurSrcPath$Candidate"}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Files specified for keyword DOCUMENT\n";
			next LINE;
		}
		if (/^EPOCALLOWDLLDATA$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$AllowDllData=1;
			next LINE;
		}
		if (/^ALWAYS_BUILD_AS_ARM$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$BuildAsARM=1;
			next LINE;
		}
		if (/^EPOCCALLDLLENTRYPOINTS$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$CallDllEntryPoints=1;
			next LINE;
		}
		if (/^EPOCDATALINKADDRESS$/o) {
			if (@$Line) { 
				my $temp=&main::Genutl_AnyToHex(shift @$Line);
				if (defined $temp) {
					$DataLinkAddress=$temp;
					next LINE;
				}
				push @MmpDie, "$CurFile($LineNum) : Data link address doesn't fit expected number format\n";
			}
			push @MmpWarn, "$CurFile($LineNum) : No data link address specified for keyword $_\n";
			next LINE;
		}
		if (/^EPOCFIXEDPROCESS$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$FixedProcess=1;
			next LINE;
		}
		if (/^EPOCHEAPSIZE$/o) {
			if (@$Line) {
				my $tempMin=&main::Genutl_AnyToHex(shift @$Line);
				if (defined $tempMin) {
					if (@$Line) {
						my $tempMax=&main::Genutl_AnyToHex(shift @$Line);
						if (defined $tempMax) {
							$HeapSize{Min}=$tempMin;
							$HeapSize{Max}=$tempMax;
							next LINE;
						}
						push @MmpDie, "$CurFile($LineNum) : maximum heap size doesn't fit expected number format\n";
						next LINE;
					}
					push @MmpDie, "$CurFile($LineNum) : No maximum heap size specified for keyword $_\n";
					next LINE;
				}
				push @MmpDie, "$CurFile($LineNum) : minimum heap size doesn't fit expected number format\n";
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No minimum heap size specified for keyword $_\n";
			next LINE;
		}
		if (/^EPOCPROCESSPRIORITY$/o) {
			if ($ProcessPriority) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine EPOCPROCESSPRIORITY\n";
				next LINE;
			}
			if ($ProcessPriority=shift @$Line) {
				if (defined($ProcessPriorityNames{uc $ProcessPriority})) {
					$ProcessPriority = $ProcessPriorityNames{uc $ProcessPriority}; # canonical form
					next LINE;
				}
				push @MmpDie, "$CurFile($LineNum) : ProcessPriority \"$ProcessPriority\" not supported\n";
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Priority specified for keyword EPOCPROCESSPRIORITY\n";
			next LINE;
		}
		if (/^EPOCSTACKSIZE$/o) {
			if (@$Line) {
				my $temp=&main::Genutl_AnyToHex(shift @$Line);
				if (defined $temp) {
					$StackSize=$temp;
					next LINE;
				}
				push @MmpDie, "$CurFile($LineNum) : Stack size doesn't fit expected number format\n";
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No stack size specified for keyword STACKSIZE\n";
			next LINE;
		}
		if (/^COMPRESSTARGET$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$CompressTarget=COMPRESS;
            $CompressTargetMethod=NOCOMPRESSIONMETHOD; # means 'use default'
			next LINE;
		}
		if (/^NOCOMPRESSTARGET$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$CompressTarget=NOCOMPRESS;
            $CompressTargetMethod=NOCOMPRESSIONMETHOD;
			next LINE;
		}
        if (/^INFLATECOMPRESSTARGET$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
            $CompressTarget=COMPRESS;
			$CompressTargetMethod=INFLATECOMPRESSIONMETHOD;
			next LINE;
		}
		if (/^BYTEPAIRCOMPRESSTARGET$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
            $CompressTarget=COMPRESS;
			$CompressTargetMethod=BYTEPAIRCOMPRESSIONMETHOD;
			next LINE;
		}
		if (/^EXPORTUNFROZEN$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$ExportUnfrozen=1;
			next LINE;
		}
		if (/^FIRSTLIB$/o) {
			if ($FirstLib) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine FIRSTLIB\n";
				next LINE;
			}
			if ($FirstLib=shift @$Line) {
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $FirstLib, $LineNum);
				$FirstLib = &Path_Norm($FirstLib);
				next LINE;
			}
			
			push @MmpWarn, "$CurFile($LineNum) : Nothing specified for keyword FIRSTLIB\n";
			next LINE;
		}
		if (/^LANG$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					if ($CheckLang{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Language \"$Candidate\" at line $CheckLang{$Candidate}\n";
						next; 
					}
					push @LangList, $Candidate;
					$CheckLang{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Languages specified for keyword LANG\n";
			next LINE;
		}
		if (/^LIBRARY$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum);
					$Candidate = &Path_Norm($Candidate);
					
					unless ($emulator or &Genutl_ParseVersionedName(\$Candidate)) {
						push @MmpWarn, "$CurFile($LineNum) : Bad version in LIBRARY\n";
					}
					if ($CheckLib{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Library \"$Candidate\" at line $CheckLib{$Candidate}\n";
						next; 
					}
					
					push @LibList, $Candidate;
					push @DebugLibList, $Candidate;	    # appears in both
					$CheckLib{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Libraries specified for keyword LIBRARY\n";
			next LINE;
		}
		if (/^LINKAS$/o) {
			if ($LinkAs) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine LINKAS\n";
				next LINE;
			}
			if ($LinkAs=shift @$Line) {
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No name specified for keyword LINKAS\n";
			next LINE;
		}
		if (/^EXPORTLIBRARY$/o) {
			if ($NoExportLibrary) {
				push @MmpDie, "$CurFile($LineNum) : Can't specify both EXPORTLIBRARY and NOEXPORTLIBRARY\n";
				next LINE;
			}
			if ($ExportLibrary) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine EXPORTLIBRARY\n";
				next LINE;
			}
			if ($ExportLibrary=shift @$Line) {
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $ExportLibrary, $LineNum);
				$ExportLibrary = &Path_Norm($ExportLibrary);
				$ExportLibrary=&Path_Split('Base',$ExportLibrary);
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No name specified for keyword EXPORTLIBRARY\n";
			next LINE;
		}
		if (/^NOEXPORTLIBRARY$/o) {
			if ($ExportLibrary) {
				push @MmpDie, "$CurFile($LineNum) : Can't specify both EXPORTLIBRARY and NOEXPORTLIBRARY\n";
				next LINE;
			}
			$NoExportLibrary = 1;
			next LINE;
		}
		if (/^NEWLIB$/o) {
			if ($NewLib) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine NEWLIB\n";
				next LINE;
			}
			if ($NewLib = shift @$Line) {
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $NewLib, $LineNum);
				$NewLib = &Path_Norm($NewLib);
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No library specified for keyword NEWLIB\n";
			next LINE;
		}
		if (/^MACRO$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					if ($CheckMacro{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Macro \"$Candidate\" at line $CheckMacro{$Candidate}\n";
						next; 
					}
					push @Macros, $Candidate;
					$CheckMacro{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			next LINE; 
		}
		if (/^NOSTRICTDEF$/o) {
			if ($NoStrictDef) {
				push @MmpWarn, "$CurFile($LineNum) : NOSTRICTDEF already set\n";
				next LINE;
			}
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword NOSTRICTDEF takes no arguments\n";
			}
			$NoStrictDef=1;
			next LINE;
		}
		if (/^RAMTARGET$/o) {
			if ($CheckRamTargets) {
				push @MmpWarn, "$CurFile($LineNum) : RAM targets already specified at line $CheckRamTargets\n";
				next LINE;
			}
			$CheckRamTargets="$CurFile($LineNum)";
			unless (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : No targets specified for keyword RAMTARGET\n";
				next LINE;
			}
			if ($$Line[0] eq '+') {
				my %Data=();
				push @RamTargets, \%Data;	# include default
				shift @$Line;
			}
			my $Elem;
			foreach $Elem (@$Line) {
				my %Data=();
				$Data{File}=&Path_Split('File',$Elem);
				$Data{Path}=&Path_Split('Path',$Elem);
				push @RamTargets, \%Data;
			}
			next LINE;
		}
		if (/^RESOURCE$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {			
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$Candidate = &Path_Norm($Candidate);
					
					if ($CheckResrc{$Candidate}) {
						push @MmpDie, "$CurFile($LineNum) : Duplicate Resource $Candidate at line $CheckResrc{$Candidate}\n";
						next;
					}
					
					$CheckResrc{$Candidate}="$CurFile($LineNum)";
					my $source="$CurSrcPath$Candidate";
					unless (-e $source) {
						push @MmpWarn, "$CurFile($LineNum) : RESOURCE source \"$source\" not found\n";
					}
					
					$CurResource{BaseTrg}=&Path_Split('Base',$Candidate);
					$CurResource{Source}=$source;
					$CurResource{Hdr}="$CurFile($LineNum)";
					# $CurResource{TrgPath} will be filled in at the end;
					my %Resource=%CurResource;
					undef %CurResource;
					push @ResourceStruct, \%Resource;
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Resources specified for keyword RESOURCE\n";
			next LINE; 
		}
		if (/^ROMTARGET$/o) {
			if ($CheckRomTargets) {
				push @MmpWarn, "$CurFile($LineNum) : ROM targets already specified at line $CheckRomTargets\n";
				next LINE;
			}
			$CheckRomTargets="$CurFile($LineNum)";
			unless (@$Line) {
				@RomTargets=();
				next LINE;
			}
			if ($$Line[0] eq '+') {
				shift @$Line;
			}
			else {
				@RomTargets=(); # remove default
			}
			my $Elem;
			foreach $Elem (@$Line) {
				my %Data=();
				$Data{File}=&Path_Split('File',$Elem);
				$Data{Path}=&Path_Split('Path',$Elem);
				push @RomTargets, \%Data;
			}
			next LINE;
		}
		if (/^SMPSAFE$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$SmpSafe = 1;
			next LINE;
		}
		if (/^SOURCE$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$Candidate = &Path_Norm($Candidate);
					
					$Candidate =~ s/^\\//;	# remove leading \, if any	
					$CurSource{BaseTrg}=&Path_Split('Base',$Candidate);
					my $path=&Path_Split('Path',$Candidate);
					if($path){
					  $CurSource{SrcPath}=&Path_MakeAbs($CurSrcPath,&Path_Split('Path',$Candidate));
					}
					else {
					  $CurSource{SrcPath}=$CurSrcPath;
					}
					$CurSource{CurFile}=&Path_Split('File',$Candidate);

					my %Source=%CurSource;
					undef %CurSource;
					push @SourceStruct, \%Source;
					
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Sources specified for keyword SOURCE\n";
			next LINE; 
		}
		if (/^SOURCEPATH$/o) {
			if ($CurSrcPath=shift @$Line) {
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $CurSrcPath, $LineNum, $CheckSource_PhysicalCheck);				
				$CurSrcPath = &Path_Norm($CurSrcPath);
				
				$CurSrcPath=~s-^(.*[^\\])$-$1\\-o;	# in case no terminating backslash
				$CurSrcPath=&Path_MakeEAbs($EPOCPath,$CurFile,$CurSrcPath);
				if (-d &Path_Chop($CurSrcPath)) {
					next LINE;
				}
				push @MmpWarn, "$CurFile($LineNum) : SOURCEPATH \"$CurSrcPath\" not found\n";
				next LINE;
			}
			push @MmpDie, "$CurFile($LineNum) : No Source Path specified for keyword SOURCEPATH\n";
			next LINE;
		}
		if (/^STATICLIBRARY$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum);
					$Candidate = &Path_Norm($Candidate);
					
					if ($CheckStatLib{$Candidate}) {
						push @MmpWarn, "$CurFile($LineNum) : Duplicate Library \"$Candidate\" at line $CheckStatLib{$Candidate}\n";
						next;
					}
					
					push @StatLibList, $Candidate;
					$CheckStatLib{$Candidate}="$CurFile($LineNum)";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Libraries specified for keyword STATICLIBRARY\n";
			next LINE;
		}
		if (/^STDCPP$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$StdCpp=1;
			next LINE;
		}
  		if (/^NOSTDCPP$/o) {
  			if (@$Line) {
  				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
  			}
  			$NoStdCpp=1;
  			next LINE;
  		}
		if (/^STRICTDEPEND$/o) {
			if ($MmpFlag{StrictDepend}) {
				push @MmpWarn, "$CurFile($LineNum) : STRICTDEPEND already set\n";
				next LINE;
			}
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword STRICTDEPEND takes no arguments\n";
			}
			$MmpFlag{StrictDepend}=1;
			next LINE;
		}
		if (/^SYSTEMINCLUDE$/o){
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck);
					$Candidate = &Path_Norm($Candidate);
					
					$Candidate=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash
					$Candidate=&Path_MakeEAbs($EPOCPath,$CurFile,$Candidate);
					if ($CheckSysInc{$Candidate}) {
						next; 
					}
					push @SysIncPaths,$Candidate;
					$CheckSysInc{$Candidate}="$CurFile($LineNum)";
					if (-d &Path_Chop($Candidate)) {
						next;
					}
					push @MmpWarn, "$CurFile($LineNum) : SYSTEMINCLUDE path \"$Candidate\" not found\n";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Paths specified for keyword SYSTEMINCLUDE\n";
			next LINE;
		}
		if (/^SYSTEMRESOURCE$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck, $CurSrcPath);
					$Candidate = &Path_Norm($Candidate);
					
					if ($CheckSysResrc{$Candidate}) {
						push @MmpDie, "$CurFile($LineNum) : Duplicate Resource \"$Candidate\" at line $CheckSysResrc{$Candidate}\n";
						next; 
					}
					$CheckSysResrc{$Candidate}="$CurFile($LineNum)";
					my $source="$CurSrcPath$Candidate";
					unless (-e $source) {
						push @MmpWarn, "$CurFile($LineNum) : SYSTEMRESOURCE source \"$source\" not found\n";
					}
					$CurResource{BaseTrg}=&Path_Split('Base',$Candidate);
					$CurResource{Source}=$source;
					$CurResource{Hdr}="$CurFile($LineNum)";
					$CurResource{TrgPath}="z\\system\\data\\";	# needs to match e32env.pm
					my %Resource=%CurResource;
					undef %CurResource;
					push @ResourceStruct, \%Resource;
				}
				if (&main::EPOCSecurePlatform()) {    
					push @MmpMigrationNote, "Obsolete SYSTEMRESOURCE keyword specified in \"$MMPFILE\"";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Resources specified for keyword SYSTEMRESOURCE\n";
			next LINE; 
		}
		if (/^TARGET$/o) {
			if ($Trg) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine TARGET\n";
				next LINE;
			}
			if ($Trg=shift @$Line) {
				CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Trg, $LineNum);
				$Trg = &Path_Norm($Trg);
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Target specified for keyword TARGET\n";
			next LINE;
		}
		if (/^TARGETPATH$/o) {
			if ($TrgPath) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine TARGETPATH\n";
				next LINE;
			}
			unless ($TrgPath=shift @$Line) {
				push @MmpWarn, "$CurFile($LineNum) : No Path specified for keyword TARGETPATH\n";
				next LINE;
			}

			CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $TrgPath, $LineNum);
			$TrgPath = &Path_Norm($TrgPath);
			
			$TrgPath=~s-^\\(.*)$-$1-o;
			$TrgPath=~s-^(.*[^\\])$-$1\\-o;
			$TrgPath="z\\$TrgPath";
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Too many arguments for keyword TARGETPATH\n";
			}
			next LINE;
		}
		if (/^TARGETTYPE$/o) {
			if ($TrgType) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine TARGETTYPE\n";
				next LINE;
			}
			unless ($TrgType=shift @$Line) {
				push @MmpWarn, "$CurFile($LineNum) : No Type specified for keyword TARGETTYPE\n";
				next LINE;
			}
			eval { &Trg_GetL($TrgType, \%TrgType); };
			if ($@) {
				push @MmpDie, "$CurFile($LineNum) : $@";
			}
			next LINE;
		}
		if (/^UID$/o) {
			if (@$Line) {
				foreach (@$Line) {
					if ($#UidList>=1) {
						push @MmpWarn, "$CurFile($LineNum) : Can't specify more than 2 Uids\n";
						next LINE;
					}
					$_=&Genutl_AnyToHex($_);
					if (defined $_) {
						push @UidList, $_;
						next;
					}
					push @MmpDie, "$CurFile($LineNum) : Uid doesn't fit expected number format\n";
					next LINE;
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Uids specified for keyword UID\n";
			next LINE;
		}
		if (/^SECUREID$/o) {
			if ($SecureId) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine SECUREID\n";
				next LINE;
			}
			if (@$Line) {
				$SecureId = &Genutl_AnyToHex(shift @$Line);
				if (!defined $SecureId) {
					push @MmpDie, "$CurFile($LineNum) : SECUREID doesn't fit expected number format\n";
					next LINE;
				}
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for keyword SECUREID\n";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Missing argument for keyword SECUREID\n";
			next LINE;
		}
		if (/^VENDORID$/o) {
			if (defined($VendorId)) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine VENDORID\n";
				next LINE;
			}
			if (@$Line) {
				$VendorId = &Genutl_AnyToHex(shift @$Line);
				if (!defined $VendorId) {
					push @MmpDie, "$CurFile($LineNum) : VENDORID doesn't fit expected number format\n";
					next LINE;
				}
				if (@$Line) {
					push @MmpWarn, "$CurFile($LineNum) : Too many arguments for keyword VENDORID\n";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Missing argument for keyword VENDORID\n";
			next LINE;
		}
		if (/^USERINCLUDE$/o) {
			if (@$Line) {
				my $Candidate;
				foreach $Candidate (@$Line) {
					CheckSource_MetaData(%CheckSourceMMPMetaData, $CurFile, $mainElement, $Candidate, $LineNum, $CheckSource_PhysicalCheck);
					$Candidate = &Path_Norm($Candidate);
					
					$Candidate=~s-^(.*[^\\])$-$1\\-o;   # ensure path ends with a backslash
					$Candidate=&Path_MakeEAbs($EPOCPath,$CurFile,$Candidate);
					if ($CheckUserInc{$Candidate}) {
						next; 
					}
					push @UserIncPaths,$Candidate;
					$CheckUserInc{$Candidate}="$CurFile($LineNum)";
					if (-d &Path_Chop($Candidate)) {
						next;
					}
					push @MmpWarn, "$CurFile($LineNum) : USERINCLUDE path \"$Candidate\" not found\n";
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : No Paths specified for keyword USERINCLUDE\n";
			next LINE;
		}
		if (/^SRCDBG$/o) {
			if (@$Line) {
				push @MmpWarn, "$CurFile($LineNum) : Keyword $_ takes no arguments\n";
			}
			$SrcDbg=1;
			next LINE;
		}
		if (/^VERSION$/o) {
			if (%Version) {
				push @MmpDie, "$CurFile($LineNum) : Attempt to redefine VERSION\n";
				next LINE;
			}
			unless (@$Line) {
				push @MmpDie, "$CurFile($LineNum) : Missing argument to VERSION\n";
				next LINE;
			}
			%Version = &Genutl_StringToVersion(shift @$Line);
			if (!%Version) {
				push @MmpDie, "$CurFile($LineNum) : Bad VERSION number\n";
				next LINE;
			}
			if (@$Line) {
				if ((lc $$Line[0]) eq 'explicit') {
					$Version{explicit} = 1;
					shift @$Line;
				}
				if (scalar(@$Line)) {
					push @MmpDie, "$CurFile($LineNum) : Garbage after VERSION number\n";
				}
			}
			next LINE;
		}
		
		if (/^OPTION$/oi ) {
			if (@$Line >= 2) {
				my $compilerkey= uc shift @$Line;
				if (!defined($Compiler{$compilerkey})) {
					# first use of "OPTION xxx"
					$Compiler{$compilerkey}=shift @$Line;
				}
				# concatenate extra stuff
				while (@$Line) {
					$Compiler{$compilerkey}.=" ".shift @$Line;
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Keyword OPTION requires at least two arguments\n";
			next LINE;
			}
		if (/^LINKEROPTION$/oi ) {
			if (@$Line >= 2) {
			        # first parameter is the compiler
				my $compilerkey= uc shift @$Line;
				if (!defined($Compiler{$compilerkey})) {
					# first use of "LINKEROPTION xxx"
					$LinkerOptions{$compilerkey}=shift @$Line;
				}
				# concatenate extra stuff
				while (@$Line) {
					$LinkerOptions{$compilerkey}.=" ".shift @$Line;
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Keyword LINKEROPTION requires at least two arguments\n";
			next LINE;
			}
		if (/^OPTION_Replace$/oi ) {
			if (@$Line >= 2) {
				my $compilerkey= uc shift @$Line;
				my $repOptions= shift @$Line;
				while (@$Line) 
				{
					$repOptions.= " ".shift @$Line;
				}
				$repOptions =~ s/=\s*/=/g;
				push @{$Replace{$compilerkey}},$repOptions;
				
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : Keyword OPTION_Replace requires at least two arguments\n";
			next LINE;
			}
		if (/^ARMFPU$/oi) {
			if ($ARMFPU) {
				push @MmpWarn, "$CurFile($LineNum) : Attempt to redefine ARMFPU\n";
				next LINE;
			}
			if ($ARMFPU=shift @$Line) {
				if (($ARMFPU !~ /^SOFTVFP$/oi) && ($ARMFPU !~ /^VFPV2$/oi)) {
					push @MmpWarn, "$CurFile($LineNum) : ARMFPU can only specify SOFTVFP or VFPV2 as an argument\n";
					undef $ARMFPU;
				}
				next LINE;
			}
			push @MmpWarn, "$CurFile($LineNum) : ARMFPU must specify either SOFTVFP or VFPV2 as an argument\n";
			next LINE;
		}
		if( /^PAGED$/o) {
			#revert "PAGED" keyword from code and data paged to code paged only
			#if ($CodePagingTargetMode == PAGED or $DataPagingTargetMode == PAGED) {
			if ($CodePagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			#revert "PAGED" keyword from code and data paged to code paged only
			#if ($CodePagingTargetMode == UNPAGED or $DataPagingTargetMode == UNPAGED) {
			if ($CodePagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$CodePagingTargetMode = PAGED;
			#revert "PAGED" keyword from code and data paged to code paged only
			#$DataPagingTargetMode = PAGED;
			next LINE;
			}
		if( /^UNPAGED$/o) {
			if ($CodePagingTargetMode == UNPAGED or $DataPagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			if ($CodePagingTargetMode == PAGED or $DataPagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$CodePagingTargetMode = UNPAGED;
			$DataPagingTargetMode = UNPAGED;
			next LINE;
			}
		if( /^PAGEDCODE$/o) {
			if ($CodePagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			if ($CodePagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$CodePagingTargetMode = PAGED;
			next LINE;
			}
		if( /^UNPAGEDCODE$/o) {
			if ($CodePagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			if ($CodePagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$CodePagingTargetMode = UNPAGED;
			next LINE;
			}
		if( /^PAGEDDATA$/o) {
			if ($DataPagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			if ($DataPagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$DataPagingTargetMode = PAGED;
			next LINE;
			}
		if( /^UNPAGEDDATA$/o) {
			if ($DataPagingTargetMode == UNPAGED) {
				push @MmpWarn, "$CurFile($LineNum) : duplicate paging setting\n";
			}
			if ($DataPagingTargetMode == PAGED) {
				push @MmpWarn, "$CurFile($LineNum) : conflict paging setting\n";
			}
			$DataPagingTargetMode = UNPAGED;
			next LINE;
			}
		if( /^DEBUGGABLE_UDEBONLY$/o) {
			$IsDebuggable = DEBUGGABLE_UDEBONLY;
			next LINE;
			}
		if( /^DEBUGGABLE$/o) {
			if ($IsDebuggable != DEBUGGABLE_UDEBONLY)
			{
				$IsDebuggable = DEBUGGABLE;
			}
			next LINE;
			}
		if( /^FEATUREVARIANT$/o) {
			push @MmpDie, "$CurFile($LineNum) : FEATUREVARIANT specified multiple times" if ($FeatureVariant);
			$FeatureVariant = 1;
			next LINE;
			}

		push @MmpWarn, "$CurFile($LineNum) : Unrecognised Keyword \"$_\"\n";
	}

	undef $Line;
	undef $MmpMacro;


	# test the mmp contents
	#----------------------
	if ($PlatTxtSwitch || $OtherPlatSwitch)	{
		push @MmpDie, $PlatTxtSwitch ? $PlatTxtSwitch : $OtherPlatSwitch, ": Unterminated START ... END block\n";
	}
	undef $PlatTxtSwitch;
	undef $OtherPlatSwitch;

	# Check the consistency of the mmp file contents
	unless ($Trg) {
		unless($TrgType=~/^NONE$/io){
			push @MmpDie, "ERROR: No Target specified\n";
		}
	}
	unless ($TrgType) {
		push @MmpDie, "ERROR: No TargetType specified\n";
	}
  	if( $StdCpp && $NoStdCpp ) {
  		push @MmpWarn, "WARNING: Keyword statement STDCPP not permitted with keyword NOSTDCPP.\n";
  		push @MmpWarn, "WARNING: Keyword statements STDCPP and NOSTDCPP ignored.\n";
  		$StdCpp = 0;
  		$NoStdCpp = 0;
  	}

	if (($TrgType =~ /^LIB$/io) && (scalar(@DebugLibList) || scalar(@LibList) || scalar(@StatLibList))) {
		push @MmpWarn, "WARNING: Library statements (DEBUGLIBRARY, LIBRARY or STATICLIBRARY) not permitted with TARGETTYPE LIB.";
		push @MmpWarn, "WARNING: Library statements (DEBUGLIBRARY, LIBRARY or STATICLIBRARY) ignored.\n";
		undef @DebugLibList;
		undef @LibList;
		undef @StatLibList;
	}

	if ($TrgType =~ /^LIB$/io && $NewLib) {
		push @MmpWarn, "WARNING: Library statement NEWLIB not permitted with TARGETTYPE LIB.";
		push @MmpWarn, "WARNING: Library statement NEWLIB ignored.\n";
		undef @DebugLibList;
		undef @LibList;
		undef @StatLibList;
	}

	if ($TrgType =~ /^STD(EXE|DLL)$/io && $NewLib) {
		push @MmpWarn, "WARNING: Library statement NEWLIB not permitted with TARGETTYPE STD*.";
		push @MmpWarn, "WARNING: Library statement NEWLIB ignored.\n";
		undef @DebugLibList;
		undef @LibList;
		undef @StatLibList;
	}

	if (($TrgType=~/^IMPLIB$/io) || ($TrgType=~/^NONE$/io)) {
		push @MmpDie, "ERROR: SOURCE not permitted with TARGETTYPE $TrgType\n" if (@SourceStruct);
	} elsif (!@SourceStruct) {
		push @MmpDie, "ERROR: No Sources specified\n";
	}
	if ($TrgType{NeedUID3} && $#UidList<1) {
		push @MmpWarn, "WARNING: No Uid3 specified in \"$MMPFILE\" for TargetType \"$TrgType\"\n";
	}
	if ($Trg && $Trg=~/\{|\}/) {
		push @MmpDie, "ERROR: Bad TARGET name specified\n";
	}
	if ($ExportLibrary and $ExportLibrary=~/\{|\}/) {
		push @MmpDie, "ERROR: Bad EXPORTLIBRARY name specified\n";
	}
	if ($LinkAs and $LinkAs=~/\{|\}/) {
		push @MmpDie, "ERROR: Bad LINKAS name specified\n";
	}
	# Make sure a valid compression method has been chosen if target is going to be paged
	if ($CodePagingTargetMode == PAGED && $CompressTarget == COMPRESS) {
		if ($CompressTargetMethod == INFLATECOMPRESSIONMETHOD) {
			push @MmpWarn, "Incompatible keywords! The INFLATECOMPRESSTARGET is not allowed with PAGED!\n";
			push @MmpWarn, "Changing compression method to BYTEPAIRCOMPRESSTARGET\n";
		}
		$CompressTargetMethod = BYTEPAIRCOMPRESSIONMETHOD;
	}

  # Ensure 2nd UID is not deprecated
  if (&main::EPOCSecurePlatform() && $TrgType{Basic} eq "DLL")
    {
    $deprecatedUIDs{"0x100039ce"} = "Unmigrated dll style application detected from use of UID 0x100039ce";
    }
  
  # Do not need UIDs for a resource only (i.e. TARGETTYPE is "none") mmp file
  if  ((!$TrgType=~/^NONE$/io) && &main::EPOCSecurePlatform() && defined($deprecatedUIDs{$UidList[0]}))
    {
    push @MmpMigrationNote, "$deprecatedUIDs{$UidList[0]}\n";
    }

#	PUT IN SOME DEFAULTS

	if ($TrgPath eq '') {
		# set up default path from $TrgType 
		$TrgPath = $TrgType{Path};
	}
	my $ResourceTrgPath = $TrgType{ResourcePath};
	if ($ResourceTrgPath eq '') {
		$ResourceTrgPath = $TrgPath;	# default to TrgPath, as before
	}
	unless (%Version) {
	    if ($$Plat_ref{DefFile} =~ /^\s*EABI\s*/i ) {
			$Version{major} = 10;	# Start major versions at 10 for EABI to allow coexistence with GCC98r2 ABI
		} else {
			$Version{major} = 1;
		}
		$Version{minor} = 0;
	}

	# check for languages
	@LangList=('SC') unless @LangList;

  if (&main::EPOCSecurePlatform() && !defined($Capability) &&
    (($TrgType{Basic} eq "DLL") || (uc($TrgType) eq "EXEXP")))
    {
    push @MmpMigrationNote, "No Capabilities set in \"$MMPFILE\" for TargetType: $TrgType\n";
    }

	# Supply default capability mask if not set explicitly, and convert to hex string
	$Capability = "none" unless (defined($Capability));
	$CapabilityFlags[0] = 0 unless (defined($CapabilityFlags[0]));
        $CapabilityFlags[1] = 0 unless (defined($CapabilityFlags[1]));

        $CapabilityFlags[0] = sprintf("0x%08x", $CapabilityFlags[0]);
        $CapabilityFlags[1] = sprintf("0x%08x", $CapabilityFlags[1]);

#	ensure all bitmaps have targetpaths and check for duplicate bitmaps
	my %BitMapCheck;
	my $BitMapRef;
	foreach $BitMapRef (@BitMapStruct) {
		unless ($$BitMapRef{TrgPath}) {
			$$BitMapRef{TrgPath}=$ResourceTrgPath;
		}
		if ($BitMapCheck{"$$BitMapRef{TrgPath}$$BitMapRef{Trg}"}) {
			push @MmpDie, "ERROR: Duplicate bitmap target \"$$BitMapRef{TrgPath}$$BitMapRef{Trg}\"\n";
			next;
		}
		$BitMapCheck{"$$BitMapRef{TrgPath}$$BitMapRef{Trg}"}=1;
	}

#	ensure all resources have targetpaths, expand language list and check for duplicates
	my %ResourceCheck;
	my $ResourceRef;
	my @PerLanguageResourceStruct;
	foreach $ResourceRef (@ResourceStruct) {
					
		unless ($$ResourceRef{BaseTrg}) {
			$$ResourceRef{BaseTrg}=&Path_Split('Base',$$ResourceRef{Source});
		}
		unless ($$ResourceRef{TrgPath}) {
			$$ResourceRef{TrgPath}=$ResourceTrgPath;
		}
		unless ($$ResourceRef{Lang}) {
			@{$$ResourceRef{Lang}}=@LangList;
		}
		# generate one instance per language.
		my @list = @{$$ResourceRef{Lang}};
		my $base = "$$ResourceRef{TrgPath}$$ResourceRef{BaseTrg}";
		foreach my $lang (@list) {
			my %newResourceRef = %{$ResourceRef};
			$newResourceRef{Lang} = $lang;
			$newResourceRef{Trg} = $base.lc("\.R$lang");
			push @PerLanguageResourceStruct, \%newResourceRef;
		}
	}
	@ResourceStruct = @PerLanguageResourceStruct;
	undef @PerLanguageResourceStruct;
	
	foreach $ResourceRef (@ResourceStruct) {
		if ($ResourceCheck{"$$ResourceRef{TrgPath}$$ResourceRef{Trg}"}) {
			push @MmpDie, "ERROR: Duplicate Resource target \"$$ResourceRef{TrgPath}$$ResourceRef{Trg}\"\n";
			next;
		}
		$ResourceCheck{"$$ResourceRef{TrgPath}$$ResourceRef{Trg}"}=1;
	}

	my $Plat=&main::Plat;

	if (@MmpDie || @MmpWarn || @MmpDiagnostic || @MmpMigrationNote) {
		warn "\nMMPFILE \"$MMPFILE\"\n";
		if (@MmpDiagnostic) {
			warn
				"DIAGNOSTIC MESSAGE(S)\n",
				@MmpDiagnostic,
				"\n"
			;
			}

		foreach my $printedWarning (@MmpWarn)
			{
			print "WARNING: $printedWarning\n";
			}
		foreach my $printedError (@MmpDie)
			{
			print "FATAL ERROR: $printedError\n";
			}

		foreach my $printedMigrationNote (@MmpMigrationNote)
			{
			print "MIGRATION_NOTE: $printedMigrationNote\n";
			}		

		if (@MmpDie)
			{
			die;
			}
	}


#	COMPLETE THE UID LIST

	while ($#UidList<1) {
		push @UidList, '0x00000000';
	}

	# check the second UID, or set it
	if ($TrgType{UID2}) {
		if ($UidList[0]=~/^0x00000000$/o) {
			# put in second uid for known targetypes without them
			$UidList[0]=$TrgType{UID2};
		}
		elsif ($UidList[0] ne $TrgType{UID2}) {
			# text comparison is OK here because UIDs have both been through AnyToHex function
			if ($UidList[0] ne '0x01111111') {
				# issue warning (but not if UID == 0x01111111 (to allow test code to deliberately set incorrect UID)
				warn(
					"WARNING: Second Uid is $UidList[0], but\n",
					" expected value for Target Type $TrgType is $TrgType{UID2}\n"
				);
			}
		}
	}

#	Put in the first UID in the list
	if ($TrgType{Basic}=~/^DLL$/o) {
		unshift @UidList, '0x10000079';
	}
	elsif ($TrgType{Basic}=~/^(EXE)$/o) {
		unshift @UidList, '0x1000007a';
	}
	elsif ($TrgType{Basic}=~/^(EXEDLL)$/o) {
# EXE on EPOC32, DLL on Emulator
# NOTE: On EKA1 EXEDLL used EXE UID1 on emulator
# On EKA2 this is unacceptable
		if (!$emulator) {
			unshift @UidList, '0x1000007a';
		} else {
			unshift @UidList, '0x10000079';
		}
	}
	else {
		unshift @UidList, '0x00000000';
	}

# If no SID specified use UID3
	$SecureId = $UidList[2] unless(defined $SecureId);

#	SORT OUT TARGET TYPE DATA STRUCTURE

	# set the target path
	if ($TrgPath) {
		$TrgType{Path}=$TrgPath;
	}

#	put in the $Linkas default
	if (!$LinkAs and $TrgType=~/^IMPLIB$/io) {
		$LinkAs = $Trg;
		$LinkAs =~ s/\.lib$/\.dll/i;
	} else {
		$LinkAs = $Trg unless $LinkAs;
	}
	$LinkAsBase = $LinkAs;
	unless ($emulator) {
		$LinkAs = &DecorateWithVersion($LinkAs, %Version);
	}

# If explicit version add to target
	if ($Version{explicit} && !$emulator) {
		$Trg = &DecorateWithVersion($Trg, %Version);
	}


#	Reconcile any EXEDLL targettypes - must be done after first UIDs put in the list
#	and after the $LinkAs keyword has been defined/defaulted
	if ($TrgType{Basic} eq 'EXEDLL') {
		$TrgType{Basic} = $emulator ? 'DLL' : 'EXE';
		$Trg=&Path_Split('Base',$Trg).'.EXE';
		$LinkAsBase=&Path_Split('Base',$LinkAsBase).'.EXE';
		$LinkAs=&Path_Split('Base',$LinkAs).'.EXE';
	}

#	put in the $ExportLibrary default
	$ExportLibrary=&Path_Split('Base',$Trg) unless $ExportLibrary;
	unless ($emulator) {
		$ExportLibrary = &DecorateWithVersion($ExportLibrary, %Version);
	}

#	Get the EPOC entrypoint static library
	unless ($FirstLib) {
		unless ($TrgType{FirstLib}) {
			$FirstLib="E$TrgType{Basic}.LIB";
		}
		else {
			$FirstLib=$TrgType{FirstLib};
		}
	}


#	 WORK OUT THE ASSP IMPLICATIONS

#	Nullify ASSP-specific API things for WINS/WINC since the API should always be
#	the same for WINC as for WINS,
	if ($emulator) {
		$ASSPABISwitch=0;
		$ASSPExports=0;
		unshift @LibList, @ASSPLibList;
		unshift @DebugLibList, @ASSPLibList;	# keep DebugLibList in sync with LibList
		@ASSPLibList=();
	}
	else {
#		Force ASSPABISwitch for known kernel components or if ASSPEXPORTS or ASSPLIBRARY specified in .MMP file
		if ($TrgType{Kernel} or $ASSPExports or @ASSPLibList) {
			$ASSPABISwitch=1;
		}
	}

#	Switch the ABI if necessary
	unless ($ASSPABISwitch) {
#		apply the standard ABI
		$ABI=$$Plat_ref{ABI};
	}
	else {
#		kernel-specific stuff
#		check that the platform is not generic
		if ($$Plat_ref{Generic}) {
			die "ERROR: Can't apply ASSPABI, ASSPEXPORTS or ASSPLIBRARY for generic platform \"$$Plat_ref{Name}\n";
		}

#		apply the ASSP-specific ABI
		$ABI=$$Plat_ref{ASSPABI};
	}

#	COMPLETE THE .DEF FILE STRUCTURE

	# apply the default .DEF filename, and
	# check as far as possible that the project is frozen
	if (($TrgType{NeedDeffile} or $CheckDef)) {
		unless ($Def{Path} and $Def{Path} !~ /\\\~\\$/) {
			my $augment;
			if ($ASSPExports) {
			    if ($$Plat_ref{DefFile} =~ /^\s*EABI\s*/i ) {
					$augment = $$Plat_ref{ASSP};
			    } else {
					$augment = "B$$Plat_ref{ASSP}";
			    }
			} else {
			    if ($$Plat_ref{DefFile} =~ /^\s*EABI\s*/i ) {
					$augment = lc($$Plat_ref{DefFile});
			    } else {
					$augment = lc("B$$Plat_ref{DefFile}");
			    }
			}
			if ($Def{Path} =~ /\\\~\\$/) {
				$Def{Path} =~ s/\\\~\\$/\\$augment\\/;
			} else {
				$Def{Path}=&Path_Strip(&Path_Split('Path',$MMPFILE)."..\\$augment\\");
			}
		}
		unless ($Def{Base}) {
			$Def{Base} = &Path_Split('Base',$LinkAsBase);
		}
		unless ($Def{Ext}) {
			$Def{Ext}='.def';
		}
#		now that we've dumped narrow, treat the 'u' basename suffix as part of the frozen
#		.DEF file basename.  Once we've dumped the suffix we won't have to store the extension
#		separately either
		if (!$emulator && $Version{explicit}) {
			$Def{Base} .= &Genutl_VersionToFileAugment(%Version);
		} elsif (!$NoStrictDef) {
			$Def{Base}.='u';
		}

		if ($Def{CheckSource_MMPEntry})
		{
			my $type = "DEFFILE";
			$type .= " (NOSTRICTDEF)" if ($NoStrictDef);
			
			# for GCCXML and X86GCC, ignore check source errors for missing .def file
			my $checkdef = (($IgnoreMissingDef) && ($Def{Path} =~ /[\\\/]bmarm[\\\/]/ || $$Plat_ref{Name} eq "X86GCC" || $$Plat_ref{Name} eq "X86GMP")) ? 0 : 1;
			
			if( $checkdef ) {
			  CheckSource_MetaData(%CheckSourceMMPMetaData, $Def{CheckSource_MMPFile}, $type, $Def{CheckSource_MMPEntry}, $Def{CheckSource_LineNumber}, $CheckSource_PhysicalCheck, $Def{Path});
			}
		}
			
#		check deffile exists,
        unless (-e "$Def{Path}$Def{Base}$Def{Ext}") {
            if($IgnoreMissingDef == 0) {
                warn "WARNING: Frozen .def file $Def{Path}$Def{Base}$Def{Ext} not found - project not frozen\n";
            }
     	}
	}
}

sub Mmp_ABI () {
	$ABI;
}
sub Mmp_AifStruct () {
	\@AifStruct;
}
sub Mmp_AllowDllData () {
	$AllowDllData;
}
sub Mmp_CompressTarget () {
	$CompressTarget;
}
sub Mmp_CompressTargetMode () {
	$CompressTargetMethod;
}
sub Mmp_ASSPExports () {
	$ASSPExports;
}
sub Mmp_ASSPLibList () {
	@ASSPLibList;
}
sub Mmp_BitMapStruct () {
	\@BitMapStruct;
}
sub Mmp_BuildAsARM () {
	$BuildAsARM;
}
sub Mmp_CallDllEntryPoints () {
	$CallDllEntryPoints;
}
sub Mmp_Capability () {
	$Capability;
}
sub Mmp_CapabilityFlags () {
	@CapabilityFlags;
}
sub Mmp_DataLinkAddress () {
	$DataLinkAddress;
}
sub Mmp_DebugLibList () {
	\@DebugLibList;
}
sub Mmp_Def () {
	\%Def;
}
sub Mmp_DocHash () {
	\%DocHash;
}
sub Mmp_ExportUnfrozen () {
	$ExportUnfrozen;
}
sub Mmp_FirstLib () {
	$FirstLib;
}
sub Mmp_FixedProcess () {
	$FixedProcess;
}
sub Mmp_HeapSize () {
	\%HeapSize;
}
sub Mmp_LibList () {
	\@LibList;
}
sub Mmp_LinkAs () {
	$LinkAs;
}
sub Mmp_LinkAsBase () {
	$LinkAsBase;
}
sub Mmp_ExportLibrary () {
	$ExportLibrary;
}
sub Mmp_NoExportLibrary () {
	$NoExportLibrary;
}
sub Mmp_NewLib () {
	$NewLib;
}
sub Mmp_Macros () {
	@Macros;
}
sub Mmp_MmpFlag () {
	\%MmpFlag;
}
sub	Mmp_PlatTxt2D () {
	@PlatTxt2D;
}
sub Mmp_ProcessPriority () {
	$ProcessPriority;
}
sub Mmp_RamTargets () {
	@RamTargets;
}
sub Mmp_ResourceStruct () {
	\@ResourceStruct;
}
sub Mmp_RomTargets () {
	@RomTargets;
}
sub Mmp_SourceStruct () {
	\@SourceStruct;
}
sub Mmp_StackSize () {
	$StackSize;
}
sub Mmp_StatLibList () {
	@StatLibList;
}
sub Mmp_StdCpp () {
	$StdCpp;
}
sub Mmp_NoStdCpp () {
	$NoStdCpp;
}
sub Mmp_SysIncPaths () {
	@SysIncPaths;
}
sub Mmp_Trg () {
	$Trg;
}
sub Mmp_TrgType () {
	\%TrgType;
}
sub Mmp_UidList () {
	@UidList;
}
sub Mmp_UserIncPaths () {
	@UserIncPaths;
}
sub Mmp_SrcDbg () {
	$SrcDbg;
}

sub Mmp_WarningLevel() {
     %Compiler; 
} 

sub Mmp_LinkerOptions() {
    %LinkerOptions
}

sub Mmp_Version() {
	%Version;
}

sub Mmp_SecureId() {
	$SecureId;
}

sub Mmp_VendorId () {
	$VendorId;
}

sub DecorateWithVersion($$) {
	my ($name, %ver) = @_;
	my $base = &Path_Split('Base', $name);
	my $ext = &Path_Split('Ext', $name);
	unless ($base =~ /\{(\d|a|b|c|d|e|f){8}\}$/i) {
		$base .= &Genutl_VersionToFileAugment(%Version);
	}
	return "$base$ext";
}

sub Mmp_Replace() {
	%Replace;
}

sub Mmp_SmpSafe() {
	$SmpSafe;
}

sub Mmp_StringTable() {
	\@StringTableStruct;
}
sub Mmp_ARMFPU() {
	$ARMFPU;
}

sub Mmp_CheckSourceMMPMetaData() {
	%CheckSourceMMPMetaData;
}

sub Mmp_CheckSourceMMPIncludes() {
	%CheckSourceMMPIncludes;
}

sub Mmp_CodePagingTargetMode() {
	$CodePagingTargetMode;
}

sub Mmp_DataPagingTargetMode() {
	$DataPagingTargetMode;
}

sub Mmp_IsWideCharMain() {
	$WideCharMain;
}

sub Mmp_IsDebuggable() {
	$IsDebuggable;
}

sub Mmp_IsFeatureVariant() {
	$FeatureVariant;
}

# Return the macros tested in the MMP file
sub Mmp_TestedMacros() {
	return \%mmptestedMacrosHash;
}

1;
