c2

UNIX v6源代码 这几乎是最经典的unix版本 unix操作系统设计和莱昂氏unix源代码分析都是用的该版

.ul
7.  Expressions
.et
The precedence of expression operators is the same
as the order of the major
subsections of this section (highest precedence first).
Thus the expressions referred to as the operands of \fG+\fR
(\(sc7.4)
are those expressions defined in \(sc\(sc7.1_7.3.
Within each subsection, the operators have the same
precedence.
Left- or right-associativity is specified
in each subsection for the operators
discussed therein.
The precedence and associativity of all the expression
operators is summarized in an
appendix.
.pg
Otherwise the order of evaluation of expressions
is undefined.  In particular the compiler
considers itself free to
compute subexpressions in the order it believes
most efficient,
even if the subexpressions
involve side effects.
.ms
7.1  Primary expressions
.et
Primary expressions
involving \fG.\fR^, \fG\(mi>\fR, subscripting, and function calls
group left to right.
.ms
7.1.1  \fIidentifier\fR
.et
An identifier is a primary expression, provided it has been
suitably declared as discussed below.
Its type is specified by its declaration.
However, if the type of the identifier is ``array of .^.^.'',
then the value of the identifier-expression
is a pointer
to the first object in the array, and the
type of the expression is
``pointer to .^.^.''.
Moreover, an array identifier is not an lvalue
expression.
.pg
Likewise, an identifier which is declared
``function returning .^.^.'',
when used except in the function-name position
of a call, is converted to ``pointer to function returning .^.^.''.
.ms
7.1.2  \fIconstant\fR
.et
A decimal, octal, character, or floating
constant is a primary expression.
Its type is \fGint\fR in the first three cases,
\fGdouble\fR in the last.
.ms
7.1.3  \fIstring\fR
.et
A string is a primary expression.
Its type is originally ``array of \fGchar\fR''; but following
the same rule as in \(sc7.1.1 for identifiers,
this is modified to ``pointer to \fGchar\fR'' and the
result is a pointer to the first character
in the string.
.ms
7.1.4  \fG(\fI expression \fG)\fR
.et
A parenthesized expression is a primary expression
whose type and value are identical
to those of the unadorned expression.
The presence of parentheses does
not affect whether the expression is an
lvalue.
.ms
7.1.5  \fIprimary-expression\fG [\fI expression \fG]\fR
.et
A primary expression followed by an expression in square
brackets is a primary expression.
The intuitive meaning is that of a subscript.
Usually, the primary expression has type ``pointer to .^.^.'',
the subscript expression is \fGint\fR,
and the type of the result is ``^.^.^.^''.
The expression ``E1[E2]'' is
identical (by definition) to ``\**^(^^(^E1^)^+^(^E2^)^^)^''.
All the clues
needed to understand
this notation are contained in this section together
with the discussions
in \(sc\(sc 7.1.1, 7.2.1, and 7.4.1 on identifiers,
\fG\**\fR, and \fG+\fR respectively;
\(sc14.3 below summarizes the implications.
.ms
7.1.6  \fIprimary-expression \fG( \fIexpression-list\*(op \fG)
.et
A function call is a primary expression followed by parentheses
containing a possibly
empty, comma-separated list of expressions
which constitute the actual arguments to the
function.
The primary expression must be of type ``function returning .^.^.'',
and the result of the function call is of type ``^.^.^.^''.
As indicated
below, a hitherto unseen identifier followed
immediately by a left parenthesis
is contextually declared
to represent a function returning
an integer;
thus in the most common case, integer-valued functions
need not be declared.
.pg
Any actual arguments of type \fGfloat\fR are
converted to \fGdouble\fR before the call;
any of type \fGchar\fR are converted to \fGint\fR.
.pg
In preparing for the call to a function,
a copy is made of each actual parameter;
thus, all argument-passing in C is strictly by value.
A function may
change the values of its formal parameters, but
these changes cannot possibly affect the values
of the actual parameters.
On the other hand, it is perfectly possible
to pass a pointer on the understanding
that the function may change the value
of the object to which the pointer points.
.pg
Recursive calls to any
function are permissible.
.ms
7.1.7  \fIprimary-lvalue \fG.\fI member-of-structure\fR
.et
An lvalue expression followed by a dot followed by the name
of a member of a structure is a primary expression.
The object referred to
by the lvalue is assumed to have the
same form as the structure
containing the structure member.
The result of the expression is an lvalue appropriately
offset from the origin of the given lvalue
whose type is that of the
named structure member.
The given lvalue is not required to have
any particular type.
.pg
Structures are discussed in \(sc8.5.
.ms
7.1.8  \fIprimary-expression \fG\(mi>\fI member-of-structure\fR
.et
The primary-expression is assumed to be a pointer
which points to an object of the same form
as the structure of which the member-of-structure is
a part.
The result is an lvalue appropriately
offset from the origin of the pointed-to structure
whose type is that of the named structure member.
The type of the primary-expression need not
in fact be pointer; it is sufficient that
it be a pointer, character, or integer.
.pg
Except for the relaxation of the requirement that
E1 be of pointer type, the expression ``E1\(mi>MOS''
is exactly equivalent to ``(\**E1).MOS''.
.ms
7.2  Unary operators
.et
Expressions with unary operators
group right-to-left.
.ms
7.2.1  \fG\**\fI expression\fR
.et
The unary \fG\**\fR operator
means
.ft I
indirection:
.ft R
the expression must be a pointer, and the result
is an lvalue referring to the object to
which the expression points.
If the type of the expression is ``pointer to .^.^.'',
the type of the result is ``^.^.^.^''.
.ms
7.2.2  \fG&\fI lvalue-expression\fR
.et
The result of the unary \fG&\fR operator is a pointer
to the object referred to by the
lvalue-expression.
If the type of the lvalue-expression is ``^.^.^.^'',
the type of the result is ``pointer to .^.^.''.
.ms
7.2.3  \fG\(mi\fI expression\fR
.et
The result is the negative of the expression,
and has the same type.
The type of the expression must be \fGchar\fR, \fGint\fR, \fGfloat\fR,
or \fGdouble\fR.
.ms
7.2.4  \fG!\fI expression\fR
.et
The result of the logical negation operator \fG!\fR
is 1 if the value of the expression is 0, 0 if the value of the
expression is non-zero.
The type of the result is \fGint\fR.
This operator is applicable only to \fGint\fRs or \fGchar\fRs.
.ms
7.2.5  \fG\*~\fI expression\fR
.et
The \*~ operator yields the one's complement of its operand.
The type of the expression must be \fGint\fR or \fGchar\fR,
and the result is \fGint\fR.
.ms
7.2.6  ++ \fIlvalue-expression\fR
.et
The object referred to by the lvalue expression
is incremented.
The value is the new value of the lvalue expression
and the type is the type of the lvalue.
If the expression is \fGint\fR or \fGchar\fR,
it is incremented by 1;
if it is a pointer to an object, it is incremented
by the length of the object.
++ is applicable only to these types.
(Not, for example, to \fGfloat\fR or \fGdouble\fR.)
.ms
7.2.7  \fR\(mi\(mi\fI lvalue-expression\fR
.et
The object referred to by the lvalue expression is decremented
analogously to the ++ operator.
.ms
7.2.8  \fIlvalue-expression ++
.et
The result is the value of the object
referred to by the lvalue expression.
After the result is noted, the object
referred to by the lvalue is incremented in the same
manner as for the prefix ++ operator: by 1 for an \fGint\fR
or \fGchar\fR, by the length of the pointed-to object for a pointer.
The type of the result is the same as the
type of the lvalue-expression.
.ms
7.2.9  \fIlvalue-expression \(mi\(mi
.et
The result of the expression is the value of the object
referred to by the
the lvalue expression.
After the result is noted, the object referred
to by the lvalue expression is decremented in a way
analogous to the postfix ++ operator.
.ms
7.2.10  \fGsizeof \fIexpression
.et
The \fGsizeof\fR operator yields the size,
in bytes, of its operand.
When applied to an array, the result is the total
number of bytes in the array.
The size is determined from
the declarations of
the objects in the expression.
This expression is semantically an integer constant and may
be used anywhere a constant is required.
Its major use is in communication with routines
like storage allocators and I/O systems.
.ms
7.3  Multiplicative operators
.et
The multiplicative operators
\fG\**\fR, \fG/\fR, and \fG%\fR
group left-to-right.
.ms
7.3.1  \fIexpression\fG \** \fIexpression\fR
.et
The binary \fG\**\fR operator indicates multiplication.
If both operands are \fGint\fR or \fGchar\fR, the result
is \fGint\fR; if one is \fGint\fR or \fGchar\fR and one \fGfloat\fR or \fGdouble\fR, the