When all the variables that a subroutine uses are local, the subroutine creates a new copy of the variables each time it calls itself. This ensures that there is no confusion or overlap.

Listing 9.12 is an example of a program that contains a recursive subroutine. This program accepts a list of numbers and operands that is to be evaluated from right to left, as if the list is a stack whose top is the left end of the list. For example, if the input is

-  955  *   26   +  11    8

this program adds 11 and 8, multiplies the result by 26, and subtracts that result from 955. This is equivalent to the following Perl expression:

955 - 26 * (11 + 8)

Listing 9.12. A program that uses a recursive subroutine to perform arithmetic.

1:  #!/usr/local/bin/perl

2:

3:  $inputline = <STDIN>;

4:  $inputline =~ s/^\s+|\s+$//g;

5:  @list = split (/\s+/, $inputline);

6:  $result = &rightcalc (0);

7:  print ("The result is $result.\n");

8:

9:  sub rightcalc {

10:         my ($index) = @_;

11:         my ($result, $operand1, $operand2);

12:

13:         if ($index+3 == @list) {

14:                 $operand2 = $list[$index+2];

15:         } else {

16:                 $operand2 = &rightcalc ($index+2);

17:         }

18:         $operand1 = $list[$index+1];

19:         if ($list[$index] eq "+") {

20:                 $result = $operand1 + $operand2;

21:         } elsif ($list[$index] eq "*") {

22:                 $result = $operand1 * $operand2;

23:         } elsif ($list[$index] eq "-") {

24:                 $result = $operand1 - $operand2;

25:         } else {

26:                 $result = $operand1 / $operand2;

27:         }

28: }

$ program9_12

 -   98 *  4 +  12  11

The result is 6.

$

This program starts off by reading a line of input from the standard input file and breaking it into its components, which are stored as a list in the array variable @list.

When given the input

 -   98 *  4 +  12  11

lines 3-5 produce the following list, which is assigned to @list:

("-", "98", "*", "4", "+", "12", "11")

Line 6 calls the subroutine rightcalc for the first time. rightcalc requires one argument, an index value that tells the subroutine what part of the list to work on. Because the first argument here is zero, rightcalc starts with the first element in the list.

Line 10 assigns the argument passed to rightcalc to the local variable $index. When rightcalc is called for the first time, $index is 0.

Lines 13-17 are the heart of this subroutine, because they control whether to call rightcalc recursively. The basic logic is that a list such as

("-", "98", "*", "4", "+", "12", "11")

can be broken into three parts: the first operator, -; the first operand, 98; and a sublist (the rest of the list). Note that the sublist

("*", "4", "+", "12", "11")

is itself a complete set of operators and operands; because this program is required to perform its arithmetic starting from the right, this sublist must be calculated first.

Line 13 checks whether there is a sublist that needs to be evaluated first. To do this, it checks whether there are more than three elements in the list. If there are only three elements in the list, the list consists of only one operator and two operands, and the arithmetic can be performed right away. If there are more than three elements in the list, a sublist exists.

To evaluate the sublist when it exists, line 16 calls rightcalc recursively. The index value passed to this second copy of rightcalc is 2; this ensures that the first element of the list examined by the second copy of rightcalc is the element with subscript 2, which is *.

At this point, the following is the chain of subroutine invocations, their arguments, and the part of the list on which they are working:

Level 1	Main program
Level 2	rightcalc(0)-list ("-", "98", "*", "4", "+", "12", "11")
Level 3	rightcalc(2)-list ("*", "4", "+", "12", "11")

When this copy of rightcalc reaches line 13, it checks whether the sublist being worked on has just three elements. Because this sublist has five elements, line 16 calls yet another copy of rightcalc, this time setting the value of $index to 4. The following is the chain of subroutine invocations after this third call:

Level 1	Main program
Level 2	rightcalc(0)-list ("-", "98", "*", "4", "+", "12", "11")
Level 3	rightcalc(2)-list ("*", "4", "+", "12", "11")
Level 4	rightcalc(4)-list ("+", "12", "11")

When the third copy of this subroutine reaches line 13, it checks whether this portion of the list contains only three elements. Because it does, the conditional expression in line 13 is true. At this point, line 14 is executed for the first time (by any copy of rightcalc); it takes the value stored in $index-in this case, 4, adds 2 to it, and uses the result as the subscript into @list. This assigns 11, the seventh element of @list, to $operand2.

Lines 18-27 perform an arithmetic operation. Line 18 adds one to the value in $index to retrieve the location of the first operand; this operand is assigned to $operand1. In this copy of rightcalc, the subscript is 5 (4+1), and the sixth element of @list, 12, is assigned to $operand1.

Line 19 uses $index as the subscript into the list to access the arithmetic operator for this operation. In this case, the fifth element of $index (subscript 4) is +, and the expression in line 19 is true. Line 20 then adds $operand1 to $operand2, yielding $result, which is 23. This value is returned by this copy of rightcalc.

When the third copy of rightcalc returns, execution continues with the second copy of rightcalc because the second copy called the third copy. Line 16 of the second copy assigns the return value of the third copy, 23, to $operand2. The following is the state of the program after line 16 has finished executing:

Level 1	Main program
Level 2	rightcalc(0)-list ("-", "98", "*", "4", "+", "12", "11")
Level 3	rightcalc(2)-list ("*", "4", "+", "12", "11"), $operand2 is 23

The Perl interpreter now executes lines 18-27. Because $index is 2 in this copy of rightcalc, line 18 assigns the fourth element of @list, 4, to $operand1. Line 21 is true in this case because the operator is *; this means that line 22 multiplies $operand1 (4) by $operand2 (23), yielding 92, which is assigned to $result.

At this point, the second copy of rightcalc is finished, and program execution returns to line 16. This assigns the return value from the second copy, 92, to $operand2.

The following is the state of the program after the second copy of rightcalc is finished:

Level 1	Main program
Level 2	rightcalc(0)-list ("-", "98", "*", "4", "+", "12", "11"), $operand2 is 92

Now you're almost finished; the program is executing only one copy of rightcalc. Because $index is 0 in this copy of rightcalc, line 18 assigns 98 to $operand1. Line 23 is true in this case because the operator here is -; line 24 then takes 98 and subtracts 92 from it, yielding a final result of 6.

This final result of 6 is passed to the main program and is assigned to $result. (Note that there is no conflict between $result in the main program and the various copies of $result in rightcalc because $result is defined as a local variable in rightcalc.) Line 7, finally, prints this result.

Passing Arrays by Name Using Aliases

As you have seen, Perl enables you to pass an array as an argument to a subroutine.

&my_sub(@array);

When the subroutine my_sub is called, the list stored in the array variable @array is copied to the variable @_ defined in the subroutine.

sub my_sub {

        my (@subarray) = @_;

        $arraylength = @subarray;

}

If the array being passed is large, it might take some time (and considerable space) to create a copy of the array. If your application is operating under time or space limitations, or you just want to make it more efficient, you can specify that the array is to be passed by name.

The following is an example of a similar subroutine that refers to an array by name:

sub my_sub {

       my (*subarray) = @_;

       $arraylength = @subarray;

}

The *subarray definition tells the Perl interpreter to operate on the actual list passed to
my_sub instead of making a copy.

To call this subroutine, specify * instead of @ with the array variable name, as in the following:

@myarray = (1, 2, 3, 4, 5);

&my_sub(*myarray);

Specifying *myarray instead of @myarray indicates that the actual contents of @myarray are to be used (and modified if desired) in my_sub. In fact, while the subroutine is being executed, the name @subarray becomes identical to the name @myarray. This process of creating another name to refer to the same variable is known as aliasing. @subarray is now an alias of @myarray.

When my_sub terminates, @subarray stops being an alias of @myarray. When my_sub is called again with a different argument, as in

&my_sub(*anotherarray);

the variable @subarray in my_sub becomes an alias for @anotherarray, which means that you can use the array variable @subarray to access the storage in @anotherarray.

Aliasing arrays in this manner has one distinct advantage and one distinct drawback. The advantage is that your program becomes more efficient. You don't need to copy the entire list from your main program to the subroutine. The disadvantage is that your program becomes more difficult to follow. You have to remember, for example, that changing the contents of @subarray in the subroutine my_sub also changes the contents of @myarray and @anotherarray. It is easy to lose track of which name refers to which variable.

There is also another problem with aliasing: aliasing affects all variables with the same name, not just array variables.

For example, consider Listing 9.13, which defines a scalar variable named $foo and an array named @foo, and then aliases @foo. As you'll see, the program aliases $foo as well.

Listing 9.13. A program that demonstrates aliasing.

1:  #!/usr/local/bin/perl

2:

3:  $foo = 26;

4:  @foo = ("here's", "a", "list");

5:  &testsub (*foo);

6:  print ("The value of \$foo is now $foo\n");

7:

8:  sub testsub {

9:          local (*printarray) = @_;

10:         foreach $element (@printarray) {

11:                 print ("$element\n");

12:         }

13:         $printarray = 61;

14: }

$ program9_13

here's

a

list

The value of $foo is now 61

$

Line 5 calls the subroutine testsub. The argument, *foo, indicates that the array @foo is to be passed to testsub and aliased.

The local variable definition in line 9 indicates that the array variable @printarray is to become an alias of the array variable @foo. This means that the name printarray is defined to be equivalent to the name foo.

As a consequence, the scalar variable $printarray becomes an alias of the scalar variable $foo. Because of this, line 13, which seems to assign 61 to $printarray, actually assigns 61 to $foo. This modified value is printed by line 6 of the main program.

Using the do Statement with Subroutines

Perl enables you to use the do statement to invoke a subroutine. For example, the following statements are identical:

&my_sub(1, 2, 3);

do my_sub(1, 2, 3);

There is no real reason to use the do statement in this context.

Specifying the Sort Order

By default, the built-in function sort sorts in alphabetical order. The following is an example:

@list = ("words", "to", "sort");

@list2 = sort (@list);

Here, @list2 is assigned ("sort", "to", "words").

If you want, you can write a subroutine that defines how sorting is to be accomplished. To understand how to do this, first you need to know a little about how sorting works.

When sort is given a list to sort, it determines the sort order of the elements of the list by repeatedly comparing pairs of elements. To compare a pair of elements, sort calls a special internal subroutine and passes it a pair of arguments. Although the subroutine is not accessible from a Perl program, it basically behaves as follows:

sub sort_criteria {

        if ($a gt $b) {

                retval = -1;

        } elsif ($a eq $b) {

                retval = 0;

        } else

                retval = 1;

        }

        $retval;

}

This subroutine compares two values, which are stored in $a and $b. It returns -1 if the first value is greater, 0 if the values are equal, and 1 if the second value is greater. (This, by the way, is how the cmp operator works; in fact, the preceding subroutine could compare the two values using a single cmp operator.)

To define your own sorting rules, you must write a subroutine whose behavior is identical to the preceding subroutine. This subroutine must use two global variables named $a and $b to represent the two items in the list currently being compared, and the subroutine must return one of the following values:

After you have written the subroutine, you must specify the subroutine name when calling the function sort. For example, if you define a function named foo that provides a set of sorting rules, the following statement sorts a list using the rules defined in foo:

@list2 = sort foo (@list1);

Listing 9.14 shows how you can define your own sort criteria. This program sorts a list in the normal order, except that it puts strings starting with a digit last. (By default, strings starting with a number appear before strings starting with a letter, and before some-but not all-special characters.) Strings that begin with a digit are assumed to be numbers and are sorted in numerical order.

Listing 9.14. A program that defines sort criteria.

1:  #!/usr/local/bin/perl

2:

3:  @list1 = ("test", "14", "26", "test2");

4:  @list2 = sort num_last (@list1);

5:  print ("@list2\n");

6:

7:  sub num_last {

8:          my ($num_a, $num_b);

9:

10:         $num_a = $a =~ /^[0-9]/;

11:         $num_b = $b =~ /^[0-9]/;

12:         if ($num_a && $num_b) {

13:                 $retval = $a <=> $b;

14:         } elsif ($num_a) {

15:                 $retval = 1;

16:         } elsif ($num_b) {

17:                 $retval = -1;

18:         } else {

19:                 $retval = $a cmp $b;

20:         }

21:         $retval;

22: }

$ program9_14

test test2 14 26

$

Line 4 sorts the program according to the sort criteria defined in the subroutine num_last. This subroutine is defined in lines 7-22.

This subroutine first determines whether the items are strings that begin with a digit. Line 10 sets the local variable $num_a to a nonzero value if the value stored in $a starts with a digit; similarly, line 11 sets $num_b to a nonzero value if the value of $b starts with a digit.

Lines 12 and 13 handle the case in which both $num_a and $num_b are true. In this case, the two strings are assumed to be digits, and the numeric comparison operator <=> compares their values. The result of the <=> operation is -1 if the first number is larger, 0 if they are equal, and 1 if the second number is larger.

If $num_a is true but $num_b is false, line 15 sets the return value for this subroutine to 1, indicating that the string that does not start with a digit, $b, is to be treated as greater. Similarly, line 17 sets the return value to -1 if $b starts with a digit and $a does not.

If neither string starts with a digit, line 19 uses the normal sort criterion-alphabetical order-to determine which value is larger. Here, the cmp operator is useful. It returns -1 if the first string is alphabetically greater, 0 if the strings are equal, and 1 if the second string is alphabetically greater.

Predefined Subroutines

Perl 5 defines three special subroutines that are executed at specific times.

• The BEGIN subroutine, which is called when your program starts running
• The END subroutine, which is called when your program terminates
• The AUTOLOAD subroutine, which is called when your program can't find a subroutine it is supposed to execute