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

# All rights reserved.

# This component and the accompanying materials are made available

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

# e32toolp\e32util\h2inc.pl

# Convert structures in C++ include files to assembler format

# Syntax:

# perl h2inc.pl <input.h> <output.inc> <format>

# where <format>=arm or x86

# 

#

%basictypes = (

	TInt8		=>	1,

	TUint8		=>	1,

	TInt16		=>	2,

	TUint16		=>	2,

	TInt32		=>	4,

	TUint32		=>	4,

	TInt		=>	4,

	TUint		=>	4,

	TInt64		=>	8,

	TUint64		=>	8,

	TLinAddr	=>	4,

	TVersion	=>	4,

	TPde		=>	4,

	TPte		=>	4,

	TProcessPriority => 4

);

if (scalar(@ARGV)!=3) {

	die "perl h2inc.pl <input.h> <output.inc> <format>\n";

}

my ($infile, $outfile, $format) = @ARGV;

open IN, $infile or die "Can't open $infile for input\n";

my $in;

while (<IN>) {

	$in.=$_;

}

close IN;

$format = uc($format);

$format_sub = undef();

$comment_sub = undef();

$end_sub = undef();

if ($format eq "ARMASM") {

	$format_sub = \&armasm_format;

	$comment_sub = \&armasm_comment;

	$end_sub = \&armasm_end;

} elsif ($format eq "AS") {

	$format_sub = \&as_format;

	$comment_sub = \&as_comment;

	$end_sub = \&as_end;

} elsif ($format eq "TASM") {

	$format_sub = \&tasm_format;

	$comment_sub = \&tasm_comment;

	$end_sub = \&tasm_end;

} else {

	die "Format $format unknown\nOnly ARMASM, AS or TASM supported\n";

}

# First remove any backslash-newline combinations

$in =~ s/\\\n//gms;

# Change escaped quotes to double quotes

$in =~ s/\\\"/\"\"/gms;

$in =~ s/\\\'/\'\'/gms;

# Remove any character constants

$in =~  s/\'(.?(${0})*?)\'//gms;

# Remove any string literals

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

# Strip comments

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

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

# Collapse whitespace into a single space or newline

$in =~ s/\t/\ /gms;

$in =~ s/\r/\ /gms;

$in =~ s/(\ )+/\ /gms;

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

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

# Tokenize on non-identifier characters

my @tokens0 = split(/(\W)/,$in);

my @tokens;

foreach $t (@tokens0) {

	next if ($t eq " " or $t eq "");

	push @tokens, $t;

}

my %macros;

my %filescope;

$filescope{file}=1;

$filescope{name}='*** FILE SCOPE ***';

my @ftypedefs;

$filescope{typedefs}=\@ftypedefs;

my $line=1;

parse_scope(\%filescope, \@tokens, \$line);

my @output;

push @output, &$comment_sub('*' x 80);

push @output, &$comment_sub($outfile);

push @output, &$comment_sub('*' x 80);

push @output, &$comment_sub("GENERATED FILE - DO NOT EDIT");

push @output, "";

output_scope(\%filescope, \@output);

push @output, &$end_sub();

push @output, "";

open OUT, ">$outfile" or die "Can't open $outfile for write\n";

print OUT join("\n", @output);

print OUT "\n\n";

close OUT;

sub get_token($$) {

	my ($tokenlist,$line) = @_;

	while (scalar(@$tokenlist)) {

		my $t = shift @$tokenlist;

		return $t if (!defined($t));

		return $t if ($t !~ /^\s*$/);

		++$$line;

	}

}

sub skip_qualifiers($) {

	my ($tokens) = @_;

	my $f=0;

	my %quals = (

		EXPORT_C => 1,

		IMPORT_C => 1,

		inline => 1,

		const => 0,

		volatile => 0,

		static => 0,

		extern => 0,

		LOCAL_C => 0,

		LOCAL_D => 0,

		GLDEF_C => 0,

		GLREF_C => 0,

		GLDEF_D => 0,

		GLREF_D => 0

		);

	for (;;) {

		my $t = $$tokens[0];

		my $q = $quals{$t};

		last unless (defined ($q));

		$f |= $q;

		shift @$tokens;

	}

	return $f;

}

sub parse_indirection($) {

	my ($tokens) = @_;

	my $level = 0;

	for (;;) {

		my $t = $$tokens[0];

		if ($t eq '*') {

			++$level;

			shift @$tokens;

			next;

		}

		last if ($t ne "const" and $t ne "volatile");

		shift @$tokens;

	}

	return $level;

}

sub parse_scope($$$) {

	my ($scope, $tokens, $line) = @_;

	my $state = 0;

	my %values;

	my @classes;

	my @enums;

	my $curr_offset=0;

	my $overall_align=0;

	$scope->{values}=\%values;

	$scope->{classes}=\@classes;

	$scope->{enums}=\@enums;

	while (scalar(@$tokens)) {

		my $t = shift @$tokens;

		if ($state>=-1 and $t eq "\n") {

			++$$line;

			$state=1;

			next;

		} elsif ($state==-1 and $t ne "\n") {

			next;

		} elsif ($state==-2 and $t ne ';') {

			next;

		}

		if ($state>0 and $t eq '#') {

			if ($scope->{scope}) {

				warn "Preprocessor directive in class/struct at line $$line\n";

			}

			$t = shift @$tokens;

			if ($t eq 'define') {

				my $ident = shift @$tokens;

				my $defn = shift @$tokens;

				if ($defn ne '(') {	# don't do macros with parameters

					$macros{$ident} = $defn;

				}

			}

			$state=-1;	# skip to next line

			next;

		}

		if ($t eq "struct" or $t eq "class") {

			next if ($state==0);

			$state=0;

			my %cl;

			$cl{specifier}=$t;

			$cl{scope}=$scope;

			my @members;

			my @typedefs;

			$cl{members}=\@members;

			$cl{typedefs}=\@typedefs;

			my $new_class = \%cl;

			my $n = get_token($tokens,$line);

			if ($n !~ /\w+/) {

				die "Unnamed $t not supported at line $$line\n";

			}

			$new_class->{name}=$n;

			my @class_match = grep {$_->{name} eq $n} @classes;

			my $exists = scalar(@class_match);

			my $b = get_token($tokens,$line);

			if ($b eq ':') {

				die "Inheritance not supported at line $$line\n";

			} elsif ($b eq ';') {

				# forward declaration

				push @classes, $new_class unless ($exists);

				next;

			} elsif ($b ne '{') {

				die "Syntax error at line $$line\n";

			}

			if ($exists) {

				$new_class = $class_match[0];

				if ($new_class->{complete}) {

					die "Duplicate definition of $cl{specifier} $n\n";

				}

			}

			push @classes, $new_class unless ($exists);

			parse_scope($new_class, $tokens, $line);

			next;

		} elsif ($t eq "enum") {

			$state=0;

			my $n = get_token($tokens,$line);

			my $name="";

			if ($n =~ /\w+/) {

				$name = $n;

				$n = get_token($tokens,$line);

			}

			push @enums, $name;

			if ($n ne '{') {

				die "Syntax error at line $$line\n";

			}

			parse_enum($scope, $tokens, $line, $name);

			next;

		} elsif ($t eq '}') {

			$state=0;

			if ($scope->{scope}) {

				$t = get_token($tokens,$line);

				if ($t eq ';') {

					$scope->{complete}=1;

					last;

				}

			}

			die "Syntax error at line $$line\n";

		}

		$state=0;

		if ($scope->{scope}) {

			if ($t eq "public" or $t eq "private" or $t eq "protected") {

				if (shift (@$tokens) eq ':') {

					next;	# ignore access specifiers

				}

			die "Syntax error at line $$line\n";

			}

		}

		unshift @$tokens, $t;

		my @currdecl = parse_decl_def($scope, $tokens, $line);

		if ($t eq 'static') {

			next;	# skip static members

		}

		my $typedef;

		if ($t eq 'typedef') {

			$typedef = 1;

			$t = shift @currdecl;

			$t = $currdecl[0];

		} else {

			$typedef = 0;

		}

		next if (scalar(@currdecl)==0);

		if ($t eq "const") {

			# check for constant declaration

			my $ctype = lookup_type($scope, $currdecl[1]);

			if ($ctype->{basic} and $currdecl[2]=~/^\w+$/ and $currdecl[3] eq '=') {

				if ($typedef!=0) {

					die "Syntax error at line $$line\n";

				}

				shift @currdecl;

				shift @currdecl;

				my $type = $ctype->{name};

				my $name = shift @currdecl;

				my $size = $ctype->{size};

				shift @currdecl;

				my $value = get_constant_expr($scope,\@currdecl,$line);

				$values{$name} = {type=>$type, size=>$size, value=>$value};

				next;

			}

		}

		if (skip_qualifiers(\@currdecl)!=0 or ($scope->{file} and !$typedef)) {

			next;	# function declaration or stuff at file scope

		}

		my $type1 = shift @currdecl;	# type, type pointed to or return type

		if ($type1 !~ /^\w+$/) {

			die "Syntax error at line $$line\n";

		}

		my $ind1 = parse_indirection(\@currdecl);

		my $ident;	# identifier being declared

		my $size = -1;

		my $array = -1;

		my $align = 0;

		my $alias;

		my $category;

		if ($currdecl[0] eq '(' and $currdecl[1] eq '*' and $currdecl[2]=~/^\w+$/) {

			# function pointer

			$ident = $currdecl[2];

			$size = 4;

			$category = 'fptr';

			shift @currdecl;

			shift @currdecl;

			shift @currdecl;

		} elsif ($currdecl[0]=~/^\w+$/) {

			$ident = shift @currdecl;

			if ($currdecl[0] ne '(') {

				# not function declaration

				if ($ind1>0) {

					# pointer

					$category = 'ptr';

					$size = 4;

				} else {

					my $type2 = lookup_type($scope, $type1);

					if (!defined($type2)) {

						die "Unrecognised type $type1 at line $$line\n";

					}

					if ($type2->{basic}) {

						$alias = $type2->{name};

						$size = $type2->{size};

						$category = 'basic';

					} elsif ($type2->{enum}) {

						$alias = $type2->{name};

						$category = 'enum';

						$size = 4;

					} elsif ($type2->{class}) {

						$alias = $type2->{name};

						$size = $type2->{class}->{size};

						$category = 'class';

						$align = $type2->{class}->{align};

					} elsif ($type->{ptr}) {

						$size = 4;

						$category = 'ptr';

						$align = 4;

					} elsif ($type->{fptr}) {

						$size = 4;

						$category = 'ptr';

						$align = 4;

					}

				}

			}

		}

		if ($size>0) {

			# data member declared

			# check for array

			if ($currdecl[0] eq '[') {

				shift @currdecl;

				$array = get_constant_expr($scope, \@currdecl, $line);

				if ($array<=0) {

					die "Bad array size at line $$line\n";

				}

				if ($currdecl[0] ne ']') {

					die "Syntax error at line $$line\n";

				}

			}

			my $members = $scope->{members};

			my $typedefs = $scope->{typedefs};

			if ($align==0) {

				$align = $size;

			}

			my $am = $align-1;

			unless ($typedef) {

				my $al = $curr_offset & $am;

				if ($align==8 and $al!=0) {

					die "Bad alignment of 64-bit data $ident at line $$line\n";

				}

				$curr_offset += ($align-$al) if ($al!=0);

			}

			if ($array>0) {

				$size = ($size + $am) &~ $am;

				if ($typedef) {

					push @$typedefs, {name=>$ident, category=>$category, alias=>$alias, size=>$size*$array, spacing=>$size, array=>$array};

				} else {

					push @$members, {name=>$ident, size=>$size*$array, offset=>$curr_offset, spacing=>$size};

				}

				$size *= $array;

			} else {

				if ($typedef) {

					push @$typedefs, {name=>$ident, category=>$category, alias=>$alias, size=>$size};

				} else {

					push @$members, {name=>$ident, size=>$size, offset=>$curr_offset};

				}

			}

			unless ($typedef) {

				$curr_offset += $size;

				if ($align > $overall_align) {

					$overall_align = $align;

				}

			}

		}

	}

	if ($scope->{scope}) {

		if ($state==-2) {

			die "Missing ; at end of file\n";

		}

		if (!$scope->{complete}) {

			die "Unexpected end of file at line $$line\n";

		}

		my $total_size = ($curr_offset + $overall_align - 1) &~ ($overall_align - 1);

		$scope->{size} = $total_size;

		$scope->{align} = $overall_align;

	}

}

sub get_operand($$$) {

	my ($scope,$tokens,$line) = @_;

	my $t = get_token($tokens,$line);

	if ($t eq '-') {

		my $x = get_operand($scope,$tokens,$line);

		return -$x;

	} elsif ($t eq '+') {

		my $x = get_operand($scope,$tokens,$line);

		return $x;

	} elsif ($t eq '~') {

		my $x = get_operand($scope,$tokens,$line);

		return ~$x;

	} elsif ($t eq '!') {

		my $x = get_operand($scope,$tokens,$line);

		return $x ? 0 : 1;

	} elsif ($t eq '(') {

		my $x = get_constant_expr($scope,$tokens,$line);

		my $t = get_token($tokens,$line);

		if ($t ne ')') {

			die "Missing ) at line $$line\n";

		}

		return $x;

	} elsif ($t eq "sizeof") {

		my $ident = get_token($tokens,$line);

		if ($ident eq '(') {

			$ident = get_token($tokens,$line);

			my $cb = get_token($tokens,$line);

			if ($cb ne ')') {

				die "Bad sizeof() syntax at line $$line\n";

			}

		}

		$ident = look_through_macros($ident);

		if ($ident !~ /^\w+$/) {

			die "Bad sizeof() syntax at line $$line\n";

		}

		my $type = lookup_type($scope, $ident);

		if (!defined $type) {

			die "Unrecognised type $ident at line $$line\n";

		}

		if ($type->{basic}) {

			return $type->{size};

		} elsif ($type->{enum}) {

			return 4;

		} elsif ($type->{ptr}) {

			return 4;

		} elsif ($type->{fptr}) {

			return 4;

		}

		my $al = $type->{class}->{align};

		my $sz = $type->{class}->{size};

		return ($sz+$al-1)&~($al-1);

	}

	$t = look_through_macros($t);

	if ($t =~ /^0x[0-9a-f]+/i) {

		return oct($t);

	} elsif ($t =~ /^\d/) {

		return $t;

	} elsif ($t =~ /^\w+$/) {

		my $x = lookup_value($scope,$t);

		die "Unrecognised identifier '$t' at line $$line\n" unless defined($x);

		return $x;

	} else {

		die "Syntax error at line $$line\n";

	}

}

sub look_through_macros($) {

	my ($ident) = @_;

	while ($ident and $macros{$ident}) {

		$ident = $macros{$ident};

	}

	return $ident;

}

sub lookup_value($$) {

	my ($scope,$ident) = @_;

	while ($scope) {

		my $vl = $scope->{values};

		if (defined($vl->{$ident})) {

			return $vl->{$ident}->{value};

		}

		$scope = $scope->{scope};

	}

	return undef();