Learning_the_bash_Shell_Third_Edition 10/n

Flow Control

 Exit Status

Every UNIX command, whether it comes from source code in C, some other language, or a shell script/function, returns an integer code to its calling process—the shell in this case—when it finishes. This is called the exit status. 0 is usually the OK exit status, while anything else (1 to 255) usually denotes an error.

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

　　

This function requires a valid directory as its argument. Let’s look at how it handles error conditions: if no argument is given, the third line of code prints an error message and exits. This is fine.

However, the function reacts deceptively when an argument is given that isn’t a valid directory. In case you didn’t figure it out when reading the last chapter, here is what happens: the cd fails, leaving you in the same directory you were in. This is also appropriate. But the second line of code has pushed the bad directory onto the stack anyway, and the last line prints a message that leads you to believe that the push was successful. Even placing the cd before the stack assignment won’t help because it doesn’t exit the function if there is an error.

We need to prevent the bad directory from being pushed and to print an error message. Here is how we can do this:

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
}

Let’s say you have the following code in your .bash_profile.

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

　　

The builtin command allows us to do this. builtin tells the shell to use the built-in command and ignore any function of that name. Using builtin is easy; you just give it the name of the built-in you want to execute and any parameters you want to pass. If you pass in the name of something which isn’t a built-in command, builtin will display an appropriate message. For example: builtin: alice: not a shell builtin.

We want this function to return the same exit status that the built-in cd returns. The problem is that the exit status is reset by every command, so it “disappears” if you don’t save it immediately. In this function, the built-in cd’s exit status disappears when the echo statement runs (and sets its own exit status).

Therefore, we need to save the status that cd sets and use it as the entire function’s exit status. Two shell features we haven’t seen yet provide the way. First is the special shell variable ?, whose value ($?) is the exit status of the last command that ran.

For example:

So, to save the exit status we need to assign the value of ? to a variable with the line es=$? right after the cd is done.

 Return

return can only be used inside functions, and shell scripts that have been executed with source. In contrast, the statement exit N exits the entire script, no matter how deeply you are

nested in functions.

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

　　Combinations of Exit Statuses

　　

statement1 && statement2

The syntax statement1 && statement2 means, “execute statement1, and if its exit status is 0, execute statement2.”

tatement1 || statement2 

 

The syntax statement1 || statement2 is the converse: it means, “execute statement1, and if its exit status is not 0, execute statement2.”

Condition Tests

 

[ condition ]

　　String comparisons

Operator	True if...
str1 = str2	str1 matches str2
str1 != str2	str1 does not match str2
str1 < str2	str1 is less than str2
str1 > str2	str1 is greater than str2
-n str1	str1 is not null (has length greater than 0)
-z str1	str1 is null (has length 0)

 File attribute checking

Operator	True if...
-a file	file exists
-d file	file exists and is a directory
-e file	file exists; same as -a
-f file	file exists and is a regular file (i.e., not a directory or other special type of file)
-r file	You have read permission on file
-s file	file exists and is not empty
-w file	You have write permission on file
-x file	You have execute permission on file, or directory search permission if it is a directory
-N file	file was modified since it was last read
-O file	You own file
-G file	file’s group ID matches yours (or one of yours, if you are in multiple groups)
file1 -nt file2	file1 is newer than file2
file1 -ot file2	file1 is older than file2

You can also negate the truth value of a conditional expression by preceding it with an exclamation point (!), so that ! expr evaluates to true only if expr is false. Furthermore, you can make complex logical expressions of conditional operators by grouping them with parentheses (which must be “escaped” with backslashes to prevent the shell from treating them specially), and by using two logical operators we haven’t seen yet: -a (AND) and -o (OR).

The -a and -o operators are similar to the && and || operators used with exit statuses. However, unlike those operators, -a and -o are only available inside a test conditional expression.

Here is how we would use two of the file operators, a logical operator, and a string operator to fix the problem of duplicate stack entries in our pushd function. Instead of having cd determine whether the argument given is a valid directory—i.e., by returning with a bad exit status if it’s not—we can do the checking ourselves. Here is the code:

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
}

　　

The conditional expression evaluates to true only if the argument $1 is not null (-n), a directory (-d) and the user has permission to change to it (-x). * Notice that this conditional handles the case where the argument is missing ($dirname is null) first; if it is,the rest of the condition is not executed. This is important because, if we had just put:

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

Task 5-1

Write a script that prints essentially the same information as ls -l but in a more user friendly way.

#

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