This is some ... interesting code. You may want to consider using consistent naming conventions as well as more intuitive return types.

In your first example, you're sharing a single variable within the scope of Get_Saves, @files. In the second example you're set up to use multiple copies since you're returning @files and assigning it to another @files variable as the result of the call to find. But at the same time you're trying to pass a reference to the @files in the scope of Get_Saves. These two mechanisms are in conflict.

One version:

sub Get_Saves {
    my @files;
    @files=find(\&FileName,"/usr/local/apache/htdocs/service/"); #sure
+ you want to hard code this?
    return  \@files, $#files+1; # why return the size?
}##END Get_Saves

sub FileName {
    my @files;
    unless (($_ eq "." )or ($_ eq "temp.svd")){ # do you need to test 
+for '..' too?
        push @files, $_;
    }
return @files; 
}##END FileName
[download]

Another version:

our @files; # globally accessible

sub Get_Saves {
    @files=find (\&FileName,"/usr/local/apache/htdocs/service/");
    return  \@files, $#files+1;
}##END Get_Saves

sub FileName {
    unless (($_ eq "." )or ($_ eq "temp.svd")){
        push @files, $_;
    }
}##END FileName
[download]

I don't believe that find (\&FileName(\@files)) will work because you're passing a reference to the subroutine, not invoking it.

I brought this up (hypothetically) in an earlier thread, and tilly provided a good working translation into real perl using a closure.

Have a look there for some ideas about closures.

Sorry if this is OT, didnt have time to read your post in detail
/me dons flame retardant suit

Yves / DeMerphq
--
When to use Prototypes?

sub Get_Saves {
    my @files;
    #Just a small mod here. Call FileName since it now
    #returns a suitable closeure, and pass in the 
    #reference to @files so that FileName knows
    #where to add stuff.
    @files=find(FileName(\@files),"/usr/local/apache/htdocs/service
+/");
    return  \@files, $#files+1;
}##END Get_Saves

sub FileName {
    my $files_ref=shift; #Use reference to array
    return sub {
       unless (($_ eq "." )or ($_ eq "temp.svd")){
          push @{$files_ref}, $_;
       }
       #removed this since returning anything from the
       #wanted function does not really make any sence(See
       #File::Find)
       #return @files
   }
}
[download]

The solution came to me months later when I learned about closeures. Unfortunately I had quit the company by then, so I couldnt tell him how he had wasted his time reimplementing File::Find. Anyway, I guess the moral is something like:Whenever File::Find doesnt seem to do all you want, start reading about closeures again.

GoldClaw

The first example works because the lexical @files is visible to the FileName subroutine (since both are defined within the Get_Saves subroutine block). This works because you have the scope correct.

The second example will not work for several reasons: 1, File::Find::find does not return anything; 2, \&FileName(\@files) is not a reference to a subroutine (only \&FileName is); and three, the @files in Get_Saves is a different beastie than the @files in FileName (the first is a lexical and the second is a global.

To use File::Find with the two seperate functions, you would need to use either global @files or a lexical @files defined outside of Get_Saves and FileName:

#!/usr/bin/perl

use strict;
use File::Find;
my @files; # could leave this out and just let FileName
           # auto-vificate global @files

Get_Saves();

sub Get_Saves {
   find( \&FileName, "/usr/local/apache/htdocs/service/" );
}

sub FileName {
   unless( ($_ eq ".") or ($_ eq "temp.svd"))
      push( @files, $_ );
   # This @files is either the lexical declared above
   # or an auto-vifified global if nothing was declared 
   # above.
}
[download]

update I really like goldclaw's Re: Sub in a Sub & Recursion but you would need to remove the "@files=" from the find since File::Find::find always returns nothing. Just do this:

#where to add stuff.
find(FileName(\@files),"/usr/local/apache/htdocs/service/");
return  \@files, $#files+1;
[download]

-derby

Thanks,
I've used the closure solution with derby's fix which has given me an insight into a practical use for closures. 'our' worked as well but I've not seen it used here much before and my instinct says to stay away from globalish things.
Update Cheers for the recursion tips anon monk reads almost like a tutorial. Recursion is a way of thinking I'm determined to bend my head around

It seems to me, that if you want to use a closure for such a thing, you'll want to use an anonymous sub instead of your FileName sub. Then the @files array will be shared as you expect it to be (e.g., each time Get_Saves is called, $sub will be bound to the new instance of @files).

sub Get_Saves {
  my @files;

  my $sub = sub {
    unless (($_ eq "." )or ($_ eq "temp.svd")){
      push @files, $_;
    }
  };

  find ($sub,"/usr/local/apache/htdocs/service/");
  return  \@files, $#files+1;
}
[download]

As to how to make two separate subs, derby seems to have already answered that. You'd "need to use either global @files or a lexical @files defined outside of Get_Saves and FileName".

Hope this helps

dmm

If you GIVE a man a fish you feed him for a day
But, TEACH him to fish and you feed him for a lifetime

sub foo {
    my @files;

    sub bar {
        push @files, @_;
    };

    bar(@_);

    return @files;
}

print join ' ', foo(123, 456);       # prints '123 456'.
print join ' ', foo('abc', 'def');   # prints nothing.
[download]

my @files;
sub foo {
    bar(@_);
}
sub bar {
    push @files, @_;
}

foo(123, 456);
print join ' ', @files; # '123 456'

foo('abc', 'def');
print join ' ', @files; # '123 456 abc def'
[download]

sub foo {
    @files = ();
    bar(@_);
    shift;
    foo(@_) if @_;
}
[download]

sub foo {
    my @files;

    my $bar = sub {
        push @files, @_;
    };

    $bar->(@_);

    return @files;
}

print join ' ', foo(123, 456);       # '123 456'
print join ' ', foo('abc', 'def');   # 'abc def'
[download]

sub foo {
    my @files;

    my $bar = sub {
        push @files, @_;
    };
    
    $bar->(@_);

    shift;
    return @files, @_ ? foo(@_) : ();
}

print join ' ', foo(123, 456);       # '123 456 456'
print join ' ', foo('abc', 'def');   # 'abc def def'
[download]