diff -r 000000000000 -r 83f4b4db085c sbsv1_os/e32toolp/e32util/makedef.pl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1_os/e32toolp/e32util/makedef.pl	Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,549 @@
+# Copyright (c) 1998-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:
+# all variables called *Path* are set up to end with a backslash
+# all variables called *Path or *File are stored as absolute (file)paths
+# all variables called UpPath* are stored as relative paths
+# 
+#
+
+use strict   ;
+
+use FindBin;		# for FindBin::Bin
+use Getopt::Long;
+
+my $PerlBinPath;	# fully qualified pathname of the directory containing this script
+my $EntryPoint;         
+my $InternalEntryPoint;
+
+# establish the path to the Perl binaries
+BEGIN {
+	require 5.005_03;				# check user has a version of perl that will cope
+	$PerlBinPath = $FindBin::Bin;	# X:/epoc32/tools
+
+	if ($^O eq "MSWin32")
+		{	
+		$PerlBinPath =~ s/\//\\/g;		# X:\epoc32\tools
+		}
+}
+use lib $PerlBinPath;
+
+use Defutl;
+use E32tpver;
+use Pathutl;
+use File::Copy;
+
+my %Options;	# command line option information
+
+my $NamedSymLkup = 0;			# This flag is used to enable named lookup on emulator
+my $IgnoreUnfrozenExports = 0;	# This flag is used to ignore the 'unfrozen exports' warnings. This is 
+								# required for STDEXEs which export symbols just to enable 'named lookup'
+								# from within the STDEXE (via 'dlsym') and are never exposed outside (via def files or
+								# import libraries.
+my $ExportEntrypointE32Dll = 0;	 # Workaround: To export entry point _E32DLL for target type STDDLL
+
+# THE MAIN PROGRAM SECTION
+##########################
+
+{
+
+	my $INFILE;
+	my $FRZFILE;
+	my $OUTFILE;
+	my @ObjFiles;
+
+	# process the command-line
+	unless (GetOptions(\%Options, '1=s', '2=s', 'deffile=s', 'frzfile=s', 'inffile=s', 'overwrite', 'absent=s', 'ignore_unfrozen_noncallable', 'SystemTargetType', 'sym_name_lkup', 'ignore_unfrozen_exports','export_entrypoint_E32Dll')) {
+		exit 1;
+	}
+	unless (@ARGV==1) {
+		&Usage;
+	}
+
+#	check the flags
+
+	if (($Options{deffile} and $Options{inffile}) or (not ($Options{deffile} or $Options{inffile}))) {
+		die "MAKEDEF ERROR: Must specify either -Deffile [file] or -Inf [file]\n";
+	}
+	if ($Options{2} && !$Options{1}) {
+		die "MAKEDEF ERROR: Can't specify second export name and not first export name\n";
+	}
+
+#	process the flags
+	if ($Options{deffile}) {
+		$INFILE=$Options{deffile};
+		unless (-e $INFILE) {
+			die "MAKEDEF ERROR: $INFILE: Deffile not found\n";
+		}
+	}
+	else {
+		$INFILE=$Options{inffile};
+		unless (-e $INFILE) {
+			die "MAKEDEF ERROR: $INFILE: Inffile not found\n";
+		}
+	}
+	if ($Options{frzfile}) {
+		$FRZFILE=$Options{frzfile};
+#		check the frozen .DEF file exists
+		unless (-e $FRZFILE) {
+			die "MAKEDEF ERROR: $FRZFILE: Frzfile not found\n";
+		}
+	}
+	$OUTFILE=pop @ARGV;
+
+
+	$NamedSymLkup = $Options{sym_name_lkup};
+	$IgnoreUnfrozenExports = $Options{ignore_unfrozen_exports};
+	$ExportEntrypointE32Dll = $Options{export_entrypoint_E32Dll};	# Workaround: To export entry point _E32DLL for target type STDDLL
+
+#	Read the Frozen .DEF file if specified
+	my @FrzDataStruct;
+	if ($FRZFILE) {
+		eval { &Def_ReadFileL(\@FrzDataStruct, $FRZFILE); };
+		die $@ if $@;
+		if ($Options{1}) {
+#			Check that frozen def file matches the -1 and -2 arguments given, if any
+			my $export1="";
+			my $export2="";
+			foreach my $FrzRef (@FrzDataStruct) {
+				next unless $$FrzRef{Name};		# ignore lines not containing an export
+				if ($$FrzRef{Ordinal} == 1) {
+					$export1 = $$FrzRef{Name};
+					next;
+				}
+				if ($$FrzRef{Ordinal} == 2) {
+					$export2 = $$FrzRef{Name};
+					next;
+				}
+				if ($Options{1} && ($Options{1} ne $export1)) {
+					die "MAKEDEF ERROR: $FRZFILE: Frzfile ordinal 1 does not match command line\n";
+				}
+				if ($Options{2} && ($Options{2} ne $export2)) {
+					die "MAKEDEF ERROR: $FRZFILE: Frzfile ordinal 2 does not match command line\n";
+				}
+			}
+		}
+	}
+	elsif ($Options{1}) {
+#		create an export structure for the names passed on the command line
+		push @FrzDataStruct, {
+			Name=>$Options{1},
+			ExportName=>$Options{1},
+			Ordinal=>1
+		};
+		if ($Options{2}) {
+			push @FrzDataStruct, {
+				Name=>$Options{2},
+				ExportName=>$Options{2},
+				Ordinal=>2
+			};
+		}
+	}
+
+#	Read the Input .DEF file
+	my @InDataStruct;
+	if ($Options{deffile}) {
+		eval { &Def_ReadFileL(\@InDataStruct, $INFILE); };
+	}
+	else {
+		eval { &ReadInfFileL(\@InDataStruct, $INFILE); };
+	}
+	die $@ if $@;
+
+#	Compare the frozen .DEF data with the input .DEF or export info file data
+	my (@NewDataStruct, @MissingDataStruct, @MatchedDataStruct);
+	eval { &CompareFrzInL (\@NewDataStruct, \@MissingDataStruct, \@MatchedDataStruct, \@FrzDataStruct, \@InDataStruct); };
+	die $@ if $@;
+
+	# MAKEDEF should generate a warning if the def file has no exports (old or new)
+	# and the associated MMP 'targettype' is not a System Target type.
+	print "MAKEDEF WARNING: $OUTFILE has no EXPORTS\n" unless (@MatchedDataStruct || @NewDataStruct || $Options{SystemTargetType});
+
+#	Create the output .DEF file
+	eval { &CreateDefFileL(\@NewDataStruct, \@MatchedDataStruct, $OUTFILE, $FRZFILE); };
+	die $@ if $@;
+
+#	report missing frozen export errors
+	if (@MissingDataStruct) {
+		my @Errors;
+		my $Num=@MissingDataStruct;
+		my $Ref;
+		if ($FRZFILE) {
+			push @Errors, "MAKEDEF ERROR: $Num Frozen Export(s) missing from object files (POSSIBLE COMPATIBILITY BREAK):\n";
+			foreach $Ref (@MissingDataStruct) {
+				push @Errors, "  $FRZFILE($$Ref{LineNum}) : $$Ref{Name} \@$$Ref{Ordinal}\n";
+			}
+		}
+		else {
+			push @Errors, "MAKEDEF ERROR: command-line: $Num Frozen Export(s) missing from object files (POSSIBLE COMPATIBILITY BREAK):\n";
+			foreach $Ref (@MissingDataStruct) {
+				push @Errors, "  $$Ref{Name} \@$$Ref{Ordinal}\n";
+			}
+		}
+		die "\n", @Errors;
+	}
+	elsif ($Options{overwrite} && -w $FRZFILE) #sag
+		{
+		print "Copying $OUTFILE to $FRZFILE\n";
+		rename $FRZFILE, "$FRZFILE.bak";
+		copy($OUTFILE, $FRZFILE);
+		}
+
+	exit 0;
+}
+
+#######################################################################
+# SUBROUTINES
+#######################################################################
+
+sub Usage () {
+
+	print(
+		"\n",
+		"MAKEDEF - .DEF file generator (Build ",&E32tpver,")\n",
+		"\n",
+		"MAKEDEF {options} [Output .DEF file]\n",
+		"\n",
+		"options:   (case-insensitive)\n",
+		"  -Deffile [Input .DEF file]\n",
+		"  -Inffile [Input export information file]\n",
+		"  -Frzfile [Frozen .DEF file]\n",
+		"  -1 [first export name] {-2 [second export name]}\n",
+		"  -Overwrite\n",
+		"  -Absent [symbol to use for absent exports]\n",
+		"  -ignore_unfrozen_noncallable\n",
+		"  -SystemTargetType\n",
+		"  -sym_name_lkup [Enable symbol lookup by name]\n",
+		"  -ignore_unfrozen_exports \n",
+		"\n",
+		"Either specify -Deffile or -Inffile, and\n",
+		"either -Frzfile or -1 {-2} if required.\n"
+	);
+	exit 1;
+}
+
+sub ReadInfFileL ($$$) {
+	my ($DataStructRef, $FILE)=@_;
+
+#	open export information file for reading
+	open (FILE, "<$FILE") or die "could not open $FILE: $!";
+
+#	read the export info. file, and create dummy frozen .DEF file text
+	my $LineNum=0;
+	my $Ordinal=0;
+	my $Comment='';
+	my $Name='';
+	my $InfType=0;	# dumpbin output
+	my %exports;	# MWLD workaround - record mangled names in case we don't see the demangled ones
+	my $Line;
+	while ($Line=<FILE>) {
+	        my $Data=0;
+			my $SymbolSize=0;
+		$LineNum++;
+		if ($InfType == 0) {
+			if ($Line =~ /\*\*\* ARCHIVE SYMBOL TABLE.* \*\*\*/o) {
+				$InfType=1;	# mwld disassembly output
+				next;
+			}
+			if ($Line =~ /^\s+(\?\S+)(\s+\((.*)\))?$/o) {
+#                   ??0TAgnAlarmDefaults@@QAE@XZ (public: __thiscall TAgnAlarmDefaults::TAgnAlarmDefaults(void))
+				$Name=$1;
+				$Comment=$3;
+			} 
+			elsif ($Line =~ /^\s+_(\S+)(\s+\((.*)\))?$/o) {
+# frozen ordinals like "UserNoLongerSupported01" seem to inherit a leading underscore in the dumpbin output
+				$Name=$1;
+				$Comment=$3;
+			}
+			elsif ($Line =~ /^\s+_(\S+) DATA (\d+)(\s+\((.*)\))?$/o) {
+#				Mark the data symbols and retain their sizes
+				$Name=$1;
+				$Data=1;
+				$SymbolSize=$2;
+				$Comment=$4;
+			}
+			else {
+				next;
+			}
+		}
+		else {
+			# The Windows CW linker produces .inf files with a 'something' unmangled comment at the end, the Linux CW linker doesn't
+			if ($Line =~ /^\s*\d+\s+\(.+\)\s+__imp_((.)(\S+))(\s+'__declspec\(dllimport\)\s+(.*)')?$/o) {
+					if ($2 eq "_") {
+							$Name = $3;		# C symbol, so remove leading underscore
+							$Comment = $5 if ($4);	# name isn't mangled anyway
+					} else {
+							$Name = $1;		# C++ mangled name
+							$Comment = $5 if ($4);	# can't unmangle names...
+					}
+
+					# One side-effect of ignoring comments if they're not present is that Windows entry points need to be
+					# specifically ignored.  Previously they were ignored by virture of the fact they had no comment.
+					next if ($Name eq "_E32Dll" || $Name eq "_E32Startup");
+
+					$Comment = $4 ? $5 : $Name;
+					
+					# need to save both the line number and
+					# comment
+					my %entry;
+					$entry{'lineNum'} = $LineNum;
+					$entry{'comment'} = $Comment;
+					$exports{$Name}=\%entry;
+					next;
+			}
+			if ($Line =~ /\*\*\* Unmangled Symbols \*\*\*/o) {
+				# Currently for Linux "Unmangled Symbols" section is blank
+				<FILE>; 
+				$Line = <FILE>; 
+				$LineNum+=2;
+				if ($^O eq "MSWin32") {
+					if ($Line !~ /^\s*\d+:\s+(\S+)$/o) {
+						print STDERR "MAKEDEF WARNING: unknown inf file format\n";
+						next;
+					}
+				}
+				$Name = $1;
+# Workaround: if MWLD can't demangle the name, we will see only the __imp_ version.
+				if ($Name =~ /^__imp_(\S+)$/o) {
+					$Name = $1;
+				}
+				$Line = <FILE>; 
+				$LineNum++;
+				next if ($Line !~ /^\s+(.+)$/o);
+				$Comment = $1;
+			}
+			elsif ($Line =~ /^0x\S{8}\s+__imp__(\S+)$/o) {
+				$Name = $1;	# leading underscore already removed
+				$Comment = '';	# a C symbol, and therefore not mangled
+			}
+			else {
+				next;
+			}
+		}
+# Check for WINS entrypoint symbols
+		if ($Name eq "_E32Dll" || $Name eq "_E32Startup") {
+			$EntryPoint = $Name;
+			# when mwld resolves an exported symbol S coming from
+			# the def file, it looks both for S() and _S() in
+			# every object file but only for _S() in static
+			# libraries.
+			#
+			# As a consequence, we need to distinguish the
+			# internal entry point name from the external one.
+			$InternalEntryPoint = "_$Name" if ($InfType != 0);
+			my $entry = $exports{$Name};
+			$entry->{'lineNum'} = 0; # indicates processed name
+			next;
+		}
+		$Ordinal++;
+		$Comment='' if (!defined $Comment);
+		push @$DataStructRef, {
+			Ordinal=>$Ordinal,
+			Name=>$Name,
+			Data=>$Data,
+			Size=>$SymbolSize,
+			ExportName=>$Name,
+			Comment=>$Comment,
+			LineNum=>$LineNum
+		};
+		my $entry = $exports{$Name};
+		$entry->{'lineNum'} = 0; # indicates processed name
+	}
+	foreach $Name (keys %exports) {
+	    	my $entry = $exports{$Name};
+		$LineNum = $entry->{'lineNum'};
+		if ($LineNum > 0) {
+			$Ordinal++;
+			push @$DataStructRef, {
+				Ordinal=>$Ordinal,
+				Name=>$Name,
+				ExportName=>$Name,
+				Comment=> $entry->{'comment'},
+				LineNum=>$LineNum
+			};
+		}
+	}
+}
+
+sub CompareFrzInL ($$$$$) {
+	my ($NewStructRef, $MissingStructRef, $MatchedStructRef, $FrzStructRef, $InStructRef)=@_;
+	my $AbsentSubst = $Options{absent};
+	my $IgnoreNoncallable = $Options{ignore_unfrozen_noncallable};
+	
+#	compare the input export data with the frozen data
+
+#	this function trashes the frozen .DEF data structure and the new .DEF data structure
+
+#	nullify non-export statements in the structures
+	foreach (@$FrzStructRef,@$InStructRef) {
+		next if $$_{Name};
+		undef $_;
+	}
+
+	my $LastOrdinal=0;
+
+	my $FrzRef;
+	my $InRef;
+	FRZLOOP: foreach $FrzRef (@$FrzStructRef) {
+		next unless $$FrzRef{Name};		# ignore lines in the .DEF file not containing an export
+		if ($LastOrdinal<$$FrzRef{Ordinal}) {
+			$LastOrdinal=$$FrzRef{Ordinal};
+		}
+		foreach $InRef (@$InStructRef) {
+			next unless defined $InRef; # ignore nullified entries in the temporary array
+#			does the function name match?
+			if ($$InRef{Name} eq $$FrzRef{Name}) {
+#				give the generated export the same number as the corresponding frozen one
+				$$InRef{Ordinal}=$$FrzRef{Ordinal};
+				$$InRef{Data}=$$FrzRef{Data};
+				$$InRef{Size}=$$FrzRef{Size};
+#				if the export is marked as absent, redirect it appropriately
+				if ($$FrzRef{Absent}) {
+					if ($AbsentSubst) {
+						$$InRef{Name} = $AbsentSubst;
+						$$InRef{ExportName} = sprintf("\"_._.absent_export_%d\"", $$InRef{Ordinal});
+					}
+				}
+				push @$MatchedStructRef, $InRef;
+				undef $InRef;
+				next FRZLOOP;
+			}
+		}
+#		these frozen exports haven't been found in the object files
+#		first check for ABSENT declarations
+		if ($AbsentSubst and $$FrzRef{Absent}) {
+			$$FrzRef{Name} = $AbsentSubst;
+			$$FrzRef{ExportName} = sprintf("\"_._.absent_export_%d\"", $$FrzRef{Ordinal});
+			push @$MatchedStructRef, $FrzRef;
+			next FRZLOOP;
+		}
+
+#		No - it's really missing
+		push @$MissingStructRef, $FrzRef;
+#		put a comment in the generated .DEF file to that effect
+		$$FrzRef{Missing}=1;
+		push @$MatchedStructRef, $FrzRef;
+	}
+
+#	all the exports left in the new .DEF file aren't frozen - give them the right ordinals
+	foreach $InRef (@$InStructRef) {
+		next unless defined $InRef; # ignore nullified entries
+		if ($$InRef{Name} =~ /^_ZTV|_ZTI/) {
+			# EABI non-callable exports
+			next if ($IgnoreNoncallable);	
+		}
+		$LastOrdinal++;
+		$$InRef{Ordinal}=$LastOrdinal;
+		push @$NewStructRef, $InRef;
+	}
+}
+
+sub CreateDefFileL ($$$$) {
+#	creates a new .DEF file
+	my ($NewStructRef, $MatchedStructRef, $FILE, $FRZFILE)=@_;
+
+	my @Text=("EXPORTS\n");
+	my $LineNum=1;
+
+
+	my $InRef;
+	foreach $InRef (@$MatchedStructRef) {
+		my $Comment='';
+		if ($$InRef{Comment}) {
+			$Comment=" ; $$InRef{Comment}";
+		}
+		if ($$InRef{Missing}) {
+			push @Text, '; MISSING:';
+		}
+		my $Data = "";
+		if( defined $$InRef{Data} && $$InRef{Data} == 1) {
+		$Data = " DATA $$InRef{Size}" ;
+		}
+		my $r3unused = $$InRef{R3Unused} ? " R3UNUSED" : "";
+
+#		A def file entry with the keyword 'NONAME' indicates the MW linker that a named-lookup is not enabled. 
+#		Note that although it may seem, but named lookup is either enabled or disabled on a per-binary basis and not
+#		per-symbol.
+		my $noname = $NamedSymLkup ? "": " NONAME";
+		if ($$InRef{ExportName} and ($$InRef{ExportName} ne $$InRef{Name})) {
+			push @Text, "\t$$InRef{ExportName}=$$InRef{Name} \@ $$InRef{Ordinal} $noname$Data$r3unused$Comment\n";
+		} else {
+			push @Text, "\t$$InRef{Name} \@ $$InRef{Ordinal} $noname$Data$r3unused$Comment\n";
+		}
+		$LineNum++;
+		next;
+	}
+	if (@$NewStructRef) {
+
+#		warn about unfrozen exports and add them to the end of the generated .DEF file
+		my $Num=@$NewStructRef;
+		my @Warnings;
+
+		if(!$IgnoreUnfrozenExports) {
+			my $warning = "MAKEDEF WARNING: $Num export(s) not yet Frozen";
+
+			if ($FRZFILE)
+				{
+				$warning .= " in $FRZFILE";
+				}
+
+			$warning .= ":\n";
+
+			push @Warnings, $warning;
+		}
+
+		push @Text, "; NEW:\n";
+		$LineNum++;
+		foreach $InRef (@$NewStructRef) {
+			my $Comment='';
+			if ($$InRef{Comment}) {
+				$Comment=" ; $$InRef{Comment}";
+			}
+			my $Data = "";
+			if(defined $$InRef{Data} && $$InRef{Data} == 1){
+			$Data = " DATA $$InRef{Size}";
+			}
+			my $r3unused = $$InRef{R3Unused} ? " R3UNUSED" : "";
+			my $noname = $NamedSymLkup ? "": " NONAME";
+			if ($$InRef{ExportName} and ($$InRef{ExportName} ne $$InRef{Name})) {
+				push @Text, "\t$$InRef{ExportName}=$$InRef{Name} \@ $$InRef{Ordinal} $noname$Data$r3unused$Comment\n";
+			} else {
+				push @Text, "\t$$InRef{Name} \@ $$InRef{Ordinal} $noname$Data$r3unused$Comment\n";
+			}
+			$LineNum++;
+			if(!$IgnoreUnfrozenExports) {
+				push @Warnings, "  $FILE($LineNum) : $$InRef{Name} \@$$InRef{Ordinal}\n";
+			}
+			next;
+		}
+		print @Warnings;
+	}
+	if ($EntryPoint) {
+		push @Text, "\t$EntryPoint";
+		push @Text, "=$InternalEntryPoint" if ($InternalEntryPoint);
+		push @Text, "\t; Entry point for emulation\n";
+	}
+	elsif ($ExportEntrypointE32Dll) {		# Workaround: To export entry point _E32DLL for target type STDDLL
+		push @Text, "\t_E32Dll";
+		push @Text, "=__E32Dll" ;
+		push @Text, "\t; Entry point for STDDLL emulation\n";
+	}
+
+#	add a terminating newline
+	push @Text, "\n";
+
+#	write the new .DEF file
+	eval { &Def_WriteFileL(\@Text, $FILE); };
+	die $@ if $@;
+}
+