#

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

#

use strict;

use integer;

BEGIN

	{

	my $perlScriptPath=$0;

	my $os = $^O; #get the OS type

	#check OS type

  if($os=~/MSWin32/) #Windows OS

    {

    $perlScriptPath=~s/\//\\/g; # replace any forward-slashes with back-slashes

    $perlScriptPath=~s/(\\?)[^\\]+$/$1/; # get rid of this Perl-script's file-name

    }

  else #Unix OS

    {

    $perlScriptPath=~s/\\/\//g; # replace any back-slashes with forward-slashes

    $perlScriptPath=~s/(\/?)[^\/]+$/$1/; # get rid of this Perl-script's file-name

    }

	unshift(@INC, $perlScriptPath); # can't do "use lib $perlScriptPath" here as "use lib" only seems to work with *hard-coded* directory names

	}

use PARSER;

use WRITER;

$|=1; # ensures that any progress information sent to the screen is displayed immediately and not buffered

if ((@ARGV==0) || ($ARGV[0]=~/\?/i) || ($ARGV[0]=~/-h/i) || ($ARGV[0]=~/help/i))

	{

	die("\nVersion 021\n\nCharacter-set conversion-table generating tool\nCopyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).\n\nUsage:\n\n\tcnvtool <control-file> <source-file> <output-file> [options]\n\nwhere the following options are available (each has a short form and a long form which are shown below separated by a '|'):\n\n\t-s | -generateSourceCode\n\t-c | -columns(<a>: <b>, <c>)\n\t-r | -omitReplacementForUnconvertibleUnicodeCharacters\n\t-p | -cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed\n\t-u | -sourceFilesToSubtract(<a>, <b>, ...)\n\n");

	}

my $generateSourceCode=0;

my @columns=(2, 1, 2);

my $omitReplacementForUnconvertibleUnicodeCharacters=0;

my $cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed=0;

my @sourceFilesToSubtract=();

my $flattenHashAndSave=0; # this flag is not published for use outside of the CHARCONV component

&extractCommandLineFlags(\$generateSourceCode, \@columns, \$omitReplacementForUnconvertibleUnicodeCharacters, \$cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed, \@sourceFilesToSubtract, \$flattenHashAndSave);

(!$omitReplacementForUnconvertibleUnicodeCharacters || $generateSourceCode) or die("Error: bad combination of flags\n");

my $controlFile=shift;

my $sourceFile=shift;

my $outputFile=shift;

print("Generating $outputFile...\n");

my $uid=0;

my $endiannessAsText='';

my $endianness=0;

my $replacementForUnconvertibleUnicodeCharacters='';

my @foreignVariableByteData=();

my @foreignToUnicodeData=();

my @unicodeToForeignData=();

my %foreignCharacterCodes=();

my %unicodeCharacterCodes=();

my %preferredForeignCharacterCodesForConflictResolution=();

my %preferredUnicodeCharacterCodesForConflictResolution=();

my %additionalSubsetTables=();

my %privateUseUnicodeCharacterSlotsUsed=();

print("    reading $controlFile...\n");

open(CONTROL_FILE, "< $controlFile") or die("Error: could not open \"$controlFile\" for reading\n");

&readHeaderFromControlFile(\*CONTROL_FILE, $controlFile, $generateSourceCode, \$uid, \$endiannessAsText, \$endianness, \$replacementForUnconvertibleUnicodeCharacters, $flattenHashAndSave);

&readForeignVariableByteDataFromControlFile(\*CONTROL_FILE, $controlFile, \@foreignVariableByteData);

&readOneDirectionDataFromControlFile(\*CONTROL_FILE, $controlFile, \@foreignToUnicodeData, \%preferredUnicodeCharacterCodesForConflictResolution, \%additionalSubsetTables, 1);

&readOneDirectionDataFromControlFile(\*CONTROL_FILE, $controlFile, \@unicodeToForeignData, \%preferredForeignCharacterCodesForConflictResolution, \%additionalSubsetTables, 0);

close(CONTROL_FILE) or die("Error: could not close \"$controlFile\"\n");

print("    reading $sourceFile...\n");

open(SOURCE_FILE, "< $sourceFile") or die("Error: could not open \"$sourceFile\" for reading\n");

&readSourceFile(\*SOURCE_FILE, $sourceFile, \%foreignCharacterCodes, \%unicodeCharacterCodes, \@columns, $cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed, \%privateUseUnicodeCharacterSlotsUsed, 0);

close(SOURCE_FILE) or die("Error: could not close \"$sourceFile\"\n");

my $sourceFileToSubtract;

foreach $sourceFileToSubtract (@sourceFilesToSubtract)

	{

	print("    subtracting from $sourceFileToSubtract...\n");

	open(SOURCE_FILE_TO_SUBTRACT, "< $sourceFileToSubtract") or die("Error: could not open \"$sourceFileToSubtract\" for reading\n");

	&readSourceFile(\*SOURCE_FILE_TO_SUBTRACT, $sourceFileToSubtract, \%foreignCharacterCodes, \%unicodeCharacterCodes, \@columns, $cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed, \%privateUseUnicodeCharacterSlotsUsed, 1);

	close(SOURCE_FILE_TO_SUBTRACT) or die("Error: could not close \"$sourceFileToSubtract\"\n");

	}

&warnIfAnyPrivateUseUnicodeCharacterSlotsBeingUsed(\%privateUseUnicodeCharacterSlotsUsed);

&resolveConflictsAndFlattenArraysToScalars(\%foreignCharacterCodes, \%preferredForeignCharacterCodesForConflictResolution, 'Unicode', 'foreign');

&resolveConflictsAndFlattenArraysToScalars(\%unicodeCharacterCodes, \%preferredUnicodeCharacterCodesForConflictResolution, 'foreign', 'Unicode');

&checkForeignVariableByteData($endianness, \@foreignVariableByteData, \@foreignToUnicodeData);

print("    writing $outputFile...\n");

open(OUTPUT_FILE, "> $outputFile") or die("Error: could not open \"$outputFile\" for writing\n");

if ($generateSourceCode)

	{

	my @sourceCodeOfForeignToUnicodeIndexedTables16=();

	my @sourceCodeOfForeignToUnicodeKeyedTables1616=();

	my @sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_indexedEntries=();

	my @sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_keyedEntries=();

	my @sourceCodeOfUnicodeToForeignIndexedTables16=();

	my @sourceCodeOfUnicodeToForeignKeyedTables1616=();

	my @sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_indexedEntries=();

	my @sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_keyedEntries=();

	# new for 32 bit encoding begin

	my @sourceCodeOfForeignToUnicodeIndexedTables32=();

	my @sourceCodeOfForeignToUnicodeKeyedTables3232=();

	my @sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_indexedEntries=();

	my @sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_keyedEntries=();

	my @sourceCodeOfUnicodeToForeignIndexedTables32=();

	my @sourceCodeOfUnicodeToForeignKeyedTables3232=();

	my @sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_indexedEntries=();

	my @sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_keyedEntries=();

	# new for 32 bit endcoding end

	my @sourceCodeOfTopLevelStructures=();

	&writeSourceCodeHeader(\*OUTPUT_FILE, $outputFile, $replacementForUnconvertibleUnicodeCharacters);

	&writeSourceCodeForeignVariableByteData(\@sourceCodeOfTopLevelStructures, \@foreignVariableByteData);

	&writeSourceCodeOneDirectionData(\@sourceCodeOfTopLevelStructures,

		\@sourceCodeOfForeignToUnicodeIndexedTables16, \@sourceCodeOfForeignToUnicodeKeyedTables1616, \@sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_indexedEntries, \@sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_keyedEntries,

		\@sourceCodeOfForeignToUnicodeIndexedTables32, \@sourceCodeOfForeignToUnicodeKeyedTables3232, \@sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_indexedEntries, \@sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_keyedEntries,

		\@foreignToUnicodeData, \%unicodeCharacterCodes, 1);

	&writeSourceCodeOneDirectionData(\@sourceCodeOfTopLevelStructures,

		\@sourceCodeOfUnicodeToForeignIndexedTables16, \@sourceCodeOfUnicodeToForeignKeyedTables1616, \@sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_indexedEntries, \@sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_keyedEntries,

		\@sourceCodeOfUnicodeToForeignIndexedTables32, \@sourceCodeOfUnicodeToForeignKeyedTables3232, \@sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_indexedEntries, \@sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_keyedEntries,

		\@unicodeToForeignData, \%foreignCharacterCodes, 0);

	&writeSourceCodeFinalStuff(\*OUTPUT_FILE,

		\@sourceCodeOfForeignToUnicodeIndexedTables16, \@sourceCodeOfForeignToUnicodeKeyedTables1616, \@sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_indexedEntries, \@sourceCodeOfForeignToUnicodeKeyedTables16OfIndexedTables16_keyedEntries,

		\@sourceCodeOfUnicodeToForeignIndexedTables16, \@sourceCodeOfUnicodeToForeignKeyedTables1616, \@sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_indexedEntries, \@sourceCodeOfUnicodeToForeignKeyedTables16OfIndexedTables16_keyedEntries,

		\@sourceCodeOfForeignToUnicodeIndexedTables32, \@sourceCodeOfForeignToUnicodeKeyedTables3232, \@sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_indexedEntries, \@sourceCodeOfForeignToUnicodeKeyedTables32OfIndexedTables32_keyedEntries,

		\@sourceCodeOfUnicodeToForeignIndexedTables32, \@sourceCodeOfUnicodeToForeignKeyedTables3232, \@sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_indexedEntries, \@sourceCodeOfUnicodeToForeignKeyedTables32OfIndexedTables32_keyedEntries,

		\@sourceCodeOfTopLevelStructures, $endiannessAsText, \%additionalSubsetTables);

	}

elsif ($flattenHashAndSave)

	{

	binmode OUTPUT_FILE;

	#instead of calling the writeBinaryHeader, just write the data I need followed by 

	# writeBinaryForeignVariableByteData...

	&write8(\*OUTPUT_FILE, $endianness);

	&write8(\*OUTPUT_FILE, length($replacementForUnconvertibleUnicodeCharacters));

	&writeString(\*OUTPUT_FILE, $replacementForUnconvertibleUnicodeCharacters);

	&writeBinaryForeignVariableByteData(\*OUTPUT_FILE, \@foreignVariableByteData);

	#choose %unicodeCharacterCodes and write the data as keypair

	my $key;

	my $rangekey;

	my $limit;

	foreach $key (keys(%unicodeCharacterCodes))

		{

		&write16(\*OUTPUT_FILE,$key);

		&write16(\*OUTPUT_FILE,$unicodeCharacterCodes{$key});

		}

	}

else

	{

	binmode OUTPUT_FILE;

	&writeBinaryHeader(\*OUTPUT_FILE, $uid, $endianness, $replacementForUnconvertibleUnicodeCharacters);

	&writeBinaryForeignVariableByteData(\*OUTPUT_FILE, \@foreignVariableByteData);

	&writeBinaryOneDirectionData(\*OUTPUT_FILE, \@foreignToUnicodeData, \%unicodeCharacterCodes, 1);

	&writeBinaryOneDirectionData(\*OUTPUT_FILE, \@unicodeToForeignData, \%foreignCharacterCodes, 0);

	}

close(OUTPUT_FILE) or die("Error: could not close \"$outputFile\"\n");

print("complete\n\n");

sub extractCommandLineFlags()

	{

	my $generateSourceCode=shift;

	my $columns=shift;

	my $omitReplacementForUnconvertibleUnicodeCharacters=shift;

	my $cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed=shift;

	my $sourceFilesToSubtract=shift;

	my $flattenHashAndSave=shift;

	my $i;

	for ($i=0; $i<=$#ARGV;) # (i) not cache-ing $#ARGV into a variable as @ARGV may change length in this loop (ii) iterate forwards as some parameters may occupy more than one element in @ARGV

		{

		if (($ARGV[$i]=~/^-s$/i) || ($ARGV[$i]=~/^-generateSourceCode$/i))

			{

			if ($$flattenHashAndSave==1)

				{

				die ("Error: Cannot have -s and -b flags set at the same time");

				}

			else

				{

				splice(@ARGV, $i, 1);

				$$generateSourceCode=1;

				}

			}

		elsif (($ARGV[$i]=~/^-c\b(.*)$/i) || ($ARGV[$i]=~/^-columns\b(.*)$/i))

			{

			my $columnsData=$1;

			splice(@ARGV, $i, 1);

			for (;;)

				{

				if ($columnsData=~/^\s*\(\s*(\d+)\s*:\s*(\d+)\s*\,?\s*(\d+)\s*\)\s*$/)

					{

					@$columns=($1, $2, $3);

					last;

					}

				($#ARGV>=$i) or die("Error: bad \"-columns\" format\n");

				$columnsData.=(splice(@ARGV, $i, 1))[0];

				}

			}

		elsif (($ARGV[$i]=~/^-r$/i) || ($ARGV[$i]=~/^-omitReplacementForUnconvertibleUnicodeCharacters$/i))

			{

			splice(@ARGV, $i, 1);

			$$omitReplacementForUnconvertibleUnicodeCharacters=1;

			}

		elsif (($ARGV[$i]=~/^-p$/i) || ($ARGV[$i]=~/^-cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed$/i))

			{

			splice(@ARGV, $i, 1);

			$$cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed=1;

			}

		elsif (($ARGV[$i]=~/^-u\b(.*)$/i) || ($ARGV[$i]=~/^-sourceFilesToSubtract\b(.*)$/i))

			{

			my $sourceFilesData=$1;

			splice(@ARGV, $i, 1);

			for (;;)

				{

				if ($sourceFilesData=~/^\s*\(\s*(.+)\)\s*$/)

					{

					my $sourceFilesData=$1;

					@$sourceFilesToSubtract=split(/,/, $sourceFilesData, -1);

					my $j;

					for ($j=$#$sourceFilesToSubtract; $j>=0; --$j)

						{

						$sourceFilesToSubtract->[$j]=~s/^\s+//;

						$sourceFilesToSubtract->[$j]=~s/\s+$//;

						($sourceFilesToSubtract->[$j] ne '') or die("Error: bad \"-sourceFilesToSubtract\" format (1)\n");

						}

					last;

					}

				($#ARGV>=$i) or die("Error: bad \"-sourceFilesToSubtract\" format (2)\n");

				$sourceFilesData.=(splice(@ARGV, $i, 1))[0];

				}

			}

		elsif (($ARGV[$i]=~/^-f$/i) || ($ARGV[$i]=~/^-flattenHashAndSave$/i))

			{

			if ($$generateSourceCode==1)

				{

				die ("Error: Cannot have -s and -b flags set at the same time");

				}

			else

				{

				splice(@ARGV, $i, 1);

				$$flattenHashAndSave=1;

				}

			}

		else

			{

			++$i;

			}

		}

	}

sub algorithm

	{

	my $algorithmAsText=shift;

	if ($algorithmAsText=~/^Direct$/i)

		{

		return 0;

		}

	elsif ($algorithmAsText=~/^Offset$/i)

		{

		return 1;

		}

	elsif ($algorithmAsText=~/^IndexedTable16$/i)

		{

		return 2;

		}

	elsif ($algorithmAsText=~/^KeyedTable1616$/i)

		{

		return 3;

		}

	elsif ($algorithmAsText=~/^KeyedTable16OfIndexedTables16$/i)

		{

		return 4;

		}

	elsif ($algorithmAsText=~/^IndexedTable32$/i)

		{

		return 5;

		}

	elsif ($algorithmAsText=~/^KeyedTable3232$/i)

		{

		return 6;

		}

	elsif ($algorithmAsText=~/^KeyedTable32OfIndexedTables32$/i)

		{

		return 7;

		}

	else

		{

		return -1;

		}

	}

sub hexadecimalify

	{

	my $string=shift;

	my $result='';

	my $lengthOfString=length($string);

	my $i;

	for ($i=0; $i<$lengthOfString; ++$i)

		{

		$result.=sprintf("\\x%02x", (unpack('C', substr($string, $i, 1)))[0]);

		}

	return $result;

	}

sub readSourceFile

	{

	my $fileHandle=shift;

	my $fileName=shift;

	my $foreignCharacterCodes=shift;

	my $unicodeCharacterCodes=shift;

	my $columns=shift;

	my $cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed=shift;

	my $privateUseUnicodeCharacterSlotsUsed=shift;

	my $subtract=shift;

	my $foreignCharacterCodeProcessingCode='';

	if (!(($columns->[0]>0) && ($columns->[1]>0) && ($columns->[2]>0) && ($columns->[1]<=$columns->[0]) && ($columns->[2]<=$columns->[0]) && ($columns->[1]!=$columns->[2])))

		{

		close($fileHandle);

		die("Error: bad \"-columns\" data\n");

		}

	my $patternOfLineContainingCharacterCodes=join('\s+', ('0x([0-9a-f]+)') x $columns->[0]);

	my $line;

	my $strippedDownLine;

	for (;;)

		{

		($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

		if (($strippedDownLine eq '')||(substr($strippedDownLine,0,1) eq chr(26)))  # if there are no more lines in the file or if we encountered EOF character

			{

			last;

			}

		if ($strippedDownLine=~/^SET_FOREIGN_CHARACTER_CODE_PROCESSING_CODE\s+(.*)$/i)

			{

			$foreignCharacterCodeProcessingCode=$1;

			}

		elsif ($strippedDownLine=~/^$patternOfLineContainingCharacterCodes$/i)

			{

			no strict 'refs'; # so that we can use symbolic references for $1, $2, etc

			my $foreignCharacterCode=hex(${$columns->[1]});

			my $unicodeCharacterCode=hex(${$columns->[2]});

			use strict 'refs';

			if ($foreignCharacterCodeProcessingCode ne '')

				{

				$foreignCharacterCode=eval($foreignCharacterCodeProcessingCode);

				}

			my $handleConversionPair=1;

			if ((($unicodeCharacterCode>=0xe000) && ($unicodeCharacterCode<=0xf8ff)) || (($unicodeCharacterCode>=0xf0000) && ($unicodeCharacterCode<=0x10ffff)))

				{

				if ($cutOutAnyPrivateUseUnicodeCharacterSlotsBeingUsed)

					{

					$handleConversionPair=0;

					}

				else

					{

					if ($subtract)

						{

						delete $privateUseUnicodeCharacterSlotsUsed->{$unicodeCharacterCode};

						}

					else

						{

						$privateUseUnicodeCharacterSlotsUsed->{$unicodeCharacterCode}=1;

						}

					}

				}

			if ($handleConversionPair)

				{

				if ($subtract)

					{

					if (!defined($foreignCharacterCodes->{$unicodeCharacterCode}->{$foreignCharacterCode}))

						{

						close($fileHandle);

						die('Error: cannot subtract conversion pair ['.sprintf('foreign 0x%x, Unicode 0x%04x', $foreignCharacterCode, $unicodeCharacterCode)."] as it does not occur in \"$fileName\"\n");

						}

					if (!defined($unicodeCharacterCodes->{$foreignCharacterCode}->{$unicodeCharacterCode}))

						{

						close($fileHandle);

						die('Error: cannot subtract conversion pair ['.sprintf('Unicode 0x%04x, foreign 0x%x', $unicodeCharacterCode, $foreignCharacterCode)."] as it does not occur in \"$fileName\"\n");

						}

					delete $foreignCharacterCodes->{$unicodeCharacterCode}->{$foreignCharacterCode};

					if (keys(%{$foreignCharacterCodes->{$unicodeCharacterCode}})==0)

						{

						delete $foreignCharacterCodes->{$unicodeCharacterCode};

						}

					delete $unicodeCharacterCodes->{$foreignCharacterCode}->{$unicodeCharacterCode};

					if (keys(%{$unicodeCharacterCodes->{$foreignCharacterCode}})==0)

						{

						delete $unicodeCharacterCodes->{$foreignCharacterCode};

						}

					}

				else

					{

					if (defined($foreignCharacterCodes->{$unicodeCharacterCode}->{$foreignCharacterCode}))

						{

						close($fileHandle);

						die('Error: same conversion pair ['.sprintf('foreign 0x%x, Unicode 0x%04x', $foreignCharacterCode, $unicodeCharacterCode)."] occurs more than once in \"$fileName\"\n");

						}

					if (defined($unicodeCharacterCodes->{$foreignCharacterCode}->{$unicodeCharacterCode}))

						{

						close($fileHandle);

						die('Error: same conversion pair ['.sprintf('Unicode 0x%04x, foreign 0x%x', $unicodeCharacterCode, $foreignCharacterCode)."] occurs more than once in \"$fileName\"\n");

						}

					$foreignCharacterCodes->{$unicodeCharacterCode}->{$foreignCharacterCode}=1;

					$unicodeCharacterCodes->{$foreignCharacterCode}->{$unicodeCharacterCode}=1;

					}

				}

			}

		elsif ($line!~/^\s*0x([0-9a-f]+)\s*#\s*undefined.*$/i)

			{

			close($fileHandle);

			die("Error: unexpected line in \"$fileName\":\n    $line\n");

			}

		}

	}

sub readHeaderFromControlFile

	{

	my $fileHandle=shift;

	my $fileName=shift;

	my $generateSourceCode=shift;

	my $uid=shift;

	my $endiannessAsText=shift;

	my $endianness=shift;

	my $replacementForUnconvertibleUnicodeCharacters=shift;

	my $flattenHashAndSave=shift;

	my $line;

	my $strippedDownLine;

	($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

	if ($strippedDownLine=~/^UID\s+0x([0-9a-f]+)$/i)

		{

		if ($generateSourceCode)

			{

			print(STDERR "Warning: \"UID\" keyword should not be used with \"-generateSourceCode\" flag - specify the UID in the MMP file\n");

			}

		$$uid=hex($1);

		($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

		}

	else

		{

		if (!$generateSourceCode && !$flattenHashAndSave)

			{

			close($fileHandle);

			die("Error: unexpected line in \"$fileName\" (\"UID\" keyword expected):\n    $line\n");

			}

		}

	if ($strippedDownLine=~/^Name\s+"(.+?)"$/i)

		{

		print(STDERR "Warning: obsolete keyword \"Name\" used\n");

		($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

		}

	if ($strippedDownLine!~/^Endianness\s+(\w+)$/i)

		{

		close($fileHandle);

		die("Error: unexpected line in \"$fileName\" (\"Endianness\" keyword expected):\n    $line\n");

		}

	$$endiannessAsText=$1;

	if ($$endiannessAsText=~/Unspecified/i)

		{

		$$endianness=0; # SCnvConversionData::EUnspecified

		}

	elsif ($$endiannessAsText=~/FixedLittleEndian/i)

		{

		$$endianness=1; # SCnvConversionData::EFixedLittleEndian

		}

	elsif ($$endiannessAsText=~/FixedBigEndian/i)

		{

		$$endianness=2; # SCnvConversionData::EFixedBigEndian

		}

	else

		{

		close($fileHandle);

		die("Error: \"$$endiannessAsText\" is not a legal value for \"Endianness\"\n");

		}

	($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

	if ($strippedDownLine!~/^ReplacementForUnconvertibleUnicodeCharacters\s+(.*?)$/i)

		{

		close($fileHandle);

		die("Error: unexpected line in \"$fileName\" (\"ReplacementForUnconvertibleUnicodeCharacters\" keyword expected):\n    $line\n");

		}

	$$replacementForUnconvertibleUnicodeCharacters='';

	my $remainderOfXxx=$1;

	while ($remainderOfXxx ne '')

		{

		if ($remainderOfXxx!~/^0x([0-9a-f]{1,2})\s*(.*)$/i)

			{

			close($fileHandle);

			die("Error: unexpected line in \"$fileName\":\n    $line\n");

			}

		$$replacementForUnconvertibleUnicodeCharacters.=pack("C", hex($1));

		$remainderOfXxx=$2;

		}

	my @temp=&nextNonEmptyStrippedDownLine($fileHandle);

	if ($temp[1]=~/^ForeignCharacterCodeProcessingCode/i)

		{

		print(STDERR "Warning: obsolete keyword \"ForeignCharacterCodeProcessingCode\" used\n");

		}

	else

		{

		ungetNonEmptyStrippedDownLine(@temp)

		}

	}

sub readForeignVariableByteDataFromControlFile

	{

	my $fileHandle=shift;

	my $fileName=shift;

	my $foreignVariableByteData=shift;

	my $line;

	my $strippedDownLine;

	($line, $strippedDownLine)=&nextNonEmptyStrippedDownLine($fileHandle);

	if ($strippedDownLine!~/^StartForeignVariableByteData$/i)

		{

		close($fileHandle);

		die("Error: unexpected line in \"$fileName\":\n    $line\n");

		}

	for (;;)

		{