# 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 {
  my $self = shift;
  my @constructors = ();
  if (exists $self->{data}) {
    my $ordinal = 0;
    foreach my $thisEntry (@{$self->{data}}) {
      $ordinal++;
      die unless (exists $thisEntry->{function});
      if ($thisEntry->{function} =~ /(.+)::(.+)\(/) {
	if ($1 eq $2) {
	  push (@constructors, $1);
	}
      }
    }
  }
  return \@constructors;
}


#
# Private.
#

sub Parse {
  my $self = shift;
  open (DEF, $self->{name}) or die "Error: Couldn't open \"$self->{name}\" for reading: $!\n";
  my $lineNum = 0;
  while (my $thisLine = <DEF>) {
    ++$lineNum;
    chomp $thisLine;
    if ($thisLine =~ /^(EXPORTS|;|\s*$)/) {
      next;
    }
	my $entry = {};
    $entry->{raw} = $thisLine;
	     
    push (@{$self->{data}}, $entry);
  }
      close (DEF);
}

sub DemangleNames {
  my $self = shift;
  open (FILT, "type $self->{name} | c++filt |") or die "Error: Couldn't open \"type $self->{name} | c++filt |\": $!\n";
  my $lineNum = 0;
  while (my $line = <FILT>) {
    ++$lineNum;
    chomp $line;
    next if ($line =~ /^(EXPORT|;|\s*$)/);
    if ($line =~ /^\s+(\"(.+)\"|(.+)) @ (\d+)/) {
      my $function;
      if ($2) {
	$function = $2;
      }
      else {
	die unless $3;
	$function = $3;
      }
      my $ordinal = $4;
      $self->{data}->[$ordinal - 1]->{function} = $function;
    }
    else {
      die "Error: Unable to parse c++filt output for \"$self->{name}\" at line $lineNum\n";
    }
  }
  close (FILT);
}


#
# ClassSize
#

package ClassSize;


#
# Public.
#

sub New {
  my $pkg = shift;
  my $self = {};
  bless $self, $pkg;
  $self->{classes} = shift;
  $self->{headers} = shift;
  $self->{includes} = shift;
  $self->{verbose} = shift;
  $self->{compName} = shift;
  $self->{bldInfDir} = shift;
  if (scalar @{$self->{classes}} > 0) {
    $self->GetClassSizes();
  }
  return $self;
}

sub Check {
  my $self = shift;
  my $other = shift;
  if ($self->{verbose}) { print "Comparing class sizes of \"$self->{bldInfDir}\" against \"$other->{bldInfDir}\"..\n"; }
  my $passed = 1;
  foreach my $thisClass (keys %{$self->{classSizes}}) {
    if ($self->{verbose}) { print "Examining class sizes of \"$thisClass\"...\n"; }
    unless (exists $other->{classSizes}->{$thisClass}) {
      print "Failure reason: \"$thisClass\" not found (possibly renamed)\n";
      $passed = 0;
      next;
    }
    unless ($self->{classSizes}->{$thisClass} == $other->{classSizes}->{$thisClass}) {
      $passed = 0;
      print "Failure reason: Class \"$thisClass\" has changed size from $self->{classSizes}->{$thisClass} to $other->{classSizes}->{$thisClass}\n";
    }
  }
  return $passed;
}


#
# Private.
#

sub GetClassSizes {
  my $self = shift;
  eval {
    $self->GenerateCode();
    $self->CompileCode();
    $self->GetOutput();
  };
  $self->CleanUp();
  if ($@) {
    die $@;
  }
}

sub GenerateCode {
  my $self = shift;
  open (CODE, '>__ClassSize.cpp') or die "Error: Couldn't open \"__ClassSize.cpp\" for writing: $!\n";
  print CODE "#include <stdio.h>\n";
  print CODE "#include <e32std.h>\n";
  print CODE "#include <e32def.h>\n";
  print CODE "#include <e32base.h>\n";
  foreach my $thisHeader (@{$self->{headers}}) {
    print CODE "#include <$thisHeader>\n";
  }
  print CODE "int main(int argc, char* argv[]) {\n";
  foreach my $thisClass (@{$self->{classes}}) {
    print CODE "\tprintf(\"$thisClass\\t%d\\n\", sizeof($thisClass));\n";
  }
  print CODE "\treturn 0; }\n";
  close (CODE);
}

sub CompileCode {
  my $self = shift;
  my $command = 'cl ';
  foreach my $thisInclude (@{$self->{includes}}) {
    $command .= " /I$thisInclude";
  }
  $command .= " /D__VC32__ /D__WINS__ /D__SYMBIAN32__ /DWIN32 /D_WINDOWS /D_UNICODE __ClassSize.cpp";
  unless ($self->{verbose}) {
    $command .= ' /nologo 2>&1 > NUL';
  }
  if (system ($command)) {
    if (exists $self->{compName} and $self->{compName}) {
      rename ("__ClassSize.cpp", "$self->{compName}.cpp");
    }
    else {
      rename ("__ClassSize.cpp", "unknown.cpp");
    }
    die "Error: Problem executing \"$command\"\n";
  }
}

sub GetOutput {
  my $self = shift;
  open (OUTPUT, '__ClassSize.exe|') or die "Error: Couldn't run \"__ClassSize.exe\": $!\n";
  while (my $thisLine = <OUTPUT>) {
    chomp $thisLine;
    next if ($thisLine =~ /^\s*$/);
    if ($thisLine =~ /^(\S+)\t(\d+)$/) {
      $self->{classSizes}->{$1} = $2;
    }
    else {
      die "Error: Problem parsing output of \"__ClassSize.exe\"\n";
    }
  }
  close (OUTPUT);
}

sub CleanUp {
  my $self = shift;
  DeleteFile('__ClassSize.cpp');
  DeleteFile('__ClassSize.obj');
  DeleteFile('__ClassSize.exe');
}

sub DeleteFile {
  my $file = shift;
  if (-e $file) {
    unlink ($file) or die "Error: Couldn't delete \"$file\"\n";
  }
}


#
# VTable
#

package VTable;


#
# Public.
#

sub New {
  my $pkg = shift;
  my $self = {};
  bless $self, $pkg;
  $self->{bldInfDir} = shift;
  my $classes = shift;
  foreach my $class (@$classes) {
    $self->{classes}->{$class} = 1;
  }
  $self->{verbose} = shift;

  Utils::PushDir($self->{bldInfDir});
  eval {
    $self->BuildAssemblerListings();
    $self->ParseAssemblerListings();
    $self->DeleteAssemblerListings();
    };
  Utils::PopDir();
  if ($@) {
    die $@;
  }
  return $self;
}

sub Check {
  my $self = shift;
  my $other = shift;
  if ($self->{verbose}) { print "Comparing vtable layout of \"$self->{bldInfDir}\" against \"$other->{bldInfDir}\"..\n"; }
  my $passed = 1;
  foreach my $class (keys %{$self->{vtables}}) {
    if (exists $other->{vtables}->{$class}) {
      if ($self->{verbose}) { print "Examining vtable of class \"$class\"...\n"; }
      for (my $ii = 0; $ii < scalar (@{$self->{vtables}->{$class}}); ++$ii) {
	my $thisVTableEntry = $self->{vtables}->{$class}->[$ii];
	if ($ii >= scalar (@{$other->{vtables}->{$class}})) {
	  print "Failure reason: Unexpected vtable entry \"$thisVTableEntry\"\n";
	  $passed = 0;
	  last;
	}
	my $otherVTableEntry = $other->{vtables}->{$class}->[$ii];
	if ($thisVTableEntry eq $otherVTableEntry) {
	  if ($self->{verbose}) { print "\tMatched vtable entry \"$thisVTableEntry\"\n"; }
	}
	else {
	  print "Failure reason: Mismatched vtable entries in class \"$class\"\n\t$thisVTableEntry\n\t$otherVTableEntry\n";
	  $passed = 0;
	}
      }
    }
    else {
      print "Failure reason: Vtable for \"$class\" missing from $other->{bldInfDir}\n";
      $passed = 0;
    }
  }
  return $passed;
}



#
# Private.
#

sub BuildAssemblerListings {
  my $self = shift;
  if ($self->{verbose}) { print "Calling \"bldmake bldfiles\" in \"$self->{bldInfDir}\"\n"; }
  open (BLDMAKE, "bldmake bldfiles 2>&1 |") or die "Error: Couldn't run \"bldmake bldfiles\" in \"$self->{bldInfDir}\": $!\n";
  while (my $line = <BLDMAKE>) {
    if ($line) {
      if ($self->{verbose}) { print "\t$line"; }
      die "Error: Problem running \"bldmake bldfiles\" in \"$self->{bldInfDir}\"\n";
    }
  }
  close (BLDMAKE);

  if ($self->{verbose}) { print "Calling \"abld makefile arm4\" in \"$self->{bldInfDir}\"\n"; }
  open (ABLD, "abld makefile arm4 2>&1 |") or die "Error: Couldn't run \"abld makefile arm4\" in \"$self->{bldInfDir}\": $!\n";
  while (my $line = <ABLD>) {
    if ($line) {
      if ($self->{verbose}) { print "\t$line"; }
    }
  }
  close (ABLD);
  
  if ($self->{verbose}) { print "Calling \"abld listing arm4 urel\" in \"$self->{bldInfDir}\"\n"; }
  open (ABLD, "abld listing arm4 urel 2>&1 |") or die "Error: Couldn't run \"abld listing arm4 urel\" in \"$self->{bldInfDir}\": $!\n";
  while (my $line = <ABLD>) {
    if ($line) {
      if ($self->{verbose}) { print "\t$line"; }
      if ($line =~ /^Created (.*)/) {
	my $listingFile = $1;
	push (@{$self->{listingFiles}}, $listingFile);
      }
    }
  }
  close (ABLD);
}

sub ParseAssemblerListings {
  my $self = shift;
  foreach my $listing (@{$self->{listingFiles}}) {
    open (LISTING, $listing) or die "Error: Couldn't open \"$listing\" for reading: $!\n";
    while (my $line = <LISTING>) {
      if ($line =~ /^\s.\d+\s+__vt_\d+(\D+):$/) {  # If start of vtable section.
	my $class = $1;
	if (exists $self->{classes}->{$class}) { # If one of the classes we're interested in.
	  while (my $line2 = <LISTING>) {
	    if ($line2 =~ /^\s.\d+\s[\da-fA-F]{4}\s[\da-fA-F]{8}\s+\.word\s+(.*)/) {  # If this is a valid vtable entry.
	      my $vtableEntry = $1;
	      push (@{$self->{vtables}->{$class}}, $vtableEntry);
	    }
	    else {
	      last;
	    }
	  }
	}
      }
    }
    close (LISTING);
  }
}

sub DeleteAssemblerListings {
  my $self = shift;
  foreach my $listing (@{$self->{listingFiles}}) {
    unlink $listing or die "Error: Unable to delete \"$listing\": $!\n";
  }
}


#
# Utils.
#

package Utils;

use File::Basename;
use Cwd 'abs_path', 'cwd';
use Win32;

sub AbsoluteFileName {
  my $fileName = shift;
  unless (-e $$fileName) {
    die "Error: \"$$fileName\" does not exist\n";
  }
  (my $base, my $path) = fileparse($$fileName);
  my $absPath = abs_path($path);
  $$fileName = $absPath;
  unless ($$fileName =~ /[\\\/]$/) {
    $$fileName .= "\\";
  }
  $$fileName .= $base;
  TidyFileName($fileName);
}

sub SplitFileName {
  my $fileName = shift;
  my $path = '';
  my $base = '';
  my $ext = '';

  if ($fileName =~ /\\?([^\\]*?)(\.[^\\\.]*)?$/) {
    $base = $1;
  }
  if ($fileName =~ /^(.*\\)/) {
    $path = $1;
  }
  if ($fileName =~ /(\.[^\\\.]*)$/o) {
    $ext =  $1;
  }

  die unless ($fileName eq "$path$base$ext");
  return ($path, $base, $ext);
}

sub TidyFileName {
  my $a = shift;
  $$a =~ s/\//\\/g;      # Change forward slashes to back slashes.
  $$a =~ s/\\\.\\/\\/g;  # Change "\.\" into "\".

  if ($$a =~ /^\\\\/) {  # Test for UNC paths.
    $$a =~ s/\\\\/\\/g;  # Change "\\" into "\".
    $$a =~ s/^\\/\\\\/;  # Add back a "\\" at the start so that it remains a UNC path.
  }
  else {
    $$a =~ s/\\\\/\\/g;  # Change "\\" into "\".
  }
}

my @dirStack;

sub PushDir {
  my $dir = shift;
  my $cwd = cwd();
  chdir ($dir) or die "Error: Couldn't change working directory to \"$dir\": $!\n";
  push (@dirStack, $cwd);
}

sub PopDir {
  if (scalar @dirStack > 0) {
    my $dir = pop @dirStack;
    chdir ($dir) or die "Error: Couldn't change working directory to \"$dir\": $!\n";
  }
  else {
    die "Error: Directory stack empty";
  }
}


1;

=head1 NAME

CheckBc.pm - A module that runs some simple tests to see if one component source tree is backwards compatible another.

=head1 SYNOPSIS

  my $checkBc = CheckBc->New('\branch1\comp\group', '\branch2\comp\group', 0);
  unless ($checkBc->CheckAll()) {
    print "Check failed\n";
  }

=head1 DESCRIPTION

C<CheckBc> does the following checks to see if a backwards compatibility breaking change has been introduced:

=over 4

=item 1

Compares the ARM F<.def> files to ensure that only new lines have been added to the end of the file.

=item 2

Compares the sizes of any classes that have an exported C++ constructor. This is done by compiling some generated C++ code that uses the C<sizeof> operator to print the relevant class sizes to C<STDOUT>. Compilation is done using the MSVC++ compiler.

=item 3

Compares the v-table layouts of any classes that have an exported C++ constructor. This is done by compiling each source code set to ARM4 assembler listings, comparing the v-table sections.

=back

=head1 LIMITATIONS

=over 4

=item 1

The component's headers must compile using Microsoft's Visual C++ compiler.

=item 2

The component's exported headers must compile when they are all #include'd into a single F<.cpp> file. If this is not the case, then additional headers and include paths can be passed into the constructor.

=item 3

Declarations of the component's exported C++ constructors must be found in one of the exported headers.

=item 4

F<.def> file lines are expected to be identical. This can lead to checks failing falsely because, for example, the name of a function may be changed without breaking BC provided the F<.def> file is carefully edited.

=item 5

The components must compile as ARM4. This is likely to mean that each set of source code needs to be accompanied with a suitable F<\epoc32> tree that allows it to be built. The simplest way to acheive this is to prepare a pair of subst'd drives.

=back

=head1 KNOWN BUGS

F<bld.inf>, F<.mmp> and F<.def> file parsing is probably not as industrial strength as it should be.

=head1 COPYRIGHT

 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:
 

=cut