Instead of having a hash for each directory, you could have a hash of hashes:

#!/opt/perl5/bin/perl -w
use strict;
use File::Slurp;

# The production files will be listed in
# the source hashes
my $report = "/home/mis/tstanley/SourceDiff.rpt";

my %input = (
  iqs_source => '/dsmpayroll/iqs-source',
  prg_source => '/dsmpayroll/prg-source',
  spg_source => '/dsmpayroll/spg-source',
  tpr_source => '/dsmpayroll/tpr-source',
  iqs        => '/dsmmigrate/development/iqs',
  prg        => '/dsmmigrate/development/prg',
  spg        => '/dsmmigrate/development/spg',
  tpr        => '/dsmmigrate/development/tpr',
);

my %data;

foreach my $key (keys(%input)) {
  my $dir = $input{$key};
  chdir($dir);
  foreach my $file (read_dir('.')) {
    my $sum = `sum $file`;
    my ($x) = split(/\s+/, $sum);
    $data{$key}{$file} = $x;
  }
}

## Open the report file
...
[download]

Update: It seems there's no need to build a hash of hashes, since we only need to look at a pair of directories at a time. I elminated the pesky chdir commands while I was at it. Here it is a version with (just about) all redundancy eliminated, but without any change in functionality:

#!/opt/perl5/bin/perl -w

use strict;

# The production files will be listed in
# the source hashes
my $report = "/home/mis/tstanley/SourceDiff.rpt";

sub DEV  () { 0 }
sub PROD () { 1 }

my %input = (
   IQS => [ '/dsmmigrate/development/iqs', '/dsmpayroll/iqs-source' ],
   PRG => [ '/dsmmigrate/development/prg', '/dsmpayroll/prg-source' ],
   SPG => [ '/dsmmigrate/development/spg', '/dsmpayroll/spg-source' ],
   TPR => [ '/dsmmigrate/development/tpr', '/dsmpayroll/tpr-source' ],
);


## Open the report file
open RPT, ">$report"
or die "Unable to open $report: $!\n";

my $date=`date`;
print RPT "$date\n\n";


## For each set of directories, we find the common file names in them,
## and then go through those files and compare the sums. If the
## Production file is different, we write it out to the report file.

my $print_seperator;  # False for first loop iteration.

foreach my $key (sort keys %input) {
   local *DH;
   my $dir;
   my $file;
   my %dev_crcs;
   my %prod_crcs;

   $dir = $input{$key}[DEV];
   opendir(DH, $dir)
   or die "Unable to open dir $dir: $!\n";
   while (defined($file = readline(DIR))) {
      next if $_ eq '.';
      next if $_ eq '..';
      next if $_ eq 'cob';
      next if substr($_, -4) eq '.ffl';
      next if substr($_, -4) eq '.lst';
      $dev_crcs{$file} = 0+`sum $dir/$file`;
   }

   $dir = $input{$key}[PROD];
   opendir(DH, $dir)
   or die "Unable to open dir $dir: $!\n";
   while (defined($file = readline(DIR))) {
      next if $_ eq '.';
      next if $_ eq '..';
      next if substr($_, -4) eq '.ffl';
      next if substr($_, -4) eq '.lst';
      $prod_crcs{$file} = 0+`sum $dir/$file`;
   }

   if ($print_seperator) {
      print RPT "\n\n";
   } else {
      # True for all but first loop iteration.
      $print_seperator = 1;
   }

   print RPT "$key Source Files\n";
   print RPT ("=" x length($key)) . "=============\n";

   foreach $file (keys(%dev_crcs)) {
      if (exists($prod_crcs{$file})
      && $prod_crcs{$file} != $dev_crcs{$file}) {
         print RPT "$dir/$file\n"
      }
   }
}
[download]

Keep in mind that files in one directory but not in the other are not printed, just like in your solution.

This doesn't directly answer your question, but judging from your shebang line, I gather that this is a Unixoid system. The GNU utility diff (and maybe other diffs as well) can be used to compare directories. E.g.:

% diff --recursive dir1 dir2
[download]

The person who asked for my help, had tried this. Some of the files are over 1000 lines in size, and trying to wade through the diff files was nearly impossible.


TStanley
--------
The only thing necessary for the triumph of evil is for good men to do nothing -- Edmund Burke

I wouldn't give up on diff though. You can use the -q switch which only outputs whether the files differ. By using some of the other diff switches (like -B which ignores changes whose lines are blank), you might be able to reduce the number of files that really differ.

lupey

Well, for one thing, you could factor all those chdir... segments down to their common denominator and call them as a subroutine within a foreach loop instead of repeatedly typing the same code again and again.

Other than that, it would help if we knew in what way you wished to change the code. Your question doesn't ask for anything specific.

use strict;
use warnings;

my @compare = (
    ['/dir1/contents/','/dir2/contents','^cob$'],
    ['/dir1/contents/','/dir2/contents','\.ffl$','\.1st$']
);

my ($dir1, $dir2, @r, $regex);
for (@compare) {
    ($dir1, $dir2, @r) = @$_;
    # Load dir info, create hash, compare hash
    # If hash doesn't match...
    $regex = join '|', @r; print "$regex\n";
    # Sort and run through files, ignoring ones that regex matches if 
+regex exists.
    # Print directory and file info for files that don't match between
+ directories
}
[download]