Advanced Perl

OVERVIEW

These lectures examine the application of Perl to tasks commonly encountered by programmers.

As an interpreted language, Perl has features not normally found in compiled languages. We will focus on two of these features:

Execution of expressions on the fly
Associative arrays

EXPRESSIONS IN THE SUBSTITUTION FUNCTION

With the substitute function, we have seen extensive use of patterns in the first position. For example, s/[0-9]+/X/ will replace the leftmost integer with "X". However, complex expressions may appear in the second position as well, with the e option of the substitute function.

For example, the following code

	s/([0-9]+)/"X" x length($1)/e

will replace "abc123def" with "abcXXXdef".

Suppose that you have a lot of code that is indented on multiples of eight columns with tabs ("\t"), and you would prefer indentation on multiples of four columns. The retab program provides this service:

	# Usage: retab < infile > outfile

	$indent = 4;

	while (<STDIN>) {
		s#^(\t+)#' ' x (length($1) * 8)#e;
		s#^( *)#' ' x (length($1) * $indent / 8)#e;
		s#^(( {8})*)#"\t" x (length($1) / 8)#e;
		print;
	}

THE EVAL FUNCTION

The e option of the substitute function allows evaluation on the fly in string substitution. The eval function provides a more general form of expression evaluation. Any string can be evaluated as a Perl program. The string can be read from a file or generated on the fly.

Consider the following "hello world" program:

	$program = 'print "Hello world\n";';
	eval $program;

The rename program uses eval to solve a common programmer's problem. Suppose that you have a large number of files that you wish to rename in a uniform way. For example, you wish to change the .c suffix to .cpp. The rename program can do this and many other renaming tasks, in just a few lines of Perl:

	# Usage: rename perlExpression [files]

	# extract perlExpression from @ARGV[0]
	($op = shift) || die "Usage: rename perlExpression [files]\n";

	for (@ARGV) {
		$oldName = $_;
		eval $op;
		die $@ if $@;
		rename($oldName,$_) unless $oldName eq $_;
	}

ASSOCIATIVE ARRAYS

An ordinary array can be indexed only by integer values in the range [0..N-1] where N is the size of the array. However, an associative array may be indexed by any scalar value, not just by integers in a tight range. Associative arrays are a powerful programming construct.
Names must start with a percent character. Indexing uses curly braces.
The indexes of an associative array are called keys. The entries in the array are values. So, the associative array is really just a list of key-value pairs.

Example usage:

	## use an associative array named %age
	$age{"jane"} = 26;
	$age{"bill"} = "21";
	$age{"fido"} = 3;
	print $age{"bill"}, "\n";
	$age{"fido"} += 1;

As with ordinary arrays, the prefix becomes $ when accessing an element (a scalar value).

The keys() function returns a list of all the keys. E.g.

	@K = keys(%age);
	foreach (@K) {
	    print "Age of ", $_, " is ", $age{$_}, "\n";
	}

The value() function returns a list of all the values. E.g.

	@V = values(%age);
	foreach (@V) {
	    print "Age: ", $_, "\n";
	}

The each() function returns a key-value pair, one at a time. For example:

	while( ($k, $v) = each(%age) ) {
	    print "Age of ", $k, " is ", $v, "\n";
	}

The defined() function can be used to determine whether an associative array contains a given key. For example:
```
	if (defined($age{$k})) {
		print "$k is present\n";
	}
```

Ordinary arrays may be converted to associative arrays, and vice-versa, by assignment. An associative array is like an ordinary array where even-numbered indexes correspond to keys, and odd-numbered indexes to values.
E.g.

	@ageArray = %age;
		## ageArray[0] = "jane", ageArray[1] = 26
		## ageArray[2] = "bill", ageArray[3] = 21
		## ageArray[4] = "fido", ageArray[5] = 4

	%colour = ("house", "white",
		"sky", "blue", "grass", "green");
		## colour{"house"} equals "white", etc.

A key-value pair can be deleted with the delete() function. For example:
```
	delete $colour{"house"};
```
removes the "house"-"white" pair from the %colour array.
Associative arrays can be used to simulate multidimensional arrays. For example:
```
	for( $i = 0;  $i < 10;  $i++ ) {
	    for( $j = 0;  $j < 10;  $j++ ) {
		$Table{$i,$j} = $i * $j;
	    }
	}
```
builds a multiplication table named %Table. In actual fact, an element $Table{4,3} is implemented as a key-value pair where the key is the string "4;3".

Example 1

Suppose that the following Perl program:

#!/public/bin/perl

while() {
	chop;
	foreach (split(/ /)) {
		if (defined($aa{$_})) {
			$aa{$_}++;
		} else {
			$aa{$_} = 1;
		}
	}
}

foreach (sort(keys(%aa))) {
	print "$_: $aa{$_}\n";
}

is run with the following input:

	Tree Ladle Picks (from "The Anguish Languish")

Once pawn term dare lift tree ladle picks.
Divorced ladle pick enter sickened ladle pick
wore lacy, fawn-laughing gauze.
Butter thread ladle pick ...

What is the exact output?

Example 2

Suppose that the Perl program from example 1 is modified as follows and run on the same input:

#!/public/bin/perl

while() {
	chop;
	foreach (split(/\W+/)) {
		tr/A-Z/a-z/;
		if (defined($aa{$_})) {
			$aa{$_}++;
		} else {
			$aa{$_} = 1;
		}
	}
}

foreach (sort(keys(%aa))) {
	print "$_: $aa{$_}\n";
}

Now what is the exact output?
What is an English translation of the input?