I believe if you try this:

sub foo {
   my $dir = shift;
   chdir $dir;

   local *CURRENT_DIR;
   # Everything else follows
}
[download]

In a broader issue, let me give you a few hints. If your directory structure is very deep, you will run out of file handles soon. Those of us with (way too much) experience writing this kind of code usually suck the contents into an array and then close the directory handle.

opendir FOO, "$dir" or die "Couldn't open $dir: $!";
@contents = readdir FOO;
closedir FOO;
[download]

@contents = grep !/^\.\.?$/, readdir FOO;
[download]

If the directory is too big to suck in at once and you are still running out of file handles, you can do it this way

sub recurse_me {
  my $dir = shift;
  opendir FOO, "$dir" or die "Couldn't open $dir: $!;
  while( readdir FOO ) {
    if ( -d $_ ) {
      push @dirs, $_;
    }
    else {
      # do something interesting
    }
  }
  closedir FOO;

  recurse_me( $_ ) for ( sort @dirs );
}
[download]

Hth,
mikfire

use strict;
use File::Recurse;
use File::Basename;

my $allcount = 0;
my $mp3count = 0;
my $rencount = 0;

{
  recurse (\&myfunc, ".");

  printf "\n";
  printf "Total Files Found = %d\n", $allcount;
  printf "  MP3 Files Found = %d\n", $mp3count;
  printf "MP3 Files Renamed = %d\n", $rencount;
}

sub myfunc
{
  my $newname = "";

  ++$allcount;

  my ($name, $path, $suffix) = fileparse ($_[0], '\.mp3');

  if (length ($suffix))    
  {
    ++$mp3count;

    $_ = $name;

    if ($name =~ m/^The /)
    {
      ++$rencount;
      s/(^The )//ge;
      $newname = $path . $_ . $suffix;
      rename $_[0], $newname;
    }
  }
}
[download]

File::Recurse seems to be very similar to File::Find which is part of the standard distribution. What advantages do you get from using File::Recurse?


--
<a href="http://www.dave.org.uk><http://www.dave.org.uk>

European Perl Conference - Sept 22/24 2000
<http://www.yapc.org/Europe/>

Most likely it's because I found File::Recurse first...

The real answer is File::Recurse allows one to set the maximum depth, and has the ability to pass a parameter with that permits easy 'statefulness'. If you were building a directory of files, and wanted to assign a unique identifier to each and every entry, then File::Recurse would be the tool.

For your purposes, File::Find would work fine, and might be more appropriate. Since I cut'n'paste a good bit, and File::Recurse is installed, I just tend to gravitate for it.

But being a good Perl monk, you'll explore the documentation for both, make an informed judgement, and use the best tool. Right?

--Chris

    opendir(DIR, $dir);
    my (@filenames) = grep(!/^\.\.?$/, readdir(DIR));
    closedir(DIR);
    for (@filenames) {
       ... something ...
    }
[download]

You may also want to look at File::Find. Or File::Recurse, or one of the File::* modules :)

Cheers,
KM

sub clean
{
    my ($dir) = @_;
    opendir (DIR, $dir) or {warn "cannot opendir $dir" and return};
    my (@subdirs, @files);
    map {
        push @subdirs, $_ if (-d "$dir/$_" && $_ !~ /\.|\.\./);
        push @files, $_ if (-f "$dir/$_");
    } readdir(DIR);
    closedir(DIR);
    map {&clean("$dir/$_")} @subdirs;
    print "DIR - $dir\n";
    foreach my $file (@files) {
        # do thing on each file
    }    
}
[download]

{
  local(*FH);
  open(FH, "<whatever")
}
[download]

This is also useful for opening an arbitary number of files. Take a reference to the glob before exiting the local block:

{
  local(*FH);
  open(FH, "<whatever")
  $fh = \*FH;
}
print $fh "Foo\n";
[download]

I would guess that opendir() and so on will work fine with this. I haven't tried it, of course, but there's no reason it shouldn't. Note that the asterix in local(*FOO) is important. local(FOO) has a different meaning...

Andrew.