The simplest type of flow control construct is the conditional, embodied in bash’s if statement. You use a conditional when you want to choose whether or not to do something, or to choose among a small number of things to do, according to the truth or falsehood of conditions. Conditions test values of shell variables, characteristics of files, whether or not commands run successfully, and other factors. The shell has a large set of built-in tests that are relevant to the task of shell programming.

The if construct has the following syntax:

if condition
then
    statements
[elif condition
    then statements...]
[else 
 statements]
fi

The simplest form (without the elif and else parts, or clauses) executes the statements only if the condition is true. If you add an else clause, you get the ability to execute one set of statements if a condition is true or another set of statements if the condition is false. You can use as many elif (a contraction of “else if”) clauses as you wish; they introduce more conditions, and thus more choices for which set of statements to execute. If you use one or more elifs, you can think of the else clause as the “if all else fails” part.

if command ran successfully
then
   normal processing
else
   error processing
fi

pushd ( )
{
    dirname=$1
    DIR_STACK="$dirname ${DIR_STACK:-$PWD' '}"
    cd ${dirname:?"missing directory name."}
    echo $DIR_STACK
}

pushd ( )
{
  dirname=$1
  if cd ${dirname:?"missing directory name."}    # if cd was successful
  then
      DIR_STACK="$dirname ${DIR_STACK:-$PWD' '}" # push the directory        
      echo $DIR_STACK
  else
      echo still in $PWD.                        # else do nothing
  fi
}

cd ( )
{
    builtin cd "$@"
    echo "$OLDPWD --> $PWD"
}

cd baddir
echo $?

cd gooddir
echo $?

cd ( )
{
    builtin cd "$@"
    es=$?
    echo "$OLDPWD --> $PWD"
    return $es
}

if statement1 && statement2
then
    ...
fi

if statement1 || statement2
then
    ...
fi

filename=$1
word1=$2
word2=$3
     
if grep $word1 $filename || grep $word2 $filename
then
    echo "$word1 or $word2 is in $filename."
fi

filename=$1
word1=$2
word2=$3
     
if grep $word1 $filename && grep $word2 $filename
then
    echo "$word1 and $word2 are both in $filename."
fi

popd ( )
{
    DIR_STACK=${DIR_STACK#* }
    cd ${DIR_STACK%% *}
    echo "$PWD"
}

popd ( )
{
    if [ -n "$DIR_STACK" ]; then
        DIR_STACK=${DIR_STACK#* }
        cd ${DIR_STACK%% *}
        echo "$PWD"
    else
        echo "stack empty, still in $PWD."
    fi
}

filename=${1:?"filename missing."}
howmany=${2:-10}
sort -nr $filename | head -$howmany

if [ -z "$1" ]; then
    echo 'usage: highest filename [-N]'
else
  filename=$1
  howmany=${2:--10}
  sort -nr $filename | head $howmany
fi

if [ -z "$1" ]; then
    echo 'usage: highest filename [-N]'
    exit 1
fi
     
filename=$1
howmany=${2:--10}
sort -nr $filename | head $howmany

filename=$1
extension=${filename##*.}
pnmfile=${filename%.*}.pnm
outfile=${filename%.*}.jpg

if [ -z $filename ]; then
    echo "procfile: No file specified"
    exit 1
fi

if [ $extension = jpg ]; then
    exit 0
elif [ $extension = tga ]; then
    tgatoppm $filename > $pnmfile
elif [ $extension = xpm ]; then
    xpmtoppm $filename > $pnmfile
elif [ $extension = pcx ]; then
    pcxtoppm $filename > $pnmfile
elif [ $extension = tif ]; then
    tifftopnm $filename > $pnmfile
elif [ $extension = gif ]; then
    giftopnm $filename > $pnmfile
else
    echo "procfile: $filename is an unknown graphics file."
    exit 1
fi

pnmtojpeg $pnmfile > $outfile

rm $pnmfile

if [ condition ] && [ condition ]; then

if command && [ condition ]; then
    ...

pushd ( )
{
    dirname=$1
    if [ -n "$dirname" ] && [ ( -d "$dirname" ) -a 
            ( -x "$dirname" ) ]; then
        DIR_STACK="$dirname ${DIR_STACK:-$PWD' '}"
        cd $dirname
        echo "$DIR_STACK"
    else
        echo "still in $PWD."
    fi
}

if [ ( -n "$dirname") -a  ( -d "$dirname" ) -a 
         ( -x "$dirname" ) ]; then

if [ ! -e "$1" ]; then
    echo "file $1 does not exist."
    exit 1
fi
if [ -d "$1" ]; then
    echo -n "$1 is a directory that you may "
    if [ ! -x "$1" ]; then
        echo -n "not "
    fi
    echo "search."
elif [ -f "$1" ]; then
    echo "$1 is a regular file."
else
    echo "$1 is a special type of file."
fi
if [ -O "$1" ]; then
    echo 'you own the file.'
else
    echo 'you do not own the file.'
fi
if [ -r "$1" ]; then
    echo 'you have read permission on the file.'
fi
if [ -w "$1" ]; then
    echo 'you have write permission on the file.'
fi
if [ -x "$1" -a ! -d "$1" ]; then
    echo 'you have execute permission on the file.'
fi

-rwxr-xr-x   1 cam      users        2987 Jan 10 20:43 adventure
-rw-r--r--   1 cam      users          30 Jan 10 21:45 alice
-r--r--r--   1 root     root        58379 Jan 11 21:30 core
drwxr-xr-x   2 cam      users        1024 Jan 10 21:41 dodo

adventure is a regular file.
you own the file.
you have read permission on the file.
you have write permission on the file.
you have execute permission on the file.

alice is a regular file.
you own the file.
you have read permission on the file.
you have write permission on the file.

dodo is a directory that you may search.
you own the file.
you have read permission on the file.
you have write permission on the file.

core is a regular file.
you do not own the file.
you have read permission on the file.

The most obvious enhancement to make the previous script is the ability to report on multiple files instead of just one. Tests like -e and -d take only single arguments, so we need a way of calling the code once for each file given on the command line.

The way to do this—indeed, the way to do many things with bash—is with a looping construct. The simplest and most widely applicable of the shell’s looping constructs is the for loop. We’ll use for to enhance fileinfo soon.

The for loop allows you to repeat a section of code a fixed number of times. During each time through the code (known as an iteration), a special variable called a loop variable is set to a different value; this way each iteration can do something slightly different.

The for loop is somewhat, but not entirely, similar to its counterparts in conventional languages like C and Pascal. The chief difference is that the shell’s standard for loop doesn’t let you specify a number of times to iterate or a range of values over which to iterate; instead, it only lets you give a fixed list of values. In other words, you can’t do anything like this Pascal-type code, which executes statements 10 times:

for x := 1 to 10 do
begin
    statements...
end

However, the for loop is ideal for working with arguments on the command line and with sets of files (e.g., all files in a given directory). We’ll look at an example of each of these. But first, we’ll show the syntax for the for construct:

for name [in list]
do
    statements that can use 
            $name...
done

The list is a list of names. (If in list is omitted, the list defaults to "$@“, i.e., the quoted list of command-line arguments, but we’ll always supply the in list for the sake of clarity.) In our solutions to the following task, we’ll show two simple ways to specify lists.

The easiest way to do this is by changing the IFS variable we saw in Chapter 4:

IFS=:
     
for dir in $PATH
do
    ls -ld $dir
done

This sets the IFS to be a colon, which is the separator used in PATH. The for loop loops through, setting dir to each of the colon delimited fields in PATH. ls is used to print out the directory name and associated information. The -l parameter specifies the “long” format and the -d tells ls to show only the directory itself and not its contents.

In using this you might see an error generated by ls saying, for example, ls: /usr/TeX/bin: No such file or directory. It indicates that a directory in PATH doesn’t exist. We can modify the listpath script to check the PATH variable for nonexistent directories by adding some of the tests we saw earlier:

IFS=:
     
for dir in $PATH; do
    if [ -z "$dir" ]; then dir=.; fi
     
    if ! [ -e "$dir" ]; then
        echo "$dir doesn't exist"
    elif ! [ -d "$dir" ]; then
        echo "$dir isn't a directory"
    else
        ls -ld $dir
    fi
done

This time, as the script loops, we first check to see if the length of $dir is zero (caused by having a value of :: in the PATH). If it is, we set it to the current directory, then check to see if the directory doesn’t exist. If it doesn’t, we print out an appropriate message. Otherwise, we check to see if the file is not a directory. If it isn’t, we say so.

The foregoing illustrated a simple use of for, but it’s much more common to use for to iterate through a list of command-line arguments. To show this, we can enhance the fileinfo script above to accept multiple arguments. First, we write a bit of “wrapper” code that does the iteration:

for filename in "$@" ; do
    finfo "$filename"
    echo
done

Next, we make the original script into a function called finfo:^[9]

finfo ( )
{
    if [ ! -e "$1" ]; then
        print "file $1 does not exist."
        return 1
    fi
    ...
}

The complete script consists of the for loop code and the above function, in either order; good programming style dictates that the function definition should go first.

The fileinfo script works as follows: in the for statement, "$@" is a list of all positional parameters. For each argument, the body of the loop is run with filename set to that argument. In other words, the function finfo is called once for each value of $filename as its first argument ($1). The call to echo after the call to finfo merely prints a blank line between sets of information about each file.

Given a directory with the same files as the earlier example, typing fileinfo* would produce the following output:

adventure is a regular file.
you own the file.
you have read permission on the file.
you have write permission on the file.
you have execute permission on the file.
     
alice is a regular file.
you own the file.
you have read permission on the file.
you have write permission on the file.
     
core is a regular file.
you do not own the file.
you have read permission on the file.
     
dodo is a directory that you may search.
you own the file.
you have read permission on the file.
you have write permission on the file.

Here is a programming task that exploits the other major use of for.

We’ll probably want output that looks something like this:

.
        adventure
                aaiw
                        dodo
                        duchess
                        hatter
                        march_hare
                        queen
                        tarts
                biog
                ttlg
                        red_queen
                        tweedledee
                        tweedledum
        lewis.carroll

Each column represents a directory level. Entries below and to the right of an entry are files and directories under that directory. Files are just listed with no entries to their right. This example shows that the directory adventure and the file lewis.carroll are in the current directory; the directories aaiw and ttlg, and the file biog are under adventure, etc. To make life simple, we’ll use TABs to line the columns up and ignore any “bleed over” of filenames from one column into an adjacent one.

We need to be able to traverse the directory hierarchy. To do this easily we’ll use a programming technique known as recursion. Recursion is simply referencing something from itself; in our case, calling a piece of code from itself. For example, consider this script, tracedir, in your home directory:

file=$1
echo $file
     
if [ -d "$file" ]; then
    cd $file
    ~/tracedir $(ls)
    cd ..
fi

First we copy and print the first argument. Then we test to see if it is a directory. If it is, we cd to it and call the script again with an argument of the files in that directory. This script is recursive; when the first argument is a directory, a new shell is invoked and a new script is run on the new directory. The old script waits until the new script returns, then the old script executes a cd back up one level and exits. This happens in each invocation of the tracedir script. The recursion will stop only when the first argument isn’t a directory.

Running this on the directory structure listed above with the argument adventure will produce:

adventure
aaiw
dodo

dodo is a file and the script exits.

This script has a few problems, but it is the basis for the solution to this task. One major problem with the script is that it is very inefficient. Each time the script is called, a new shell is created. We can improve on this by making the script into a function, because (as you probably remember from Chapter 4) functions are part of the shell they are started from. We also need a way to set up the TAB spacing. The easiest way is to have an initializing script or function and call the recursive routine from that. Let’s look at this routine.

recls ( )
{
    singletab="	"
     
    for tryfile in "$@"; do
        echo $tryfile
        if [ -d "$tryfile" ]; then
            thisfile=$tryfile
            recdir $(command ls $tryfile)
        fi
    done
     
    unset dir singletab tab
}

First, we set up a variable to hold the TAB character for the echo command (Chapter 7 explains all of the options and formatting commands you can use with echo). Then we loop through each argument supplied to the function and print it out. If it is a directory, we call our recursive routine, supplying the list of files with ls. We have introduced a new command at this point: command. command is a shell built-in that disables function and alias look-up. In this case, it is used to make sure that the ls command is one from your command search path, PATH, and not a function (for further information on command see Chapter 7). After it’s all over, we clean up by unsetting the variables we have used.

Now we can expand on our earlier shell script.

recdir ( )
{
    tab=$tab$singletab
     
    for file in "$@"; do
        echo -e $tab$file
        thisfile=$thisfile/$file
     
        if [ -d "$thisfile" ]; then
            recdir $(command ls $thisfile)
        fi
     
        thisfile=${thisfile%/*}
    done
     
    tab=${tab%"$singletab"}
}

Each time it is called, recdir loops through the files it is given as arguments. For each one it prints the filename and then, if the file is a directory, calls itself with arguments set to the contents of the directory. There are two details that have to be taken care of: the number of TABs to use, and the pathname of the “current” directory in the recursion.

Each time we go down a level in the directory hierarchy we want to add a TAB character, so we append a TAB to the variable tab every time we enter recdir. Likewise, when we exit recdir we are moving up a directory level, so we remove the TAB when we leave the function. Initially, tab is not set, so the first time recdir is called, tab will be set to one TAB. If we recurse into a lower directory, recdir will be called again and another TAB will be appended. Remember that tab is a global variable, so it will grow and shrink in TABs for every entry and exit of recdir. The -e option to echo tells it to recognize escaped formatting characters, in our case the TAB character, .

In this version of the recursive routine we haven’t used cd to move between directories. That means that an ls of a directory will have to be supplied with a relative path to files further down in the hierarchy. To do this, we need to keep track of the directory we are currently examining. The initialization routine sets the variable thisfile to the directory name each time a directory is found while looping. This variable is then used in the recursive routine to keep the relative pathname of the current file being examined. On each iteration of the loop, thisfile has the current filename appended to it, and at the end of the loop the filename is removed.

You might like to think of ways to modify the behavior and improve the output of this code. Here are some programming challenges:

At the start of this section we pointed out that the for loop in its standard form wasn’t capable of iterating over a specified range of values as can be done in most programming languages. bash 2.0 introduced a new style of for loop which caters for this task; the arithmetic for loop. Well come back to it in the next chapter when we look at arithmetic operations.

The next flow-control construct we will cover is case. While the case statement in Pascal and the similar switch statement in Java and C can be used to test simple values like integers and characters, bash’s case construct lets you test strings against patterns that can contain wildcard characters. Like its conventional-language counterparts, case lets you express a series of if-then-else type statements in a concise way.

The syntax of case is as follows:

case expression 
            in
            pattern1 
            )
            statements ;;
             pattern2 
            )
            statements ;;
             ...
            esac

Any of the patterns can actually be several patterns separated by pipe characters (|). If expression matches one of the patterns, its corresponding statements are executed. If there are several patterns separated by pipe characters, the expression can match any of them in order for the associated statements to be run. The patterns are checked in order until a match is found; if none is found, nothing happens.

This construct should become clearer with an example. Let’s revisit our solution to Task 4-2 and the additions to it presented earlier in this chapter (our graphics utility). Remember that we wrote some code that processed input files according to their suffixes ( .pcx for PCX format, .gif for GIF format, etc.).

We can improve upon this solution in two ways. Firstly, we can use a for loop to allow multiple files to be processed one at a time; secondly, we can use the case construct to streamline the code:

for filename in "$@"; do
    pnmfile=${filename%.*}.ppm

    case $filename in
        *.jpg ) exit 0 ;;

        *.tga ) tgatoppm $filename > $pnmfile ;;

        *.xpm ) xpmtoppm $filename > $pnmfile ;;

        *.pcx ) pcxtoppm $filename > $pnmfile ;;

        *.tif ) tifftopnm $filename > $pnmfile ;;

        *.gif ) giftopnm $filename > $pnmfile ;;

            * ) echo "procfile: $filename is an unknown graphics file."
                exit 1 ;;
    esac

    outfile=${pnmfile%.ppm}.new.jpg

    pnmtojpeg $pnmfile > $outfile

    rm $pnmfile

done

The case construct in this code does the same thing as the if statements that we saw in the earlier version. It is, however, clearer and easier to follow.

The first six patterns in the case statement match the various file extensions that we wish to process. The last pattern matches anything that hasn’t already been matched by the previous statements. It is essentially a catchall and is analogous to the default case in C.

There is another slight difference to the previous version; we have moved the pattern matching and replacement inside the added for loop that processes all of the command-line arguments. Each time we pass through the loop, we want to create a temporary and final file with a name based on the name in the current command-line argument.

We’ll return to this example in Chapter 6, when we further develop the script and discuss how to handle dash options on the command line. In the meantime, here is a task that requires that we use case.

We can implement this by using a case statement to check the number of arguments and the built-in cd command to do the actual change of directory.

Here is the code:^[10]

cd( )
{
    case "$#" in
        0 | 1)  builtin cd $1 ;;
        2    ) newdir=${PWD//$1/$2}
                case "$newdir" in
                    $PWD)   echo "bash: cd: bad substitution" >&2 ;
                        return 1 ;;
                    *   )   builtin cd "$newdir" ;;
                esac ;;
        *    )  echo "bash: cd: wrong arg count" 1>&2 ; return 1 ;;
    esac
}

The case statement in this task tests the number of arguments to our cd command against three alternatives.

For zero or one arguments, we want our cd to work just like the built-in one. The first alternative in the case statement does this. It includes something we haven’t used so far; the pipe symbol between the 0 and 1 means that either pattern is an acceptable match. If the number of arguments is either of these, the built-in cd is executed.

The next alternative is for two arguments, which is where we’ll add the new functionality to cd. The first thing that has to be done is finding and replacing the old string with the new one. We use the pattern matching and replacement that we saw in the last chapter, the result being assigned to newdir. If the substitution didn’t take place, the pathname will be unchanged. We’ll use this fact in the next few lines.

Another case statement chooses between performing the cd or reporting an error because the new directory is unchanged. The * alternative is a catchall for anything other than the current pathname (caught by the first alternative).

You might notice one small problem with this code: if your old and new strings are the same you’ll get bash:: cd: bad substitution. It should just leave you in the same directory with no error message, but because the directory path doesn’t change, it uses the first alternative in the inner case statement. The problem lies in knowing if sed has performed a substitution or not. You might like to think about ways to fix this problem (hint: you could use grep to check whether the pathname has the old string in it).

The last alternative in the outer case statement prints an error message if there are more than two arguments.

All of the flow-control constructs we have seen so far are also available in the Bourne shell, and the C shell has equivalents with different syntax. Our next construct, select, is available only in the Korn shell and bash;^[11] moreover, it has no analogy in conventional programming languages.

select allows you to generate simple menus easily. It has concise syntax, but it does quite a lot of work. The syntax is:

select name 
            [in 
            list
            ]
do
    statements that can use 
            $name...
done

This is the same syntax as for except for the keyword select. And like for, you can omit the in list and it will default to "$@“, i.e., the list of quoted command-line arguments. Here is what select does:

Here is a task that adds another command to our pushd and popd utilities.

The display and selection of directories is best handled by using select. We can start off with something along the lines of:^[12]

selectd ( )
{
    PS3='directory? '
    select selection in $DIR_STACK; do
        if [ $selection ]; then
            #statements that manipulate the stack...
            break
        else
            echo 'invalid selection.'
        fi
    done
}

If you type DIR_STACK="/usr /home /bin" and execute this function, you’ll see:

1) /usr
2) /home
3) /bin
directory?

The built-in shell variable PS3 contains the prompt string that select uses; its default value is the not particularly useful "#?“. So the first line of the above code sets it to a more relevant value.

The select statement constructs the menu from the list of choices. If the user enters a valid number (from 1 to the number of directories), then the variable selection is set to the corresponding value; otherwise it is null. (If the user just presses RETURN, the shell prints the menu again.)

The code in the loop body checks if selection is non-null. If so, it executes the statements we will add in a short while; then the break statement exits the select loop. If selection is null, the code prints an error message and repeats the menu and prompt.

The break statement is the usual way of exiting a select loop. Actually (like its analog in Java and C), it can be used to exit any surrounding control structure we’ve seen so far (except case, where the double semicolons act like break) as well as the while and until we will see soon. We haven’t introduced break until now because it is considered bad coding style to use it to exit a loop. However, it can make code easier to read if used judiciously. break is necessary for exiting select when the user makes a valid choice. ^[13]

Now we’ll add the missing pieces to the code:

selectd ( )
{
    PS3='directory? '
    dirstack=" $DIR_STACK "
     
    select selection in $dirstack; do
        if [ $selection ]; then
            DIR_STACK="$selection${dirstack%% $selection *}"
            DIR_STACK="$DIR_STACK ${dirstack##* $selection }"
            DIR_STACK=${DIR_STACK% }
            cd $selection
            break
        else
            echo 'invalid selection.'
        fi
    done
}

The first two lines initialize environment variables. dirstack is a copy of DIR_STACK with spaces appended at the beginning and end so that each directory in the list is of the form space directory space. This form simplifies the code when we come to manipulating the directory stack.

The select and if statements are the same as in our initial function. The new code inside the if uses bash’s pattern-matching capability to manipulate the directory stack.

The first statement sets DIR_STACK to selection, followed by dirstack with everything from selection to the end of the list removed. The second statement adds everything in the list from the directory following selection to the end of DIR_STACK. The next line removes the trailing space that was appended at the start. To complete the operation, a cd is performed to the new directory, followed by a break to exit the select code.

As an example of the list manipulation performed in this function, consider a DIR_STACK set to /home /bin /usr2. In this case, dirstack would become /home /bin /usr2. Typing selectd would result in:

$ selectd
1) /home
2) /bin
3) /usr2
directory?

After selecting /bin from the list, the first statement inside the if section sets DIR_STACK to /bin followed by dirstack with everything from /bin onwards removed, i.e., /home.

The second statement then takes DIR_STACK and appends everything in dirstack following /bin (i.e., /usr2) to it. The value of DIR_STACK becomes /bin /home /usr2. The trailing space is removed in the next line.

The remaining two flow control constructs bash provides are while and until. These are similar; they both allow a section of code to be run repetitively while (or until) a certain condition becomes true. They also resemble analogous constructs in Pascal (while/do and repeat/until) and C (while and do/until).

while and until are actually most useful when combined with features we will see in the next chapter, such as integer arithmetic, input/output of variables, and command-line processing. Yet we can show a useful example even with what we have covered so far.

The syntax for while is:

while condition
            do
            statements...
            done

For until, just substitute until for while in the above example. As with if, the condition is really a list of statements that are run; the exit status of the last one is used as the value of the condition. You can use a conditional with test here, just as you can with if.

Note that the only difference between while and until is the way the condition is handled. In while, the loop executes as long as the condition is true; in until, it runs as long as the condition is false. The until condition is checked at the top of the loop, not at the bottom as it is in analogous constructs in C and Pascal.

The result is that you can convert any until into a while by simply negating the condition. The only place where until might be more meaningful is something like this:

until command
            ; do
            statements...
            done

The meaning of this is essentially, “Do statements until command runs correctly.” This is not a likely contingency.

Here is an earlier task that can be rewritten using a while.

We can use the while construct and pattern matching to traverse the PATH list:

path=$PATH:
     
while [ $path ]; do
    ls -ld ${path%%:*}
    path=${path#*:}
done

The first line copies PATH to a temporary copy, path, and appends a colon to it. Normally colons are used only between directories in PATH; adding one to the end makes the code simple.

Inside the while loop we display the directory with ls as we did in Task 5-2. path is then updated by removing the first directory pathname and colon (which is why we needed to append the colon in the first line of the script). The while will keep looping until $path expands to nothing (the empty string “”), which occurs once the last directory in path has been listed.

Here is another task that is a good candidate for until.

Here is the code:

until cp $1 $2; do
    echo 'Attempt to copy failed. waiting...'
    sleep 5
done

This is a fairly simple use of until. First, we use the cp command to perform the copy for us. If it can’t perform the copy for any reason, it will return with a non-zero exit code. We set our until loop so that if the result of the copy is not 0 then the script prints a message and waits five seconds.

As we said earlier, an until loop can be converted to a while by the use of the ! operator:

while ! cp $1 $2; do
    echo 'Attempt to copy failed. waiting...'
    sleep 5
done

In our opinion, you’ll seldom need to use until; therefore, we’ll use while throughout the rest of this book. We’ll see further use of the while construct in Chapter 7.