This sets $argument to the next command-line (or subroutine argument) if there is one, and "default_value" otherwise. It should be read as $argument = (shift || "default_value").

This succeeds if $file is a plain file (-f) and a text file to boot (-T). The symbol _ refers to the last filehandle used for a file test or stat().

When Perl is invoked with the -s option, command-line arguments implicitly define variables of the same name. So if our program is called with a -version argument, $version will be defined and the print() statement will execute. If $version is undefined, it's necessarily false and so the statement fails before the print() statement is reached.

Off With Its Tail - An Aside

At the risk of our patient expiring from lack of attention, let me talk about the statement that grabs the input: chomp($answer = <STDIN>). The chomp() function lops off the line terminator from the end of the string - the \n resulting from Tom hitting the RETURN key. chomp() returns the number of characters that were lopped off (usually 1). So if Tom's answer to the prompt printed by our example is:

y<RETURN>

then the incorrect $answer = chomp(<STDIN>) sets $answer to 1 (on UNIX, DOS, and Windows) rather than y. chop(), which you'll still see in Perl 4 programs, has a similar potential for disaster. chop() removes the last character whether it's a line terminator or not. The proper idiom is chomp($answer = <STDIN>) (or chop($answer = <STDIN>)) which both set $answer to y. If you want to chop more than one character, use substr(), described later.

An Operator By Any Other Name

Perl 5 provides the and and or operators which work just like && and ||, but with lower precedence (and in fact the lowest precedence of all Perl operators). If you're one of those people who object to code that looks like line noise, go ahead and use them - in fact, their low precedence often saves on parentheses:

open FILE, "foo" or die "Can't open file\n";

in contrast to

open (FILE, "foo") || die "Can't open file\n";

But be careful! $argument = shift || "some_value" does the right thing, but $argument = shift or "some_value" doesn't. The first is equivalent to $argument = (shift || "some_value") and the second is equivalent to ($argument = shift) or "some_value"). When in doubt, parenthesize.

Loop The Loop

While Tom is off contacting the ladies and gentlemen of the ambulance service, Dick and Harry have established that the patient is in arrest (no pulse) and is apnic (not breathing). As it is unlikely that our unfortunate victim choked or drowned to death, there is only one course of action - CPR. Harry seems to knows how to perform rescue breathing, but Dick is looking a bit uncertain.

while ($pulse ne "y") { 
    print "Do 3 sets of 5 chest compressions\n"; 
    print "Any sign of a pulse? ";
    chomp($pulse = <STDIN>); 
} 
print "Yippee!\n";

We've set up a while loop with an exit condition ("is there a pulse?"). This is a simple construct with one downside - if our prostrate friend is on the way to her next incarnation, Dick will be left doing chest compressions until his batteries run down, and for no good reason. In fact exhaustion is one of the four sanctioned reasons for ceasing CPR.**

The others being:

• the patient revives
• the patient dies
• you are relieved by qualified personnel

What we really want to do is keep going until Dick is tired, but to stop as soon as we get a pulse. The usual way of exiting a loop is via last:

while ($pulse ne "y") { 
    print "Do 3 sets of 5 chest compressions\n";
    print "Any sign of a pulse? ";
    chomp($pulse = <STDIN>);
    last if $compressions++ > 500;
}

As you can see, last terminates a loop immediately. Other loop control statements are next (which skips the rest of the block - the statements inside the curly braces) and begins the next execution), redo (which restarts the loop without testing the conditional) and continue (which identifies a block to be executed before the loop is re-entered).

Labels make it possible to move around between loops:

CPR: while ($tired ne "y") {  # outer loop
  print "Do 3 sets of 5 chest compressions\n";
  foreach (1..3) {            # inner loop
    print "Any sign of a pulse? "; 
    chomp($pulse = <STDIN>);
    last CPR if $pulse eq "y";
    print "Are you too tired? "; 
    chomp($tired = <STDIN>); 
  }
}

One Statement To Rule Them All

Finally let's not forget our final

print "Yippee!\n"

If we've exited the loop because poor Dick has collapsed with exhaustion next to a corpse, crowing with triumph might be considered tactless. But we can discern how we exited the loop - if it was because of fatigue, we know that $tired must be y. Let's make our conclusion more appropriate:

$message = (($tired eq "y") ? "Too bad\n" : "Yippee!\n");

print $message, "\n";

or even better

print (($tired eq "y") ? "Too bad\n" : "Yippee!\n");

This construct, which we visited briefly last issue, is the conditional operator ?: which is trinary (takes three operators) and behaves identically to:

if ($tired eq "y") { 
    print "Too bad\n"; 
} else { 
    print "Yippee!\n"; 
}

A particularly yummy (or maybe perverse) use of this operator arises from the fact that you can actually assign to it. Consider this code:

$we = $undertaker = 'sad'; 
print "How is the patient? "; 
chomp($patient = <STDIN>); 
($patient eq "ok" ? $we : $morgue) = 'happy';
print "Patient is $patient, we are $we, undertaker is $morgue\n";

where we assign happy to either $we or $morgue depending on whether the patient is okay. Running it yields:

How is the patient? ok 
Patient is ok, we are happy, undertaker is sad

or, if we're unlucky:

How is the patient? dead 
Patient is dead, we are sad, undertaker is happy

Great Value, Low Prices

This works because you can assign to ?: when both the second and third arguments are lvalues. The term "lvalue" sounds technical, but it's just a fancy word for "Something you can assign a value to." The "l" derives from the fact that lvalues usually appear on the left hand of an equals sign; the opposite of an lvalue is an rvalue. Nearly all variables are lvalues, but this is Perl, where the obvious is never enough:

• Assignment, under some circumstances, can be thought of as an lvalue. When you say chomp($answer = <STDIN>), the assignment $answer = <STDIN> is an lvalue that can be chomped just like a variable.

• Various functions are lvaluable. For example, you can use substr() in an assignment if its first argument is an lvalue:

$exclaim = "No way!\n"; 
print $exclaim; 
substr($exclaim,0,2) = "Yes"; 
print $exclaim;

displays

No way! 
Yes way!

Nothing Like A Happy Ending

Needless to say, Tom arrived with the cavalry and our patient is in safe hands, while everybody celebrates Perl's medicinal qualities. Incidentally, never perform CPR on a victim if they are breathing, since that means they have a pulse and their heart is beating. If you do, you can cause cardiac arrest.

See http://www.catt.citri.edu.au/emergency/docs/jokes.html for the story of the ambulance driver who arrived to find a bystander performing CPR on a woman with a broken ankle who yelled "Ow!" at each compression.

_ _END_ _

Further Reading

• the perlsyn documentation
• ftp://www.perl.org/CPAN/doc/FMTEYEWTK/switch_statements
• http://www.medaccess.com/first_aid/FA_TOC.htm Frossie Economou is an astronomer who battles software (and users) at the Joint Astronomy Centre, Hawaii, in order to fund her book habit and feed her fish.

_ _END_ _