Context Navigation

-                      r0638c44
+                      r7937abf
 %% Created On       : Wed Apr  6 14:52:25 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue May  3 09:23:43 2016
 %% Update Count     : 52
+%% Last Modified On : Tue May  3 18:00:28 2016
+%% Update Count     : 64
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \subsection{Scopes of identifiers}\index{scopes}
+\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same
+\Index{name space}, instead of hiding them.
+\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same \Index{name space}, instead of hiding them.
 The outer declaration is hidden if the two declarations have \Index{compatible type}, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type, or if one declaration is a ©type©\use{type} or ©typedef©\use{typedef} declaration and the other is not.
 The outer declaration becomes \Index{visible} when the scope of the inner declaration terminates.
 …
 \CFA's linkage rules differ from C's in only one respect: instances of a particular identifier with external or internal linkage do not necessarily denote the same object or function.
+Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have
+\Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
+Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have \Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
 Within one translation unit, each instance of an identifier with \Index{internal linkage} denotes the same object or function in the same circumstances.
 Identifiers with \Index{no linkage} always denote unique entities.
 …
 \CFA defines situations where values of one type are automatically converted to another type.
 These conversions are called \define{implicit conversion}s.
+The programmer can request
+\define{explicit conversion}s using cast expressions.
+The programmer can request \define{explicit conversion}s using cast expressions.
 …
 \label{anon-conv}
+If an expression's type is a pointer to a structure or union type that has a member that is an
+\Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
+If an expression's type is a pointer to a structure or union type that has a member that is an \Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
 The result of the conversion is a pointer to the member.
 …
 \rewriterules
 \begin{lstlisting}
 a[b] §\rewrite§ ?[?]( b, a ) // if a has integer type§\use{?[?]}§
 a[b] §\rewrite§ ?[?]( a, b ) // otherwise
 a( §\emph{arguments}§ ) §\rewrite§ ?()( a, §\emph{arguments}§ )§\use{?()}§
 a++ §\rewrite§ ?++(&( a ))§\use{?++}§
 a-- §\rewrite§ ?--(&( a ))§\use{?--}§
+a[b] => ?[?]( b, a ) // if a has integer type§\use{?[?]}§
+a[b] => ?[?]( a, b ) // otherwise
+a( §\emph{arguments}§ ) => ?()( a, §\emph{arguments}§ )§\use{?()}§
+a++ => ?++(&( a ))§\use{?++}§
+a-- => ?--(&( a ))§\use{?--}§
 \end{lstlisting}
 …
 Subscript expressions are rewritten as function calls that pass the first parameter by value.
 This is somewhat unfortunate, since array-like types tend to be large.
 The alternative is to use the rewrite rule ``©a[b]© \rewrite ©?[?](&(a), b)©''.
+The alternative is to use the rewrite rule ``©a[b] => ?[?](&(a), b)©''.
 However, C semantics forbid this approach: the ©a© in ``©a[b]©'' can be an arbitrary pointer value, which does not have an address.
 …
 The type of the valid interpretation is the return type of the function designator.
+For those combinations where the interpretation of the \nonterm{postfix-expression} is a
+\Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
+For those combinations where the interpretation of the \nonterm{postfix-expression} is a \Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
 \begin{itemize}
 \item
 …
 For instance, it should be possible to replace a function ``©int f( int );©'' with ``©forall( otype T ) T f( T );©'' without affecting any calls of ©f©.
+\CFA\index{deficiencies!generalizability} does not fully possess this property, because
+\Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
+\CFA\index{deficiencies!generalizability} does not fully possess this property, because \Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
 Consider
 \begin{lstlisting}
 …
 \rewriterules
 \begin{lstlisting}
 *a      §\rewrite§ *?( a ) §\use{*?}§
 +a      §\rewrite§ +?( a ) §\use{+?}§
 -a      §\rewrite§ -?( a ) §\use{-?}§
 ~a      §\rewrite§ ~?( a ) §\use{~?}§
 !a      §\rewrite§ !?( a ) §\use{"!?}§
 ++a     §\rewrite§ ++?(&( a )) §\use{++?}§
 --a     §\rewrite§ --?(&( a )) §\use{--?}§
+*a      => *?( a )§\use{*?}§
++a      => +?( a )§\use{+?}§
+-a      => -?( a )§\use{-?}§
+~a      => ~?( a )§\use{~?}§
+!a      => !?( a )§\use{"!?}§
+++a     => ++?(&( a ))§\use{++?}§
+--a     => --?(&( a ))§\use{--?}§
 \end{lstlisting}
 …
 \constraints
+The operand of the unary ``©&©'' operator shall have exactly one
+\Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
+The operand of the unary ``©&©'' operator shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
 \semantics
 …
 long int li;
 void eat_double( double );§\use{eat_double}§
 eat_double(-li ); // §\rewrite§ eat_double( -?( li ) );
+eat_double(-li ); // => eat_double( -?( li ) );
 \end{lstlisting}
 The valid interpretations of ``©-li©'' (assuming no extended integer types exist) are
 …
 \rewriterules
 \begin{lstlisting}
 a * b §\rewrite§ ?*?( a, b )§\use{?*?}§
 a / b §\rewrite§ ?/?( a, b )§\use{?/?}§
 a % b §\rewrite§ ?%?( a, b )§\use{?%?}§
+a * b => ?*?( a, b )§\use{?*?}§
+a / b => ?/?( a, b )§\use{?/?}§
+a % b => ?%?( a, b )§\use{?%?}§
 \end{lstlisting}
 …
 \begin{rationale}
+{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the
+\Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
+{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the \Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
 \end{rationale}
 …
 \rewriterules
 \begin{lstlisting}
 a + b §\rewrite§ ?+?( a, b )§\use{?+?}§
 a - b §\rewrite§ ?-?( a, b )§\use{?-?}§
+a + b => ?+?( a, b )§\use{?+?}§
+a - b => ?-?( a, b )§\use{?-?}§
 \end{lstlisting}
 …
 \end{syntax}
 \rewriterules \use{?>>?}%use{?<<?}
 \begin{lstlisting}
 a << b §\rewrite§ ?<<?( a, b )
 a >> b §\rewrite§ ?>>?( a, b )
+\rewriterules
+\begin{lstlisting}
+a << b => ?<<?( a, b )§\use{?<<?}§
+a >> b => ?>>?( a, b )§\use{?>>?}§
 \end{lstlisting}
 …
 \end{syntax}
 \rewriterules\use{?>?}\use{?>=?}%use{?<?}%use{?<=?}
 \begin{lstlisting}
 a < b §\rewrite§ ?<?( a, b )
 a > b §\rewrite§ ?>?( a, b )
 a <= b §\rewrite§ ?<=?( a, b )
 a >= b §\rewrite§ ?>=?( a, b )
+\rewriterules
+\begin{lstlisting}
+a < b => ?<?( a, b )§\use{?<?}§
+a > b => ?>?( a, b )§\use{?>?}§
+a <= b => ?<=?( a, b )§\use{?<=?}§
+a >= b => ?>=?( a, b )§\use{?>=?}§
 \end{lstlisting}
 …
 \rewriterules
 \begin{lstlisting}
 a == b §\rewrite§ ?==?( a, b )§\use{?==?}§
 a != b §\rewrite§ ?!=?( a, b )§\use{?"!=?}§
+a == b => ?==?( a, b )§\use{?==?}§
+a != b => ?!=?( a, b )§\use{?"!=?}§
 \end{lstlisting}
 …
 \rewriterules
 \begin{lstlisting}
 a & b §\rewrite§ ?&?( a, b )§\use{?&?}§
+a & b => ?&?( a, b )§\use{?&?}§
 \end{lstlisting}
 …
 \rewriterules
 \begin{lstlisting}
 a ^ b §\rewrite§ ?^?( a, b )§\use{?^?}§
+a ^ b => ?^?( a, b )§\use{?^?}§
 \end{lstlisting}
 …
 \end{syntax}
 \rewriterules\use{?"|?}
 \begin{lstlisting}
 a | b §\rewrite§ ?|?( a, b )
+\rewriterules
+\begin{lstlisting}
+a | b => ?|?( a, b )§\use{?"|?}§
 \end{lstlisting}
 …
          \nonterm{assignment-expression}
 \lhs{assignment-operator} one of
+\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \
+         ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
+\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \ ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
 \end{syntax}
 \rewriterules
 Let ``\(\leftarrow\)'' be any of the assignment operators.
+Let ``©<-©'' be any of the assignment operators.
 Then
+\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}
+\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
+\begin{lstlisting}
+a §$\leftarrow$§ b §\rewrite§ ?§$\leftarrow$§?( &( a ), b )
+\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
+\begin{lstlisting}
+a <- b => ?<-?( &( a ), b )
 \end{lstlisting}
 …
 D( §\normalsize\nonterm{parameter-type-list}§ )
 \end{lstlisting} then a type identifier declared by one of the \nonterm{forall-specifier}s is an \define{inferred parameter} of the function declarator if and only if it is not an inferred parameter of a function declarator in ©D©, and it is used in the type of a parameter in the following
+\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a
+\Index{specification} in one of the \nonterm{forall-specifier}s.
+\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a \Index{specification} in one of the \nonterm{forall-specifier}s.
 The identifiers declared by assertions that use an inferred parameter of a function declarator are \Index{assertion parameter}s of that function declarator.
 …
 If a function declarator is part of a function definition, its inferred parameters and assertion parameters have \Index{block scope};
+otherwise, identifiers declared by assertions have a
+\define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
+otherwise, identifiers declared by assertions have a \define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
 A function type that has at least one inferred parameter is a \define{polymorphic function} type.
 …
 Let $f$ and $g$ be two polymorphic function types with the same number of inferred parameters, and let $f_i$ and $g_i$ be the inferred parameters of $f$ and $g$ in their order of occurance in the function types' \nonterm{parameter-type-list}s.
 Let $f'$ be $f$ with every occurrence of $f_i$ replaced by $g_i$, for all $i$.
+Then $f$ and $g$ are
+\Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
+Then $f$ and $g$ are \Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
 \examples
 …
 \semantics
+An \define{assertion} is a declaration of a collection of objects and functions, called
+\define{assertion parameters}.
+An \define{assertion} is a declaration of a collection of objects and functions, called \define{assertion parameters}.
 The assertion parameters produced by an assertion that applies the name of a specification to type arguments are found by taking the declarations specified in the specification and treating each of the specification's parameters as a synonym for the corresponding \nonterm{type-name} argument.
 …
 A type declaration without an \Index{initializer} and without a \Index{storage-class specifier} or with storage-class specifier ©static©\use{static} defines an \Index{incomplete type}.
+If a
+\Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
+If a \Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
 \begin{rationale}
 Incomplete type declarations allow compact mutually-recursive types.
 …
 A type declaration without an initializer and with \Index{storage-class specifier} ©extern©\use{extern} is an \define{opaque type declaration}.
+Opaque types are
+\Index{object type}s.
+Opaque types are \Index{object type}s.
 An opaque type is not a \nonterm{constant-expression};
 neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.  Every other
 \Index{object type} is a \nonterm{constant-expression}.
+neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.
+Every other \Index{object type} is a \nonterm{constant-expression}.
 Objects with static storage duration shall be declared with a type that is a \nonterm{constant-expression}.
 \begin{rationale}
 …
 An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a value of \Index{type-class} ©dtype©.
 An object type\index{object types} which is not a qualified version of a type is a value of type-classes ©type© and ©dtype©.
+A
+\Index{function type} is a value of type-class ©ftype©.
+A \Index{function type} is a value of type-class ©ftype©.
 \begin{rationale}
 Syntactically, a type value is a \nonterm{type-name}, which is a declaration for an object which omits the identifier being declared.
 …
 //  File a.c:
         extern type t1;
         type t2 = struct { t1 f1; ... } // illegal
+        type t2 = struct { t1 f1; ... } // illegal
 //  File b.c:
         extern type t2;
         type t1 = struct { t2 f2; ... } // illegal
+        type t1 = struct { t2 f2; ... } // illegal
 \end{lstlisting}
 \end{rationale}
 …
 #include <stdlib.h>
 T * new( otype T ) { return ( T * )malloc( sizeof( T) ); };
 §\ldots§ int * ip = new( int );
+... int * ip = new( int );
 \end{lstlisting}
 This looks sensible, but \CFA's declaration-before-use rules mean that ``©T©'' in the function body refers to the parameter, but the ``©T©'' in the return type refers to the meaning of ©T© in the scope that contains ©new©;
 …
 A definition\index{type definition} of a type identifier ©T© with \Index{implementation type} ©I© and type-class ©type© implicitly defines a default assignment function.
+A definition\index{type definition} of a type identifier ©T© with implementation type ©I© and an assertion list implicitly defines \define{default function}s and
+\define{default object}s as declared by the assertion declarations.
+A definition\index{type definition} of a type identifier ©T© with implementation type ©I© and an assertion list implicitly defines \define{default function}s and \define{default object}s as declared by the assertion declarations.
 The default objects and functions have the same \Index{scope} and \Index{linkage} as the identifier ©T©.
 Their values are determined as follows:
 …
 Default functions and objects are subject to the normal scope rules.
 \begin{lstlisting}
 otype T = §\ldots§;
 T a_T = §\ldots§;               // Default assignment used.
+otype T = ...;
+T a_T = ...;            // Default assignment used.
 T ?=?( T *, T );
 T a_T = §\ldots§;               // Programmer-defined assignment called.
+T a_T = ...;            // Programmer-defined assignment called.
 \end{lstlisting}
 \begin{rationale}
 …
 The statement
 \begin{lstlisting}
 for ( a; b; c ) §\ldots§
+for ( a; b; c ) ...
 \end{lstlisting} is treated as
 \begin{lstlisting}
 …
 \end{lstlisting}
+The various flavors of ©char© and ©int© and the enumerated types make up the
+\define{integral types}.
+The various flavors of ©char© and ©int© and the enumerated types make up the \define{integral types}.
 \begin{lstlisting}
 trait integral( otype T | arithmetic( T ) ) {§\impl{integral}§§\use{arithmetic}§

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 7937abf for doc/refrat

Legend:

doc/refrat/refrat.tex

Download in other formats: