# Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "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:

# hal\halcfg.pl

# Check arguments and open files

# 

#

my $nargs=scalar(@ARGV);

my $xmode=0;

if ($nargs==0) {

	usage();

}

elsif ($nargs!=3 and $nargs!=4) {

	die "Invalid number of arguments.  Run with no arguments for help on usage.\n";

	exit;

}

my $arg=0;

if ($nargs==4) {

	if ($ARGV[$arg] eq '-x') {

		$xmode=1;

	} elsif ($ARGV[$arg] eq '-s') {

		$xmode=2;

	} elsif ($ARGV[$arg] eq '-h') {

		$xmode=3;

	} else {

		usage();

		die "Invalid 1st argument $ARGV[0]\n";

	}

	++$arg;

}

my $headerFileName=$ARGV[$arg++];

my @hdr = &read_file_strip_comments($headerFileName);

my $inputFileName=$ARGV[$arg++];

my @input = &read_file_strip_comments($inputFileName);

my $outputFileName=$ARGV[$arg++];

#

# Parse the header file

#

my $line=0;

my $state=0;

my $enumName;

my %enumValues=();

my $nextValue=0;

my $bitmask=0;

my %enumList=();

foreach (@hdr) {

	++$line;

	next if (/^\s*\#/);		# ignore preprocessor directives

	next if (/^\s*\/\//);	# ignore comments starting with //

	next if (/^\s*$/);		# ignore blank lines

	if ($state==0) {

		if (/^\s*class\s+HALData\s*$/) {

			$state=1;

		}

		if (/^\s*class\s+HALData\s*{/) {

			$state=2;

		}

		next;

	}

	if ($state==1) {

		if (/^\s*{/) {

			$state=2;

		}

		next;

	}

	if ($state==2) {

		if (/^\s*};/) {

			$state=3;

			last;

		}

		if (/^\s*enum\s+(\w+)(.*)/) {

			$enumName=$1;

			%enumValues=();

			$nextValue=0;

			$bitmask=0;

			if ($2=~/^\s+{/) {

				$state=5;

			} else {

				$state=4;

			}

		}

		if (/^\s*bitmask\s+(\w+)(.*)/) {

			$enumName=$1;

			%enumValues=();

			$nextValue=0;

			$bitmask=1;

			if ($2=~/^\s+{/) {

				$state=5;

			} else {

				$state=4;

			}

		}

		next;

	}

	if ($state==4) {

		if (/^\s*{/) {

			$state=5;

		}

		next;

	}

	if ($state==5) {

		if (/^\s*(\w+)(.*)/) {

			my $tag=$1;

			my $val=0;

			my $rest=$2;

#			print "$tag\n$rest\n";

			if ($rest=~/^\s*,/) {

				$val=$nextValue;

			} elsif ($rest=~/^\s*\=\s*(\d\w*)\s*\,/) {

				$val=$1;

				unless ($val=~/^\d*$/) {

					if ($val=~/^0x(\w+)$/i) {

						$val=hex $1;

					} else {

						undef $val;

					}

				}

			} elsif ($rest=~/^\s*$/) {	# ignore last one

				next;

			} else {

				undef $val;

			}

			unless (defined $val) {

				die "Syntax error at line $line in file $headerFileName\n";

			}

			$nextValue=$val+1;

			$enumValues{$tag}=$val;

#			print "$tag=$val\n";

		} elsif (/^\s*};/) {

			$state=2;

			if ($bitmask) {

				$enumValues{'__bitmask__'}=-1;

			}

			my %temp=%enumValues;

			$enumList{$enumName}=\%temp;

		}

		next;

	}

}

if ($state!=3) {

	die "Unexpected end of file in $headerFileName\n";

}

#	my @keys=keys %enumList;

#	foreach(@keys) {

#		print "enum $_\n\t{\n";

#		my $ref=$enumList{$_};

#		my @tags=keys(%$ref);

#		foreach(@tags) {

#			my $value=$$ref{$_};

#			print "\t$_=$value\n";

#		}

#		print "\t};\n";

#	}

#

# Build a list of properties for each attribute

#

my $attribref=$enumList{'TAttribute'};

unless ($attribref) {

	die "No TAttribute enum defined\n";

}

my @attribs=keys %$attribref;

my %attribList;

foreach (@attribs) {

	my %properties;

	$properties{'name'}=$_;

	$properties{'ordinal'}=$$attribref{$_};

	my $enum=$_;

	$enum=~s/^E/T/;			# change initial E to T

	if (defined $enumList{$enum}) {

		my $enumRef=$enumList{$enum};

		$properties{'enum'}=$enumRef;

		if (defined $$enumRef{'__bitmask__'}) {

			$properties{'bitmask'}=1;

		}

	}

	$attribList{$_}=\%properties;

}

my $attpropref=$enumList{'TAttributeProperty'};

my %PropTable;

if ($xmode) {

	unless ($attpropref) {

		die "No TAttributeProperty enum defined\n";

	}

	my @attprops=keys(%$attpropref);

	foreach (@attprops) {

		if (/^E(\w+)$/) {

			my $propname=lc $1;

			$PropTable{$propname}='HAL::'.$_;

		} else {

			die "Invalid attribute property $_\n";

		}

	}

}

my @PropTableKeys=keys %PropTable;

#

# Parse the input file

#

$line=0;

foreach (@input) {

	++$line;

	next if (/^\s*\/\//);	# ignore comments starting with //

	next if (/^\s*$/);		# ignore blank lines

	if (/^\s*(\w+)\s*(.*)/) {

		my $attrib=$1;

		my $rest=$2;

		my $propRef=$attribList{$attrib};

		unless (defined $propRef) {

			die "Unrecognised attribute at line $line in file $inputFileName\n";

		}

#		print "$rest\n";

		if ($rest=~/^\:\s*(.*)/) {	# attribute properties follow

			if (!$xmode) {

				die "Line $line: Properties not permitted without -x option\n";

			}

			$rest=$1;

#			print "$rest\n";

			while ($rest=~/^(\w+)\s*(.*)/) {

				my $prop=lc $1;

				$rest=$2;

#				print "$rest\n";

				my $error=matchabbrev(\$prop, \@PropTableKeys);

				if ($error) {

					die "$error property $prop at line $line in file $inputFileName\n";

				}

				$$propRef{$prop}=1;

				if ($rest=~/^,\s*(.*)/) {

					$rest=$1;

				} elsif ($rest=~/^=\s*(.*)/) {

					$rest=$1;

					last;

				} else {

					die "Syntax error at line $line in file $inputFileName\n";

				}

			}

		} elsif ($rest=~/^=\s*(.*)/) {

			$rest=$1				# attribute value follows

		} else {

			die "Invalid attribute specification at line $line in file $inputFileName\n";

		}

#		print "$rest\n";

		if ($xmode) {

#			print "$rest\n";

			if ($rest=~/^((\w|:)+)/) {

				$$propRef{'value'}=$1;

			} else {

				die "Invalid function name $rest at line $line in file $inputFileName\n";

			}

		} elsif (defined $$propRef{'bitmask'}) {		# bitmask value

			my $enumRef=$$propRef{'enum'};

			my @keys=keys %$enumRef;

			my $val=0;

			while ($rest=~/^(\w+)\s*(.*)/) {

				my $bitmaskKey=$1;

				$rest=$2;

				if ($bitmaskKey eq '0' or lc($bitmaskKey) eq 'none') {

					last if ($val==0);

					die "Inconsistent bit mask values at line $line in file $inputFileName\n";

				}

				my $error=matchabbrev(\$bitmaskKey,\@keys);

				if ($error) {

					die "$error bit value $bitmaskKey at line $line in file $inputFileName\n";

				}

				$val |= $$enumRef{$bitmaskKey};

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

					$rest=$1;

				} elsif ($rest=~/^\s*$/) {

					last;

				} else {

					die "Syntax error at line $line in file $inputFileName\n";

				}

			}

			$$propRef{'value'}=$val;

		} elsif (defined $$propRef{'enum'} and $rest!~/^\d/) {	# enum value

			my $enumRef=$$propRef{'enum'};

			my @keys=keys %$enumRef;

			if ($rest=~/^(\w+)\s*$/) {

				my $enumKey=$1;

				my $error=matchabbrev(\$enumKey,\@keys);

				if ($error) {

					die "$error enumeration value $enumKey at line $line in file $inputFileName\n";

				}

				$$propRef{'value'}=$$enumRef{$enumKey};

			} else {

				die "Invalid enum value $rest at line $line in file $inputFileName\n";

			}

		} elsif ($rest=~/^(\-?\d\w*)\s*$/) {		# numeric value (decimal or hex) with optional -ve sign

			my $val=$1;

			unless ($val=~/^(\-?\d)\d*$/) {         # First character should be an optional -ve sign followed by only digits

				if ($val=~/^(\-?)0x(\w+)$/i) {       # First character should be an optional -ve sign followed by only alphanumerics 

					my $sign=$1;

					$val=hex $2;

					if ($sign  eq '-') {

					  $val=-$val;

					} 

				} else {

					undef $val;

				}

			}

			unless (defined $val) {

				die "Invalid attribute value $1 at line $line in file $inputFileName\n";

			}

			$$propRef{'value'}=$val;

		} else {								# invalid

			die "Invalid attribute value at line $line in file $inputFileName\n";

		}

	} else {

		die "Unrecognised attribute at line $line in file $inputFileName\n";

	}

}

#	foreach (@attribs) {

#		my $propRef=$attribList{$_};

#		if (defined $$propRef{'value'}) {

#			print "Attribute $_:\n";

#			my @keys=keys %$propRef;

#			foreach (@keys) {

#				print "\t$_=$$propRef{$_}\n";

#			}

#		}

#	}

#

# Sort attributes by ordinal

#

my @AttribsByOrdinal;

foreach (@attribs) {

	my $propRef=$attribList{$_};

	my $ordinal=$$propRef{'ordinal'};

	$AttribsByOrdinal[$ordinal]=$propRef;

}

my $nAttribs=scalar(@AttribsByOrdinal);

#

# Generate the output file

#

open OUT, ">$outputFileName" or die "Cannot open output file $outputFileName\n";

#	binmode OUT;

#	my $i=0;

#	while ($i<$nAttribs) {

#		my $value=0x80000000;

#		my $propRef=$AttribsByOrdinal[$i];

#		if (defined $$propRef{'value'}) {

#			$value=$$propRef{'value'};

#		}

#		++$i;

#		my $b3=($value>>24)&0xff;

#		my $b2=($value>>16)&0xff;

#		my $b1=($value>>8)&0xff;

#		my $b0=$value&0xff;

#		my $b0123=chr $b0;

#		$b0123.=chr $b1;

#		$b0123.=chr $b2;

#		$b0123.=chr $b3;

#		my $writeres=syswrite OUT, $b0123, 4;

#		if ($writeres != 4) {

#			die "Error writing output file $outputFileName\n";

#		}

#	}

#	exit;

my @splitName=split /(:|\\)/, $outputFileName;

my $rootName=pop @splitName;

my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime;

#print "\n$hour:$min:$sec $mday-$mon-$year wday=$wday, yday=$yday, isdst=$isdst\n\n";

$year+=1900;

print OUT "// $rootName\n";

print OUT "//\n";

print OUT "// Copyright (c) 1999-$year Nokia Corporation and/or its subsidiary(-ies).";

print OUT "// All rights reserved.\n";

print OUT "//\n";

if ($xmode!=2) {

	print OUT "// GENERATED FILE - DO NOT EDIT\n";

	print OUT "//\n";

}

print OUT "\n";

print OUT "#include <kernel/hal_int.h>\n";

if ($xmode==0) {

	print OUT <<EOF;

#ifdef __CW32__

// CodeWarrior requires EXPORT_C on the definiton here, as well as the declaration (in hal_int.h)

EXPORT_C const TInt HalInternal::InitialValue[]=

#else

EXPORT_D const TInt HalInternal::InitialValue[]=

#endif

	{

EOF

	my $i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $separator=($i<$nAttribs)?',':'';

		my $name=$$propRef{'name'};

		my $value=0;

		if (defined $$propRef{'value'}) {

			$value=$$propRef{'value'};

		}

		print OUT "\t$value$separator\t\t// $name\n";

	}

	print OUT "\t};\n";

} elsif ($xmode==1) {

	print OUT "\n";

	my $i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $name=$$propRef{'name'};

		my $imp=$$propRef{'value'};

		if ($imp=~/^\s*0\s*$/) {

			undef $imp;

		}

		if (defined $imp) {

			print OUT "GLREF_C TInt $imp(TInt, TInt, TBool, TAny*);\t// $name\n";

		}

	}

	print OUT "\n";

	print OUT "const TUint8 HalInternal::Properties[]=\n";

	print OUT "\t{\n";

	$i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $separator=($i<$nAttribs)?',':'';

		my $properties="";

		my $name=$$propRef{'name'};

		if (defined $$propRef{'value'}) {

			$properties=$PropTable{'valid'};

			my @keys=keys(%$propRef);

			foreach (@keys) {

				my $pConst=$PropTable{$_};

				if (defined $pConst) {

					$properties.="|$pConst";

				}

			}

		}

		if ($properties=~/^\s*$/) {

			$properties='0';

		}

		print OUT "\t$properties$separator\t\t// $name\n";

	}

	print OUT "\t};\n";

	print OUT "\n#if 0\n";

	print OUT "const TInt HalInternal::Offset[]=\n";

	print OUT "\t{\n";

	my $memOffset=0;

	$i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $separator=($i<$nAttribs)?',':'';

		my $name=$$propRef{'name'};

		my $imp=$$propRef{'value'};

		if ($imp=~/^\s*0\s*$/) {

			print OUT "\t$memOffset$separator\t\t// $name\n";

			$memOffset+=4;

		} else {

			print OUT "\t-1$separator\t\t// $name\n";

		}

	}

	print OUT "\t};\n";

	print OUT "\n#endif\n";

	print OUT "const TInt HalInternal::HalDataSize=$memOffset;\n";

	print OUT "\n";

	print OUT "const THalImplementation HalInternal::Implementation[]=\n";

	print OUT "\t{\n";

	$i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $separator=($i<$nAttribs)?',':'';

		my $name=$$propRef{'name'};

		my $imp=$$propRef{'value'};

		if (!defined $imp or $imp=~/^\s*0\s*$/) {

			$imp='NULL';

		}

		print OUT "\t$imp$separator\t\t// $name\n";

	}

	print OUT "\t};\n";

} elsif ($xmode==2) {

	print OUT "\n";

	$i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $name=$$propRef{'name'};

		my $imp=$$propRef{'value'};

		if ($imp=~/^\s*0\s*$/) {

			undef $imp;

		}

		my $setarg=' /*aSet*/';

		if (defined $$propRef{'settable'}) {

			$setarg=' aSet';

		}

		if (defined $imp) {

			print OUT "// $name\n";

			print OUT "TInt $imp(TInt /*aDeviceNumber*/, TInt /*aAttrib*/, TBool$setarg, TAny* aInOut)\n";

			print OUT "\t{\n";

			print OUT "\treturn KErrNone;\n";

			print OUT "\t}\n";

			print OUT "\n";

		}

	}

	print OUT "\n";

} elsif ($xmode==3) {

	my $hdrprot='__'.uc $rootName.'__';

	$hdrprot=~s/\./_/;

	print OUT "\n";

	print OUT "#ifndef $hdrprot\n";

	print OUT "#define $hdrprot\n";

	$i=0;

	while ($i<$nAttribs) {

		my $propRef=$AttribsByOrdinal[$i];

		++$i;

		my $name=$$propRef{'name'};

		my $imp=$$propRef{'value'};

		if ($imp=~/^\s*0\s*$/) {

			undef $imp;

		}

		if (defined $imp) {

			print OUT "GLREF_C TInt $imp(TInt, TInt, TBool, TAny*);\t// $name\n";

		}

	}

	print OUT "\n";

	print OUT "#endif\n";

}

print OUT "\n";

exit;

# END OF MAIN

sub matchabbrev($$) {

	my ($inref, $lref)=@_;

	my @matches=grep(/$$inref/i,@$lref);

	my $nmatches=scalar(@matches);

	if ($nmatches==0) {

		return "Unknown";

	} elsif ($nmatches>1) {

		my @xmatches=grep(/^$$inref$/i,@matches);

		if (scalar(@xmatches)!=1) {

			return "Ambiguous";

		} else {

			$$inref=$xmatches[0];

			return undef;

		}

	} else {

		$$inref=$matches[0];

		return undef;

	}

}

sub read_file_strip_comments($) {

	my ($filename) = @_;

	open IN, $filename or die "Cannot read file $filename\n";

	my $in;

	while (<IN>) {

		$in .= $_;

	}

	close IN;

	# Strip comments

	$in =~ s/\/\*(.*?)\*\//\n/gms;

	$in =~ s/\/\/(.*?)\n/\n/gms;

	return split(/(\n)/, $in);

}

sub usage() {

	print

		"\n",

		"halcfg.pl is a perl script that is used by the build system to generate the\n",

		"C++ source files from the Config and Values files.\n",

		"\n",

		"There are four modes in which the Perl script halcfg.pl can be used.\n",

		"\n",

		"\"perl halcfg.pl hal_data.h values.hda values.cpp\"\n",

		"\n",

		"takes the values.hda text file and generates a table of initial values for\n",

		"items stored by the HAL.\n",

		"\n",

		"\"perl halcfg.pl -x hal_data.h config.hcf config.cpp\"\n",

		"\n",

		"generates three tables:\n",

		"\n",

		"  - the properties, i.e. whether valid and/or writable, for each item\n",

		"\n",

		"  - the offset of each item within the DllGlobal block\n",

		"\n",

		"  - the function implementing each item, for derived attributes. ie. those\n",

		"    attributes that are not simply stored by the HAL.\n",

		"\n",

		"\"perl halcfg.pl -s hal_data.h config.hcf source.cpp\"\n",

		"\n",

		"generates a source file containing skeleton code for the implementation of the\n",

		"accessor function for each derived attribute\n",

		"\n",

		"\"perl halcfg.pl -h hal_data.h config.hcf header.h\"\n",

		"\n",

		"generates a header file containing prototypes for the accessor functions for\n",

		"each derived attribute\n",

		"\n",

		"Note that the header file hal_data.h containing the attributes and values used\n",

		"by the HAL is passed on all calls to the perl script.\n";

	exit;

}