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

# 

#

use strict;

package CheckBc;

#

# Public.

#

sub New {

  my $pkg = shift;

  my $self = {};

  bless $self, $pkg;

  my $bldInfDir1 = shift;

  my $bldInfDir2 = shift;

  Utils::AbsoluteFileName(\$bldInfDir1);

  Utils::AbsoluteFileName(\$bldInfDir2);

  $self->{verbose} = shift;

  $self->{compName} = shift;

  $self->{additionalHeaders} = shift;

  $self->{additionalIncludePaths} = shift;

  my $ignoreClasses = shift;

  foreach my $thisClass (@$ignoreClasses) {

    $self->{ignoreClasses}->{$thisClass} = 1;

  }

  $self->{ignoreR3Unused} = shift;

  $self->{bldInf1} = BldInf->New($bldInfDir1, $self->{verbose});

  $self->{bldInf2} = BldInf->New($bldInfDir2, $self->{verbose});

  return $self;

}

sub CheckAll {

  my $self = shift;

  my $passed = 1;

  unless ($self->CheckDefFiles()) {

    $passed = 0;

  }

  unless ($self->CheckClassSizes()) {

    $passed = 0;

  }

  unless ($self->CheckVTables()) {

    $passed = 0;

  }

  return $passed;

}

sub CheckDefFiles {

  my $self = shift;

  return $self->{bldInf1}->CheckDefFiles($self->{bldInf2}, $self->{ignoreR3Unused});

}

sub CheckClassSizes {

  my $self = shift;

  my $classSizes1 = $self->GetClassSizes($self->{bldInf1});

  my $classSizes2 = $self->GetClassSizes($self->{bldInf2});

  return $classSizes1->Check($classSizes2);

}

sub CheckVTables {

  my $self = shift;

  my $vtable1 = $self->GetVTable($self->{bldInf1});

  my $vtable2 = $self->GetVTable($self->{bldInf2});

  return $vtable1->Check($vtable2);

}

#

# Private.

#

sub GetClassSizes {

  my $self = shift;

  my $bldInf = shift;

  my $constructorsToCheck = $self->GetConstructorsToCheck($bldInf->ListConstructors());

  my @headers;

  if ($self->{additionalHeaders}) {

    push (@headers, @{$self->{additionalHeaders}});

  }

  foreach my $thisExport (@{$bldInf->ListExports()}) {

    if ($thisExport =~ /\.h$/i) {

      push (@headers, $thisExport);

    }

  }

  my $includes = $bldInf->ListIncludes();

  if ($self->{additionalIncludePaths}) {

    push (@$includes, @{$self->{additionalIncludePaths}});

  }

  return ClassSize->New($constructorsToCheck, \@headers, $includes, $self->{verbose}, $self->{compName}, $bldInf->{dir});

}

sub GetVTable {

  my $self = shift;

  my $bldInf = shift;

  my $constructorsToCheck = $self->GetConstructorsToCheck($bldInf->ListConstructors());

  return VTable->New($bldInf->{dir}, $constructorsToCheck, $self->{verbose});

}

sub GetConstructorsToCheck {

  my $self = shift;

  my $constructors = shift;

  my @constructorsToCheck;

  foreach my $thisConstructor (@$constructors) {

    unless (exists $self->{ignoreClasses}->{$thisConstructor}) {

      push (@constructorsToCheck, $thisConstructor);

    }

  }

  return \@constructorsToCheck;

}

#

# BldInf

#

package BldInf;

#

# Public.

#

sub New {

  my $pkg = shift;

  my $self = {};

  bless $self, $pkg;

  $self->{dir} = shift;

  $self->{verbose} = shift;

  $self->Parse();

  return $self;

}

sub CheckDefFiles {

  my $self = shift;

  my $other = shift;

  my $ignoreR3Unused = shift;

  my $passed = 1;

  foreach my $thisMmp (keys %{$self->{mmps}}) {

    if (exists $other->{mmps}->{$thisMmp}) {

      unless ($self->{mmps}->{$thisMmp}->CheckDefFile($other->{mmps}->{$thisMmp}, $ignoreR3Unused)) {

	$passed = 0;

      }

    }

    else {

      print "Mmp file \"$thisMmp\" missing for bld.inf \"$other->{dir}\"\n";

      $passed = 0;

    }

  }

  return $passed;

}

sub ListConstructors {

  my $self = shift;

  my @constructors = ();

  foreach my $thisMmp (keys %{$self->{mmps}}) {

    push (@constructors, @{$self->{mmps}->{$thisMmp}->ListConstructors()});

  }

  return \@constructors;

}

sub ListExports {

  my $self = shift;

  if (exists $self->{exports}) {

    return $self->{exports};

  }

  return [];

}

sub ListIncludes {

  my $self = shift;

  my %includes = ();

  foreach my $thisMmp (keys %{$self->{mmps}}) {

    foreach my $thisInclude (@{$self->{mmps}->{$thisMmp}->ListIncludes()}) {

      $includes{$thisInclude} = 1;

    }

  }

  my @includes = keys %includes;

  return \@includes;

}

#

# Private.

#

sub Parse {

  my $self = shift;

  if ($self->{verbose}) {  print "Parsing $self->{dir}\\bld.inf...\n"; }

  Utils::PushDir($self->{dir});

  my $fullName = "$self->{dir}\\bld.inf";

  unless (open (BLDINF, "cpp -DARM -DMARM $fullName|")) {

    Utils::PopDir();

    die "Error: Couldn't open \"cpp -DARM -DMARM $fullName\": $!\n";

  }

  my $foundMmps = 0;

  my $foundExports = 0;

  my $doDie = 0;

  my $currentDir = $self->{dir};

  while (my $line = <BLDINF>) {

    if ($line =~ /^# \d+ "(.*)" \d+?/) {

	my $newFile = $1;

	$newFile =~ s/\\\\/\\/g;

	$newFile =~ s/\\$//;

	Utils::AbsoluteFileName(\$newFile);

	($currentDir) = Utils::SplitFileName($newFile);

	next;

      }

    if ($line =~ /^#/ or $line =~ /^\s*$/) {	

	# Ignore lines starting with '#' or those filled with white space.

	next;

      }

    chomp $line;

    if ($line =~ /PRJ_MMPFILES/i) {

      $foundMmps = 1;

      $foundExports = 0;

      next;

    }

    elsif ($line =~ /PRJ_EXPORTS/i) {

      $foundMmps = 0;

      $foundExports = 1;

      next;

    }

    elsif ($line =~ /PRJ_/i) {

      $foundMmps = 0;

      $foundExports = 0;

      next;

    }

    if ($foundMmps) {

      if ($line =~ /makefile\s+(\S+)/i) {

	if ($self->{verbose}) { print "Info: \"makefile $1\" found in \"$self->{dir}\\bld.inf\", ignoring.\n"; }

	next;

      }

      $line =~ /\s*(\S+)/;

      my $mmpName = lc($1);

      if (not $mmpName =~ /\.mmp$/) {

	$mmpName .= '.mmp';

      }

      unless (-e $mmpName) {

	if (-e "$currentDir\\$mmpName") {

	  $mmpName = "$currentDir\\$mmpName";

	}

	elsif (-e "$self->{dir}\\$mmpName") {

	  $mmpName = "$self->{dir}\\$mmpName";

	}

	else {

	  print "Warning: Couldn't find location of \"$mmpName\n";

	  next;

	}

      }

      Utils::AbsoluteFileName(\$mmpName);

      (my $path, my $name, my $ext) = Utils::SplitFileName($mmpName);

      eval {

	$self->{mmps}->{lc("$name$ext")} = Mmp->New($mmpName, $self->{verbose});

      };

      if ($@) {

	$doDie = 1;

	print "$@";

      }

      next;

    }

    elsif ($foundExports) {

      my $thisExport;

      if ($line =~  /^\s*\"([^\"]*)/) {

	$thisExport = $1;

      }

      elsif ($line =~ /\s*(\S+)/) {

	$thisExport = $1;

      }

      else {

	die;

      }

      unless (-e $thisExport) {

	if (-e "$currentDir\\$thisExport") {

	  $thisExport = "$currentDir\\$thisExport";

	}

	elsif (-e "$self->{dir}\\$thisExport") {

	  $thisExport = "$self->{dir}\\$thisExport";

	}

	else {

	  print "Warning: Couldn't find location of \"$thisExport\n";

	  next;

	}

      }

      Utils::AbsoluteFileName(\$thisExport);

      push (@{$self->{exports}}, $thisExport);

    }

  }

  close (BLDINF);

  Utils::PopDir();

  if ($doDie) {

    die "Aborting due to above errors\n";

  }

}

#

# Mmp

#

package Mmp;

#

# Public.

#

sub New {

  my $pkg = shift;

  my $self = {};

  bless $self, $pkg;

  $self->{name} = shift;

  $self->{verbose} = shift;

  $self->Parse();

  return $self;

}

sub CheckDefFile {

  my $self = shift;

  my $other = shift;

  my $ignoreR3Unused = shift;

  if ($self->{def}) {

    return $self->{def}->Check($other->{def}, $ignoreR3Unused);

  }

  return 1;

}

sub ListConstructors {

  my $self = shift;

  if ($self->{def}) {

    return $self->{def}->ListConstructors();

  }

  return [];

}

sub ListIncludes {

  my $self = shift;

  if (exists $self->{includes}) {

    my @includes = keys %{$self->{includes}};

    return \@includes;

  }

  return [];

}

#

# Private.

#

sub Parse {

  my $self = shift;

  if ($self->{verbose}) {  print "Parsing $self->{name}...\n"; }

  (my $path) = Utils::SplitFileName($self->{name});

  $path =~ s/(.*)\\.*/$1/; # Extract path.

  Utils::PushDir($path);

  unless (open (MMP, "cpp -DARM -DMARM $self->{name}|")) {

    Utils::PopDir();

    die "Error: Couldn't open \"cpp -DARM -DMARM $self->{name}\": $!\n";

  }

  my $noStrictDef = 0;

  my $targetType = '';

  while (my $line = <MMP>) {

    if ($line =~ /^#/ or $line =~ /^\s*$/) {	

	# Ignore lines starting with '#' or those filled with white space.

	next;

      }

    chomp $line;

    if ($line =~ /^\s*targettype\s+(\S*)\s*$/i) {

	$targetType = $1;

    }

    elsif ($line =~ /^\s*deffile\s+(\S*)\s*$/i) {

      die if exists $self->{defFileName};

      $self->{defFileName} = $1;

    }	 

    elsif ($line =~ /nostrictdef/i) {

      $noStrictDef = 1;

    }

    elsif ($line =~ /^\s*userinclude\s+(.+)/i) {

      my @userIncludes = split (/\s+/, $1);

      foreach my $thisUserInclude (@userIncludes) {

	$thisUserInclude =~ s/\+/$ENV{EPOCROOT}epoc32/;

	Utils::AbsoluteFileName(\$thisUserInclude);

	$self->{includes}->{lc($thisUserInclude)} = 1;

      }

    }

    elsif ($line =~ /^\s*systeminclude\s+(.+)/i) {

      my @systemIncludes = split (/\s+/, $1);

      foreach my $thisSystemInclude (@systemIncludes) {

	$thisSystemInclude =~ s/\+/$ENV{EPOCROOT}epoc32/;

	Utils::AbsoluteFileName(\$thisSystemInclude);

	$self->{includes}->{lc($thisSystemInclude)} = 1;

      }

    }

  }

  close (MMP);

  if ($targetType =~ /^(app|ani|ctl|ctpkg|epocexe|exe|exedll|fsy|kdll|kext|klib|ldd|lib|ecomiic|mda|mdl|notifier|opx|pdd|pdl|rdl|var|wlog)$/i) {

    # Don't bother looking for the deffile.

    Utils::PopDir();

    return;

  }

  (my $mmpPath, my $mmpBase) = Utils::SplitFileName($self->{name});

  if (exists $self->{defFileName}) {

    (my $path, my $base, my $ext) = Utils::SplitFileName($self->{defFileName});

    if ($base eq '') {

      $base = $mmpBase;

    }

    if ($ext eq '') {

      $ext = '.def';

    }

    if ($path eq '') {

      $path = $mmpPath;

    }

    unless ($noStrictDef) {

      $base .= 'u';

    }

    unless (-e "$path$base$ext") {

      $path = "$path..\\bmarm\\";

    }

    unless (-e "$path$base$ext") {

      $path = $mmpPath . $path;

    }

    $self->{defFileName} = "$path$base$ext";

    Utils::AbsoluteFileName(\$self->{defFileName});

  }

  else {

    # Assume default.

    $self->{defFileName} = $mmpBase;

    unless ($noStrictDef) {	

      $self->{defFileName} .= 'u';

    }

    $self->{defFileName} .= '.def';

    $self->AddDefaultDefFilePath();

  }

  if ($self->{defFileName}) {

    $self->{def} = Def->New($self->{defFileName}, $self->{verbose});

  }

  Utils::PopDir();

}

sub AddDefaultDefFilePath {

  my $self = shift;

  (my $path) = Utils::SplitFileName($self->{name});

  $self->{defFileName} = "$path\\..\\bmarm\\$self->{defFileName}";

  if (-e $self->{defFileName}) {

    Utils::AbsoluteFileName(\$self->{defFileName});

  }

  else {

    print "Warning: Unable to find def file in \"$self->{name}\"\n";

    delete $self->{defFileName};

  }

}

#

# Def

#

package Def;

#

# Public.

#

sub New {

  my $pkg = shift;

  my $self = {};

  bless $self, $pkg;

  $self->{name} = shift;

  $self->{verbose} = shift;

  $self->Parse();

  $self->DemangleNames();

  return $self;

}

sub Check {

  my $self = shift;

  my $other = shift;

  my $ignoreR3Unused = shift;

  if ($self->{verbose}) { print "Checking DEF file \"$self->{name}\" against \"$other->{name}\"...\n"; }

  my $passed = 1;

  if (exists $self->{data}) {

    for (my $ii = 0; $ii < scalar(@{$self->{data}}); ++$ii) {

      my $ordinal = $ii + 1;

      if ($ii >= scalar @{$other->{data}}) {

	print "Failure reason: \"$self->{name}\" has more exports than \"$other->{name}\"\n";

	$passed = 0;

	last;

      }

      my $selfRaw = $self->{data}->[$ii]->{raw};

      my $otherRaw = $other->{data}->[$ii]->{raw};

      if ($ignoreR3Unused) {

	$selfRaw =~ s/R3UNUSED //;

	$otherRaw =~ s/R3UNUSED //;

      }

      unless ($selfRaw eq $otherRaw) {

	$passed = 0;

	print "Failure reason: Def file mismatch between \"$self->{name}\" and \"$other->{name}\" at $ordinal\n";

	if ($self->{verbose}) {

	  print "\t$self->{data}->[$ii]->{raw}\n\t$other->{data}->[$ii]->{raw}\n";

	}

      }

    }

  }

  return $passed;

}

sub ListConstructors {