🚀 go-pugleaf

From: Orlando Sotomayor-Diaz (The Moderator) <cbosgd!std-c>


mod.std.c Digest            Sun, 11 May 86       Volume 16 : Issue   6

Today's Topics:
 Differences from April 1985 to February 1986 Draft Standard, Part 5
----------------------------------------------------------------------

Date: Sun, 27 Apr 86 01:17:06 est
From: <ihnp4!utcsri!lsuc!msb%utcsri>
Subject: Differences from April 1985 to February 1986 Draft Standard, Part 5
To: cbosgd!std-c%utcsri

# C.3.0.1 Lvalues {--> and function locators}

  *    An "lvalue" is an expression that designates an object {and  that
  *    may  be  used  to  change its value -->}.  {--> When an object is
       said to have a particular type, the  type  is  specified  by  the
       lvalue used to designate the object.}

N-->   If an lvalue appears in a context other than as an  operand  that
N-->   may  or  shall be an lvalue, if it has array type it is converted
N-->   to a pointer as described in #C.2.2.1, otherwise it  is  replaced
N-->   by  the  value  of  the  designated  object.  In either case, the
N-->   result is not an lvalue.

N-->   A "modifiable lvalue" is an lvalue that does not have array  type
N-->   and does not have a type declared with the const type specifier.

N-->   A "function locator" is an expression that has function type.  If
N-->   a  function locator appears in a context other than as an operand
N-->   that may or shall be a function locator, it  is  converted  to  a
N-->   pointer  as  described in #C.2.2.1.  The result is not a function
N-->   locator.

  *    {Some operators yield lvalues. -->} The discussion of each opera-
  *    tor  {states if it expects --> identifies those that may or shall
  *    have an lvalue {-->,  modifiable  lvalue,  or  function  locator}
  *    operand, and {if it --> those that} yield an lvalue {--> or func-
       tion locator} result.

  *    ...  The name "lvalue" comes {--> originally} from the assignment
       expression  E1 = E2,  in  which  the  left  operand E1 must be an
  *    lvalue.  {--> It is perhaps better considered as representing  an
       object  "locator value".  What is sometimes called "rvalue" is in
       this Standard described as the "value of an expression".}

  *    An obvious example of an lvalue is an  identifier  {used  on  the
       left  side  of  an  assignment  operator --> of an object}.  As a
       further example, if E is a  unary  expression  that  has  pointer
       type,  *E  is  an  lvalue  that  designates the object to which E
       points.



# C.3.1 Primary expression

<--O   An identifier is a primary expression, provided it has been suit-
<--O   ably  declared  as discussed later.  Its type is specified by its
<--O   declaration, except for the conversions of function and array ex-
<--O   pressions  discussed  previously.   Because of these conversions,
<--O   function and array identifiers are not lvalues.

N-->   An identifier is a primary expression, provided it has  been  de-
N-->   clared as an object (in which case it is an lvalue) or a function
N-->   (in which case it is a function locator).

       A constant is a primary expression.   Its  type  depends  on  its
  *    form, as detailed {previously --> in #C.1.1.3}.

<--O   A string literal is a primary expression.  Its type is originally
<--O   "array of const char"; following the conversion rule given previ-
<--O   ously for arrays, this is converted to "pointer  to  const  char"
<--O   and  the  result  is  a  pointer  to the initial character in the
<--O   string literal.

N-->   A string literal is a primary expression.  It  is  an  lvalue  of
N-->   type "array of char", as detailed in #C.1.1.4.

  *    A parenthesized expression is a primary  ...   {The  presence  of
       parentheses  does not affect whether the expression is an lvalue.
       --> It is an lvalue if the unadorned expression is an lvalue,  or
       a  function locator if the unadorned expression is a function lo-
       cator.}



# C.3.2.1 Array subscripting

<--O   Usually,  the  first  expression  has  type   "array   of   TYPE"
<--O   (equivalently,  "pointer  to  TYPE"),  the subscript has integral
<--O   type, and the type of the result is "TYPE".

N-->   One of the expressions shall have type  "pointer  to  TYPE",  the
N-->   other  expression  shall  have  integral type, and the result has
N-->   type "TYPE".



# C.3.2.1 Array subscripting

  *    If E is an n-dimensional array ...  then E, {appearing in an  ex-
       pression  -->  used  as  other than an lvalue}, is converted to a
       pointer to an (n-1)-dimensional array ...  If the unary *  opera-
       tor  is  applied  to  this pointer explicitly, or implicitly as a
       result of subscripting,  the  result  is  the  pointed-to  (n-1)-
  *    dimensional  array, which is itself {immediately converted into a
       pointer --> converted into a pointer if used  as  other  than  an
       lvalue}.



# C.3.2.2 Function calls

  *    The {first expression --> expression preceding  the  parentheses}
  *    shall  have  type  {"function returning TYPE" or -->} "pointer to
  *    function returning TYPE" {--> (which could be the result of  con-
       verting a function locator)}.



# C.3.2.2 Function calls

N-->   If a function prototype declarator is in scope, the number of ar-
N-->   guments  shall  agree  with the number of formal parameters.  The
N-->   types shall be such that each formal parameter  may  be  assigned
N-->   the value of the corresponding argument.



# C.3.2.2 Function calls

  *    An argument may be {a function identifier or an  expression  that
       has  the  type of any object --> any expression other than a void
       expression}.  In preparing for the call to a function, each argu-
  *    ment  is  {assigned  to the corresponding formal parameter; thus,
       all argument passing is strictly by value --> evaluated, and each
       formal parameter is assigned the value of the corresponding argu-
       ment}.

  *    ...  If no {"function prototype" (a declaration that declares the
       types of the parameters) --> function prototype declarator} is in
       scope, the integral promotions are performed, and arguments  that
  *    have  type  float  are promoted to double.  {--> These are called
       the "default argument conversions".  If the number  of  arguments
       or  their  types  after conversion do not agree with those of the
       formal parameters, the behavior is undefined.}



# C.3.2.3 Structure and union members

       A postfix expression followed by a dot and an  identifier  desig-
  *    nates  a member of a structure or union {object --> entity}.  The
  *    value ... is an lvalue {if the first expression is an lvalue  and
       the  type of the member is not array or a type with the const at-
       tribute --> unless the first expression is the value returned  by
       a function call}.

       A postfix expression followed by an arrow ...  and an  identifier
       designates  a  member  of a structure or union object.  The value
  *    ... is an lvalue {if the type of the member is  not  array  or  a
       type with the const attribute -->}.

<--O   ...  If f is a function returning a structure or union, and x  is
<--O   a member of that structure of union, f().x is a valid postfix ex-
<--O   pression but is not an lvalue.



# C.3.2.4 Postfix increment and decrement operators

  *    The operand ... shall be a {--> modifiable} lvalue.  ...



# C.3.3.1 Prefix increment and decrement operators

  *    The operand ... shall be a {--> modifiable} lvalue.  ...



# C.3.3.2 Address and indirection operators

N-->   The operand of the unary & operator shall be a  function  locator
N-->   or  an lvalue that designates an object other than a bit-field or
N-->   an object declared with the register storage-class specifier.

  *    The operand of the unary * operator shall have pointer type {-->,
       other than pointer to void.}



# C.3.3.2 Address and indirection operators

       The unary * operator denotes indirection.  If the operand  points
  *    to a function, the result is {an expression by which the function
       can be called --> a function locator}; ...



# C.3.3.2 Address and indirection operators

  *    It is always true that if E is an lvalue {--> or  function  loca-
  *    tor}, *&E is an lvalue {--> or function locator} equal to E.

  *    If *P is an lvalue and T is the name of an {-->  object}  pointer
       type,  the  cast  expression *(T)P is an lvalue that has the same
       type as that to which T points.

  *    Forward references: cast operators (#C.3.4)  {-->,  storage-class
       specifiers (#C.5.1), structure and union specifiers (#C.5.2.1)}.

------------------------------

End of mod.std.c Digest - Sun, 11 May 86 07:27:01 EDT
******************************
USENET -> posting only through cbosgd!std-c.
ARPA -> ... through cbosgd!std-c@BERKELEY.ARPA (NOT to INFO-C)
In all cases, you may also reply to the author(s) above.