The result of the pattern match, either true or false, is stored in the scalar variable $match.

Line 22 checks whether the date is a valid date in any century. The only difference between this pattern and the one in line 20 is that the year can be any one-to-four-digit number. The result of the pattern match is stored in $olddate.

Lines 23-29 check whether either $match or $olddate is true and print the appropriate message.

As you can see, the pattern-matching facility in Perl is quite powerful. This program is less than 30 lines long, including comments; the equivalent program in almost any other programming language would be substantially longer and much more difficult to write.

Specifying a Different Pattern Delimiter

So far, all the patterns you have seen have been enclosed by / characters.

/de*f/

These / characters are known as pattern delimiters.

Because / is the pattern-delimiter character, you must use \/ to include a / character in a pattern. This can become awkward if you are searching for a directory such as, for example, /u/jqpublic/perl/prog1.

/\/u\/jqpublic\/perl\/prog1/

To make it easier to write patterns that include / characters, Perl enables you to use any pattern-delimiter character you like. The following pattern also matches the directory /u/jqpublic/perl/prog1:

m!/u/jqpublic/perl/prog1!

Here, the m indicates the pattern-matching operation. If you are using a pattern delimiter other than /, you must include the m.

There are two things you should watch out for when you use other pattern delimiters. First, if you use the ' character as a pattern delimiter, the Perl interpreter does not substitute for scalar-variable names. m'$var' This matches the string $var, not the current value of the scalar variable $var. Second, if you use a pattern delimiter that is normally a special-pattern character, you will not be able to use that special character in your pattern. For example, if you want to match the pattern ab?c (which matches a, optionally followed by b, followed by c) you cannot use the ? character as a pattern delimiter. The pattern m?ab?c? produces a syntax error, because the Perl interpreter assumes that the ? after the b is a pattern delimiter. You can still use m?ab\?c? but this pattern won't match what you want. Because the ? inside the pattern is escaped, the Perl interpreter assumes that you want to match the actual ? character, and the pattern matches the sequence ab?c.

Pattern-Matching Options

When you specify a pattern, you also can supply options that control how the pattern is to be matched. Table 7.4 lists these pattern-matching options.

All pattern options are included immediately after the pattern. For example, the following pattern uses the i option to ignore case:

/ab*c/i

You can specify as many of the options as you like, and the options can be in any order.

Matching All Possible Patterns

The g operator tells the Perl interpreter to match all the possible patterns in a string. For example, if you search the string balata using the pattern

/.a/g

which matches any character followed by a, the pattern matches ba, la, and ta.

If a pattern with the g option specified appears as an assignment to an array variable, the array variable is assigned a list consisting of all the patterns matched. For example,

@matches = "balata" =~ /.a/g;

assigns the following list to @matches:

("ba", "la", "ta")

Now, consider the following statement:

$match = "balata" =~ /.a/g;

The first time this statement is executed, $match is assigned the first pattern matched, which in this case is ba. If this assignment is performed again, $match is assigned the second pattern matched in the string, which is la, and so on until the pattern runs out of matches.

This means that you can use patterns with the g option in loops. Listing 7.10 shows how this works.

Listing 7.10. A program that loops using a pattern.

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

2:  

3:  while ("balata" =~ /.a/g) {

4:          $match = $&;

5:          print ("$match\n");

6:  }

$ program7_10

ba

la

ta

$

The first time through the loop, $match has the value of the first pattern matched, which is ba. (The system variable $& always contains the last pattern matched; this pattern is assigned to $match in line 4.) When the loop is executed for a second time, $match has the value la. The third time through, $match has the value ta. After this, the loop terminates; because the pattern doesn't match anything else, the conditional expression is now false.

Determining the Match Location

If you need to know how much of a string has been searched by the pattern matcher when the g operator is specified, use the pos function.

$offset = pos($string);

This returns the position at which the next pattern match will be started.

You can reposition the pattern matcher by putting pos() on the left side of an assignment.

pos($string) = $newoffset;

This tells the Perl interpreter to start the next pattern match at the position specified by $newoffset.

If you change the string being searched, the match position is reset to the beginning of the string.

Ignoring Case

The i option enables you to specify that a matched letter can either be uppercase or lowercase. For example, the following pattern matches de, dE, De, or DE:

/de/i

Patterns that match either uppercase or lowercase letters are said to be case-insensitive.

Treating the String as Multiple Lines

The m option tells the Perl interpreter that the string to be matched contains multiple lines of text. When the m option is specified, the ^ special character matches either the start of the string or the start of any new line. For example, the pattern

/^The/m

matches the word The in

This pattern matches\nThe first word on the second line

The m option also specifies that the $ special character is to match the end of any line. This means that the pattern

/line.$/m

is matched in the following string:

This is the end of the first line.\nHere's another line.

Evaluating a Pattern Only Once

The o option enables you to tell the Perl interpreter that a pattern is to be evaluated only once. For example, consider the following:

$var = 1;

$line = <STDIN>;

while ($var < 10) {

        $result = $line =~ /$var/o;

        $line = <STDIN>;

        $var++;

}

The first time the Perl interpreter sees the pattern /$var/, it replaces the name $var with the current value of $var, which is 1; this means that the pattern to be matched is /1/.

Because the o option is specified, the pattern to be matched remains /1/ even when the value of $var changes. If the o option had not been specified, the pattern would have been /2/ the next time through the loop.

Treating the String as a Single Line

The s option specifies that the string to be matched is to be treated as a single line of text. In this case, the . special character matches every character in a string, including the newline character. For example, the pattern /a.*bc/s is matched successfully in the following string:

axxxxx \nxxxxbc

If the s option is not specified, this pattern does not match, because the . character does not match the newline.

Using White Space in Patterns

One problem with patterns in Perl is that they can become difficult to follow. For example, consider this pattern, which you saw earlier:

/\d{2}([\W])\d{2}\1\d{2}/

Patterns such as this are difficult to follow, because there are a lot of backslashes, braces, and brackets to sort out.

Perl 5 makes life a little easier by supplying the x option. This tells the Perl interpreter to ignore white space in a pattern unless it is preceded by a backslash. This means that the preceding pattern can be rewritten as the following, which is much easier to follow:

/\d{2} ([\W]) \d{2} \1 \d{2}/x

Here is an example of a pattern containing an actual blank space:

/[A-Z] [a-z]+ \ [A-Z] [a-z]+ /x

This matches a name in the standard first-name/last-name format (such as John Smith). Normally, you won't want to use the x option if you're actually trying to match white space, because you wind up with the backslash problem all over again.

The Substitution Operator

Perl enables you to replace part of a string using the substitution operator, which has the following syntax:

s/pattern/replacement/

The Perl interpreter searches for the pattern specified by the placeholder pattern. If it finds pattern, it replaces it with the string represented by the placeholder replacement. For example:

$string = "abc123def";

$string =~ s/123/456/;

Here, 123 is replaced by 456, which means that the value stored in $string is now abc456def.

You can use any of the pattern special characters in the substitution operator. For example,

s/[abc]+/0/

searches for a sequence consisting of one or more occurrences of the letters a, b, and c (in any order) and replaces the sequence with 0.

If you just want to delete a sequence of characters rather than replace it, leave out the replacement string as in the following example, which deletes the first occurrence of the pattern abc:

s/abc//

Using Pattern-Sequence Variables in Substitutions

You can use pattern-sequence variables to include a matched pattern in the replacement string. The following is an example:

s/(\d+)/[$1]/

This matches a sequence of one or more digits. Because this sequence is enclosed in parentheses, it is stored in the scalar variable $1. In the replacement string, [$1], the scalar variable name $1 is replaced by its value, which is the matched pattern.

Options for the Substitution Operator

The substitution operator supports several options, which are listed in Table 7.5.

As with pattern matching, options are appended to the end of the operator. For example, to change all occurrences of abc to def, use the following:

s/abc/def/g

Global Substitution

The g option changes all occurrences of a pattern in a particular string. For example, the following substitution puts parentheses around any number in the string:

s/(\d+)/($1)/g

Listing 7.11 is an example of a program that uses global substitution. It examines each line of its input, removes all extraneous leading spaces and tabs, and replaces multiple spaces and tabs between words with a single space.

Listing 7.11. A simple white space cleanup program.

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

2:  

3:  @input = <STDIN>;

4:  $count = 0;

5:  while ($input[$count] ne "") {

6:          $input[$count] =~ s/^[ \t]+//;

7:          $input[$count] =~ s/[ \t]+\n$/\n/;

8:          $input[$count] =~ s/[ \t]+/ /g;

9:          $count++;

10: }

11: print ("Formatted text:\n");

12: print (@input);

$ program7_11

This is   a  line   of    input.

  Here   is another line.  

This     is my  last line of   input.

^D

Formatted text:

This is a line of input.

Here is another line.

This is my last line of input.

$

This program performs three substitutions on each line of its input. The first substitution, in line 6, checks whether there are any spaces or tabs at the beginning of the line. If any exist, they are removed.

Similarly, line 7 checks whether there are any spaces or tabs at the end of the line (before the trailing newline character). If any exist, they are removed. To do this, line 7 replaces the following pattern (one or more spaces and tabs, followed by a newline character, followed by the end of the line) with a newline character:

/[ \t]+\n$/

Line 8 uses a global substitution to remove extra spaces and tabs between words. The following pattern matches one or more spaces or tabs, in any order; these spaces and tabs are replaced by a single space:

/[ \t]+/

Ignoring Case

The i option ignores case when substituting. For example, the following substitution replaces all occurrences of the words no, No, NO, and nO with NO. (Recall that the \b escape character specifies a word boundary.)

s/\bno\b/NO/gi

Replacement Using an Expression

The e option treats the replacement string as an expression, which it evaluates before replacing. For example, consider the following:

$string = "0abc1";

$string =~ s/[a-zA-Z]+/$& x 2/e

The substitution shown here is a quick way to duplicate part of a string. Here's how it works:

1. The pattern /[a-zA-Z]+/ matches abc, which is stored in the built-in variable $&.
2. The e option indicates that the replacement string, $& x 2, is to be treated as an expression. This expression is evaluated, producing the result abcabc.
3. abcabc is substituted for abc in the string stored in $string. This means that the new value of $string is 0abcabc1.

Listing 7.12 is another example that uses the e option in a substitution. This program takes every integer in a list of input files and multiplies them by 2, leaving the rest of the contents unchanged. (For the sake of simplicity, the program assumes that there are no floating-point numbers in the file.)

---

Listing 7.12. A program that multiplies every integer in a file by 2.

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

2:  

3:  $count = 0;

4:  while ($ARGV[$count] ne "") {

5:          open (FILE, "$ARGV[$count]");

6:          @file = <FILE>;

7:          $linenum = 0;

8:          while ($file[$linenum] ne "") {

9:                  $file[$linenum] =~ s/\d+/$& * 2/eg;

10:                 $linenum++;

11:         }

12:         close (FILE);

13:         open (FILE, ">$ARGV[$count]");

14:         print FILE (@file);

15:         close (FILE);

16:         $count++;

17: }

---

If a file named foo contains the text

This contains the number 1.

This contains the number 26.

and the name foo is passed as a command-line argument to this program, the file foo becomes

This contains the number 2.

This contains the number 52.

This program uses the built-in variable @ARGV to retrieve filenames from the command line. Note that the program cannot use <>, because the following statement reads the entire contents of all the files into a single array:

@file = <>;

Lines 8-11 read and substitute one line of a file at a time. Line 9 performs the actual substitution as follows:

1. The pattern \d+ matches a sequence of one or more digits, which is automatically assigned to $&.
2. The value of $& is substituted into the replacement string.
3. The e option indicates that this replacement string is to be treated as an expression. This expression multiplies the matched integer by 2.
4. The result of the multiplication is then substituted into the file in place of the original integer.
5. The g option indicates that every integer on the line is to be substituted for.

After all the lines in the file have been read, the file is closed and reopened for writing. The call to print in line 14 takes the list stored in @file-the contents of the current file-and writes them back out to the file, overwriting the original contents.

Evaluating a Pattern Only Once

As with the match operator, the o option to the substitution operator tells the Perl interpreter to replace a scalar variable name with its value only once. For example, the following statement substitutes the current value of $var for its name, producing a replacement string:

$string =~ /abc/$var/o;

This replacement string then never changes, even if the value of $var changes. For example:

$var = 17;

while ($var > 0) {

        $string = <STDIN>;

        $string =~ /abc/$var/o;

        print ($string);

        $var--;  # the replacement string is still "17"

}

Again, as with the match operator, there is no real reason to use the o option.

Treating the String as Single or Multiple Lines

As in the pattern-matching operator, the s and m options specify that the string to be matched is to be treated as a single line or as multiple lines, respectively.

The s option ensures that the newline character \n is matched by the . special character.

$string = "This is a\ntwo-line string.";

$string =~ s/a.*o/one/s;

# $string now contains "This is a one-line string."

If the m option is specified, ^ and $ match the beginning and end of any line.

$string = "The The first line\nThe The second line";

$string =~ s/^The//gm;

# $string now contains "The first line\nThe second line"

$string =~ s/e$/k/gm;

# $string now contains "The first link\nThe second link"

The \A and \Z escape sequences (defined in Perl 5) always match only the beginning and end of the string, respectively. (This is the only case where \A and \Z behave differently from ^ and $.)

NOTE

The m and s options are defined only in Perl 5. To treat a string as multiple lines when you run Perl 4, set the $* system variable, described on Chapter 17.

Using White Space in Patterns

The x option tells the Perl interpreter to ignore all white space unless preceded by a backslash. As with the pattern-matching operator, ignoring white space makes complicated string patterns easier to read.

$string =~ s/\d{2} ([\W]) \d{2} \1 \d{2}/$1-$2-$3/x

This converts a Chapter-month-year string to the dd-mm-yy format.

NOTE

Even if the x option is specified, spaces in the replacement string are not ignored. For example, the following replaces 14/04/95 with 14 - 04 - 95, not 14-04-95: $string =~ s/\d{2} ([\W]) \d{2} \1 \d{2}/$1 - $2 - $3/x Also note that the x option is defined only in Perl 5.

Specifying a Different Delimiter

You can specify a different delimiter to separate the pattern and replacement string in the substitution operator. For example, the following substitution operator replaces /u/bin with /usr/local/bin:

s#/u/bin#/usr/local/bin#

The search and replacement strings can be enclosed in parentheses or angle brackets.

s(/u/bin)(/usr/local/bin)

s</u/bin>/\/usr\/local\/bin/

NOTE

As with the match operator, you cannot use a special character both as a delimiter and in a pattern. s.a.c.def. This substitution will be flagged as containing an error because the . character is being used as the delimiter. The substitution s.a\.c.def. does work, but it substitutes def for a.c, where . is an actual period and not the pattern special character.

The Translation Operator

Perl also provides another way to substitute one group of characters for another: the tr translation operator. This operator uses the following syntax:

tr/string1/string2/

Here, string1 contains a list of characters to be replaced, and string2 contains the characters that replace them. The first character in string1 is replaced by the first character in string2, the second character in string1 is replaced by the second character in string2, and so on.

Here is a simple example:

$string = "abcdefghicba";

$string =~ tr/abc/def/;

Here, the characters a, b, and c are to be replaced as follows:

• All occurrences of the character a are to be replaced by the character d.
• All occurrences of the character b are to be replaced by the character e.
• All occurrences of the character c are to be replaced by the character f.

After the translation, the scalar variable $string contains the value defdefghifed.

NOTE

If the string listing the characters to be replaced is longer than the string containing the replacement characters, the last character of the replacement string is repeated. For example: $string = "abcdefgh"; $string =~ tr/efgh/abc/; Here, there is no character corresponding to d in the replacement list, so c, the last character in the replacement list, replaces h. This translation sets the value of $string to abcdabcc. Also note that if the same character appears more than once in the list of characters to be replaced, the first replacement is used:

$string =~ tr/AAA/XYZ/; replaces A with X

The most common use of the translation operator is to convert alphabetic characters from uppercase to lowercase or vice versa. Listing 7.13 provides an example of a program that converts a file to all lowercase characters.

---

Listing 7.13. An uppercase-to-lowercase conversion program.

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

2:  

3:  while ($line = <STDIN>) {

4:          $line =~ tr/A-Z/a-z/;

5:          print ($line);

6:  }

---

$ program7_13

THIS LINE IS IN UPPER CASE.

this line is in upper case.

ThiS LiNE Is iN mIxED cASe.

this line is in mixed case.

^D

$

This program reads a line at a time from the standard input file, terminating when it sees a line containing the Ctrl+D (end-of-file) character.

Line 4 performs the translation operation. As in the other pattern-matching operations, the range character (-) indicates a range of characters to be included. Here, the range a-z refers to all the lowercase characters, and the range A-Z refers to all the uppercase characters.

NOTE

There are two things you should note about the translation operator: The pattern special characters are not supported by the translation operator. You can use y in place of tr if you want. $string =~ y/a-z/A-Z/;

Options for the Translation Operator

The translation operator supports three options, which are listed in Table 7.6.

The c option (c is for "complement") translates all characters that are not specified. For example, the statement

$string =~ tr/\d/ /c;

replaces everything that is not a digit with a space.

Table 7.6. Options for the translation operator.

Option	Description
c	Translate all characters not specified
d	Delete all specified characters
s	Replace multiple identical output characters with a single character

The d option deletes every specified character.

$string =~ tr/\t //d;

This deletes all the tabs and spaces from $string.

The s option (for "squeeze") checks the output from the translation. If two or more consecutive characters translate to the same output character, only one output character is actually used. For example, the following replaces everything that is not a digit and outputs only one space between digits:

$string =~ tr/0-9/ /cs;

Listing 7.14 is a simple example of a program that uses some of these translation options. It reads a number from the standard input file, and it gets rid of every input character that is not actually a digit.

---

Listing 7.14. A program that ensures that a string consists of nothing but digits.

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

2:  

3:  $string = <STDIN>;

4:  $string =~ tr/0-9//cd;

5:  print ("$string\n");

---

$ program7_14

The number 45 appears in this string.

45

$

Line 4 of this program performs the translation. The d option indicates that the translated characters are to be deleted, and the c option indicates that every character not in the list is to be deleted. Therefore, this translation deletes every character in the string that is not a digit. Note that the trailing newline character is not a digit, so it is one of the characters deleted.

Extended Pattern-Matching

Perl 5 provides some additional pattern-matching capabilities not found in Perl 4 or in standard UNIX pattern-matching operations.

Extended pattern-matching capabilities employ the following syntax:

(?<c>pattern)

<c> is a single character representing the extended pattern-matching capability being used, and pattern is the pattern or subpattern to be affected.

The following extended pattern-matching capabilities are supported by Perl 5:

• Parenthesizing subpatterns without saving them in memory
• Embedding options in patterns
• Positive and negative look-ahead conditions
• Comments

Parenthesizing Without Saving in Memory

In Perl, when a subpattern is enclosed in parentheses, the subpattern is also stored in memory. If you want to enclose a subpattern in parentheses without storing it in memory, use the ?: extended pattern-matching feature. For example, consider this pattern:

/(?:a|b|c)(d|e)f\1/

This matches the following:

• One of a, b, or c
• One of d or e
• f
• Whichever of d or e was matched earlier

Here, \1 matches either d or e, because the subpattern a|b|c was not stored in memory. Compare this with the following:

/(a|b|c)(d|e)f\1/

Here, the subpattern a|b|c is stored in memory, and one of a, b, or c is matched by \1.

Embedding Pattern Options

Perl 5 provides a way of specifying a pattern-matching option within the pattern itself. For example, the following patterns are equivalent:

/[a-z]+/i

/(?i)[a-z]+/

In both cases, the pattern matches one or more alphabetic characters; the i option indicates that case is to be ignored when matching.

The syntax for embedded pattern options is

(?option)

where option is one of the options shown in Table 7.7.

Table 7.7. Options for embedded patterns.

Option	Description
i	Ignore case in pattern
m	Treat pattern as multiple lines
s	Treat pattern as single line
x	Ignore white space in pattern

The g and o options are not supported as embedded pattern options.

Embedded pattern options give you more flexibility when you are matching patterns. For example:

$pattern1 = "[a-z0-9]+";

$pattern2 = "(?i)[a-z]+";

if ($string =~ /$pattern1|$pattern2/) {

        ...

}

Here, the i option is specified for some, but not all, of a pattern. (This pattern matches either any collection of lowercase letters mixed with digits, or any collection of letters.)

Positive and Negative Look-Ahead

Perl 5 enables you to use the ?= feature to define a boundary condition that must be matched in order for the pattern to match. For example, the following pattern matches abc only if it is followed by def:

/abc(?=def)/

This is known as a positive look-ahead condition.

NOTE

The positive look-ahead condition is not part of the pattern matched. For example, consider these statements: $string = "25abc8"; $string =~ /abc(?=[0-9])/; $matched = $&; Here, as always, $& contains the matched pattern, which in this case is abc, not abc8.

Similarly, the ?! feature defines a negative look-ahead condition, which is a boundary condition that must not be present if the pattern is to match. For example, the pattern /abc(?!def)/ matches any occurrence of abc unless it is followed by def.

Pattern Comments

Perl 5 enables you to add comments to a pattern using the ?# feature. For example:

if ($string =~ /(?i)[a-z]{2,3}(?# match two or three alphabetic characters)/ {
...
}

Adding comments makes it easier to follow complicated patterns.

Summary

Perl enables you to search for sequences of characters using patterns. If a pattern is found in a string, the pattern is said to be matched.

Patterns often are used in conjunction with the pattern-match operators, =~ and !~. The =~ operator returns true if the pattern matches, and the !~ operator returns true if the pattern does not match.

Special-pattern characters enable you to search for a string that meets one of a variety of conditions.

• The + character matches one or more occurrences of a character.
• The * character matches zero or more occurrences of a character.
• The [] characters enclose a set of characters, any one of which matches.
• The ? character matches zero or one occurrences of a character.
• The ^ and $ characters match the beginning and end of a line, respectively. The \b and \B characters match a word boundary or somewhere other than a word boundary, respectively.
• The {} characters specify the number of occurrences of a character.
• The | character specifies alternatives, either of which match.

To give a special character its natural meaning in a pattern, precede it with a backslash \.

Enclosing a part of a pattern in parentheses stores the matched subpattern in memory; this stored subpattern can be recalled using the character sequence \n, and stored in a scalar variable using the built-in scalar variable $n. The built-in scalar variable $& stores the entire matched pattern.

You can substitute for scalar-variable names in patterns, specify different pattern delimiters, or supply options that match every possible pattern, ignore case, or perform scalar-variable substitution only once.

The substitution operator, s, enables you to replace a matched pattern with a specified string. Options to the substitution operator enable you to replace every matched pattern, ignore case, treat the replacing string as an expression, or perform scalar-variable substitution only once.

The translation operator, tr, enables you to translate one set of characters into another set. Options exist that enable you to perform translation on everything not in the list, to delete characters in the list, or to ignore multiple identical output characters.

Perl 5 provides extended pattern-matching capabilities not provided in Perl 4. To use one of these extended pattern features on a subpattern, put (? at the beginning of the subpattern and ) at the end of the subpattern.

Q&A

Q:	How many subpatterns can be stored in memory using \1, \2, and so on?
A:	Basically, as many as you like. After you store more than nine patterns, you can retrieve the later patterns using two-digit numbers preceded by a backslash, such as \10.
Q:	Why does pattern-memory variable numbering start with 1, whereas subscript numbering starts with 0?
A:	Subscript numbering starts with 0 to remain compatible with the C programming language. There is no such thing as pattern memory in C, so there is no need to be compatible with it.
Q:	What happens when the replacement string in the translate command is left out, as in tr/abc//?
A:	If the replacement string is omitted, a copy of the first string is used. This means that :t:r/abc// does not do anything, because it is the same as tr/abc/abc/ If the replacement string is omitted in the substitute command, as in s/abc// the pattern matched-in this case, abc-is deleted.
Q:	Why does Perl use characters such as +, *, and ? as pattern special characters?
A:	These special characters usually correspond to special characters used in other UNIX applications, such as vi and csh. Some of the special characters, such as +, are used in formal syntax description languages.
Q:	Why does Perl use both \1 and $1 to store pattern memory?
A:	To enable you to distinguish between a subpattern matched in the current pattern (which is stored in \1) and a subpattern matched in the previous statement (which is stored in $1).

Workshop

The Workshop provides quiz questions to help you solidify your understanding of the material covered and exercises to give you experience in using what you've learned. Try and understand the quiz and exercise answers before you go on to tomorrow's lesson.

Quiz

1. What do the following patterns match?
   a.   /a|bc*/
   b.   /[\d]{1,3}/
   c.   /\bc[aou]t\b/
   d.   /(xy+z)\.\1/
   e.   /^$/
2. Write patterns that match the following:
   a.   Five or more lowercase letters (a-z).
   b.   Either the number 1 or the string one.
   c.   string of digits optionally containing a decimal point.
   d.   Any letter, followed by any vowel, followed by the same letter again.
   e.   One or more + characters.
3. Suppose the variable $var has the value abc123. Indicate whether the following conditional expressions return true or false.
   a.  $var =~ /./
   b.  $var =~ /[A-Z]*/
   c.  $var =~ /\w{4-6}/
   d.  $var =~ /(\d)2(\1)/
   e.  $var =~ /abc$/
   f.  $var =~ /1234?/
4. Suppose the variable $var has the value abc123abc. What is the value of $var after the following substitutions?
   a.   $var =~ s/abc/def/;
   b.   $var =~ s/[a-z]+/X/g;
   c.   $var =~ s/B/W/i;
   d.   $var =~ s/(.)\d.*\1/d/;
   e.   $var =~ s/(\d+)/$1*2/e;
5. Suppose the variable $var has the value abc123abc. What is the value of $var after the following translations?
   a.   $var =~ tr/a-z/A-Z/;
   b.   $var =~ tr/123/456/;
   c.   $var =~ tr/231/564/;
   d.   $var =~ tr/123/ /s;
   e.   $var =~ tr/123//cd;

Exercises

1. Write a program that reads all the input from the standard input file, converts all the vowels (except y) to uppercase, and prints the result on the standard output file.
2. Write a program that counts the number of times each digit appears in the standard input file. Print the total for each digit and the sum of all the totals.
3. Write a program that reverses the order of the first three words of each input line (from the standard input file) using the substitution operator. Leave the spacing unchanged, and print each resulting line.
4. Write a program that adds 1 to every number in the standard input file. Print the results.
5. BUG BUSTER: What is wrong with the following program?
   #!/usr/local/bin/perl
   
   while ($line = <STDIN>) {
   # put quotes around each line of input
   $line =~ /^.*$/"\1"/;
   print ($line);
   }
6. BUG BUSTER: What is wrong with the following program?
   #!/usr/local/bin/perl
   
   while ($line = <STDIN>) {
   if ($line =~ /[\d]*/) {
   print ("This line contains the digits '$&'\n");
   }
   }

---

---