Perl Module 3  Functions, References and Packages
K. Yue, copyright 2001
September 19, 2001

User-Defined Functions

• In Perl, functions may either be system-defined or user-defined.
• User-defined functions are also called subroutines.
• The format of user-defined functions is:

sub function_name
{  statements  ...
}

• Subroutines
1. are global,
2. can be put anywhere (usually at the end), and
3. invoked by calling the subroutine name, preceded by &; or by using the do operator.

hello();
&hello;
do hello();

• Subroutine names use its own namespace.
• The value of the last expression evaluated is the value returned.
• The return function can also be used to return a value and exit the subroutine.

• A Perl subroutine can access to the following variables:
1. global variables,
2. passed arguments, and
3. locally defined variables.

• The special system-defined array @_ is used to store arguments passed to a subroutine.
• $_[i] is the (i+1)th arguments passed in.
• @_ is local to the subroutine.
• Perl's arguments are passed by reference in the sense that @_ stores references of the actual parameters.
• The my() function is used to create local versions of variables.
• Note that my() can also be used for blocked statements and eval.
• The my() function is used to simulate passing by value.

$mood = "great";
&show_mood;
# Now mood is depressing.
# Although global variables can be used,
# it is not a good style
sub show_mood
{  print "I feel $mood.\n";
   $mood = "depressing";
}

#  sum all arguments
sub sum
{  myl ($sum) = 0;
   foreach (@_)
   { $sum += $_;
   }
   $sum;
}

sub hello
{  my ($fname, $lname) = @_;
   print "Welcome to UHCL, $fname $lname!\n";
}

Illustrating argument passing mechanism:

#    passing.pl
$a = 10;
$b = 20;

dummy1($a, $b);
print "\$a = $a\n";
print "\$b = $b\n";

$a = 10;
$b = 20;

dummy2($a, $b);
print "\$a = $a\n";
print "\$b = $b\n";

sub dummy1 {
    $_[0] = 50;
    $_[1] = 60;
}

sub dummy2 {
    my ($arg1, $arg2) = @_;
    $arg1 = 50;
    $arg2 = 60;
}

Exercise 1:

Write a Perl subroutine max, which takes a list of numbers and returns the largest value.

Exercise 2:

Write a function which accepts a yes-or-no question and prompt for user input: "yes" or "no".  Return 1 if users typed in 'y' or 'Y'.  Return 0 if 'n' or 'N'.  Otherwise, repeat the prompt until a valid response is typed in.

Exercise 3:

Write a Perl subroutine date to accept a string of date of format "mm/dd/yy" and return a string of date of format "month day, year".  For example, if the input is "09/17/96", the output is "September 17, 1996".

2. System-Defined Functions

• There are many system defined functions.
• Before writing your own function, consult the manual to see whether there are any system defined functions that you may use.
• Look at the section perlfunc for built-in Perl functions.

The function splice(ARRAY, OFFSET, LENGTH, LIST) replaces ARRAY[OFFSET ..OFFSET+LENGTH-1} by LIST.  It returns the replaced substring.

#!/opt/gnu/bin/perl
# Randomly printing strings from STDIN.
srand;
@list = <STDIN>;
while (@list)
{  $string = splice(@list, rand @list, 1);
   print $string;
}

3. Packages

• Packages allow the definition of user's defined namespaces.
• Variables can then be declared as local to packages to provide data encapsulation.
• A package declaration in a block makes subsequent variable references in the block as variables of the packages.
• The main body of a Perl program is in the predefined package main.
• The variables of a package can be referred from outside the package using the full name (with package name and a ' before the variable name).

# A priority queue.
sub add_entry
{  package Priority_Queue;
   local ($priority, $message) = @_;
   for ($i=0; $i <= $#queue; $i++)
   {  last if $priority > $queue[$i];
   }
   splice(@queue, $i, 0, "$priority:$message");
}

sub next_entry
{  package Priority_Queue;
   return () unless @queue;
   split(/:/, shift(@queue), 2);
}

#  Print all messages from 'main'.
foreach (@Priority_Queue'queue)
{  print s/.*://;
}

4. Modules

• A Perl module is a self-contained piece of Perl code that can be used by a Perl program or by other Perl modules.
• Perl provides a hierarchical, unique namespace for modules, similar to the namespace for Java classes.
• A module may have more than one component, separated by ‘::’.
• Each module is stored in a single .pm file.  Module files are stored in a subdirectory hierarchy that parallels the module name hierarchy.  For example, the module Math::Complex is stored in the file Math/Complex.pm.
• The Perl interpreter has a list of directories in which it searches for modules. Within a Perl program, this list is available in the global array @INC.
• The statement use is used to import a Perl module.  An example:

use CGI;
use LWP::Simple;

5. References

Symbolic References

This subsection can be skipped for beginners.

• In Perl, a symbolic reference is a variable that names another variable.
• A typeglob is a type of symbolic reference that allows the definition of an alias.
• To create an alias for a variable, an asterisk is perpended to the alias name: *alias = *variable.  An example:

• A typeglob can be used for true parameter passing by reference.

#!/opt/gnu/bin/perl
@num = (2, 5, 8);
print "The numbers: @num.\n";
&process_num(@num);
print "The numbers are now: @num.\n";

sub process_num {
   print "The last number is ", pop(@_), ".  It is removed.\n";
   foreach (@_) {
      $_++;
   }
}

#!/opt/gnu/bin/perl
@num = (2, 5, 8);
print "The numbers: @num.\n";
&process_num(*num);
print "The numbers are now: @num.\n";

sub process_num {
   local(*para) = @_;
   print "The number of parameter passed: " , scalar(@_), ".\n";
   print "The last number is ", pop(@para), ".  It is removed.\n";
   foreach (@para) {
      $_++;
   }
}

Hard References

• A hard reference is a scalar that holds the address of another data.  It is similar to Pascal's and C's pointers.
• A hard reference refers to the value and not the name of a variable.  A hard reference refers to a thingy.
• A hard reference can be defined using the unary backlash operator.
• A hard reference can refer to variables, constants, functions and filehandlers.

$scalarref = \$m;
$arrayref = \@ARGV;
$hashref = \%ENV;
$coderef = \&handler;
$globref = \*STDOUT;
$reftoref = \$scalarref;
$constref=\1997.5;
$name="Bun Yue";

• Dereferencing is done by evaluating the reference (giving the address) and preceding by the correct prefix ($, @, %, etc).

$q = 10;
$p = \$q;
print "\$p is ", $p, ".\n";
print "\$\$p is ", $$p, ".\n";

@nums = (1, 2, 3, 4);
$r = \@nums;
print "\$r is ", $r, ".\n";
print "\@\$r is ", @$r, ".\n";

The output looks like:

$p is SCALAR(0xb75e0c).
$$p is 10.
$r is ARRAY(0xb75e9c).
@$r is 1234.

Using hard references to simulate true pass by reference.

#!/Opt/gnu/bin/perl
@num = (2, 5, 8);
print "The numbers: @num.\n";
&process_num(\@num);
print "The numbers are now: @num.\n";

sub process_num {
   local($ref) = @_;
   print "The number of parameter passed: " , scalar(@_), ".\n";
   print "The last number is ", pop(@$ref), ".  It is removed.\n";
   foreach (@$ref) {
      $_++;
   }
}

Suggested Solutions To Module #3

1. For example,

sub max
{  my $max = pop(@_);
   foreach (@_)
   {  $max = $_ if $_ > $max;
   }
   $max;
}

2. For example,

sub yes_or_no
{  my ($answer);
   for (;;)
   {  print "@_[0] [y/n].\n==> ";
      $answer = <STDIN>;
      return 1 if $answer =~ /^y/i;
      return 0 if $answer =~ /^n/i;
   }
}

3. For example,

sub date
{ my (@month) = ('January', 'February', 'March',
                    'April', 'May', 'June',
                    'July', 'August', 'September',
                    'October', 'November', 'December');
  my ($m, $d, $y) = split(/\//, (shift @_));
  return "$month[$m-1]" . " $d, 20$y";
}