sub file_processing {
   my ($script, $arg, $file) = @_;
   my @ret;

   open(FILE, "$script $arg $file |") or die "can't do it: $!";

   while (<FILE>) {
      chomp;
      next if /^#|none|unkno/i;
      push(@ret, $_);
   }
   close(FILE);

   return @ret;
}
[download]

my $pid = open(FILE, "-|");
if (!$pid) {
   die "Couldn't fork: $!" unless defined $pid;

   exec($script, $arg, $file) or die "Couldn't exec: $!";
}
[download]

ie in the main loop:

$stuff_to_do[0] = "/path/to/script -e;;arguments;;file";
...

...
foreach $line (@stuff_to_do)
{
  ($script,$arg,$file) = split(/;;/,$line);
   &file_processing($script,$arg,$file);
}
...

then your subroutine would be:
sub file_processing {
    my ($script, $arg, $file) = @_;

    ....

}

I think that's what you're trying to do, but not sure..

-brad..
[download]

I think that's what he's trying to do, but he's also modifying the global @array1, and he wants to modify the global @array2 the second time around.

Personally, I'd consider that poor style, and rewrite it as...

@array1 = file_processing($script,$arg1,$file1);
@array2 = file_proceesing($script,$arg2,$file2);
...
sub file_processing {
  my ($script,$arg,$file) = @_;
  my @results;
  ...
  return @results;
}
[download]

Actually, I wouldn't... I'd call the sub "processfile", and make several other tweaks if I was writing this myself, but that's just me.

It looks like you are not passing arguments to your subroutine, and using @array1 as a global variable too.

You will have to pass the arg and file as parameters, and get the array as the return value.So the call will go from:

  # you use strict do you?
  my $arg1= "foo";
  my $file1="bar";
  my @array1;
  file_processing();
  foreach (@array1) { process( $_); }
[download]

to

  my $arg1= "foo";
  my $file1="bar";
  my @array1=  file_processing( $arg1, $file1);
  foreach (@array1) { process( $_); }
[download]

The subroutine should look like this:

sub file_processing {
  my( $arg, $file)= @_;                        # added
  my @array;                                   # added
  $script = "/export/home/ssesar/Perl/another_script.pl -e";
  $open = "$script $arg $file";                # changed
  open(FILE, "$open |") or die "can't do it\n";# changed
        while (<FILE>) {                       # changed
            chomp;
   next if /^\#/;
          next if /None/;
          next if /Unkno/;
          next if /unkno/;
          next if /NONE/;
            @_ = split ( /\n/, $_);
            @array = @_;
        }
  close FILE;
  return @array;                           # added
  }
[download]

We can help you much better this way.

--
Casey
   I am a superhero.

The basic point is that it is poor programming style (and ineffecient to boot) to have two subroutines that essentially do the exact same thing.

From my standpoint as someone who has learnt to code that painful way (is there any other), I've developped the standard methodology that if I have duplicated code (or code that closely duplicates functionalities I've used elsewhere) then I need to go back and look at condensing the duplicates into a single subroutine.

In this case, then, you might start by changing the subroutine as follows:

sub file_processing {
    my ($array_ref, $script, $arg, $file) = @_;

    open(FILE, $script . ' ' . $arg . ' ' . $file . ' |') or die ("can
+'t do it: $!\n");

    while (<FILE>) { 
        chomp;
        next if /^\#/;
        next if /none/i;
        next if /unkno/i;
        push @{$array_ref}, split ( /\n/, $_);
    }

    close FILE;
}
[download]

Notice, however, that there are some areas that could use some more work:

1. The regexp that matches none/unknown/# could be improved and probably condensed into a single one looking something like this: /(?:#|unknown|none)/
2. The assignment back to $array_ref may not do exactly what you expect/need -- a little testing would be in order

And finally, you'd call this script by doing the following:

&file_processing(\@array1, $script1, $arg1, $file1);
&file_processing(\@array1, $script2, $arg2, $file2);
[download]

Which, of course, using the heuristic of duplicated code = BAD, could be condensed into a single array of arrays that are looped over and passed in in turn.

Does that help?

my $arg1 = "foo";
my $file1 = "file_1.gz;
my $arg2 = "bar";
my $file2 = "file_2.gz";

sub file_processing {
    $script = "/export/home/ssesar/Perl/another_script.pl";
    $open = "$script -e $arg1 $file1";
    open(FILE1, "$open |") or die "can't do it\n";

    while (<FILE1>) { 
        chomp;
        next if /^\#/;
        next if /None/;
        next if /Unkno/;
        next if /unkno/;
        next if /NONE/;
        @_ = split ( /\n/, $_);
        @array1 = @_;
           }
    close FILE1;
}
[download]

1.I want this subroutine to be run as it reads

2. Then, I want this subroutine to be run a second time with the follo
+wing changes:
<CODE>
$open = "$script -e $arg2 $file2";
    open(FILE2, "$open |") or die "can't do it\n";
while (<FILE2>) {
[download]

and...

@array2 = @_;
[download]

Right, here's what we're saying:

my @array1;
my @array2;

my @args = (
    [ \@array1, "foo", "file_1.gz"],
    [ \@array2, "bar", "file_2.gz"]
);

foreach (@args) {
    &file_processing($args->[0], $args->[1], $args->[2]);
}

sub file_processing {
      my ($array_ref, $arg, $file) = @_;
      my $script = "/export/home/ssesar/Perl/another_script.pl";
      open(FILE, $script . ' ' . $arg . ' ' . $file . ' |') or die ("c
+an't do it: $!\n");

      while (<FILE>) { 
          chomp;
          push @{$array_ref}, $_ unless /^(?:\#|none|unknow)/i;
      }
      close FILE;
  }
[download]

This should do what you want as best as I can tell -- open a file and push into an array (either array 1 or array 2 depending on which iteration) any line that doesn't start with UNKNOW/unknow/#/NONE/none.

Your lines

@_ = split ( /\n/, $_);
@array1 = @_;
[download]

look very strange -- as someone else pointed out, if you're reading in the file line by line (which is what <FILE> implies) then the final split on \n is useless.

In addition, you're only assigning the last value of @_ to @array1 (meaning the other values are lost) unless you've undefined $/, in which case you should just use my $file = <FILE> rather than the while loop.

Hope this helps.