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:

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

&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.
sub show_mood
{  print "I feel $mood.\n";
   $mood = "depressing";
}

#  sub add from Llama.
sub add
{  local ($sum) = 0;
   foreach (@_)
   { $sum += $_;
   }
   $sum;
}

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

#    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".

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.

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

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

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/.*://;
}

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 name space for modules, similar to the name space 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:

References

Symbolic References

• 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 references.

#!/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 symbol ($, @, %, 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.

Example 2.2: redoing 1.1 using hard references.

#!/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
{  local ($max) = pop(@_);
   foreach (@_)
   {  $max = $_ if $_ > $max;
   }
   $max;
}

2. For example,

sub yes_or_no
{  local($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
{ local (@month) = ('January', 'February', 'March',
                    'April', 'May', 'June',
                    'July', 'August', 'September',
'October', 'November', 'December');
  local ($m, $d, $y) = split(/\//, (shift @_));
  return "$month[$m-1]" . " $d, 19$y";
}