# Copyright (c) 1995-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:

# e32\kernel\genexec.pl

# Generate user/kernel interface classes from single description file

# Usage:

# perl genexec.pl -i <input file> -e <enum.h> -u <user.h> -k <kernel.h>

# where:	<input file>	is the name of the description file

# <enum.h>		is the name of the generated header file containing the dispatch enumeration

# <user.h>		is the name of the generated header file containing user side interface

# <kernel.h>		is the name of the generated header file containing kernel side interface

# 

#

use Getopt::Long;

use Cwd;

#Getopt::Long::Configure("ignore_case");

my %opts=();

my $result = GetOptions (	\%opts,

							"input=s",

							"enum=s",

							"user=s",

							"kernel=s"

							);

# Bit 0 = argument permitted

# Bit 1 = argument mandatory

# Bit 2 = can be used with fast

# Bit 3 = can be used with slow

# Bit 4 = remember all arguments from repeated use of keyword

my %keywords = (

					'name'			=>	0x0f,

					'number'		=>	0x0f,

					'user'			=>	0x0f,

					'specialuser'	=>	0x0c,

					'kernel'		=>	0x0f,

					'specialkernel'	=>	0x0f,

					'export'		=>	0x0c,

					'return'		=>	0x0d,

					'arg1'			=>	0x0f,

					'arg2'			=>	0x0b,

					'arg3'			=>	0x0b,

					'arg4'			=>	0x0b,

					'karg1'			=>	0x0f,

					'karg2'			=>	0x0b,

					'karg3'			=>	0x0b,

					'karg4'			=>	0x0b,

					'unprotected'	=>	0x08,

					'lock'			=>	0x08,

					'nr'			=>	0x08,

					'handle'		=>	0x0b,

					'asm'			=>	0x0d,

					'hw'			=>	0x0c,

					'emulator'		=>	0x0c,

					'extended'		=>	0x0b,

					'ifdef'			=>	0x1f,

					'ifndef'		=>	0x1f

				);

my %keyword_synonyms = (

					'norelease'		=>	'nr',

					'noemulator'	=>	'hw'

				);

my @keyword_list = keys(%keywords);

my %objects =	(

					'thread'		=>	['EThread','DThread',1],

					'process'		=>	['EProcess','DProcess',1],

					'chunk'			=>	['EChunk','DChunk',1],

					'library'		=>	['ELibrary','DLibrary',1],

					'semaphore'		=>	['ESemaphore','DSemaphore',1],

					'mutex'			=>	['EMutex','DMutex',1],

					'timer'			=>	['ETimer','DTimer',1],

					'server'		=>	['EServer','DServer',1],

					'session'		=>	['ESession','DSession',1],

					'logicaldevice'	=>	['ELogicalDevice','DLogicalDevice',1],

					'physicaldevice'=>	['EPhysicalDevice','DPhysicalDevice',1],

					'logicalchannel'=>	['ELogicalChannel','DLogicalChannelBase',1],

					'changenotifier'=>	['EChangeNotifier','DChangeNotifier',1],

					'undertaker'	=>	['EUndertaker','DUndertaker',1],

					'msgqueue'		=>	['EMsgQueue','DMsgQueue',1],

					'property'		=>	['EPropertyRef','DPropertyRef',1],

					'condvar'		=>	['ECondVar','DCondVar',1],

					'shpool'		=>	['EShPool','DShPool',1],

					'shbuf'			=>	['EShBuf','DShBuf',1],

					'any'			=>	['','DObject',1],

					'ipcmessaged'	=>	['EIpcMessageD','RMessageK',0],

					'ipcmessage'	=>	['EIpcMessage','RMessageK',0],

					'ipcclient'		=>	['EIpcClient','DThread',0]

				);

my %object_synonyms = (

					'ldevice'		=>	'logicaldevice',

					'pdevice'		=>	'physicaldevice',

					'channel'		=>	'logicalchannel',

					'chnotifier'	=>	'changenotifier'

				);

my @object_list = keys(%objects);

my @fast;

my @slow;

my @input;

my $file;

my $line;

my $state = 0;

my $xref;

# need to add drive letter to path of execs.txt as cpp doesn't like

# absolute paths without a drive letter

my $drive = "";

if (($^O eq "" || $^O =~ /mswin32/i) && $opts{input} !~ /^[a-z]:/i)

{

$drive = substr(Cwd::cwd(),0,2);

}

open PIPE, "cpp -I- -I. -lang-c++ $drive$opts{input} | ";

while (<PIPE>)	{

	if (/^\s*\#\s+(\d+)\s+\"(.*?)\"/) {

		$line = $1;

		$file = $2;

		next;

	}

	if (/^\s*$/) {

		++$line;

		next;

	}

	if ($state == 0) {

		my %exec;

		if (/^\s*slow\s*\{\s*$/) {

			$exec{'type'} = 0;

			$exec{'file'} = $file;

			$exec{'line'} = $line;

			$xref = \%exec;

		} elsif (/^\s*fast\s*\{\s*$/) {

			$exec{'type'} = 1;

			$exec{'file'} = $file;

			$exec{'line'} = $line;

			$xref = \%exec;

		} else {

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

		}

		++$state;

	} elsif ($state == 1) {

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

			if ($$xref{'type'}==0) {

				push @slow, $xref;

			} elsif ($$xref{'type'}==1) {

				push @fast, $xref;

			}

			undef $xref;

			$state = 0;

		} else {

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

				my $keyword = $1;

				my $rest = $2;

				my $argument = -1;

				my $match_res = matchabbrev(\$keyword, \@keyword_list, \%keyword_synonyms);

				if ($match_res) {

					die "$match_res keyword $keyword at $file line $line\n";

				}

				my $flags = $keywords{$keyword};

				if ($$xref{'type'}==1 && ($flags&4)==0) {

					die "Keyword $keyword not permitted with FAST exec at $file line $line\n";

				}

				if ($$xref{'type'}==0 && ($flags&8)==0) {

					die "Keyword $keyword not permitted with SLOW exec at $file line $line\n";

				}

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

					die "Missing argument at $file line $line\n" if ($flags & 2);

				} else {

					die "Invalid argument at $file line $line\n" unless ($flags & 1);

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

						$argument = $1;

					} else {

						die "Invalid argument syntax at $file line $line\n";

					}

				}

				if ($keyword eq 'hw') {

					$keyword = 'ifdef';

					$argument = '__EPOC32__';

					$flags = 0x1f;

				} elsif ($keyword eq 'emulator') {

					$keyword = 'ifndef';

					$argument = '__EPOC32__';

					$flags = 0x1f;

				}

				my $existing = $$xref{$keyword};

				if ($flags & 16) {

					if (!defined($existing)) {

						my @kw_args = ();

						$$xref{$keyword} = \@kw_args;

						$existing = \@kw_args;

					}

					push @$existing, $argument;

				} else {

					if (!defined($existing)) {

						$$xref{$keyword} = $argument;

					} else {

						die "Duplicate keyword $keyword at $file line $line\n";

					}

				}

			}

		}

	}

	++$line;

}

close PIPE;

checkexecs(\@fast, 'fast');

checkexecs(\@slow, 'slow');

my @ixfast = sortexecs(\@fast);

my @ixslow = sortexecs(\@slow);

my $fileheader = <<EOF;

//

// Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).All rights reserved.

//

// GENERATED FILE - DO NOT EDIT

//

/**

 * \@file

 * \@internalComponent

 */

EOF

my @enumfile;

push @enumfile, $fileheader;

genenum(\@ixfast, \@enumfile, "TFastExecDispatch");

genenum(\@ixslow, \@enumfile, "TExecDispatch");

my @userfile;

push @userfile, $fileheader;

push @userfile, "class Exec\n\t{\npublic\:\n";

genexecp(\@ixfast, \@userfile);

genexecp(\@ixslow, \@userfile);

push @userfile, "\t\};\n\n";

push @userfile, "#ifdef __GEN_USER_EXEC_CODE__\n";

genuser(\@ixfast, \@userfile);

genuser(\@ixslow, \@userfile);

push @userfile, "#endif\n";

my @kernelfile;

push @kernelfile, $fileheader;

push @kernelfile, "class ExecHandler\n\t{\npublic\:\n";

genexechp(\@ixfast, \@kernelfile);

genexechp(\@ixslow, \@kernelfile);

push @kernelfile, "\t\};\n\n";

push @kernelfile, "#ifdef __GEN_KERNEL_EXEC_CODE__\n";

genkernelfast(\@ixfast, \@kernelfile);

genkernelslow(\@ixslow, \@kernelfile);

push @kernelfile, "#endif\n";

if ($opts{enum}) {

	open FILE, ">$opts{enum}" or die "Can't open file $opts{enum} for write\n";

	print FILE @enumfile;

	close FILE;

}

if ($opts{user}) {

	open FILE, ">$opts{user}" or die "Can't open file $opts{user} for write\n";

	print FILE @userfile;

	close FILE;

}

if ($opts{kernel}) {

	open FILE, ">$opts{kernel}" or die "Can't open file $opts{kernel} for write\n";

	print FILE @kernelfile;

	close FILE;

}

# Match an input string against a list of strings with a list of synonyms.

# Any non-ambiguous abbreviation will be accepted.

# IN:	1st argument is input string

#		2nd argument is reference to match list

#		3rd argument is reference to synonym hash

# OUT:	If match found, return undef and replace first argument with unabbreviated match string

#		If no match found, return "Unknown"

#		If ambiguous input, return "Ambiguous"

#

sub matchabbrev($$$) {

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

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

	my $nmatches = scalar(@matches);

	my $synonym = 0;

	if ($nmatches==0) {

		@matches = grep(/^$$inref/i,keys(%$sref));

		$nmatches = scalar(@matches);

		$synonym = 1;

	}

	return "Unknown" if ($nmatches==0);

	if ($nmatches>1) {

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

		return "Ambiguous" if (scalar(@xmatches)!=1);

		$$inref=$xmatches[0];

	} else {

		$$inref=$matches[0];

	}

	$$inref = $sref->{$$inref} if ($synonym);

	return undef;

}

#

# Check a list of executive calls for bad or missing arguments

# and duplicate definitions.

# Assign executive dispatch numbers.

#

sub checkexecs($$) {

	my ($listref, $listname) = @_;

	my $next_num = 0;

	my @execnum;

	my @execnames;

	foreach(@$listref)	{

		my $xref = $_;

		my $n = $xref->{'number'};

		my $type = $xref->{'type'};

		if ($n) {

			if ($execnum[$n]) {

				die "Duplicate $listname exec number $n at $xref->{'file'} line $xref->{'line'}\n";

			}

			$execnum[$n] = 1;

		}

		my $nm = $xref->{'name'};

		if (!$nm) {

			die "Unnamed $listname exec at $xref->{'file'} line $xref->{'line'}\n";

		} elsif ($nm !~ /^\w+$/) {

			die "Invalid $listname exec name $nm at $xref->{'file'} line $xref->{'line'}\n";

		}

		if ( scalar(grep {$_ eq $nm} @execnames) ) {

			die "Duplicate $listname exec name $nm at $xref->{'file'} line $xref->{'line'}\n";

		}

		push @execnames, $nm;

		$xref->{'enumname'} = ($type==1) ? "EFastExec$nm" : "EExec$nm";

		my $u = $xref->{'user'};

		if ($u) {

			if ($u eq 'special') {

				undef $xref->{'userclass'};

				undef $xref->{'userfunc'};

				$xref->{'specialuser'} = -1;

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

				$xref->{'userclass'} = $1;

				$xref->{'userfunc'} = $u;

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

				$xref->{'userclass'} = '';

				$xref->{'userfunc'} = $1;

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

				$xref->{'userclass'} = $1;

				$xref->{'userfunc'} = "$1::$nm";

			}

		} else {

			$xref->{'userclass'} = 'Exec';

			$xref->{'userfunc'} = "Exec::$nm";

		}

		my $k = $xref->{'kernel'};

		if ($k) {

			if ($k eq 'special') {

				undef $xref->{'kernelclass'};

				undef $xref->{'kernelfunc'};

				if ($type!=1 || $n!=0) {

					die "special kernel only applicable to FAST EXEC 0\n";

				}

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

				$xref->{'kernelclass'} = $1;

				$xref->{'kernelfunc'} = $k;

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

				$xref->{'kernelclass'} = '';

				$xref->{'kernelfunc'} = $1;

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

				$xref->{'kernelclass'} = $1;

				$xref->{'kernelfunc'} = "$1::$nm";

			}

		} else {

			$xref->{'kernelclass'} = 'ExecHandler';

			$xref->{'kernelfunc'} = "ExecHandler::$nm";

		}

		$xref->{'karg1'} = $xref->{'arg1'} if (!defined ($xref->{'karg1'}));

		my $nargs = 0;

		$nargs=1 if (defined $xref->{'karg1'});

		if (!$xref->{'return'}) {

			$xref->{'return'} = 'void';

		}

		$xref->{'nargs'} = $nargs;

		my $spk = $xref->{'specialkernel'};

		if ($spk =~ /(\w+)(\:\:\w+)?/) {

			$xref->{'kerneldispatch'} = $spk;

		} elsif ($spk) {

			die "Invalid function name with SPECIALKERNEL at $xref->{'file'} line $xref->{'line'}\n";

		} else {

			$xref->{'kerneldispatch'} = $xref->{'kernelfunc'};

		}

		next if ($type == 1);		# nothing more to do for fast execs

		$xref->{'karg2'} = $xref->{'arg2'} if (!defined ($xref->{'karg2'}));

		$xref->{'karg3'} = $xref->{'arg3'} if (!defined ($xref->{'karg3'}));

		$xref->{'karg4'} = $xref->{'arg4'} if (!defined ($xref->{'karg4'}));

		my $h = $xref->{'handle'};

		if ($h) {

			my $matchres = matchabbrev(\$h, \@object_list, \%object_synonyms);

			if ($matchres) {

				die "$matchres object type at $xref->{'file'} line $xref->{'line'}\n";

			}

			my $obj_info = $objects{$h};

			my $add_one = $obj_info->[2];

			if ($h eq 'any') {

				$xref->{'handlep'} = "0";

			} else {

				if ($add_one) {

					$xref->{'handlep'} = "$obj_info->[0]+1";

				} else {

					$xref->{'handlep'} = "$obj_info->[0]";

				}

			}

			$xref->{'arg1'} = 'TInt';

			$xref->{'karg1'} = "$obj_info->[1]"."*";

			$xref->{'lock'} = -1;

		}

		$nargs=1 if (defined $xref->{'karg1'});

		$nargs=2 if (defined $xref->{'karg2'});

		$nargs=3 if (defined $xref->{'karg3'});

		$nargs=4 if (defined $xref->{'karg4'});

		$xref->{'nargs'} = $nargs;

		if ($xref->{'nr'} && !$xref->{'lock'}) {

			die "NR without LOCK/HANDLE at $xref->{'file'} line $xref->{'line'}\n";

		}

		if ($xref->{'unprotected'} && $xref->{'lock'}) {

			die "UNPROTECTED and LOCK/HANDLE incompatible at $xref->{'file'} line $xref->{'line'}\n";

		}

		my $ext = $xref->{'extended'};

		if ($ext) {

			if ( ($ext !~ /^\d$/) || $ext<2 || $ext2>8) {

				die "Invalid argument to EXTENDED at $xref->{'file'} line $xref->{'line'}\n";

			} elsif ($nargs<3) {

				die "Need >=3 normal arguments with EXTENDED at $xref->{'file'} line $xref->{'line'}\n";

			}

		}

	}

	foreach(@$listref)	{

		my $xref = $_;

		my $n = $xref->{'number'};

		unless ($n) {

			while ($execnum[$next_num]) {

				++$next_num;

			}

			$xref->{'number'} = $next_num++;

		}

	}

}

#

# Return a list of execs indexed by dispatch number

# Include gaps for nonexistent ones

#

sub sortexecs($) {

	my ($listref) = @_;

	my @indexed;

	my $xref;

	foreach $xref (@$listref) {

		my $n = $xref->{'number'};

		$indexed[$n] = $xref;

	}

	return @indexed;

}

#

# Generate enum definition

#

sub genenum($$$) {

	my ($srcref, $destref, $enumname) = @_;

	push @$destref, "\nenum $enumname\n\t\{\n";

	my $n;

	my $xref;

	for ($n=0; $n<scalar(@$srcref); ++$n) {

		$xref = $$srcref[$n];

		if ($xref) {

			push @$destref, "\t$xref->{'enumname'} = $n,\n";

		}

	}

	push @$destref, "\t\};\n";

}

#

# Output Exec class prototypes

#

sub genexecp($$) {

	my ($srcref, $destref) = @_;

	my $n;

	my $xref;

	for ($n=0; $n<scalar(@$srcref); ++$n) {

		$xref = $$srcref[$n];

		if ($xref && $xref->{'userclass'} eq 'Exec') {

			$xref->{'userfunc'} =~ /^Exec\:\:(\w+)$/;

			my $fdecl = "\t";

			$fdecl .= "IMPORT_C " if ($xref->{'export'});

			$fdecl .= "static $xref->{'return'} $1\(";

			$fdecl .= $xref->{'arg1'} if ($xref->{'arg1'});

			$fdecl .= ", $xref->{'arg2'}" if ($xref->{'arg2'});

			$fdecl .= ", $xref->{'arg3'}" if ($xref->{'arg3'});

			$fdecl .= ", $xref->{'arg4'}" if ($xref->{'arg4'});

			$fdecl .= "\);\n";

			push @$destref, $fdecl;

		}

	}

}

#

# Output ExecHandler class prototypes

#

sub genexechp($$) {