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

 }