Perl recursion through filesystem (without File:Find) follows "top" one path only - perl

Question

The general problem: Iterate through a windows folder structure, without the use of Find::File and rename all folders to be some short value. This is intended to fix the classic "windows file paths are more then 256 characters" problem.
My problem: I've got everything working, except that it will correctly process a single path through the tree, but not any others and I can't see why.
Note: use File:Find is still present, though not used, and the code is likely in-elegant. It renames the current folder, then iterates through subfolders.
Code:
use strict;
use File::Find;
use File::Copy;
use File::Path;
my $target = "E:\\bl10s\\";
opendir( DIR, $target );
my $newFolderName = 0;
my $file;
while ( $file = readdir(DIR) ) {
# A file test to check that it is a directory
# Use -f to test for a file
next if ( $file eq "." );
next if ( $file eq ".." );
next if ( -f "$target\\$file" );
print "$target/$file" . "\n";
while ( -e $target . $newFolderName ) {
$newFolderName++;
}
print $target. $file . " rename to " . $target . $newFolderName . "\n";
rename( $target . $file, $target . $newFolderName );
}
closedir(DIR);
opendir( DIR, $target );
while ( $file = readdir(DIR) ) {
next if ( $file eq "." );
next if ( $file eq ".." );
if ( -f "$target\\$file" )
{
print "Failed name check on itterator main line \n";
}
my $nextDirectoryPathCalled = $target . $file;
print "Re-iterating on: " . $nextDirectoryPathCalled;
my $someint = &stripper($nextDirectoryPathCalled);
}
closedir(DIR);
# find( \&dir_names, $target );
sub stripper {
print "\nNew level\n";
print "$_[0] . \n";
my $target = $_[0] . "\\";
opendir( DIR, $target );
my $newFolderName = 0;
my $file;
while ( $file = readdir(DIR) ) {
# A file test to check that it is a directory
# Use -f to test for a file
next if ( $file eq "." );
next if ( $file eq ".." );
next if ( -f "$target\\$file" );
print "TARGET: $target FILE: $file" . "\n";
while ( -e $target . $newFolderName ) {
$newFolderName++;
}
print $target
. $file
. " rename to "
. $target
. $newFolderName . "\n";
rename( $target . $file, $target . $newFolderName );
}
closedir(DIR);
opendir( DIR, $target );
while ( $file = readdir(DIR) ) {
next if ( $file eq "." );
next if ( $file eq ".." );
next if ( -f "$target\\$file" );
my $nextDirectoryPathCalled = $target . $file;
print "Re-iterating on: " . $nextDirectoryPathCalled;
&stripper($nextDirectoryPathCalled);
}
closedir(DIR);
}
Any ideas? Feel free to be critical...
Thanks

Answer 1

When doing recursion, it is important that each level has its own set of variables, and does not change those of upper levels. Take for example this implementation of the factorial, which is:
fac(n) = 1 · 2 · 3 · … · n
In naïve Perl code, we could write
sub fac {
$n = shift;
return 1 if $n < 2;
return $n * fac($n-1);
}
Output for fac(10) is 1. This is cleary wrong, we expected 1*2*3*4*5*6*7*8*9*10 = 3628800.
The problem is that each recursion level assigned to the same $n variable. We have the following call stack:
fac(10)
$n = 10
fac(9) * $n
$n = 9
fac(8) * $n * $n
$n = 8
...
fac(1) * $n * $n * $n * $n * $n * $n * $n * $n * $n * $n
$n = 1
return 1
So all of that evaluates to 1. Duh.
We can give each level a different $n variable by declaring it with my:
sub fac {
my $n = shift;
return 1 if $n < 2;
return $n * fac($n-1);
}
Now, everything works as expected.
In Perl, bareword filehandles are global variables. When you do
opendir DIR, $somepath;
then you assign a handle to that global bareword. While recursing, you constantly reassign to it. When your function returns from a lower level, the handle does not get the previous value back.
Instead, you should use lexical variables for your handles as well:
opendir my $dir, $somepath;
Then each invocation of your subroutine has its own, non-global dirhandle, and everything should work as expected.
Using File::Find handles all of that complexity behind the scenes, and just makes the correct element directly available to your callback. It is robust, widely used, so you should really see if you shouldn't be using the find function from that module instead.