Changeset 7937abf for doc/refrat


Ignore:
Timestamp:
May 4, 2016, 1:58:35 PM (6 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
1b7ea43, 7b93757
Parents:
0638c44
Message:

update examples with new keywords, more formatting changes in documentation

File:
1 edited

Legend:

Unmodified
Added
Removed
  • doc/refrat/refrat.tex

    r0638c44 r7937abf  
    1010%% Created On       : Wed Apr  6 14:52:25 2016
    1111%% Last Modified By : Peter A. Buhr
    12 %% Last Modified On : Tue May  3 09:23:43 2016
    13 %% Update Count     : 52
     12%% Last Modified On : Tue May  3 18:00:28 2016
     13%% Update Count     : 64
    1414%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1515
     
    139139\subsection{Scopes of identifiers}\index{scopes}
    140140
    141 \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
    142 \Index{name space}, instead of hiding them.
     141\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.
    143142The 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.
    144143The outer declaration becomes \Index{visible} when the scope of the inner declaration terminates.
     
    153152
    154153\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.
    155 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
    156 \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.
     154Instead, 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.
    157155Within one translation unit, each instance of an identifier with \Index{internal linkage} denotes the same object or function in the same circumstances.
    158156Identifiers with \Index{no linkage} always denote unique entities.
     
    229227\CFA defines situations where values of one type are automatically converted to another type.
    230228These conversions are called \define{implicit conversion}s.
    231 The programmer can request
    232 \define{explicit conversion}s using cast expressions.
     229The programmer can request \define{explicit conversion}s using cast expressions.
    233230
    234231
     
    281278\label{anon-conv}
    282279
    283 If an expression's type is a pointer to a structure or union type that has a member that is an
    284 \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.
     280If 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.
    285281The result of the conversion is a pointer to the member.
    286282
     
    708704\rewriterules
    709705\begin{lstlisting}
    710 a[b] §\rewrite§ ?[?]( b, a ) // if a has integer type§\use{?[?]}§
    711 a[b] §\rewrite§ ?[?]( a, b ) // otherwise
    712 a( §\emph{arguments}§ ) §\rewrite§ ?()( a, §\emph{arguments}§ )§\use{?()}§
    713 a++ §\rewrite§ ?++(&( a ))§\use{?++}§
    714 a-- §\rewrite§ ?--(&( a ))§\use{?--}§
     706a[b] => ?[?]( b, a ) // if a has integer type§\use{?[?]}§
     707a[b] => ?[?]( a, b ) // otherwise
     708a( §\emph{arguments}§ ) => ?()( a, §\emph{arguments}§ )§\use{?()}§
     709a++ => ?++(&( a ))§\use{?++}§
     710a-- => ?--(&( a ))§\use{?--}§
    715711\end{lstlisting}
    716712
     
    744740Subscript expressions are rewritten as function calls that pass the first parameter by value.
    745741This is somewhat unfortunate, since array-like types tend to be large.
    746 The alternative is to use the rewrite rule ``©a[b]© \rewrite ©?[?](&(a), b)©''.
     742The alternative is to use the rewrite rule ``©a[b] => ?[?](&(a), b)©''.
    747743However, C semantics forbid this approach: the ©a© in ``©a[b]©'' can be an arbitrary pointer value, which does not have an address.
    748744
     
    771767The type of the valid interpretation is the return type of the function designator.
    772768
    773 For those combinations where the interpretation of the \nonterm{postfix-expression} is a
    774 \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
     769For 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
    775770\begin{itemize}
    776771\item
     
    798793For 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©.
    799794
    800 \CFA\index{deficiencies!generalizability} does not fully possess this property, because
    801 \Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
     795\CFA\index{deficiencies!generalizability} does not fully possess this property, because \Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
    802796Consider
    803797\begin{lstlisting}
     
    11231117\rewriterules
    11241118\begin{lstlisting}
    1125 *a      §\rewrite§ *?( a ) §\use{*?}§
    1126 +a      §\rewrite§ +?( a ) §\use{+?}§
    1127 -a      §\rewrite§ -?( a ) §\use{-?}§
    1128 ~a      §\rewrite§ ~?( a ) §\use{~?}§
    1129 !a      §\rewrite§ !?( a ) §\use{"!?}§
    1130 ++a     §\rewrite§ ++?(&( a )) §\use{++?}§
    1131 --a     §\rewrite§ --?(&( a )) §\use{--?}§
     1119*a      => *?( a )§\use{*?}§
     1120+a      => +?( a )§\use{+?}§
     1121-a      => -?( a )§\use{-?}§
     1122~a      => ~?( a )§\use{~?}§
     1123!a      => !?( a )§\use{"!?}§
     1124++a     => ++?(&( a ))§\use{++?}§
     1125--a     => --?(&( a ))§\use{--?}§
    11321126\end{lstlisting}
    11331127
     
    12701264
    12711265\constraints
    1272 The operand of the unary ``©&©'' operator shall have exactly one
    1273 \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
     1266The operand of the unary ``©&©'' operator shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
    12741267
    12751268\semantics
     
    13171310long int li;
    13181311void eat_double( double );§\use{eat_double}§
    1319 eat_double(-li ); // §\rewrite§ eat_double( -?( li ) );
     1312eat_double(-li ); // => eat_double( -?( li ) );
    13201313\end{lstlisting}
    13211314The valid interpretations of ``©-li©'' (assuming no extended integer types exist) are
     
    14251418\rewriterules
    14261419\begin{lstlisting}
    1427 a * b §\rewrite§ ?*?( a, b )§\use{?*?}§
    1428 a / b §\rewrite§ ?/?( a, b )§\use{?/?}§
    1429 a % b §\rewrite§ ?%?( a, b )§\use{?%?}§
     1420a * b => ?*?( a, b )§\use{?*?}§
     1421a / b => ?/?( a, b )§\use{?/?}§
     1422a % b => ?%?( a, b )§\use{?%?}§
    14301423\end{lstlisting}
    14311424
     
    14611454
    14621455\begin{rationale}
    1463 {\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the
    1464 \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.
     1456{\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.
    14651457\end{rationale}
    14661458
     
    15361528\rewriterules
    15371529\begin{lstlisting}
    1538 a + b §\rewrite§ ?+?( a, b )§\use{?+?}§
    1539 a - b §\rewrite§ ?-?( a, b )§\use{?-?}§
     1530a + b => ?+?( a, b )§\use{?+?}§
     1531a - b => ?-?( a, b )§\use{?-?}§
    15401532\end{lstlisting}
    15411533
     
    16151607\end{syntax}
    16161608
    1617 \rewriterules \use{?>>?}%use{?<<?}
    1618 \begin{lstlisting}
    1619 a << b §\rewrite§ ?<<?( a, b )
    1620 a >> b §\rewrite§ ?>>?( a, b )
     1609\rewriterules
     1610\begin{lstlisting}
     1611a << b => ?<<?( a, b )§\use{?<<?}§
     1612a >> b => ?>>?( a, b )§\use{?>>?}§
    16211613\end{lstlisting}
    16221614
     
    16561648\end{syntax}
    16571649
    1658 \rewriterules\use{?>?}\use{?>=?}%use{?<?}%use{?<=?}
    1659 \begin{lstlisting}
    1660 a < b §\rewrite§ ?<?( a, b )
    1661 a > b §\rewrite§ ?>?( a, b )
    1662 a <= b §\rewrite§ ?<=?( a, b )
    1663 a >= b §\rewrite§ ?>=?( a, b )
     1650\rewriterules
     1651\begin{lstlisting}
     1652a < b => ?<?( a, b )§\use{?<?}§
     1653a > b => ?>?( a, b )§\use{?>?}§
     1654a <= b => ?<=?( a, b )§\use{?<=?}§
     1655a >= b => ?>=?( a, b )§\use{?>=?}§
    16641656\end{lstlisting}
    16651657
     
    17171709\rewriterules
    17181710\begin{lstlisting}
    1719 a == b §\rewrite§ ?==?( a, b )§\use{?==?}§
    1720 a != b §\rewrite§ ?!=?( a, b )§\use{?"!=?}§
     1711a == b => ?==?( a, b )§\use{?==?}§
     1712a != b => ?!=?( a, b )§\use{?"!=?}§
    17211713\end{lstlisting}
    17221714
     
    18051797\rewriterules
    18061798\begin{lstlisting}
    1807 a & b §\rewrite§ ?&?( a, b )§\use{?&?}§
     1799a & b => ?&?( a, b )§\use{?&?}§
    18081800\end{lstlisting}
    18091801
     
    18371829\rewriterules
    18381830\begin{lstlisting}
    1839 a ^ b §\rewrite§ ?^?( a, b )§\use{?^?}§
     1831a ^ b => ?^?( a, b )§\use{?^?}§
    18401832\end{lstlisting}
    18411833
     
    18671859\end{syntax}
    18681860
    1869 \rewriterules\use{?"|?}
    1870 \begin{lstlisting}
    1871 a | b §\rewrite§ ?|?( a, b )
     1861\rewriterules
     1862\begin{lstlisting}
     1863a | b => ?|?( a, b )§\use{?"|?}§
    18721864\end{lstlisting}
    18731865
     
    20242016         \nonterm{assignment-expression}
    20252017\lhs{assignment-operator} one of
    2026 \rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \ 
    2027          ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
     2018\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \ ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
    20282019\end{syntax}
    20292020
    20302021\rewriterules
    2031 Let ``\(\leftarrow\)'' be any of the assignment operators.
     2022Let ``©<-©'' be any of the assignment operators.
    20322023Then
    2033 \use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}
    2034 \use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
    2035 \begin{lstlisting}
    2036 a §$\leftarrow$§ b §\rewrite§ ?§$\leftarrow$§?( &( a ), b )
     2024\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
     2025\begin{lstlisting}
     2026a <- b => ?<-?( &( a ), b )
    20372027\end{lstlisting}
    20382028
     
    27092699D( §\normalsize\nonterm{parameter-type-list}§ )
    27102700\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
    2711 \nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a
    2712 \Index{specification} in one of the \nonterm{forall-specifier}s.
     2701\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.
    27132702The identifiers declared by assertions that use an inferred parameter of a function declarator are \Index{assertion parameter}s of that function declarator.
    27142703
     
    27322721
    27332722If a function declarator is part of a function definition, its inferred parameters and assertion parameters have \Index{block scope};
    2734 otherwise, identifiers declared by assertions have a
    2735 \define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
     2723otherwise, identifiers declared by assertions have a \define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
    27362724
    27372725A function type that has at least one inferred parameter is a \define{polymorphic function} type.
     
    27422730Let $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.
    27432731Let $f'$ be $f$ with every occurrence of $f_i$ replaced by $g_i$, for all $i$.
    2744 Then $f$ and $g$ are
    2745 \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.
     2732Then $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.
    27462733
    27472734\examples
     
    29602947
    29612948\semantics
    2962 An \define{assertion} is a declaration of a collection of objects and functions, called
    2963 \define{assertion parameters}.
     2949An \define{assertion} is a declaration of a collection of objects and functions, called \define{assertion parameters}.
    29642950
    29652951The 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.
     
    30403026
    30413027A 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}.
    3042 If a
    3043 \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).
     3028If 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).
    30443029\begin{rationale}
    30453030Incomplete type declarations allow compact mutually-recursive types.
     
    30593044
    30603045A type declaration without an initializer and with \Index{storage-class specifier} ©extern©\use{extern} is an \define{opaque type declaration}.
    3061 Opaque types are
    3062 \Index{object type}s.
     3046Opaque types are \Index{object type}s.
    30633047An opaque type is not a \nonterm{constant-expression};
    3064 neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.  Every other
    3065 \Index{object type} is a \nonterm{constant-expression}.
     3048neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.
     3049Every other \Index{object type} is a \nonterm{constant-expression}.
    30663050Objects with static storage duration shall be declared with a type that is a \nonterm{constant-expression}.
    30673051\begin{rationale}
     
    30753059An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a value of \Index{type-class} ©dtype©.
    30763060An object type\index{object types} which is not a qualified version of a type is a value of type-classes ©type© and ©dtype©.
    3077 A
    3078 \Index{function type} is a value of type-class ©ftype©.
     3061A \Index{function type} is a value of type-class ©ftype©.
    30793062\begin{rationale}
    30803063Syntactically, a type value is a \nonterm{type-name}, which is a declaration for an object which omits the identifier being declared.
     
    31283111//  File a.c:
    31293112        extern type t1;
    3130         type t2 = struct { t1 f1; ... } // illegal
     3113        type t2 = struct { t1 f1; ... } // illegal
    31313114//  File b.c:
    31323115        extern type t2;
    3133         type t1 = struct { t2 f2; ... } // illegal
     3116        type t1 = struct { t2 f2; ... } // illegal
    31343117\end{lstlisting}
    31353118\end{rationale}
     
    31543137#include <stdlib.h>
    31553138T * new( otype T ) { return ( T * )malloc( sizeof( T) ); };
    3156 §\ldots§ int * ip = new( int );
     3139... int * ip = new( int );
    31573140\end{lstlisting}
    31583141This 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©;
     
    32393222
    32403223A definition\index{type definition} of a type identifier ©T© with \Index{implementation type} ©I© and type-class ©type© implicitly defines a default assignment function.
    3241 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
    3242 \define{default object}s as declared by the assertion declarations.
     3224A 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.
    32433225The default objects and functions have the same \Index{scope} and \Index{linkage} as the identifier ©T©.
    32443226Their values are determined as follows:
     
    32963278Default functions and objects are subject to the normal scope rules.
    32973279\begin{lstlisting}
    3298 otype T = §\ldots§;
    3299 T a_T = §\ldots§;               // Default assignment used.
     3280otype T = ...;
     3281T a_T = ...;            // Default assignment used.
    33003282T ?=?( T *, T );
    3301 T a_T = §\ldots§;               // Programmer-defined assignment called.
     3283T a_T = ...;            // Programmer-defined assignment called.
    33023284\end{lstlisting}
    33033285\begin{rationale}
     
    34213403The statement
    34223404\begin{lstlisting}
    3423 for ( a; b; c ) §\ldots§
     3405for ( a; b; c ) ...
    34243406\end{lstlisting} is treated as
    34253407\begin{lstlisting}
     
    35813563\end{lstlisting}
    35823564
    3583 The various flavors of ©char© and ©int© and the enumerated types make up the
    3584 \define{integral types}.
     3565The various flavors of ©char© and ©int© and the enumerated types make up the \define{integral types}.
    35853566\begin{lstlisting}
    35863567trait integral( otype T | arithmetic( T ) ) {§\impl{integral}§§\use{arithmetic}§
Note: See TracChangeset for help on using the changeset viewer.