Changeset 2fc0e5c for doc/refrat


Ignore:
Timestamp:
Sep 13, 2015, 2:03:00 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, string, with_gc
Children:
05f0d98
Parents:
32a1e5fd
Message:

fix special characters in sanserif font, and use inline index

File:
1 edited

Legend:

Unmodified
Added
Removed
  • doc/refrat/refrat.tex

    r32a1e5fd r2fc0e5c  
     1% requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
     2
    13\documentclass[openright,twoside]{report}
    24\usepackage{fullpage,times}
     
    5557\def\c11{ISO/IEC C}% cannot have numbers in latex command name
    5658
     59% replace/adjust characters that look bad in sanserif
     60\makeatletter
     61\lst@CCPutMacro
     62\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
     63\lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
     64\lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
     65\lst@ProcessOther{"5E}{$\sim$} % circumflex
     66\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
     67\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
     68\@empty\z@\@empty
     69
     70\newcommand{\Index}{\@ifstar\@sIndex\@Index}
     71\newcommand{\@Index}[2][\@empty]{\lowercase{\def\temp{#2}}#2\ifx#1\@empty\index{\temp}\else\index{#1@{\protect#2}}\fi}
     72\newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
     73\makeatother
     74
    5775\lstdefinelanguage{CFA}[ANSI]{C}%
    5876  {morekeywords={asm,_Atomic,catch,choose,_Complex,context,dtype,fallthru,forall,ftype,_Imaginary,lvalue,restrict,throw,try,type,},
     
    7189
    7290\setcounter{secnumdepth}{3}     % number subsubsections
     91\setcounter{tocdepth}{3}                % subsubsections in table of contents
    7392\makeindex
    7493
     
    142161
    143162\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may
    144 overload\index{overloading} outer declarations of lexically identical identifiers in the same name
    145 space\index{name spaces}, instead of hiding them. The outer declaration is hidden if the two
    146 declarations have compatible type\index{compatible type}, or if one declares an array type and the
    147 other declares a pointer type and the element type and pointed-at type are compatible, or if one has
    148 function type and the other is a pointer to a compatible function type, or if one declaration is a
    149 \lstinline$type$\use{type} or \lstinline$typedef$\use{typedef} declaration and the other is not.
    150 The outer declaration becomes visible\index{visible} when the scope of the inner declaration
    151 terminates.
     163overload\index{overloading} outer declarations of lexically identical identifiers in the same
     164\Index{name space}, instead of hiding them. The outer declaration is hidden if the two declarations
     165have \Index{compatible type}, or if one declares an array type and the other declares a pointer type
     166and the element type and pointed-at type are compatible, or if one has function type and the other
     167is a pointer to a compatible function type, or if one declaration is a \lstinline$type$\use{type} or
     168\lstinline$typedef$\use{typedef} declaration and the other is not.  The outer declaration becomes
     169\Index{visible} when the scope of the inner declaration terminates.
    152170\begin{rationale}
    153171Hence, a \CFA program can declare an \lstinline$int v$ and a \lstinline$float v$ in the same
     
    156174
    157175
    158 \subsection{Linkage of identifiers}\index{linkage}
    159 
    160 \CFA's linkage rules differ from C's in only one respect: instances of a particular identifier
    161 with external or internal linkage do not necessarily denote the same object or function. Instead,
    162 in the set of translation units and libraries that constitutes an entire program, any two instances
    163 of a particular identifier with external linkage\index{external linkage} denote the same object or
    164 function if they have compatible types\index{compatible type}, or if one declares an array type and
    165 the other declares a pointer type and the element type and pointed-at type are compatible, or if one
    166 has function type and the other is a pointer to a compatible function type. Within one translation
    167 unit, each instance of an identifier with internal linkage\index{internal linkage} denotes the same
    168 object or function in the same circumstances. Identifiers with no linkage\index{no linkage} always
    169 denote unique entities.
     176\subsection{Linkage of identifiers}
     177\index{linkage}
     178
     179\CFA's linkage rules differ from C's in only one respect: instances of a particular identifier with
     180external or internal linkage do not necessarily denote the same object or function. Instead, in the
     181set of translation units and libraries that constitutes an entire program, any two instances of a
     182particular identifier with \Index{external linkage} denote the same object or function if they have
     183\Index{compatible type}s, or if one declares an array type and the other declares a pointer type and
     184the element type and pointed-at type are compatible, or if one has function type and the other is a
     185pointer to a compatible function type. Within one translation unit, each instance of an identifier
     186with \Index{internal linkage} denotes the same object or function in the same circumstances.
     187Identifiers with \Index{no linkage} always denote unique entities.
    170188\begin{rationale}
    171189A \CFA program can declare an \lstinline$extern int v$ and an \lstinline$extern float v$; a C
     
    175193\section{Conversions}
    176194\CFA defines situations where values of one type are automatically converted to another type.
    177 These conversions are called \define{implicit conversions}. The programmer can request
    178 \define{explicit conversions} using cast expressions.
     195These conversions are called \define{implicit conversion}s. The programmer can request
     196\define{explicit conversion}s using cast expressions.
    179197
    180198
     
    184202
    185203\subsubsection{Safe arithmetic conversions}
    186 In C, a pattern of conversions known as the \define{usual arithmetic conversions} is used with most
     204In C, a pattern of conversions known as the \define{usual arithmetic conversion}s is used with most
    187205binary arithmetic operators to convert the operands to a common type and determine the type of the
    188206operator's result. In \CFA, these conversions play a role in overload resolution, and
    189 collectively are called the \define{safe arithmetic conversions}.
     207collectively are called the \define{safe arithmetic conversion}s.
    190208
    191209Let \(int_r\) and \(unsigned_r\) be the signed and unsigned integer types with integer conversion
    192 rank\index{integer conversion rank} \index{rank|see{integer conversion rank}} $r$. Let
     210rank\index{integer conversion rank}\index{rank|see{integer conversion rank}} $r$. Let
    193211\(unsigned_{mr}\) be the unsigned integer type with maximal rank.
    194212
     
    196214\begin{itemize}
    197215\item
    198 The integer promotions\index{integer promotions}.
     216The \Index{integer promotion}s.
    199217
    200218\item
     
    234252
    235253\begin{rationale}
    236 Note that {\c11} does not include conversion from real types\index{real type} to complex
    237 types\index{complex type} in the usual arithmetic conversions, and \CFA does not include them as
    238 safe conversions.
     254Note that {\c11} does not include conversion from \Index{real type}s to \Index{complex type}s in the
     255usual arithmetic conversions, and \CFA does not include them as safe conversions.
    239256\end{rationale}
    240257
     
    248265
    249266If an expression's type is a pointer to a structure or union type that has a member that is an
    250 anonymous structure\index{anonymous structure} or an anonymous union\index{anonymous union}, it can
    251 be implicitly converted\index{implicit conversions} to a pointer to the anonymous structure's or
    252 anonymous union's type. The result of the conversion is a pointer to the member.
     267\Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly
     268converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's
     269type. The result of the conversion is a pointer to the member.
    253270
    254271\examples
     
    273290
    274291\subsubsection{Specialization}
    275 A function or value whose type is polymorphic may be implicitly converted to one whose type is less
    276 polymorphic\index{less polymorphic} by binding values to one or more of its inferred
    277 parameters\index{inferred parameter}. Any value that is legal for the inferred parameter may be
    278 used, including other inferred parameters.
    279 
    280 If, after the inferred parameter binding, an assertion parameter\index{assertion parameters} has no
    281 inferred parameters in its type, then an object or function must be visible at the point of the
    282 specialization that has the same identifier as the assertion parameter and has a type that is
    283 compatible\index{compatible type} with or can be specialized to the type of the assertion parameter.
    284 The assertion parameter is bound to that object or function.
     292A function or value whose type is polymorphic may be implicitly converted to one whose type is
     293\Index{less polymorphic} by binding values to one or more of its \Index{inferred parameter}. Any
     294value that is legal for the inferred parameter may be used, including other inferred parameters.
     295
     296If, after the inferred parameter binding, an \Index{assertion parameter} has no inferred parameters
     297in its type, then an object or function must be visible at the point of the specialization that has
     298the same identifier as the assertion parameter and has a type that is compatible\index{compatible
     299  type} with or can be specialized to the type of the assertion parameter.  The assertion parameter
     300is bound to that object or function.
    285301
    286302The type of the specialization is the type of the original with the bound inferred parameters and
     
    325341\item
    326342from a pointer to a structure or union type to a pointer to the type of a member of the structure or
    327 union that is an anonymous structure\index{anonymous structure} or an anonymous
    328 union\index{anonymous union};
    329 \item
    330 within the scope of an initialized type declaration\index{type declaration}, conversions between a
    331 type and its implementation or between a pointer to a type and a pointer to its implementation.
     343union that is an \Index{anonymous structure} or an \Index{anonymous union};
     344\item
     345within the scope of an initialized \Index{type declaration}, conversions between a type and its
     346implementation or between a pointer to a type and a pointer to its implementation.
    332347\end{itemize}
    333348
    334 Conversions that are not safe conversions are \define{unsafe conversions}.
     349Conversions that are not safe conversions are \define{unsafe conversion}s.
    335350\begin{rationale}
    336351As in C, there is an implicit conversion from \lstinline$void *$ to any pointer type. This is
     
    343358\subsection{Conversion cost}
    344359
    345 The \define{conversion cost} of a safe\index{safe conversions}
    346 conversion\footnote{Unsafe\index{unsafe conversions} conversions do not have defined conversion
     360The \define{conversion cost} of a safe\index{safe conversion}
     361conversion\footnote{Unsafe\index{unsafe conversion} conversions do not have defined conversion
    347362costs.} is a measure of how desirable or undesirable it is. It is defined as follows.
    348363\begin{itemize}
     
    395410\subsection{Identifiers}
    396411
    397 \CFA allows operator overloading\index{overloading} by associating operators with special
    398 function identifiers. Furthermore, the constants ``\lstinline$0$'' and ``\lstinline$1$'' have
    399 special status for many of C's data types (and for many programmer-defined data types as well), so
    400 \CFA treats them as overloadable identifiers. Programmers can use these identifiers to declare
    401 functions and objects that implement operators and constants for their own types.
     412\CFA allows operator \Index{overloading} by associating operators with special function
     413identifiers. Furthermore, the constants ``\lstinline$0$'' and ``\lstinline$1$'' have special status
     414for many of C's data types (and for many programmer-defined data types as well), so \CFA treats them
     415as overloadable identifiers. Programmers can use these identifiers to declare functions and objects
     416that implement operators and constants for their own types.
    402417
    403418
     
    561576
    562577\section{Expressions}
     578
    563579\CFA allows operators and identifiers to be overloaded. Hence, each expression can have a number
    564 of \define{interpretations}, each of which has a different type. The interpretations that are
    565 potentially executable are called \define{valid interpretations}. The set of interpretations
     580of \define{interpretation}s, each of which has a different type. The interpretations that are
     581potentially executable are called \define{valid interpretation}s. The set of interpretations
    566582depends on the kind of expression and on the interpretations of the subexpressions that it contains.
    567583The rules for determining the valid interpretations of an expression are discussed below for each
     
    575591
    576592The \define{best valid interpretations} are the valid interpretations that use the fewest
    577 unsafe\index{unsafe conversions} conversions. Of these, the best are those where the functions and
     593unsafe\index{unsafe conversion} conversions. Of these, the best are those where the functions and
    578594objects involved are the least polymorphic\index{less polymorphic}. Of these, the best have the
    579 lowest total conversion cost\index{conversion cost}, including all implicit conversions in the
    580 argument expressions. Of these, the best have the highest total conversion cost for the implicit
    581 conversions (if any) applied to the argument expressions. If there is no single best valid
    582 interpretation, or if the best valid interpretation is ambiguous, then the resulting interpretation
    583 is ambiguous\index{ambiguous interpretation}.
     595lowest total \Index{conversion cost}, including all implicit conversions in the argument
     596expressions. Of these, the best have the highest total conversion cost for the implicit conversions
     597(if any) applied to the argument expressions. If there is no single best valid interpretation, or if
     598the best valid interpretation is ambiguous, then the resulting interpretation is
     599ambiguous\index{ambiguous interpretation}.
    584600
    585601\begin{rationale}
     
    595611The ``least polymorphic'' rule reduces the number of polymorphic function calls, since such
    596612functions are presumably more expensive than monomorphic functions and since the more specific
    597 function is presumably more appropriate. It also gives preference to monomorphic values (such as
    598 the \lstinline$int$ \lstinline$0$) over polymorphic values (such as the null pointer
    599 \lstinline$0$)\use{0}\index{null pointer}. However, interpretations that call polymorphic functions
    600 are preferred to interpretations that perform unsafe conversions, because those conversions
    601 potentially lose accuracy or violate strong typing.
     613function is presumably more appropriate. It also gives preference to monomorphic values (such as the
     614\lstinline$int$ \lstinline$0$) over polymorphic values (such as the \Index{null pointer}
     615\lstinline$0$\use{0}). However, interpretations that call polymorphic functions are preferred to
     616interpretations that perform unsafe conversions, because those conversions potentially lose accuracy
     617or violate strong typing.
    602618
    603619There are two notable differences between \CFA's overload resolution rules and the rules for
     
    614630by \define{rewrite rules}. Each operator has a set of predefined functions that overload its
    615631identifier. Overload resolution determines which member of the set is executed in a given
    616 expression. The functions have internal linkage\index{internal linkage} and are implicitly declared
    617 with file scope\index{file scope}. The predefined functions and rewrite rules are discussed below
    618 for each of these operators.
     632expression. The functions have \Index{internal linkage} and are implicitly declared with \Index{file
     633scope}. The predefined functions and rewrite rules are discussed below for each of these
     634operators.
    619635\begin{rationale}
    620636Predefined functions and constants have internal linkage because that simplifies optimization in
     
    629645of its subexpressions, this chapter can be taken as describing an overload resolution algorithm that
    630646uses one bottom-up pass over an expression tree. Such an algorithm was first described (for Ada) by
    631 Baker \cite{Bak:overload}. It is extended here to handle polymorphic functions and arithmetic
    632 conversions. The overload resolution rules and the predefined functions have been chosen so that,
    633 in programs that do not introduce overloaded declarations, expressions will have the same meaning in
    634 C and in \CFA.
     647Baker~\cite{Bak:overload}. It is extended here to handle polymorphic functions and arithmetic
     648conversions. The overload resolution rules and the predefined functions have been chosen so that, in
     649programs that do not introduce overloaded declarations, expressions will have the same meaning in C
     650and in \CFA.
    635651\end{rationale}
    636652
     
    641657\end{rationale}
    642658
     659
    643660\subsection{Primary expressions}
     661
    644662\begin{syntax}
    645663\lhs{primary-expression}
     
    660678
    661679\semantics
    662 The valid interpretations\index{valid interpretations} of an \nonterm{identifier} are given by the
    663 visible\index{visible} declarations of the identifier.
     680The \Index{valid interpretation} of an \nonterm{identifier} are given by the visible\index{visible}
     681declarations of the identifier.
    664682
    665683A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type
     
    702720\end{rationale}
    703721
     722
    704723\subsubsection{Generic selection}
     724
    705725\constraints The best interpretation of the controlling expression shall be
    706726unambiguous\index{ambiguous interpretation}, and shall have type compatible with at most one of the
     
    742762\end{lstlisting}
    743763
     764
    744765\subsubsection{Array subscripting}
     766
    745767\begin{lstlisting}
    746768forall( type T ) lvalue T ?[?]( T *, ptrdiff_t );@\use{ptrdiff_t}@
     
    794816
    795817Each combination of function designators and argument interpretations is considered. For those
    796 interpretations of the \nonterm{postfix-expression} that are monomorphic\index{monomorphic function}
    797 function designators, the combination has a valid interpretation\index{valid interpretations} if the
    798 function designator accepts the number of arguments given, and each argument interpretation matches
    799 the corresponding explicit parameter:
     818interpretations of the \nonterm{postfix-expression} that are \Index{monomorphic function}
     819designators, the combination has a \Index{valid interpretation} if the function designator accepts
     820the number of arguments given, and each argument interpretation matches the corresponding explicit
     821parameter:
    800822\begin{itemize}
    801823\item
     
    805827\item
    806828if the function designator's type does not include a prototype or if the argument corresponds to
    807 ``\lstinline$...$'' in a prototype, a default argument promotion\index{default argument promotions}
    808 is applied to it.
     829``\lstinline$...$'' in a prototype, a \Index{default argument promotion} is applied to it.
    809830\end{itemize}
    810831The type of the valid interpretation is the return type of the function designator.
    811832
    812833For those combinations where the interpretation of the \nonterm{postfix-expression} is a
    813 polymorphic\index{polymorphic function} function designator and the function designator accepts the
    814 number of arguments given, there shall be at least one set of \define{implicit arguments} for the
    815 implicit parameters such that
     834\Index{polymorphic function} designator and the function designator accepts the number of arguments
     835given, there shall be at least one set of \define{implicit argument}s for the implicit parameters
     836such that
    816837\begin{itemize}
    817838\item
    818 If the declaration of the implicit parameter uses type-class\index{type-class}
    819 \lstinline$type$\use{type}, the implicit argument must be an object type; if it uses
    820 \lstinline$dtype$, the implicit argument must be an object type or an incomplete type; and if it
    821 uses \lstinline$ftype$, the implicit argument must be a function type.
     839If the declaration of the implicit parameter uses \Index{type-class} \lstinline$type$\use{type}, the
     840implicit argument must be an object type; if it uses \lstinline$dtype$, the implicit argument must
     841be an object type or an incomplete type; and if it uses \lstinline$ftype$, the implicit argument
     842must be a function type.
    822843
    823844\item
    824845if an explicit parameter's type uses any implicit parameters, then the corresponding explicit
    825 argument must have a type that is (or can be safely converted\index{safe conversions} to) the type
     846argument must have a type that is (or can be safely converted\index{safe conversion} to) the type
    826847produced by substituting the implicit arguments for the implicit parameters in the explicit
    827848parameter type.
     
    832853
    833854\item
    834 for each assertion parameter\index{assertion parameters} in the function designator's type, there
    835 must be an object or function with the same identifier that is visible at the call site and whose
    836 type is compatible with or can be specialized to the type of the assertion declaration.
     855for each \Index{assertion parameter} in the function designator's type, there must be an object or
     856function with the same identifier that is visible at the call site and whose type is compatible with
     857or can be specialized to the type of the assertion declaration.
    837858\end{itemize}
    838859There is a valid interpretation for each such set of implicit parameters. The type of each valid
     
    848869Every set of valid interpretations that have mutually compatible\index{compatible type} result types
    849870also produces an interpretation of the function call expression. The type of the interpretation is
    850 the composite\index{composite type} type of the types of the valid interpretations, and the value of
    851 the interpretation is that of the best valid interpretation\index{best valid interpretations}.
     871the \Index{composite type} of the types of the valid interpretations, and the value of the
     872interpretation is that of the \Index{best valid interpretation}.
    852873\begin{rationale}
    853874One desirable property of a polymorphic programming language is \define{generalizability}: the
     
    858879
    859880\CFA\index{deficiencies!generalizability} does not fully possess this property, because
    860 unsafe\index{unsafe conversions} conversions are not done when arguments are passed to polymorphic
    861 parameters. Consider
     881\Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
     882Consider
    862883\begin{lstlisting}
    863884float g( float, float );
     
    960981r( 0 );
    961982\end{lstlisting}
    962 The \lstinline$int 0$ could be passed to (8), or the \lstinline$(void *)$
    963 specialization\index{specialization} of the null pointer\index{null pointer} \lstinline$0$\use{0}
    964 could be passed to (9). The former is chosen because the \lstinline$int$ \lstinline$0$ is less
    965 polymorphic\index{less polymorphic}. For the same reason, \lstinline$int$ \lstinline$0$ is passed
    966 to \lstinline$r()$, even though it has \emph{no} declared parameter types.
     983The \lstinline$int 0$ could be passed to (8), or the \lstinline$(void *)$ \Index{specialization} of
     984the null pointer\index{null pointer} \lstinline$0$\use{0} could be passed to (9). The former is
     985chosen because the \lstinline$int$ \lstinline$0$ is \Index{less polymorphic}. For
     986the same reason, \lstinline$int$ \lstinline$0$ is passed to \lstinline$r()$, even though it has
     987\emph{no} declared parameter types.
    967988
    968989
     
    972993least one interpretation of \lstinline$s$ whose type is a structure type or union type containing a
    973994member named \lstinline$m$. If two or more interpretations of \lstinline$s$ have members named
    974 \lstinline$m$ with mutually compatible types, then the expression has an ambiguous
    975 interpretation\index{ambiguous interpretation} whose type is the composite type of the types of the
    976 members. If an interpretation of \lstinline$s$ has a member \lstinline$m$ whose type is not
    977 compatible with any other \lstinline$s$'s \lstinline$m$, then the expression has an interpretation
    978 with the member's type. The expression has no other interpretations.
     995\lstinline$m$ with mutually compatible types, then the expression has an \Index{ambiguous
     996interpretation} whose type is the composite type of the types of the members. If an interpretation
     997of \lstinline$s$ has a member \lstinline$m$ whose type is not compatible with any other
     998\lstinline$s$'s \lstinline$m$, then the expression has an interpretation with the member's type. The
     999expression has no other interpretations.
    9791000
    9801001The expression ``\lstinline$p->m$'' has the same interpretations as the expression
     
    11471168\begin{lstlisting}
    11481169X ?++( volatile X * ), ?++( _Atomic volatile X * ),
    1149  ?--( volatile X * ), ?--( _Atomic volatile X * );
     1170  ?--( volatile X * ), ?--( _Atomic volatile X * );
    11501171\end{lstlisting}
    11511172For every complete enumerated type \lstinline$E$ there exist
     
    11531174\begin{lstlisting}
    11541175E ?++( volatile E * ), ?++( _Atomic volatile E * ),
    1155  ?--( volatile E * ), ?--( _Atomic volatile E * );
     1176  ?--( volatile E * ), ?--( _Atomic volatile E * );
    11561177\end{lstlisting}
    11571178
     
    11741195First, each interpretation of the operand of an increment or decrement expression is considered
    11751196separately. For each interpretation that is a bit-field or is declared with the
    1176 \lstinline$register$\index{register@{\lstinline$register$}} storage-class
    1177 specifier\index{storage-class specifier}, the expression has one valid interpretation, with the type
    1178 of the operand, and the expression is ambiguous if the operand is.
     1197\lstinline$register$\index{register@{\lstinline$register$}} \index{Itorage-class specifier}, the
     1198expression has one valid interpretation, with the type of the operand, and the expression is
     1199ambiguous if the operand is.
    11791200
    11801201For the remaining interpretations, the expression is rewritten, and the interpretations of the
     
    15231544\constraints
    15241545The operand of the unary ``\lstinline$&$'' operator shall have exactly one
    1525 interpretation\index{ambiguous interpretation}\index{interpretations}, which shall be unambiguous.
     1546\Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
    15261547
    15271548\semantics
     
    15961617forall( ftype FT ) int !?( FT * );
    15971618\end{lstlisting}
    1598 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    1599 rank}greater than the rank of \lstinline$int$ there exist
     1619For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     1620rank of \lstinline$int$ there exist
    16001621% Don't use predefined: keep this out of prelude.cf.
    16011622\begin{lstlisting}
     
    16601681
    16611682
    1662 \subsubsection{The {\tt sizeof} and {\tt \_Alignof} operators}
     1683\subsubsection{The \lstinline$sizeof$ and \lstinline$_Alignof$ operators}
    16631684
    16641685\constraints
     
    16671688
    16681689When the \lstinline$sizeof$\use{sizeof} operator is applied to an expression, the expression shall
    1669 have exactly one interpretation\index{ambiguous interpretation}\index{interpretations}, which shall
     1690have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall
    16701691be unambiguous. \semantics A \lstinline$sizeof$ or \lstinline$_Alignof$ expression has one
    16711692interpretation, of type \lstinline$size_t$.
     
    16971718\end{rationale}
    16981719
     1720
    16991721\subsection{Cast operators}
     1722
    17001723\begin{syntax}
    17011724\lhs{cast-expression}
     
    17101733\semantics
    17111734
    1712 In a cast expression\index{cast expression} ``\lstinline$($\nonterm{type-name}\lstinline$)e$'', if
    1713 \nonterm{type-name} is the type of an interpretation of \lstinline$e$, then that interpretation is the
    1714 only interpretation of the cast expression; otherwise, \lstinline$e$ shall have some interpretation that
    1715 can be converted to \nonterm{type-name}, and the interpretation of the cast expression is the cast
    1716 of the interpretation that can be converted at the lowest cost. The cast expression's interpretation
    1717 is ambiguous\index{ambiguous interpretation} if more than one interpretation can be converted at the
    1718 lowest cost or if the selected interpretation is ambiguous.
     1735In a \Index{cast expression} ``\lstinline$($\nonterm{type-name}\lstinline$)e$'', if
     1736\nonterm{type-name} is the type of an interpretation of \lstinline$e$, then that interpretation is
     1737the only interpretation of the cast expression; otherwise, \lstinline$e$ shall have some
     1738interpretation that can be converted to \nonterm{type-name}, and the interpretation of the cast
     1739expression is the cast of the interpretation that can be converted at the lowest cost. The cast
     1740expression's interpretation is ambiguous\index{ambiguous interpretation} if more than one
     1741interpretation can be converted at the lowest cost or if the selected interpretation is ambiguous.
    17191742
    17201743\begin{rationale}
     
    17231746\end{rationale}
    17241747
     1748
    17251749\subsection{Multiplicative operators}
     1750
    17261751\begin{syntax}
    17271752\lhs{multiplicative-expression}
     
    17831808        ?/?( _Complex long double, _Complex long double );
    17841809\end{lstlisting}
    1785 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    1786 rank}greater than the rank of \lstinline$int$ there exist
     1810For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     1811rank of \lstinline$int$ there exist
    17871812% Don't use predefined: keep this out of prelude.cf.
    17881813\begin{lstlisting}
     
    17911816
    17921817\begin{rationale}
    1793 {\c11} does not include conversions from the real types\index{real type} to complex
    1794 types\index{complex type} in the usual arithmetic conversions\index{usual arithmetic conversions}.
    1795 Instead it specifies conversion of the result of binary operations on arguments from mixed type
    1796 domains. \CFA's predefined operators match that pattern.
     1818{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the
     1819\Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary
     1820operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
    17971821\end{rationale}
    17981822
     
    18291853
    18301854\begin{rationale}
    1831 {\c11} defines most arithmetic operations to apply an integer promotion\index{integer promotions} to
    1832 any argument that belongs to a type that has an integer conversion rank\index{integer conversion
    1833  rank} less than that of \lstinline$int$.If \lstinline$s$ is a \lstinline$short int$,
    1834 ``\lstinline$s *s$'' does not have type \lstinline$short int$; it is treated as
    1835 ``\lstinline$( (int)s ) * ( (int)s )$'', and has type \lstinline$int$. \CFA matches that pattern;
    1836 it does not predefine ``\lstinline$short ?*?( short, short )$''.
     1855{\c11} defines most arithmetic operations to apply an \Index{integer promotion} to any argument that
     1856belongs to a type that has an \Index{integer conversion rank} less than that of \lstinline$int$.If
     1857\lstinline$s$ is a \lstinline$short int$, ``\lstinline$s *s$'' does not have type \lstinline$short int$;
     1858it is treated as ``\lstinline$( (int)s ) * ( (int)s )$'', and has type \lstinline$int$. \CFA matches
     1859that pattern; it does not predefine ``\lstinline$short ?*?( short, short )$''.
    18371860
    18381861These ``missing'' operators limit polymorphism. Consider
     
    19862009        * ?-?( _Atomic const restrict volatile T *, _Atomic const restrict volatile T * );
    19872010\end{lstlisting}
    1988 For every extended integer type \lstinline$X$ with integer conversion rank
    1989 \index{integer conversion rank}greater than the rank of \lstinline$int$ there
    1990 exist
     2011For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2012rank of \lstinline$int$ there exist
    19912013% Don't use predefined: keep this out of prelude.cf.
    19922014\begin{lstlisting}
     
    20392061         ?>>?( long long unsigned int, int);
    20402062\end{lstlisting}
    2041 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2042  rank}greater than the rank of \lstinline$int$ there exist
     2063For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2064rank of \lstinline$int$ there exist
    20432065% Don't use predefined: keep this out of prelude.cf.
    20442066\begin{lstlisting}
     
    20482070\begin{rationale}
    20492071The bitwise shift operators break the usual pattern: they do not convert both operands to a common
    2050 type. The right operand only undergoes integer promotion\index{integer promotion}.
     2072type. The right operand only undergoes \Index{integer promotion}.
    20512073\end{rationale}
    20522074
     
    21232145        ?>=?( _Atomic const restrict volatile DT *, _Atomic const restrict volatile DT * );
    21242146\end{lstlisting}
    2125 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2126  rank}greater than the rank of \lstinline$int$ there exist
     2147For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2148rank of \lstinline$int$ there exist
    21272149% Don't use predefined: keep this out of prelude.cf.
    21282150\begin{lstlisting}
     
    22262248        ?!=?( forall( ftype FT2) FT2*, forall( ftype FT3) FT3 * );
    22272249\end{lstlisting}
    2228 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2229  rank}greater than the rank of \lstinline$int$ there exist
     2250For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2251rank of \lstinline$int$ there exist
    22302252% Don't use predefined: keep this out of prelude.cf.
    22312253\begin{lstlisting}
     
    22372259The polymorphic equality operations come in three styles: comparisons between pointers of compatible
    22382260types, between pointers to \lstinline$void$ and pointers to object types or incomplete types, and
    2239 between the null pointer constant\index{null pointer} and pointers to any type. In the last case, a
    2240 special constraint rule for null pointer constant operands has been replaced by a consequence of the
    2241 \CFA type system.
     2261between the \Index{null pointer} constant and pointers to any type. In the last case, a special
     2262constraint rule for null pointer constant operands has been replaced by a consequence of the \CFA
     2263type system.
    22422264\end{rationale}
    22432265
     
    22782300long long unsigned int ?&?( long long unsigned int, long long unsigned int );
    22792301\end{lstlisting}
    2280 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2281 rank}greater than the rank of \lstinline$int$ there exist
     2302For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2303rank of \lstinline$int$ there exist
    22822304% Don't use predefined: keep this out of prelude.cf.
    22832305\begin{lstlisting}
     
    23112333long long unsigned int ?^?( long long unsigned int, long long unsigned int );
    23122334\end{lstlisting}
    2313 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2314  rank}greater than the rank of \lstinline$int$ there exist
     2335For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2336rank of \lstinline$int$ there exist
    23152337% Don't use predefined: keep this out of prelude.cf.
    23162338\begin{lstlisting}
     
    23442366long long unsigned int ?|?( long long unsigned int, long long unsigned int );
    23452367\end{lstlisting}
    2346 For every extended integer type \lstinline$X$ with integer conversion rank \index{integer conversion
    2347 rank}greater than the rank of \lstinline$int$ there exist
     2368For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the
     2369rank of \lstinline$int$ there exist
    23482370% Don't use predefined: keep this out of prelude.cf.
    23492371\begin{lstlisting}
     
    25022524
    25032525\begin{rationale}
    2504 The object of the above is to apply the usual arithmetic conversions\index{usual arithmetic
    2505 conversions} when the second and third operands have arithmetic type, and to combine the
    2506 qualifiers of the second and third operands if they are pointers.
     2526The object of the above is to apply the \Index{usual arithmetic conversion}s when the second and
     2527third operands have arithmetic type, and to combine the qualifiers of the second and third operands
     2528if they are pointers.
    25072529\end{rationale}
    25082530
     
    31723194
    31733195\constraints
    3174 If an identifier has no linkage\index{no linkage}, there shall be no more than one declaration of
    3175 the identifier ( in a declarator or type specifier ) with compatible types in the same scope and in
    3176 the same name space, except that:
     3196If an identifier has \Index{no linkage}, there shall be no more than one declaration of the
     3197identifier ( in a declarator or type specifier ) with compatible types in the same scope and in the
     3198same name space, except that:
    31773199\begin{itemize}
    31783200\item
     
    32763298\semantics
    32773299The \nonterm{type-parameter-list}s and assertions of the \nonterm{forall-specifier}s declare type
    3278 identifiers, function and object identifiers with no linkage\index{no linkage}.
     3300identifiers, function and object identifiers with \Index{no linkage}.
    32793301
    32803302If, in the declaration ``\lstinline$T D1$'', \lstinline$T$ contains \nonterm{forall-specifier}s and
     
    32843306\end{lstlisting}
    32853307then a type identifier declared by one of the \nonterm{forall-specifier}s is an \define{inferred
    3286  parameter} of the function declarator if and only if it is not an inferred parameter of a function
     3308parameter} of the function declarator if and only if it is not an inferred parameter of a function
    32873309declarator in \lstinline$D$, and it is used in the type of a parameter in the following
    32883310\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a
    3289 specification\index{specification} in one of the \nonterm{forall-specifier}s. The identifiers
    3290 declared by assertions that use an inferred parameter of a function declarator are assertion
    3291 parameters\index{assertion parameters} of that function declarator.
     3311\Index{specification} in one of the \nonterm{forall-specifier}s. The identifiers declared by
     3312assertions that use an inferred parameter of a function declarator are \Index{assertion parameter}s
     3313of that function declarator.
    32923314\begin{rationale}
    32933315Since every inferred parameter is used by some parameter, inference can be understood as a single
     
    33123334
    33133335If a function declarator is part of a function definition, its inferred parameters and assertion
    3314 parameters have block scope\index{block scope}; otherwise, identifiers declared by assertions have a
     3336parameters have \Index{block scope}; otherwise, identifiers declared by assertions have a
    33153337\define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
    33163338
     
    33263348and $g$ in their order of occurance in the function types' \nonterm{parameter-type-list}s. Let $f'$
    33273349be $f$ with every occurrence of $f_i$ replaced by $g_i$, for all $i$. Then $f$ and $g$ are
    3328 compatible types\index{compatible type} if $f'$'s and $g$'s return types and parameter lists are
    3329 compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with
    3330 the same identifier and compatible type, and vice versa.
     3350\Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if
     3351for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same
     3352identifier and compatible type, and vice versa.
    33313353
    33323354\examples
     
    34383460\lstinline$lvalue$ may be used to qualify the return type of a function type. Let \lstinline$T$ be
    34393461an unqualified version of a type; then the result of calling a function with return type
    3440 \lstinline$lvalue T$ is a modifiable lvalue\index{modifiable lvalue} of type \lstinline$T$.
     3462\lstinline$lvalue T$ is a \Index{modifiable lvalue} of type \lstinline$T$.
    34413463\lstinline$const$\use{const} and \lstinline$volatile$\use{volatile} qualifiers may also be added to
    34423464indicate that the function result is a constant or volatile lvalue.
     
    34463468\end{rationale}
    34473469
    3448 An {lvalue}-qualified type may be used in a cast expression\index{cast expression} if the operand is
    3449 an lvalue; the result of the expression is an lvalue.
     3470An {lvalue}-qualified type may be used in a \Index{cast expression} if the operand is an lvalue; the
     3471result of the expression is an lvalue.
    34503472
    34513473\begin{rationale}
     
    34903512
    34913513\item
    3492 References to const-qualified\index{const-qualified} types can be used instead of value parameters.
    3493 Given the {\CC} function call ``\lstinline$fiddle( a_thing )$'', where the type of
    3494 \lstinline$a_thing$ is \lstinline$Thing$, the type of \lstinline$fiddle$ could be either of
     3514References to \Index{const-qualified} types can be used instead of value parameters.  Given the
     3515{\CC} function call ``\lstinline$fiddle( a_thing )$'', where the type of \lstinline$a_thing$ is
     3516\lstinline$Thing$, the type of \lstinline$fiddle$ could be either of
    34953517\begin{lstlisting}
    34963518void fiddle( Thing );
     
    35253547object being initialized. An expression used in an \nonterm{initializer-list} is treated as being
    35263548cast to the type of the aggregate member that it initializes. In either case the cast must have a
    3527 single unambiguous interpretation\index{interpretations}.
     3549single unambiguous \Index{interpretation}.
    35283550
    35293551
     
    35473569\begin{rationale}
    35483570The declarations allowed in a specification are much the same as those allowed in a structure,
    3549 except that bit fields are not allowed, and incomplete types\index{incomplete types} and function
    3550 types are allowed.
     3571except that bit fields are not allowed, and \Index{incomplete type}s and function types are allowed.
    35513572\end{rationale}
    35523573
     
    35633584
    35643585\subsubsection{Assertions}
     3586
    35653587\begin{syntax}
    35663588\lhs{assertion-list}
     
    35803602each \nonterm{type-parameter} in that specification's \nonterm{spec-parameter-list}. If the
    35813603\nonterm{type-parameter} uses type-class \lstinline$type$\use{type}, the argument shall be the type
    3582 name of an object type\index{object types}; if it uses \lstinline$dtype$, the argument shall be the
    3583 type name of an object type or an incomplete type\index{incomplete types}; and if it uses
    3584 \lstinline$ftype$, the argument shall be the type name of a function type\index{function types}.
     3604name of an \Index{object type}; if it uses \lstinline$dtype$, the argument shall be the type name of
     3605an object type or an \Index{incomplete type}; and if it uses \lstinline$ftype$, the argument shall
     3606be the type name of a \Index{function type}.
    35853607
    35863608\semantics
     
    35953617combining the declarations produced by each assertion. If the collection contains two declarations
    35963618that declare the same identifier and have compatible types, they are combined into one declaration
    3597 with the composite type\index{composite type} constructed from the two types.
     3619with the \Index{composite type} constructed from the two types.
    35983620
    35993621\examples
     
    36303652\end{lstlisting}
    36313653
     3654
    36323655\subsection{Type declarations}
     3656
    36333657\begin{syntax}
    36343658\lhs{type-parameter-list}
     
    36563680
    36573681\semantics
    3658 A \nonterm{type-parameter} or a \nonterm{type-declarator} declares an identifier to be a type
    3659 name\index{type names} for a type incompatible with all other types.
    3660 
    3661 An identifier declared by a \nonterm{type-parameter} has no linkage\index{no linkage}. Identifiers
    3662 declared with type-class \lstinline$type$\use{type} are object types\index{object types}; those
    3663 declared with type-class \lstinline$dtype$\use{dtype} are incomplete types\index{incomplete types};
    3664 and those declared with type-class \lstinline$ftype$\use{ftype} are function types\index{function
    3665  types}. The identifier has block scope\index{block scope} that terminates at the end of the
    3666 \nonterm{spec-declaration-list} or polymorphic function that contains the \nonterm{type-parameter}.
    3667 
    3668 A \nonterm{type-declarator} with an initializer\index{initializer} is a \define{type definition}.
    3669 The declared identifier is an incomplete type\index{incomplete types} within the initializer, and an
    3670 object type\index{object types} after the end of the initializer. The type in the initializer is
    3671 called the \define{implementation type}. Within the scope of the declaration, implicit
    3672 conversions\index{implicit conversions} can be performed between the defined type and the
    3673 implementation type, and between pointers to the defined type and pointers to the implementation
    3674 type.
    3675 
    3676 A type declaration without an initializer\index{initializer} and without a storage-class
    3677 specifier\index{storage-class specifiers} or with storage-class specifier
    3678 \lstinline$static$\use{static} defines an incomplete type\index{incomplete types}. If a translation
    3679 unit\index{translation unit} or block \index{block} contains one or more such declarations for an
    3680 identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block,
    3681 which would define a new type known only within that block).
     3682A \nonterm{type-parameter} or a \nonterm{type-declarator} declares an identifier to be a \Index{type
     3683name} for a type incompatible with all other types.
     3684
     3685An identifier declared by a \nonterm{type-parameter} has \Index{no linkage}. Identifiers declared
     3686with type-class \lstinline$type$\use{type} are \Index{object type}s; those declared with type-class
     3687\lstinline$dtype$\use{dtype} are \Index{incomplete type}s; and those declared with type-class
     3688\lstinline$ftype$\use{ftype} are \Index{function type}s. The identifier has \Index{block scope} that
     3689terminates at the end of the \nonterm{spec-declaration-list} or polymorphic function that contains
     3690the \nonterm{type-parameter}.
     3691
     3692A \nonterm{type-declarator} with an \Index{initializer} is a \define{type definition}.  The declared
     3693identifier is an \Index{incomplete type} within the initializer, and an \Index{object type} after
     3694the end of the initializer. The type in the initializer is called the \define{implementation
     3695  type}. Within the scope of the declaration, \Index{implicit conversion}s can be performed between
     3696the defined type and the implementation type, and between pointers to the defined type and pointers
     3697to the implementation type.
     3698
     3699A type declaration without an \Index{initializer} and without a \Index{storage-class specifier} or
     3700with storage-class specifier \lstinline$static$\use{static} defines an \Index{incomplete type}. If a
     3701\Index{translation unit} or \Index{block} contains one or more such declarations for an identifier,
     3702it must contain exactly one definition of the identifier ( but not in an enclosed block, which would
     3703define a new type known only within that block).
    36823704\begin{rationale}
    36833705Incomplete type declarations allow compact mutually-recursive types.
     
    36983720\end{rationale}
    36993721
    3700 A type declaration without an initializer and with storage-class specifier \index{storage-class
    3701  specifiers} \lstinline$extern$\use{extern} is an \define{opaque type declaration}. Opaque types
    3702 are object types\index{object types}. An opaque type is not a \nonterm{constant-expression};
    3703 neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.
    3704 Every other object type\index{object types} is a \nonterm{constant-expression}. Objects with static
    3705 storage duration shall be declared with a type that is a \nonterm{constant-expression}.
     3722A type declaration without an initializer and with \Index{storage-class specifier}
     3723\lstinline$extern$\use{extern} is an \define{opaque type declaration}. Opaque types are
     3724\Index{object type}s. An opaque type is not a \nonterm{constant-expression}; neither is a structure
     3725or union that has a member whose type is not a \nonterm{constant-expression}.  Every other
     3726\Index{object type} is a \nonterm{constant-expression}. Objects with static storage duration shall
     3727be declared with a type that is a \nonterm{constant-expression}.
    37063728\begin{rationale}
    37073729Type declarations can declare identifiers with external linkage, whereas typedef declarations
     
    37143736\end{rationale}
    37153737
    3716 An incomplete type\index{incomplete types} which is not a qualified version\index{qualified type} of
    3717 a type is a value of type-class\index{type-class} \lstinline$dtype$. An object type\index{object
    3718  types} which is not a qualified version of a type is a value of type-classes \lstinline$type$ and
    3719 \lstinline$dtype$. A function type\index{function types} is a value of type-class
    3720 \lstinline$ftype$.
     3738An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a
     3739value of \Index{type-class} \lstinline$dtype$. An object type\index{object types} which is not a
     3740qualified version of a type is a value of type-classes \lstinline$type$ and \lstinline$dtype$. A
     3741\Index{function type} is a value of type-class \lstinline$ftype$.
    37213742\begin{rationale}
    37223743Syntactically, a type value is a \nonterm{type-name}, which is a declaration for an object which
     
    37523773
    37533774\begin{rationale}
    3754 Since incomplete types\index{incomplete types} are not type values, they can not be used as the
    3755 initializer in a type declaration, or as the type of a structure or union member. This prevents the
    3756 declaration of types that contain each other.
     3775Since \Index{incomplete type}s are not type values, they can not be used as the initializer in a
     3776type declaration, or as the type of a structure or union member. This prevents the declaration of
     3777types that contain each other.
    37573778\begin{lstlisting}
    37583779type t1;
     
    39003921A declaration\index{type declaration} of a type identifier \lstinline$T$ with type-class
    39013922\lstinline$type$ implicitly declares a \define{default assignment} function
    3902 \lstinline$T ?=?( T *, T )$\use{?=?}, with the same scope\index{scopes} and linkage\index{linkage} as
    3903 the identifier \lstinline$T$.
     3923\lstinline$T ?=?( T *, T )$\use{?=?}, with the same \Index{scope} and \Index{linkage} as the
     3924identifier \lstinline$T$.
    39043925\begin{rationale}
    39053926Assignment is central to C's imperative programming style, and every existing C object type has
     
    39123933\end{rationale}
    39133934
    3914 A definition\index{type definition} of a type identifier \lstinline$T$ with implementation
    3915 type\index{implementation type} \lstinline$I$ and type-class \lstinline$type$ implicitly defines a
    3916 default assignment function. A definition\index{type definition} of a type identifier \lstinline$T$
    3917 with implementation type \lstinline$I$ and an assertion list implicitly defines \define{default
    3918  functions} and \define{default objects} as declared by the assertion declarations. The default
    3919 objects and functions have the same scope\index{scopes} and linkage\index{linkage} as the identifier
    3920 \lstinline$T$. Their values are determined as follows:
     3935A definition\index{type definition} of a type identifier \lstinline$T$ with \Index{implementation
     3936type} \lstinline$I$ and type-class \lstinline$type$ implicitly defines a default assignment
     3937function. A definition\index{type definition} of a type identifier \lstinline$T$ with implementation
     3938type \lstinline$I$ and an assertion list implicitly defines \define{default function}s and
     3939\define{default object}s as declared by the assertion declarations. The default objects and
     3940functions have the same \Index{scope} and \Index{linkage} as the identifier \lstinline$T$. Their
     3941values are determined as follows:
    39213942\begin{itemize}
    39223943\item
     
    40144035
    40154036\section{Statements and blocks}
     4037
    40164038Many statements contain expressions, which may have more than one interpretation. The following
    4017 sections describe how the \CFA translator selects an interpretation. In all cases the result of
    4018 the selection shall be a single unambiguous interpretation\index{interpretations}.
     4039sections describe how the \CFA translator selects an interpretation. In all cases the result of the
     4040selection shall be a single unambiguous \Index{interpretation}.
    40194041
    40204042
     
    40324054\end{lstlisting}
    40334055may have more than one interpretation, but it shall have only one interpretation with an integral
    4034 type. An integer promotion\index{integer promotion} is performed on the expression if necessary.
    4035 The constant expressions in \lstinline$case$ statements with the switch are converted to the
    4036 promoted type.
     4056type. An \Index{integer promotion} is performed on the expression if necessary.  The constant
     4057expressions in \lstinline$case$ statements with the switch are converted to the promoted type.
    40374058
    40384059
     
    40804101\appendix
    40814102
     4103
    40824104\chapter{Examples}
     4105
    40834106
    40844107\section{C types}
     
    41834206\end{lstlisting}
    41844207
    4185 Specifications that define the dereference operator ( or subscript operator ) require two parameters,
    4186 one for the pointer type and one for the pointed-at ( or element ) type. Different specifications are
    4187 needed for each set of type qualifiers\index{type qualifiers}, because qualifiers are not included
    4188 in types. The assertion ``\lstinline$|ptr_to( Safe_pointer, int )$'' should be read as
     4208Specifications that define the dereference operator ( or subscript operator ) require two
     4209parameters, one for the pointer type and one for the pointed-at ( or element ) type. Different
     4210specifications are needed for each set of \Index{type qualifier}s, because qualifiers are not
     4211included in types. The assertion ``\lstinline$|ptr_to( Safe_pointer, int )$'' should be read as
    41894212``\lstinline$Safe_pointer$ acts like a pointer to \lstinline$int$''.
    41904213\begin{lstlisting}
Note: See TracChangeset for help on using the changeset viewer.