while ( <$fh> ) {
    chomp;           # Remove trailing newlines (a subset of \s)
    s/\s//g;         # Remove ALL whitespace.
    next if /^#/;    # Skip comments.
    next if /^\s*$/; # Skip lines with space, or lines with nothing.
                     # This doesn't make sense because you
                     # already removed all space.  But it
                     # works because you allow it to match
                     # 'nothing' too.
    next if $_ eq "";# This line is never true, because
                     # you already skipped lines with nothing
                     # in the previous statement.
#......
[download]

In other words, much of what you're doing there is either redundant or otherwise peculiar.

Next, your "read_cal" function is being called with two arguments, but within the function, you're only using the first argument.

I didn't even look at what you're doing in the if (!$mode... code, because I don't see $mode being set.

Also, you're only printing out hash elements with a value equal to one, though it might be simpler to just check for the existance of a hash element.

Update: None of these are the central problem. Congrats Roger for finding the straw that breaks this camel's back. I found a lot of other issues, but you found the big one. I'd recommend considering reworking the code a bit based on the suggestions people have given in this thread though, as the result will be cleaner.

Yup...I had a lot of extraneous stuff in there because I was trying to get rid of the error. Originally, I had:

while(<$fh>) {
    chomp;
    next if /^#/;
    next if /^\s*$/;
    ...
[download]

I'd like to think that I'm not a complete dolt...:-)

thor

#!/usr/local/perl/bin/perl -w
use strict;

my %hash;
my $cal = shift;

read_cal($cal, 0);
foreach my $file (@ARGV) {
    read_cal($file, 1);
}

foreach my $key (sort keys %hash) {
    print "$key\n" if $hash{$key} == 1;
}

sub read_cal {
    my ($cal, $mode) = @_;

    print "---------------$cal-----------------\n";

    my $fh;
    open($fh, $cal) or die;
    while(my $line = <$fh>) {
        chomp($line);
        next if $line =~ /^\s*$/;
        next if $line =~ /^#/;
        $line =~ s/\s//g;
        # print "before $cal, |$line|\n";
        read_cal(substr($line,1), $mode) if $line =~ /^I/;
        print "|$line|\n";
        my $schedule = (split ':', $line)[-1];
        if (!$mode || exists $hash{$schedule}) {
            $hash{$schedule}++;
        };
    }
}
[download]

Your test for /^\s*$/ is redundant, because you've already removed all whitespace, and you test for an empty line.

I think your main problem is that you should have a next after the recursive call, or put the rest of the stuff in an else. You don't want to read a file and parse the line, do you?

As for mode not being set...while unfortunate, that wasn't causing the problem (though it did cause incorrect results). The next after the recursive call did it though. Sometimes a guy just needs a second set of eyes. Thanks!

thor

Not trying to answer your question, but where is your close? Once you are done with an opened file, just close it. Regardless what Perl might do for you towards those open files, it is a bad style not to close the files you opened. People might use those little things to judge whether you are professional.

Because a lexical filehandle was used, the file opened by each call to the subroutine will be closed when the that call to the subroutine returns.

There may be a problem if you are expecting hundreds of nested calls, but otherwise there is nothing wrong here. Each file is closed immediately after reaching its end.

it is a bad style not to close the files you opened

A few things:

1. This was a quick and dirty script. Wrote it in about 5 minutes. Were this a production level script, I'd have done things differently.
2. As I was using scalars ($fh) instead of barewords (FH), and I was lexically scoping them with 'my', the files are closed when the scalar goes out of scope. I tend to use features of the language when available.

thor

Point taken, it was quick and dirty. All the same, I consider it a good idea to have the habit of writing the close when you write the open. But then, too, I'm one of the those people that fastens the safety belt by habit, even if I'm going two blocks. So have a grain of salt with this post.

                if (/^I/) {
                        read_cal(substr($_,1), $mode);
                } else {
                        print "|$_|\n";
                }
[download]

                if (/^I/) {
                        read_cal(substr($_,1), $mode);
                }
                print "|$_|\n";
[download]