CSCI A348/A548 Lecture Notes 7 Fall 1999

Handin Information

You need to create a directory called assignments in your htdocs where you will place all your source code assignments. Make sure that the files are not readable by anybody other than the owner and make this directory accessible by dgerman only following the instructions provided tonight in class. Use htpasswd to create a password for this username and send me the password. I will check your source code and assignments during the semester as you post them in this directory.

Review of Perl

We now review Perl with our future tasks in mind.

Normally, people consider Perl to be an interpreted language because program execution basically starts at the top and continues line-by-line. But when a Perl program is run, it is actually first parsed and compiled, and only then is it executed. This approach provides some of the efficiency of compilation while permitting the convenience and flexibility of interpreted languages.

Perl's power derives from a combination of the best properties of many different languages. For example, as with most interpreted scripting languages, commands in a Perl program need not be included within a function. Each line in a script is run from top to bottom; the first line of the script ordinarily will be the first to be executed. Contrast this with a C program, in which all commands (or statements) must reside within functions, and program execution always begins with the main function. Like C, however, Perl is a free-form language. You can generally put as many statements as you like on a single line and put line breaks wherever you want. To tell where each statement ends and another begins, each statement must be terminated with a semicolon.

This flexibility carries over to Perl functions and variables as well. Perl variables come in many different flavors, but all of them are case-sensitive, don't need to be declared in advance of use, and are global by default. That is, unless you explicitely indicate otherwise, each variable will be shared across all the functions in a script. And speaking of functions, you don't need to declare them in advance either. Furthermore, many functions in Perl do not require you to enclose parameters in parentheses - a necessity for many programming languages. In what follows we review variables and functions in detail.

As in most scripting languages, Perl's comments are line-based, beginning with a hash (#) sign and continuing to the end of line. There is no way of making a true multi-line comment other than by putting a # on each line.

Perl Variables Part I: Scalars

Most programming languages have various data types, and Perl is no exception - but like almost everything else in Perl, there's a twist. Perl's simplest and most common data type, the scalar, replaces many of the common data types found in other languages. A scalar is simply a a single item; integer, floating point number, string, or boolean value; the precise type need not be specified in advance. A nifty feature of scalars is that they automatically convert between the different types as needed. As in most scripting languages Perl's comments are line-based, beginning with a hash sign (#) and continuing to the end of the line.

$number = 4;         # $number is 4, as you would expect
$string = "Hello";   # a nice, friendly string 
$bond = "007";       # a more exciting string 
print $bond - 2;     # prints "5" -- automagic string/number conversion 
$scalar = "2" . "1"; # .(dot) is string concatenate; $scalar is "21" 
$scalar -= 15;       # $scalar is now 6

In case you haven't noticed, all scalar variables begin with a dollar sign ($). Though this may seem annoying (and perhaps ugly) at first, it turns out to be phenomenally useful because it prevents variable names from being confused with Perl keywords. More interestingly, it also allows the variables to be directly subsituted, or interpolated into strings:

print "the value of my scalar is $scalar."

The value of my scalar is 6.

Perl Variables Part II: Arrays

Perl can group a number of scalars together in an array; the entire array can then be referenced as a single variable. In Perl, arrays are denoted by the "at" character (@) and perhaps bear a stronger resemblance to lists in LISP than to arrays in C. Each array can contain any number of elements, which are simply scalars. For convenience, arrays can be assigned both to and from lists (denoted by parentheses):

@array = ("1", "two", "3"); 
($first, $second, $third) = @array;

@newarray = (0, @array, 4); 

# @newarray now contains (0, "1", "two", 3, 4)

$first = $array[0]; 

# $first is the first item in the $array array: "1"

The highest idnex (the one which specifies the last element) of an array named @array is given by $#array, while the size of the array (generally one larger) is the scalar value of the array. These also work backwards; assigning a number to the highest index changes its size:

$last = $array[$#array]; # $#array is 2; $last is 3
$scalar = @array;        # $scalar is 3 (number of elements in @array) 
$#array = 1;             # @array is now ("1", "two"); 

Perl Variables Part III: Associative Arrays

Associative arrays are like normal arrays; however, rather than being indexed by numbers, they're indexed by strings. Thus, while a standard array will limit you to looking up entry 3, with an associative array you can use "3.141519", "pi", or even

"the whole kit and caboodle"

Like scalars and ordinary arrays, associative arrays are indicated by a special character, in this case a percent sign: (%). And, as with arrays, each of the elements of an associative array is a scalar. However, in order to differentiate elements of associative arrays from those of normal ones, curly braces, rather than square brackets, are used to enclose the index:

$myassociativearray{'index'} = "myvalue";

$addresses{'John Smith'} = "1234 Main Street"; 
$addresses{'Mary Doe'} = "115 Central Avenue"; 

$two_d{'2,3'} = "I'm element 2,3!"; 

It is possible to assign associative arrays to ordinary arrays and viceversa. The ordinary array represents the name/value pairs as sequential entries:

@ary = %myassociativearray; # @ary is ("myindex", "myvalue");

@humps_list = ("dromedary", 1, "bactrian", 2, "camel", "1 or 2");
%humps = @humps_list;
$dromedary = $humps{"dromedary"}; #dromedary is 1 

print "A camel has $humps{'camel'} hump(s)\n";

One final note: if an array like @humps_list contained thousands of entries, searching through it could take a long time. However associative array lookups in Perl are very fast because they make use of hash tables. Accordingly (and also because it's much easier to say and type), associative arrays are often referred to as hashes.

Simple Subroutines

A subroutine function is just a block, preceded by the keyword sub and a name. Functions can be placed almost anywhere in a Perl program, and the sub indicates that code should not be executed when the interpreter gets to it. Instead, it will be simply tucked away for use when needed.

Unlike some languages that have both functions (which perform some action and return a value to their caller), and procedures (which perform some action but do not return anything), Perl has only the former. By default, the value returned is simply the result of the last expression in the subroutine. Suppose the following code fragment:

#!/usr/bin/perl
print &compute;

sub compute {
  $four = 2 + 2;
}

Parameter Passing

In Perl, the parameters that are passed into a function do not have any special names. They neither need to be declared in advance, nor must they be specified as part of the function definition. Instead, the special array @_ (the underscore character) holds all the parameters that are passed into a function. Each parameter can be accessed by its zero-based index; that is, the order in which it was passed to the function. Thus the first parameter would be $_[0] and the tenth would be $_[9].

Unfortunately, variable names like $_[14] don't roll off the tongue and can become pretty confusing. A good solution is to assign @_ to a list of named scalar variables. A function which takes three parameters could use a statement like:

local ($param1, param2, param3) = @_;

local ($name, $rank, $serial_number) = @_;

For this reason you can and should define them local.

Notable Quotes

The most common quotes in Perl are the double quotes: "". They can interpolate variables. They cannot span multiple lines. They need to have double quotes inside escaped with the backslash character. Look at some examples below.

$billions = "35 dollars"; 
print "We lost $billions\n"; 
# We lost 35 dollars followed by a newline 

$billions = "35 dollars"; 
print 'We lost $billions\n'; 
# We lost $billions\n 

kill -HUP `cat httpd.pid`

Substitutions

To substitute patterns of characters in a variable that holds a string we use the s/// operator. Here are a few simple examples that illustrate how this works.

We call the part that comes in between the first two slashes left-hand side and the part that comes in between the other two right-hand side. If a match is found the left-hand side is replaced by the right-hand side.

$weather = "A rainy day."; 
$weather =~ s/rainy/sunny/; # $weather is now "A sunny day". 

$weather = "A snowy day."; 
$weather =~ s/rainy/sunny/; # $weather is still snowy. 

Pattern Matching and Regular Expressions

Changing the weather in a predictable way is nice, but you can do that just by flying from England to California. What you usually want to do is to match and substitute more general strings, without knowing in advance what they are. This is done using regular expressions and here's a very simple example.

In Perl regular expressions a dot (.) or period is the most unrestricted character; it will match any single character. The percent sign is not a special character so it will match itself, so we have:

$weather = "Probability of precipitation is 80%."; 
$weather =~ s/..%/5%/; # Only a 5% chance now.

HTML Forms

• Forms are simply HTML pages that make use of special tags to provide an interface to solicit information from the user. Each form relies on a script to process the results.

• The <form> tag sets apart a logical form and establishes the relationship between the form and the CGI script that processes its data.

• A number of form elements, including <input>, <select>, and <textarea>, can be employed to create the user interface for the form. Some of the most common form elements are summarized below.

• Each form element has both a name and a value, which the scripts receives when the form is submitted (after the requested is parsed, see the lab notes for a jumpstart on that).

<input type=text>

name
value
maxlength
size

<input type=password>

name
value
maxlength
size

<textarea></textarea>

name
cols
rows
wrap

<input type=checkbox>

name
value
checked

<input type=radio>

name
value
checked

name
multiple
size

value
selected

<input type=image>

name
align
src

<input type=file>

name
accept

<input type=hidden>

name
value

<input type=reset>

value

<input type=submit>

name
value

Your textbook contains a similar table/quick guide at the end and so does the Javascript chapter. Check the posted lab notes as well, as they contain important lab exercises.

These lecture notes build on a pretty book written by Steven Brenner and Edwin Aoki, published in 1996, and that is now out of print (but you can find it in the library). Steve Brenner is the author of cgi-lib.pl library, the standard library used with Perl4 (just as Lincoln Stein's CGI.pm, described in your text, is regarded as the de facto standard library for CGI processing with Perl5).