All the arguments are in the array @_. In the provided code, the function only has one argument, so it can be referenced as $_[0]. A convenient way of assigning names to your arguments is

sub parse_header {
   my ($header) = @_;
   do this and thia
}
[download]

but some people prefer

sub parse_header {
   my $header = shift;
   do this and thia
}
[download]

Inside a function, shift with no arguments is the same as shift(@_).

If you had more than one argument, the above would look as follows:

sub three_args_func {
   my ($arg0, $arg1, $arg2) = @_;
   do this and thia
}
[download]

sub three_args_func {
   my $arg0 = shift;
   my $arg1 = shift;
   my $arg2 = shift;
   do this and thia
}
[download]

Reference: perlsub

Veering OT for a moment...

Stylistically, I prefer the

my ($header) = @_;

method of receiving arguments, but always end up doing it the other way for the sake of being able to specify defaults when not all arguments are passed:

my $arg0 = shift || 'foo';
my $arg1 = shift || 'bar';
my $arg2 = shift || 'baz';
[download]

Is there a concise way to get this same functionality when using the my ($arg) = @_ method?

It would be quite ugly:

my @defaults = qw( foo bar baz );
my ($arg0, $arg1, $arg2) = map { $_[$_] || $defaults[$_] } 0..$#_;
[download]

unixhome,

# 1.
sub parse_header {
  # Get the first argument passed to the function/method.
  my $header = shift(); 
  ....
}
[download]

# 2.
sub parse_header {
  # Get the first argument passed to the function/method.
  my $header = $_[0];
  ....
}
[download]

perldoc perlsub
[download]

Perl passes a list of copies of things to a subroutine in the special array @_.

There are a couple of things to note here. First off a list is passed, always. It may be empty (@_ == 0) or contain a single item (@_ == 1), but it is still a list and is passed in @_. So the answer to your question is $_[0] or my $headerCopy = shift; (which removes the item from @_), or some similar construct.

The other thing to notice thought is that Perl passes a copy of the original string. If you wanted to update the original string then you have either to assign a new (returned) version of the string back into the variable ($header = parse_header ($header);) or pass the string by reference (parse_header (\$header);).

However, in most things Perlish, it pays to let other people do the work. In this case you should take a look at MIME::Tools and MIME::Parser in particular.

Update: Struck stuff was just plain wrong! @_ contains aliases to the parameters so changing the contents of the elements of @_ changes the matching actual parameter.

It is @_, definitely not $_.

You can refer to a single argument like your $header as $_[0]. If the contents you parse may be delivered in a list,

sub parse_header {
    for (@_) {
        # do this and that to $_, which is set by 'for'
    }
}
[download]

What you need is something more like the following (assuming your data is coming in through STDIN - I haven't tested that part):

use strict;
use warnings;

my $header;
while (1) {
    chomp($_ = <STDIN>);
    last if !$_;
    $header .= "$_\n";
}
parse_header($header);

sub parse_header {
    my $header = $_[0];
    print $header;
    ## Do necessary $header processing
}
[download]

Or

while (<STDIN>) {
    chomp;
    last if !$_; # or other suitable termination test
    $header .= "$_\n";
}
[download]

---

DWIM is Perl's answer to Gödel

Ted: Sorry about that. I did not put it on my first posting but the first while loop already knows when to execute the sub (when $_ =~ /^$?/). You see, if I run both of those loops independantly from each other (piping the output of one to the second) as in: # cat header.eml | ./first_loop.pl | ./second_loop.pl It works. This is an excersise in Perl programming (with a real purpose...) and I cannot even say (Perl modules) out loud...