|
Getting Help
Class Lab Schedules
Spring
Fall
|
|
Home >
Online Help >
Unix >
C Shell >
Expression Syntax
C Shell: Expression Syntax
Expressions: Arithmetic, Logic Operations, and Decisions
An expression is a group of words (numbers, strings, and operators separated
by spaces) which the C shell replaces by a single number, called its value. The
act of replacing an expression by its value is a kind of substitution called evaluation,
and forms the basis for all arithmetic, logic operations, and decisions. Loosely
speaking, the term "expression" applies to any construct whatever in the C shell,
but here it has a specific sense.
Expressions are only evaluated, hence useful, in conjunction with four
built-in commands:
if (expression) then
while (expression)
@ name = (expression)
exit (expression)
The if and while statements use the value of expression to determine
whether to execute the next command or group of commands. In particular,
when the C shell produces a value of zero (false), the next group of
commands is not done; otherwise it is done. The @ command (yes, it is
actually a command), not to be confused with the "at" command or the old
default line-kill character, stores the value of expression in the
variable name. Except for providing the only way to store the results of
an arithmetic or logic computation, it is identical to the "set" command.
The exit command quits the current shell (e.g., in a script) and sets the
command completion status (which other programs sometimes want to know)
with the value of expression.
The command forms above do not all require parentheses, but including them
always is probably a good practice. Moreover, the words inside an
expression generally require spaces between each other. These words
ultimately consist of strings (such as filenames), numbers (such as
3.1415), and operators (such as +, -, <, and >). Usually, however, you
have entered some of the words as references to variable values, and so
the shell will provide the actual values during variable substitution just
prior to evaluating the expression.
The C shell has two main kinds of expressions: arithmetic and logic. Of
logic expressions it has three kinds: boolean, file enquiry, and command
status enquiry. Each category is described below.
Arithmetic Expressions
Here evaluation simply means doing the arithmetic indicated, and the value
that replaces the expression is just the result. You may use any of the
operators and precedences valid in the C programming language (without
tremendously reliable results), and octal numbers must begin with a 0.
The only numbers recognized by the shell are integers.
In the following examples, suppose we have issued "% set y = 8 ; set num
= (4 168 10 8808)":
EXPRESSION VALUE EXPRESSION VALUE
(2 + 2) 4 (5 - 27 + 7) -15
(3 + $y + $num[3]) 21 ($num[4] - 5) 8803
(5 * 5) 25 (24 / $y - 6) -3
% @ x = (354 - 128 + 52 * 5 / 3)
% echo Result is $x
Result is 174
% set y = (354 - 128 + 52 / 3)
% echo Result is $y
Result is 354 - 128 + 52 / 3
Logic Expressions
Evaluation means asking the question "Is it true that expression?", where
expression is a statement or assertion phrased in C Shell terms. The
value replacing it is 1 if the statement is true, 0 if false. There
are three kinds of logic expressions: boolean, file enquiry, and command
status enquiry. Any nonzero valued expression is taken as true, whatever
you may have intended (e.g., (3 + 2) is both 5 and true).
Boolean Expressions
These expressions, named after the English mathematician George Boole,
make assertions about the relative sizes of two numbers. There are 8
kinds of assertions,
== literal equals != literal not-equals
=~ regular expr. equals !~ regular expr. not equals
> greater than < less than
>= > or = <= < or =,
2 ways to combine two assertions,
&& and || or
and one way to negate an assertion
! not
Here are some examples:
EXPRESSION VALUE EXPRESSION VALUE
(3 > 2) 1 (-5 < $num[3]) 1
(234 <= 234) 1 (234 <= 233) 0
(2 == $y || 3 > 2) 1 (1 > -8 && 3 > 1) 1
(1) 1 (2 + (5 == 5)) 3
(prog.c == *.c) 0 (prog.c =~ *.c) 1
% set x = 340
% if ($x > 200) echo You cannot afford it.
You cannot afford it.
File Enquiry Expressions
These have the form (-L filename), where the `L' specifies one of 8
different assertions about filename. You may employ these to have the
shell determine whether or not permission is granted for a certain file,
whether it is a directory, etc. The possible choices for `L' are:
r read access o ownership
w write access z zero size
x execute access f plain file
e existence d directory
Here are some examples.
% if (! -z /usr/spool/mail/jak) echo You have mail.
You have mail.
% if (! -z netcopy.out) echo ready
% if (! -e stuff) echo Not executable
Command Status Expressions
These have the form ( { command } ), where the shell executes command
during evaluation, and uses the completion status as the value of the
variable. Note the spaces between command and the {}'s. Unlike command
substitution, nothing special happens to the output of command. In fact,
frequently you do not need output anyway since the expression relies upon
the return status. In the examples below the -s option suppresses any
printed output in both cases.
For instance, to take a certain action in case two files differ,
if ( { cmp -s file1 file2 } ) then ...
or to leave a script and let the calling process know of a match for a
string in a file,
exit ( { grep -s string file } )
|