Index: doc/refrat/refrat.tex =================================================================== --- doc/refrat/refrat.tex (revision 0638c4478ec4ff0f8f60a487e62a73c0cf2fad06) +++ doc/refrat/refrat.tex (revision 21995bcc5c902a2a43cb6fedb971d92bed446a37) @@ -10,6 +10,6 @@ %% 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 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -139,6 +139,5 @@ \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. @@ -153,6 +152,5 @@ \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. @@ -229,6 +227,5 @@ \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. @@ -281,6 +278,5 @@ \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. @@ -708,9 +704,9 @@ \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} @@ -744,5 +740,5 @@ 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. @@ -771,6 +767,5 @@ 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 @@ -798,6 +793,5 @@ 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} @@ -1123,11 +1117,11 @@ \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} @@ -1270,6 +1264,5 @@ \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 @@ -1317,5 +1310,5 @@ 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 @@ -1425,7 +1418,7 @@ \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} @@ -1461,6 +1454,5 @@ \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} @@ -1536,6 +1528,6 @@ \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} @@ -1615,8 +1607,8 @@ \end{syntax} -\rewriterules \use{?>>?}%use{?<> b §\rewrite§ ?>>?( a, b ) +\rewriterules +\begin{lstlisting} +a << b => ?<> b => ?>>?( a, b )§\use{?>>?}§ \end{lstlisting} @@ -1656,10 +1648,10 @@ \end{syntax} -\rewriterules\use{?>?}\use{?>=?}%use{? b §\rewrite§ ?>?( a, b ) -a <= b §\rewrite§ ?<=?( a, b ) -a >= b §\rewrite§ ?>=?( a, b ) +\rewriterules +\begin{lstlisting} +a < b => ? b => ?>?( a, b )§\use{?>?}§ +a <= b => ?<=?( a, b )§\use{?<=?}§ +a >= b => ?>=?( a, b )§\use{?>=?}§ \end{lstlisting} @@ -1717,6 +1709,6 @@ \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} @@ -1805,5 +1797,5 @@ \rewriterules \begin{lstlisting} -a & b §\rewrite§ ?&?( a, b )§\use{?&?}§ +a & b => ?&?( a, b )§\use{?&?}§ \end{lstlisting} @@ -1837,5 +1829,5 @@ \rewriterules \begin{lstlisting} -a ^ b §\rewrite§ ?^?( a, b )§\use{?^?}§ +a ^ b => ?^?( a, b )§\use{?^?}§ \end{lstlisting} @@ -1867,7 +1859,7 @@ \end{syntax} -\rewriterules\use{?"|?} -\begin{lstlisting} -a | b §\rewrite§ ?|?( a, b ) +\rewriterules +\begin{lstlisting} +a | b => ?|?( a, b )§\use{?"|?}§ \end{lstlisting} @@ -2024,15 +2016,13 @@ \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} @@ -2709,6 +2699,5 @@ 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. @@ -2732,6 +2721,5 @@ 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. @@ -2742,6 +2730,5 @@ 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 @@ -2960,6 +2947,5 @@ \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. @@ -3040,6 +3026,5 @@ 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. @@ -3059,9 +3044,8 @@ 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} @@ -3075,6 +3059,5 @@ 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. @@ -3128,8 +3111,8 @@ // 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} @@ -3154,5 +3137,5 @@ #include 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©; @@ -3239,6 +3222,5 @@ 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: @@ -3296,8 +3278,8 @@ 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} @@ -3421,5 +3403,5 @@ The statement \begin{lstlisting} -for ( a; b; c ) §\ldots§ +for ( a; b; c ) ... \end{lstlisting} is treated as \begin{lstlisting} @@ -3581,6 +3563,5 @@ \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}§