--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1/abld/makmake/mmp.pm Wed Jun 30 11:35:58 2010 +0800
@@ -0,0 +1,2410 @@
+# 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;