Flow Control Operations

do BLOCK

Returns the value of the last command in the sequence of commands indicated by BLOCK. When modified by a loop modifier, executes the BLOCK once before testing the loop condition. (On other statements the loop modifiers test the conditional first.)

do SUBROUTINE (LIST)

Executes a SUBROUTINE declared by a sub declaration, and returns the value of the last expression evaluated in SUBROUTINE. If there is no subroutine by that name, produces a fatal error. (You may use the "defined" operator to determine if a subroutine exists.) If you pass arrays as part of LIST you may wish to pass the length of the array in front of each array. (See the section on subroutines later on.) The parentheses are required to avoid confusion with the "do EXPR" form.

SUBROUTINE may also be a single scalar variable, in which case the name of the subroutine to execute is taken from the variable.

As an alternate (and preferred) form, you may call a subroutine by prefixing the name with an ampersand: &foo(@args). If you aren't passing any arguments, you don't have to use parentheses. If you omit the parentheses, no @_ array is passed to the subroutine. The & form is also used to specify subroutines to the defined and undef operators:

        if (defined &$var) { &$var($parm); undef &$var; }

do EXPR

Uses the value of EXPR as a filename and executes the contents of the file as a perl script. Its primary use is to include subroutines from a perl subroutine library.

        do 'stat.pl';

is just like

        eval \`cat stat.pl\`;

except that it's more efficient, more concise, keeps track of the current filename for error messages, and searches all the -I libraries if the file isn't in the current directory (see also the @INC array in Predefined Names). It's the same, however, in that it does reparse the file every time you call it, so if you are going to use the file inside a loop you might prefer to use -P and #include, at the expense of a little more startup time. (The main problem with #include is that cpp doesn't grok # comments--a workaround is to use ";#" for standalone comments.) Note that the following are NOT equivalent:

        do $foo;        # eval a file
        do $foo();      # call a subroutine

Note that inclusion of library routines is better done with the "require" operator.

goto LABEL

Finds the statement labeled with LABEL and resumes execution there. Currently you may only go to statements in the main body of the program that are not nested inside a do {} construct. This statement is not implemented very efficiently, and is here only to make the sed-to- perl translator easier. I may change its semantics at any time, consistent with support for translated sed scripts. Use it at your own risk. Better yet, don't use it at all.

last

last LABEL

last

last command is like the break statement in C (as used in loops); it immediately exits the loop in question. If the LABEL is omitted, the command refers to the innermost enclosing loop. The continue block, if any, is not executed:

        line: while () {
                last line if /^$/;      # exit when done with header
                ...
        }

next LABEL

next

The next command is like the continue statement in C; it starts the next iteration of the loop:

        line: while () {
                next line if /^#/;      # discard comments
                ...
        }

Note that if there were a continue block on the above, it would get executed even on discarded lines. If the LABEL is omitted, the command refers to the innermost enclosing loop.

redo

redo LABEL

redo

The redo command restarts the loop block without evaluating the conditional again. The continue block, if any, is not executed. If the LABEL is omitted, the command refers to the innermost enclosing loop. This command is normally used by programs that want to lie to themselves about what was just input:

        # a simpleminded Pascal comment stripper
        # (warning: assumes no { or } in strings)
        line: while () {
                while (s|({.*}.*){.*}|$1 |) {}
                s|{.*}| |;
                if (s|{.*| |) {
                        $front = $_;
                        while () {
                                if (/}/) {      # end of comment?
                                        s|^|$front{|;
                                        redo line;
                                }
                        }
                }
                print;
        }

return LIST

Returns from a subroutine with the value specified. (Note that a subroutine can automatically return the value of the last expression evaluated. That's the preferred method--use of an explicit return is a bit slower.)