Perl as a Scripting Language

Learning Basic Perl Syntax

Perl is free-form, like C; no constraints exist on the exact placement of any keyword. Often, Perl programs are stored in files with names that end in .pl, but there is no restriction on the filenames you use.

As in C, each Perl statement ends with a semicolon (;). A number sign or hash mark (#) marks the start of a comment; the perl program disregards the rest of the line beginning with the number sign.

Groups of Perl statements are enclosed in braces ({...}). This feature also is similar in C.

Using Variables in Perl

You don't have to declare Perl variables before using them, as you do in C. You can recognize a variable in a Perl script easily, because each variable name begins with a special character: an at symbol (@), a dollar sign ($), or a percent sign (%). These special characters denote the variable's type.

Secret

The three variable types in Perl are as follows:

• Scalar variables represent the basic data types: integer, floating-point number, and string. A dollar sign ($) precedes a scalar variable. Following are some examples:

      $maxlines = 256;
      $title = "Red Hat Linux Professional Secrets";

• Array variables are collections of scalar variables. An array variable has an at symbol (@) as a prefix. Thus, the following are arrays:

      @pages = (62, 26, 22, 24);
      @commands = ("start", "stop", "draw", "exit");

• Associative arrays are collections of key-value pairs, in which each key is a string and the value is any scalar variable. A percent-sign (%) prefix indicates an associative array. You can use associative arrays to associate a name with a value. You might store the amount of disk space each user occupies in an associative array, such as the following:

      %disk_usage = ("root", 147178, "naba", 28547, "emily", 55);

  Because each variable type has a special character prefix, you can use the same name for different variable types. Thus, %disk_usage, @disk_usage, and $disk_usage can appear within the same Perl program.

print "Name undefined!\n" if !(defined $name);

undef $name;

#!/usr/bin/perl
$title = "Red Hat Linux Professional Secrets";
$count1 = 650;
$count2 = 425;

$total = $count1 + $count2;

print "Title: $title -- $total pages\n";

Title: Red Hat Linux Professional Secrets -- 1075 pages

 print 'Title: $title -- $total pages\n';

Title: $title -- $total pages\n

Using Arrays

An array is a collection of scalars. The array name begins with an at symbol (@). As in C, array subscripts start at zero. You can access the elements of an array with an index. Perl allocates space for arrays dynamically.

Consider the following simple script:

#!/usr/bin/perl
@commands = ("start", "stop", "draw" , "exit");

$numcmd = @commands;
print "There are $numcmd commands.\n";
print "The first command is: $commands[0]\n";

When you run the script, it produces the following output:

There are 4 commands.
The first command is: start

Secret

Equating a scalar to an array sets the scalar to the number of elements in the array. The first element of an array is referenced by changing the @ sign to $ and then appending the index 0 in square brackets. Thus, the first element of the @commands array is referenced as $commands[0] because the index starts at zero. Thus, the fourth element in the @commands array is $commands[3].

Two special scalars are related to an array. The $[ variable is the current base index (the starting index), which is zero by default. The scalar $#arrayname (in which arrayname is the name of an array variable) has the last array index as the value. Thus, for the @commands array that has three elements, $#commands is 3.

You can print an entire array with a simple print statement like this:

print "@commands\n";

When Perl executes this statement for the @commands array used in this section's examples, it displays the following output:

start stop draw exit

print "PATH = $ENV{PATH}\n";

Listing the Predefined Variables in Perl

Perl has several predefined variables that contain useful information you may need in a Perl script. Following are a few important predefined variables:

• @ARGV is an array of strings that contains the command-line options to the script. The first option is $ARGV[0], the second one is $ARGV[1], and so on.

• %ENV is an associative array that contains the environment variables. You can access this array by using the environment-variable name as a key. Thus, $ENV{HOME} is the home directory, and $ENV{PATH} is the current search path that the shell uses to locate commands.

• $_ is the default argument for many functions. If you see a Perl function used without any argument, the function probably is expecting its argument in the $_ variable.

• @_ is the list of arguments passed to a subroutine.

• $0 is the name of the file containing the Perl program.

• $^V is the version number of Perl you are using (for example, if you use Perl Version 5.8.0, $^V will be v5.8.0).

• $< is the user ID (an identifying number) of the user running the script. This is useful on UNIX and Linux, where each user has an ID.

• $$ is the script's process ID.

• $? is the status the last system call has returned.

Using Operators and Expressions

Operators are used to combine and compare Perl variables. Typical mathematical operators are addition (+), subtraction (-), multiplication (*), and division (/). Perl and C provide nearly the same set of operators. When you use operators to combine variables, you end up with expressions. Each expression has a value.

Following are some typical Perl expressions:

error < 0
$count == 10
$count + $i
$users[$i]

These expressions are examples of the comparison operator (the first two lines), the arithmetic operator, and the array-index operator.

Secret

In Perl, don't use the == operator to determine whether two strings match; the == operator works only with numbers. To test the equality of strings, Perl includes the FORTRAN-style eq operator. Use eq to see whether two strings are identical, as follows:

if ($input eq "stop") { exit; }

Other FORTRAN-style, string-comparison operators include ne (inequality), lt (less than), gt (greater than), le (less than or equal), and ge (greater than or equal). Also, you can use the cmp operator to compare two strings. The return value is -1, 0, or 1, depending on whether the first string is less than, equal to, or greater than the second string.

Perl also provides another unique operators. C lacks an exponentiation operator, which FORTRAN includes; Perl uses ** as the exponentiation operator. Thus, you can enter the following:

$x = 2;
$y = 3;
$z = $x**$y;  # z should be 8 (2 raised to the power 3)
$y **= 2;     # y is now 9 (3 raised to the power 2)

You can initialize an array to null by using ()-the null-list operator-as follows:

@commands = ();

The dot operator (.) enables you to concatenate two strings, as follows:

$part1 = "Hello, ";
$part2 = "World!";
$message = $part1.$part2;  # Now $message = "Hello, World!"

The repetition operator, denoted by x=, is curious but useful. You can use the x= operator to repeat a string a specified number of times. Suppose that you want to initialize a string to 65 asterisks (*). The following example shows how you can initialize the string with the x= operator:

$marker = "*";
$marker x= 65;  # Now $marker is a string of 65 asterisks.

Another powerful operator in Perl is range, which is represented by two periods (..). You can initialize an array easily by using the range operator. Following are some examples:

@numerals = (0..9); # @numerals = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
@alphabet = ('A'..'Z'); # @alphabet = capital letters A through Z

Learning Regular Expressions

If you have used Linux (or any variant of UNIX) for a while, you probably know about the grep command, which enables you to search files for a pattern of strings. Following is a typical use of grep to locate all files that have any occurrences of the string blaster or Blaster-on any line of all files with names that end in .c:

cd /usr/src/linux*/drivers/cdrom
grep "[bB]laster"  *.c

The preceding commands produce the following output on my system:

sbpcd.c: *          Works with SoundBlaster compatible cards and with "no-sound"
sbpcd.c:        0x230, 1, /* Soundblaster Pro and 16 (default) */
sbpcd.c:        0x250, 1, /* OmniCD default, Soundblaster Pro and 16 */
sbpcd.c:        0x270, 1, /* Soundblaster 16 */
sbpcd.c:        0x290, 1, /* Soundblaster 16 */
sbpcd.c:static const char *str_sb_l = "soundblaster";
sbpcd.c:static const char *str_sb = "SoundBlaster";
sbpcd.c: *                 sbpcd=0x230,SoundBlaster
sbpcd.c:        msg(DBG_INF,"   LILO boot: ... sbpcd=0x230,SoundBlaster\n");
sjcd.c: *  the SoundBlaster/Panasonic style CDROM interface. But today, the

As you can see, grep has found all occurrences of blaster and Blaster in the files with names ending in .c.

The grep command's "[bB]laster" argument is known as a regular expression, a pattern that matches a set of strings. You construct a regular expression with a small set of operators and rules that resemble the ones for writing arithmetic expressions. A list of characters inside brackets ([...]), for example, matches any single character in the list. Thus, the regular expression "[bB]laster" is a set of two strings, as follows:

blaster   Blaster

Secret

Perl supports regular expressions, just as the grep command does. Many other UNIX programs, such as the vi editor and sed (the stream editor), also support regular expressions. The purpose of a regular expression is to search for a pattern of strings in a file. That's why editors support regular expressions.

Perl enables you to construct complex regular expressions. The rules, however, are fairly simple. Essentially, the regular expression is a sequence of characters in which some characters have special meaning. Table 24-2 describes the basic rules for interpreting the characters.

If you want to match one of the characters $, |, *, ^, [, ], \, and /, you have to place a backslash before them. Thus, you type these characters as \$, \|, \*, \^, \[, \], \\, and \/. Regular expressions often look confusing because of the preponderance of strange character sequences and the generous sprinkling of backslashes. As with anything else, however, you can start slowly and use only a few of the features in the beginning.

Table 24-2: Rules for Interpreting Regular Expression Characters

Expression	Meaning
.	Matches any single character except a newline
x*	Matches zero or more occurrences of the character x
x+	Matches one or more occurrences of the character x
x?	Matches zero or one occurrence of the character x
[...]	Matches any of the characters inside the brackets
x{n}	Matches exactly n occurrences of the character x
x{n,}	Matches n or more occurrences of the character x
x{,m}	Matches zero or, at most, m occurrences of the character x
x{n,m}	Matches at least n occurrences, but no more than m occurrences of the character x
$	Matches the end of a line
\0	Matches a null character
\b	Matches a backspace
\B	Matches any character not at the beginning or end of a word
\b	Matches the beginning or end of a word-when not inside brackets
\cX	Matches Ctrl-X (where X is any alphabetic character)
\d	Matches a single digit
\D	Matches a nondigit character
\f	Matches a form feed
\n	Matches a newline (line-feed) character
\ooo	Matches the octal value specified by the digits ooo (where each o is a digit between 0 and 7)
\r	Matches a carriage return
\S	Matches a non-white-space character
\s	Matches a white-space character (space, tab, or newline)
\t	Matches a tab
\W	Matches a nonalphanumeric character
\w	Matches an alphanumeric character
\xhh	Matches the hexadecimal value specified by the digits hh (where each h is a digit between 0 and f)
^	Matches the beginning of a line

So far, this section has summarized the syntax of regular expressions. But, you have not seen how to use regular expressions in Perl. Typically, you place a regular expression within a pair of slashes and use the match (=~)or not-match (!~) operators to test a string. You can write a Perl script that performs the same search as the one done with grep earlier in this section. The following steps help you complete this exercise:

1. Use a text editor to type and save the following script in a file named lookup:

   #!/usr/bin/perl
   
   while (<STDIN>)
   {
       if ( $_ =~ /[bB]laster/ ) { print $_; }
   }

2. Make the lookup file executable by using the following command:

   chmod +x lookup

3. Try the script by using the following command:

   cat /usr/src/linux*/drivers/cdrom/sbpcd.c | ./lookup

   My system responds with this:

    *    Works with SoundBlaster compatible cards and with "no-sound"
           0x230, 1, /* Soundblaster Pro and 16 (default) */
           0x250, 1, /* OmniCD default, Soundblaster Pro and 16 */
           0x270, 1, /* Soundblaster 16 */
           0x290, 1, /* Soundblaster 16 */
   static const char *str_sb_l = "soundblaster";
   static const char *str_sb = "SoundBlaster";
    *                 sbpcd=0x230,SoundBlaster
                   msg(DBG_INF,"   LILO boot: ... sbpcd=0x230,SoundBlaster\n");
    *    Works with SoundBlaster compatible cards and with "no-sound"
           0x230, 1, /* Soundblaster Pro and 16 (default) */
           0x250, 1, /* OmniCD default, Soundblaster Pro and 16 */
           0x270, 1, /* Soundblaster 16 */
           0x290, 1, /* Soundblaster 16 */
   static const char *str_sb_l = "soundblaster";
   static const char *str_sb = "SoundBlaster";
    *                 sbpcd=0x230,SoundBlaster
                   msg(DBG_INF,"   LILO boot: ... sbpcd=0x230,SoundBlaster\n");

   The cat command feeds the contents of a specific file (which, as you know from the grep example, contains some lines with the regular expression) to the lookup script. The script simply applies Perl's regular expression-match operator (=~) and prints any matching line.

The $_ variable in the script needs some explanation. The <STDIN> expression gets a line from the standard input and, by default, stores that line in the $_ variable. Inside the while loop, the regular expression is matched against the $_ string. The following single Perl statement completes the lookup script's work:

if ( $_ =~ /[bB]laster/ ) { print $_; }

This example illustrates how you might use a regular expression to search for occurrences of strings in a file.

After you use regular expressions for a while, you can better appreciate their power. The trick is to find the regular expression that performs the task you want. Following is a search that looks for all lines that begin with exactly seven spaces and end with a right parenthesis:

while (<STDIN>)
{
    if ( $_ =~ /\)\n/ && $_ =~ /^ {7}\S/ )  { print $_; }
}

Using Flow-Control Statements

So far, you have seen Perl statements intended to execute in a serial fashion, one after another. Perl also includes statements that enable you to control the flow of execution of the statements. You already have seen the if statement and a while loop. Perl includes a complete set of flow-control statements just like those in C, but with a few extra features.

In Perl, all conditional statements take the following form:

conditional-statement
{ Perl code to execute if conditional is true }

Notice that you must enclose within braces ({...}) the code that follows the conditional statement. The conditional statement checks the value of an expression to determine whether to execute the code within the braces. In Perl, as in C, any nonzero value is considered true, whereas a zero value is false.

The following sections briefly describe the syntax of the major conditional statements in Perl.

Using if and unless Statements

The Perl if statement resembles the C if statement. For example, an if statement might check a count to see whether the count exceeds a threshold, as follows:

if ( $count > 25 ) { print "Too many errors!\n"; }

You can add an else clause to the if statement, as follows:

if ($user eq "root")
{
    print "Starting simulation...\n";
}
else
{
    print "Sorry $user, you must be \"root\" to run this program.\n.";
    exit;
}

If you know C, you can see that Perl's syntax looks quite a bit like that in C. Conditionals with the if statement can have zero or more elsif clauses to account for more alternatives, such as the following:

print "Enter version number:"; # prompt user for version number
$os_version = <STDIN>;         # read from standard input
chop $os_version;  # get rid of the newline at the end of the line
# Check version number
if ($os_version >= 10 ) { print "No upgrade necessary\n";}
elsif ($os_version >= 6 && $os_version < 9) 
                                    { print "Standard upgrade\n";}
elsif ($os_version > 3 && $os_version < 6) { print "Reinstall\n";}
else { print "Sorry, cannot upgrade\n";}

Secret

The unless statement is unique to Perl. This statement has the same form as if, including the use of elsif and else clauses. The difference is that unless executes its statement block only if the condition is false. You can, for example, use the following:

unless ($user eq "root")
{
    print "You must be \"root\" to run this program.\n";
    exit;
}

In this case, unless the string user is "root", the script exits.

Using the while Statement

Use Perl's while statement for looping-the repetition of some processing until a condition becomes false. To read a line at a time from standard input and to process that line, you might use the following:

while ($in = <STDIN>)
{
# Code to process the line
    print $in;
}

Secret

If you read from the standard input without any argument, Perl assigns the current line of standard input to the $_ variable. Thus, you can write the while loop to read lines from the standard input, as follows:

while (<STDIN>)
{
# Code to process the line
    print $_;
}

Perl's while statements are more versatile than those of C because you can use almost anything as the condition to be tested. If you use an array as the condition, for example, the while loop executes until the array has no elements left, as in the following example:

# Assume @arglist has the current set of command arguments
while (@arglist)
{
    $arg = shift @arglist;  # this extracts one argument
# Code to process the current argument
    print $arg;
}

The shift function removes the first element of an array and returns that element.

You can skip to the end of a loop with the next keyword; the last keyword exits the loop. The following while loop adds the numbers from 1 to 10, skipping 5:

while (1)
{
    $i++;
    if($i == 5) { next;}  # Jump to the next iteration if $i is 5
    if($i > 10) { last;}  # When $i exceeds 10, end the loop
    $sum += $i;           # Add the numbers
}
# At this point $sum should be 50.

Using for and foreach Statements

Perl and C's for statements have similar syntax. Use the for statement to execute a statement any number of times, based on the value of an expression. The syntax of the for statement is as follows:

for (expr_1; expr_2; expr_3) { statement block }

expr_1 is evaluated one time, at the beginning of the loop; the statement block is executed until expression expr_2 evaluates to zero. The third expression, expr_3, is evaluated after each execution of the statement block. You can omit any of the expressions, but you must include the semicolons. In addition, the braces around the statement block are required. Following is an example that uses a for loop to add the numbers from 1 to 10:

for($i=0, $sum=0; $i <= 10; $sum += $i, $i++) {}

In this example, the actual work of adding the numbers is done in the third expression, and the statement the for loop controls is an empty block ({}).

Secret

The foreach statement is most appropriate for processing arrays. Following is the syntax of the foreach statement:

foreach Variable (Array) { statement block }

The foreach statement assigns to Variable an element from the Array and executes the statement block. The foreach statement repeats this procedure until no array elements remain. The following foreach statement adds the numbers from 1 to 10:

foreach $i (1..10) { $sum += $i;}

Notice that I declare the array with the range operator (..). You also can use a list of comma-separated items as the array.

If you omit the Variable in a foreach statement, Perl implicitly uses the $_ variable to hold the current array element. Thus, you can use the following:

foreach (1..10) { $sum += $_;}

ReEnter:
print "Enter offset: ";
$offset = <STDIN>;
chop $offset;
unless ($offset > 0 && $offset < 512)
{
    print "Bad offset: $offset\n";
    goto ReEnter;
}

Accessing Linux Commands

You can execute any Linux command from Perl in several ways:

• Call the system function with a string that contains the Linux command you want to execute.

• Enclose a Linux command within backquotes (`command`), which also are known as grave accents. You can run a Linux command this way and capture its output.

• Call the fork function to copy the current script and process new commands in the child process. (If a process starts another process, the new one is known as a child process.)

• Call the exec function to overlay the current script with a new script or Linux command.

• Use fork and exec to provide shell-like behavior. (Monitor user input, and process each user-entered command through a child process.) This section presents a simple example of how to accomplish this task.

The simplest way to execute a Linux command in your script is to use the system function with the command in a string. After the system function returns, the exit code from the command is in the $? variable. You can easily write a simple Perl script that reads a string from the standard input and processes that string with the system function. Follow these steps:

1. Use a text editor to enter and save the following script in a file named rcmd.pl:

   #!/usr/bin/perl
   # Read user input and process command
   
   $prompt = "Command (\"exit\" to quit): ";
   print $prompt;
   
   while (<STDIN>)
   {
       chop;
       if ($_ eq "exit") { exit 0;}
   
   # Execute command by calling system
       system $_;
       unless ($? == 0) {print "Error executing: $_\n";}
       print $prompt;
   }

2. Make the rcmd.pl file executable by using the following command:

   chmod +x rcmd.pl

3. Run the script by typing ./rcmd.pl at the shell prompt in a terminal window. The following listing shows some sample output from the rcmd.pl script (the output depends on what commands you enter):

   Command ("exit" to quit): ps
     PID TTY          TIME CMD
     767 pts/0    00:00:00 bash
     940 pts/0    00:00:00 rcmd.pl
     945 pts/0    00:00:00 ps
   Command ("exit" to quit): exit      

Also, you can run Linux commands by using fork and exec in your Perl script. Following is an example script-psh.pl-that uses fork and exec to execute commands the user enters:

#!/usr/bin/perl

# This is a simple script that uses "fork" and "exec" to
# run a command entered by the user

$prompt = "Command (\"exit\" to quit): ";
print $prompt;

while (<STDIN>)
{
    chop;    # remove trailing newline
    if($_ eq "exit") { exit 0;}

    $status = fork;
    if($status)
    {
# In parent... wait for child process to finish...
        wait;
        print $prompt;
        next;
    }
    else
    {
        exec $_;
    }
}

The following example shows how the psh.pl script executes the ps command (remember to type chmod +x psh.pl before typing ./psh.pl):

Command ("exit" to quit