Changeset 7584279 for doc/user/user.tex
 Timestamp:
 Feb 8, 2021, 10:06:05 PM (3 years ago)
 Branches:
 ADT, armeh, astexperimental, enum, forallpointerdecay, jacob/cs343translation, master, newastuniqueexpr, pthreademulation, qualifiedEnum
 Children:
 735b627
 Parents:
 00f24f6
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

doc/user/user.tex
r00f24f6 r7584279 11 11 %% Created On : Wed Apr 6 14:53:29 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Mon Oct 5 08:57:29 202014 %% Update Count : 399813 %% Last Modified On : Mon Feb 8 21:53:31 2021 14 %% Update Count : 4327 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 37 37 \usepackage{mathptmx} % better math font with "times" 38 38 \usepackage[usenames]{color} 39 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} 40 \usepackage{breakurl} 41 42 \renewcommand\footnoterule{\kern 3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt} 43 44 \usepackage[pagewise]{lineno} 45 \renewcommand{\linenumberfont}{\scriptsize\sffamily} 46 \usepackage[firstpage]{draftwatermark} 47 \SetWatermarkLightness{0.9} 48 49 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore 50 % removes it as a variablename character so keywords in variables are highlighted. MUST APPEAR 51 % AFTER HYPERREF. 52 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}} 53 54 \setlength{\topmargin}{0.45in} % move running title into header 55 \setlength{\headsep}{0.25in} 56 57 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 58 39 59 \newcommand{\CFALatin}{} 40 60 % inline code ©...© (copyright symbol) emacs: Cq M) … … 46 66 % math escape $...$ (dollar symbol) 47 67 \input{common} % common CFA document macros 48 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}49 \usepackage{breakurl}50 51 \renewcommand\footnoterule{\kern 3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}52 53 \usepackage[pagewise]{lineno}54 \renewcommand{\linenumberfont}{\scriptsize\sffamily}55 \usepackage[firstpage]{draftwatermark}56 \SetWatermarkLightness{0.9}57 58 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore59 % removes it as a variablename character so keywords in variables are highlighted. MUST APPEAR60 % AFTER HYPERREF.61 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}62 63 \setlength{\topmargin}{0.45in} % move running title into header64 \setlength{\headsep}{0.25in}65 66 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%67 68 68 \CFAStyle % use default CFA formatstyle 69 \lstset{language=CFA} % CFA default lnaguage 69 70 \lstnewenvironment{C++}[1][] % use C++ style 70 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{ ®}{®},#1}}71 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}} 71 72 {} 72 73 … … 81 82 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}} 82 83 \newcommand{\R}[1]{\Textbf{#1}} 84 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}} 83 85 \newcommand{\B}[1]{{\Textbf[blue]{#1}}} 84 86 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}} … … 104 106 \author{ 105 107 \huge \CFA Team \medskip \\ 106 \Large Andrew Beach, Richard Bilson, Peter A. Buhr, Thierry Delisle, \smallskip \\ 107 \Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Rob Schluntz 108 \Large Andrew Beach, Richard Bilson, Michael Brooks, Peter A. Buhr, Thierry Delisle, \smallskip \\ 109 \Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Colby Parsons, Rob Schluntz, \smallskip \\ 110 \Large Fangren Yu, Mubeen Zulfiqar 108 111 }% author 109 112 … … 144 147 \section{Introduction} 145 148 146 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{Cforall}'', and written \CFA, CFA, or \CFL.} is a modern generalpurpose programminglanguage, designed as an evolutionary step forward for the C programming language.149 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{Cforall}'', and written \CFA, CFA, or \CFL.} is a modern generalpurpose concurrent programminglanguage, designed as an evolutionary step forward for the C programming language. 147 150 The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers. 148 151 % Any language feature that is not described here can be assumed to be using the standard \Celeven syntax. 149 \CFA adds many modern programminglanguagefeatures that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance.152 \CFA adds many modern features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance. 150 153 Like C, \CFA is a statically typed, procedural (non\Index{objectoriented}) language with a lowoverhead runtime, meaning there is no global \Index{garbagecollection}, but \Index{regional garbagecollection}\index{garbagecollection!regional} is possible. 151 154 The primary new features include polymorphic routines and types, exceptions, concurrency, and modules. … … 157 160 instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features. 158 161 As well, new programs can be written in \CFA using a combination of C and \CFA features. 162 In many ways, \CFA is to C as \Index{Scala}~\cite{Scala} is to Java, providing a vehicle for new typing and controlflow capabilities on top of a highly popular programming language allowing immediate dissemination. 159 163 160 164 \Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing objectoriented programming to be incrementally added to C. … … 165 169 For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result. 166 170 \begin{center} 167 \begin{tabular}{@{}l@{\hspace{1 .5em}}l@{\hspace{1.5em}}l@{}}168 \multicolumn{1}{c@{\hspace{1 .5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\169 \begin{cfa} 170 #include <stdio.h> §\indexc{stdio.h}§171 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}} 172 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ 173 \begin{cfa} 174 #include <stdio.h>$\indexc{stdio.h}$ 171 175 172 176 int main( void ) { 173 177 int x = 0, y = 1, z = 2; 174 ®printf( "%d %d %d\n", x, y, z );®178 @printf( "%d %d %d\n", x, y, z );@ 175 179 } 176 180 \end{cfa} 177 181 & 178 182 \begin{cfa} 179 #include <fstream> §\indexc{fstream}§183 #include <fstream>$\indexc{fstream}$ 180 184 181 185 int main( void ) { 182 186 int x = 0, y = 1, z = 2; 183 ®sout  x  y  z;®§\indexc{sout}§187 @sout  x  y  z;@$\indexc{sout}$ 184 188 } 185 189 \end{cfa} 186 190 & 187 191 \begin{cfa} 188 #include <iostream> §\indexc{iostream}§192 #include <iostream>$\indexc{iostream}$ 189 193 using namespace std; 190 194 int main() { 191 195 int x = 0, y = 1, z = 2; 192 ®cout<<x<<" "<<y<<" "<<z<<endl;®196 @cout<<x<<" "<<y<<" "<<z<<endl;@ 193 197 } 194 198 \end{cfa} 195 199 \end{tabular} 196 200 \end{center} 197 While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).201 While \CFA I/O \see{\VRef{s:StreamIOLibrary}} looks similar to \Index*[C++]{\CC{}}, there are important differences, such as automatic spacing between variables and an implicit newline at the end of the expression list, similar to \Index*{Python}~\cite{Python}. 198 202 199 203 … … 210 214 \section{Why fix C?} 211 215 212 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operatingsystems.216 The C programming language is a foundational technology for modern computing with billions of lines of code implementing everything from hobby projects to commercial operatingsystems. 213 217 This installation base and the programmers producing it represent a massive softwareengineering investment spanning decades and likely to continue for decades more. 214 218 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction. 215 For system programming, where direct access to hardware, storage management, and realtime issues are a requirement, C is usuallythe only language of choice.216 The TIOBE index~\cite{TIOBE} for February 202 0 ranks the top six most \emph{popular} programming languages as \Index*{Java} 17.4\%, C 16.8\%, Python 9.3\%, \Index*[C++]{\CC{}} 6.2\%, \Csharp 5.9\%, Visual Basic 5.9\% = 61.5\%, where the next 50 languages are less than 2\% each, with a long tail.219 For system programming, where direct access to hardware, storage management, and realtime issues are a requirement, C is the only language of choice. 220 The TIOBE index~\cite{TIOBE} for February 2021 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail. 217 221 The top 4 rankings over the past 35 years are: 218 222 \begin{center} 219 223 \setlength{\tabcolsep}{10pt} 220 224 \begin{tabular}{@{}rcccccccc@{}} 221 & 202 0 & 2015 & 2010 & 2005 & 2000 & 1995 & 1990 & 1985\\ \hline222 Java & 1 & 2 & 1 & 2 & 3 &  &  & \\223 \R{C} & \R{2} & \R{1} & \R{2} & \R{1} & \R{1} & \R{2} & \R{1} & \R{1}\\224 Python & 3 & 7 & 6 & 6 & 22 & 21&  &  \\225 \CC & 4 & 4 & 4 & 3 & 2 & 1 & 2 & 12\\225 & 2021 & 2016 & 2011 & 2006 & 2001 & 1996 & 1991 & 1986 \\ \hline 226 \R{C} & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\ 227 Java & 2 & 1 & 1 & 2 & 3 & 28 &  &  \\ 228 Python & 3 & 5 & 6 & 7 & 23 & 13 &  &  \\ 229 \CC & 4 & 3 & 3 & 3 & 2 & 2 & 2 & 8 \\ 226 230 \end{tabular} 227 231 \end{center} … … 232 236 As stated, the goal of the \CFA project is to engineer modern languagefeatures into C in an evolutionary rather than revolutionary way. 233 237 \CC~\cite{C++14,C++} is an example of a similar project; 234 however, it largely extended the C language, and did not address m ostof C's existing problems.\footnote{%238 however, it largely extended the C language, and did not address many of C's existing problems.\footnote{% 235 239 Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.} 236 240 \Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern languagefeatures (\eg objects, concurrency) are added and problems fixed within the framework of the existing language. … … 241 245 242 246 The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while adding modern languagefeatures. 243 To achieve these goals required a significant engineering exercise, where we had to ``think inside the existing C box''. 244 Without these significant extension to C, it is unable to cope with the needs of modern programming problems and programmers; 245 as a result, it will fade into disuse. 246 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language. 247 To achieve these goals required a significant engineering exercise, \ie ``thinking \emph{inside} the C box''. 248 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern language. 247 249 While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern languagefeatures. 248 250 While some may argue that modern languagefeatures may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today. … … 251 253 \section{History} 252 254 253 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \Index*{KW C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples. 254 (See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.) 255 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \Index*{KW C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples \see{\cite{Werther96} for similar work in \Index*[C++]{\CC{}}}. 255 256 The first \CFA implementation of these extensions was by \Index*{Rodolfo Esteves}\index{Esteves, Rodolfo}~\cite{Esteves04}. 256 257 257 258 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametricpolymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name): 258 259 \begin{cfa} 259 ®forall( otype T )®T identity( T val ) { return val; }260 int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§260 @forall( otype T )@ T identity( T val ) { return val; } 261 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$ 261 262 \end{cfa} 262 263 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of objectoriented extensions. 263 264 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}. 264 265 However, at that time, there was little interesting in extending C, so work did not continue. 265 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of legacy codebases, so the \CFA project has been restarted.266 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of the legacy codebase, so the \CFA project was restarted in 2015. 266 267 267 268 … … 273 274 This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features. 274 275 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself. 275 Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.276 Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at zero or very low cost. 276 277 Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backwardcompatible} features. 277 278 … … 286 287 287 288 double key = 5.0, vals[10] = { /* 10 sorted floating values */ }; 288 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§289 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$ 289 290 \end{cfa} 290 291 which can be augmented simply with a polymorphic, typesafe, \CFAoverloaded wrappers: … … 295 296 296 297 forall( otype T  { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) { 297 T * result = bsearch( key, arr, size ); §\C{// call first version}§298 return result ? result  arr : size; } §\C{// pointer subtraction includes sizeof(T)}§299 300 double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§298 T * result = bsearch( key, arr, size ); $\C{// call first version}$ 299 return result ? result  arr : size; } $\C{// pointer subtraction includes sizeof(T)}$ 300 301 double * val = bsearch( 5.0, vals, 10 ); $\C{// selection based on return type}$ 301 302 int posn = bsearch( 5.0, vals, 10 ); 302 303 \end{cfa} … … 310 311 \begin{cfa} 311 312 forall( dtype T  sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); } 312 int * ip = malloc(); §\C{// select type and size from lefthand side}§313 int * ip = malloc(); $\C{// select type and size from lefthand side}$ 313 314 double * dp = malloc(); 314 315 struct S {...} * sp = malloc(); … … 319 320 However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC. 320 321 For example, the C mathlibrary provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©. 321 Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©: 322 \begin{cfa} 323 char ®abs®( char ); 324 extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§ 325 long int ®abs®( long int ); 326 long long int ®abs®( long long int ); 327 float ®abs®( float ); 328 double ®abs®( double ); 329 long double ®abs®( long double ); 330 float _Complex ®abs®( float _Complex ); 331 double _Complex ®abs®( double _Complex ); 332 long double _Complex ®abs®( long double _Complex ); 333 \end{cfa} 334 The problem is the name clash between the library routine ©abs© and the \CFA names ©abs©. 335 Hence, names appearing in an ©extern "C"© block have \newterm*{C linkage}. 336 Then overloading polymorphism uses a mechanism called \newterm{name mangling}\index{mangling!name} to create unique names that are different from C names, which are not mangled. 337 Hence, there is the same need, as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed. 338 There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and types. 339 340 This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}. 322 Whereas, \CFA wraps each of these routines into one overloaded name ©abs©: 323 \begin{cfa} 324 char @abs@( char ); 325 extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$ 326 long int @abs@( long int ); 327 long long int @abs@( long long int ); 328 float @abs@( float ); 329 double @abs@( double ); 330 long double @abs@( long double ); 331 float _Complex @abs@( float _Complex ); 332 double _Complex @abs@( double _Complex ); 333 long double _Complex @abs@( long double _Complex ); 334 \end{cfa} 335 The problem is \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default). 336 Overloaded names must use \newterm{name mangling}\index{mangling!name} to create unique names that are different from unmangled C names. 337 Hence, there is the same need as in \CC to know if a name is a C or \CFA name, so it can be correctly formed. 338 The only way around this problem is C's approach of creating unique names for each pairing of operation and type. 339 340 This example illustrates a core idea in \CFA: \emph{the \Index{power of a name}}. 341 341 The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value. 342 342 Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable. … … 344 344 345 345 346 \section [Compiling a CFA Program]{Compiling a \CFA Program}346 \section{\CFA Compilation} 347 347 348 348 The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg: 349 349 \begin{cfa} 350 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gccoptions ] [ C/§\CFA{}§ sourcefiles ] [ assembler/loader files ] 351 \end{cfa} 352 \CFA programs having the following ©gcc© flags turned on: 353 \begin{description} 350 cfa$\indexc{cfa}\index{compilation!cfa@©cfa©}$ [ gcc/$\CFA{}$options ] [ C/$\CFA{}$ sourcefiles ] [ assembler/loader files ] 351 \end{cfa} 352 There is no ordering among options (flags) and files, unless an option has an argument, which must appear immediately after the option possibly with or without a space separating option and argument. 353 354 \CFA has the following ©gcc© flags turned on: 355 \begin{description}[topsep=0pt] 354 356 \item 355 357 \Indexc{std=gnu11}\index{compilation option!std=gnu11@{©std=gnu11©}} … … 359 361 Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files. 360 362 \end{description} 361 The following new \CFA options are available: 362 \begin{description} 363 364 \CFA has the following new options: 365 \begin{description}[topsep=0pt] 363 366 \item 364 367 \Indexc{CFA}\index{compilation option!CFA@©CFA©} 365 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.368 Only the C preprocessor (flag ©E©) and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator. 366 369 The generated code starts with the standard \CFA \Index{prelude}. 370 371 \item 372 \Indexc{XCFA}\index{compilation option!XCFA@©XCFA©} 373 Pass next flag asis to the ©cfacpp© translator (see details below). 367 374 368 375 \item 369 376 \Indexc{debug}\index{compilation option!debug@©debug©} 370 377 The program is linked with the debugging version of the runtime system. 371 The debug version performs runtime checks to help duringthe debugging phase of a \CFA program, but can substantially slow program execution.378 The debug version performs runtime checks to aid the debugging phase of a \CFA program, but can substantially slow program execution. 372 379 The runtime checks should only be removed after the program is completely debugged. 373 380 \textbf{This option is the default.} … … 399 406 \item 400 407 \Indexc{noincludestdhdr}\index{compilation option!noincludestdhdr@©noincludestdhdr©} 401 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).408 Do not supply ©extern "C"© wrappers for \Celeven standard include files \see{\VRef{s:StandardHeaders}}. 402 409 \textbf{This option is \emph{not} the default.} 403 410 \end{comment} … … 430 437 \begin{cfa} 431 438 #ifndef __CFORALL__ 432 #include <stdio.h> §\indexc{stdio.h}§ §\C{// C header file}§439 #include <stdio.h>$\indexc{stdio.h}$ $\C{// C header file}$ 433 440 #else 434 #include <fstream> §\indexc{fstream}§ §\C{// \CFA header file}§441 #include <fstream>$\indexc{fstream}$ $\C{// \CFA header file}$ 435 442 #endif 436 443 \end{cfa} … … 438 445 439 446 The \CFA translator has multiple steps. 440 The following flags control how the tran lator works, the stages run, and printing within a stage.447 The following flags control how the translator works, the stages run, and printing within a stage. 441 448 The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers. 449 Each option must be escaped with \Indexc{XCFA}\index{translator option!XCFA@{©XCFA©}} to direct it to the compiler step, similar to the ©Xlinker© flag for the linker, \eg: 450 \begin{lstlisting}[language=sh] 451 cfa $test$.cfa CFA XCFA p # print translated code without printing the standard prelude 452 cfa $test$.cfa XCFA P XCFA parse XCFA n # show program parse without prelude 453 \end{lstlisting} 442 454 \begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt] 443 455 \item 444 \Indexc{h}\index{translator option!h@{©h©}}, \Indexc{help}\index{translator option!help@{©help©}} \, print help message 445 \item 446 \Indexc{l}\index{translator option!l@{©l©}}, \Indexc{libcfa}\index{translator option!libcfa@{©libcfa©}} \, generate libcfa.c 456 \Indexc{c}\index{translator option!c@{©c©}}, \Indexc{colors}\index{translator option!colors@{©colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto} 457 \item 458 \Indexc{g}\index{translator option!g@{©g©}}, \Indexc{gdb}\index{translator option!gdb@{©gdb©}} \, wait for gdb to attach 459 \item 460 \Indexc{h}\index{translator option!h@{©h©}}, \Indexc{help}\index{translator option!help@{©help©}} \, print translator help message 461 \item 462 \Indexc{l}\index{translator option!l@{©l©}}, \Indexc{libcfa}\index{translator option!libcfa@{©libcfa©}} \, generate ©libcfa.c© 447 463 \item 448 464 \Indexc{L}\index{translator option!L@{©L©}}, \Indexc{linemarks}\index{translator option!linemarks@{©linemarks©}} \, generate line marks … … 454 470 \Indexc{n}\index{translator option!n@{©n©}}, \Indexc{noprelude}\index{translator option!noprelude@{©noprelude©}} \, do not read prelude 455 471 \item 456 \Indexc{p}\index{translator option!p@{©p©}}, \Indexc{prototypes}\index{translator option!prototypes@{©prototypes©}} \, generate prototypes for prelude functions 472 \Indexc{p}\index{translator option!p@{©p©}}, \Indexc{prototypes}\index{translator option!prototypes@{©prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed 473 \item 474 \Indexc{d}\index{translator option!d@{©d©}}, \Indexc{deterministicout}\index{translator option!deterministicout@{©deterministicout©}} \, only print deterministic output 457 475 \item 458 476 \Indexc{P}\index{translator option!P@{©P©}}, \Indexc{print}\index{translator option!print@{©print©}} \, one of: 459 477 \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt] 460 478 \item 479 \Indexc{ascodegen}\index{translator option!P@{©P©}!©ascodegen©}\index{translator option!print@{©print©}!©ascodegen©} \, as codegen rather than AST 480 \item 481 \Indexc{asterr}\index{translator option!P@{©P©}!©asterr©}\index{translator option!print@{©print©}!©asterr©} \, AST on error 482 \item 483 \Indexc{declstats}\index{translator option!P@{©P©}!©declstats©}\index{translator option!print@{©print©}!©declstats©} \, code property statistics 484 \item 485 \Indexc{parse}\index{translator option!P@{©P©}!©parse©}\index{translator option!print@{©print©}!©parse©} \, yacc (parsing) debug information 486 \item 487 \Indexc{pretty}\index{translator option!P@{©P©}!©pretty©}\index{translator option!print@{©print©}!©pretty©} \, prettyprint for ©ascodegen© flag 488 \item 489 \Indexc{rproto}\index{translator option!P@{©P©}!©rproto©}\index{translator option!print@{©print©}!©rproto©} \, resolverproto instance 490 \item 491 \Indexc{rsteps}\index{translator option!P@{©P©}!©rsteps©}\index{translator option!print@{©print©}!©rsteps©} \, resolver steps 492 \item 493 \Indexc{tree}\index{translator option!P@{©P©}!©tree©}\index{translator option!print@{©print©}!©tree©} \, parse tree 494 \item 495 \Indexc{ast}\index{translator option!P@{©P©}!©ast©}\index{translator option!print@{©print©}!©ast©} \, AST after parsing 496 \item 497 \Indexc{symevt}\index{translator option!P@{©P©}!©symevt©}\index{translator option!print@{©print©}!©symevt©} \, symbol table events 498 \item 461 499 \Indexc{altexpr}\index{translator option!P@{©P©}!©altexpr©}\index{translator option!print@{©print©}!©altexpr©} \, alternatives for expressions 462 500 \item 463 \Indexc{ascodegen}\index{translator option!P@{©P©}!©ascodegen©}\index{translator option!print@{©print©}!©ascodegen©} \, as codegen rather than AST464 \item465 \Indexc{ast}\index{translator option!P@{©P©}!©ast©}\index{translator option!print@{©print©}!©ast©} \, AST after parsing466 \item467 501 \Indexc{astdecl}\index{translator option!P@{©P©}!©astdecl©}\index{translator option!print@{©print©}!©astdecl©} \, AST after declaration validation pass 468 502 \item 469 \Indexc{ asterr}\index{translator option!P@{©P©}!©asterr©}\index{translator option!print@{©print©}!©asterr©} \, AST on error503 \Indexc{resolver}\index{translator option!P@{©P©}!©resolver©}\index{translator option!print@{©print©}!©resolver©} \, before resolver step 470 504 \item 471 505 \Indexc{astexpr}\index{translator option!P@{©P©}!©astexpr©}\index{translator option!print@{©print©}!©altexpr©} \, AST after expression analysis 472 506 \item 507 \Indexc{ctordtor}\index{translator option!P@{©P©}!©ctordtor©}\index{translator option!print@{©print©}!©ctordtor©} \, after ctor/dtor are replaced 508 \item 509 \Indexc{tuple}\index{translator option!P@{©P©}!©tuple©}\index{translator option!print@{©print©}!©tuple©} \, after tuple expansion 510 \item 473 511 \Indexc{astgen}\index{translator option!P@{©P©}!©astgen©}\index{translator option!print@{©print©}!©astgen©} \, AST after instantiate generics 474 512 \item 475 513 \Indexc{box}\index{translator option!P@{©P©}!©box©}\index{translator option!print@{©print©}!©box©} \, before box step 476 514 \item 477 \Indexc{ctordtor}\index{translator option!P@{©P©}!©ctordtor©}\index{translator option!print@{©print©}!©ctordtor©} \, after ctor/dtor are replaced478 \item479 515 \Indexc{codegen}\index{translator option!P@{©P©}!©codegen©}\index{translator option!print@{©print©}!©codegen©} \, before code generation 480 \item481 \Indexc{declstats}\index{translator option!P@{©P©}!©declstats©}\index{translator option!print@{©print©}!©declstats©} \, code property statistics482 \item483 \Indexc{parse}\index{translator option!P@{©P©}!©parse©}\index{translator option!print@{©print©}!©parse©} \, yacc (parsing) debug information484 \item485 \Indexc{pretty}\index{translator option!P@{©P©}!©pretty©}\index{translator option!print@{©print©}!©pretty©} \, prettyprint for ascodegen flag486 \item487 \Indexc{resolver}\index{translator option!P@{©P©}!©resolver©}\index{translator option!print@{©print©}!©resolver©} \, before resolver step488 \item489 \Indexc{rproto}\index{translator option!P@{©P©}!©rproto©}\index{translator option!print@{©print©}!©rproto©} \, resolverproto instance490 \item491 \Indexc{rsteps}\index{translator option!P@{©P©}!©rsteps©}\index{translator option!print@{©print©}!©rsteps©} \, resolver steps492 \item493 \Indexc{symevt}\index{translator option!P@{©P©}!©symevt©}\index{translator option!print@{©print©}!©symevt©} \, symbol table events494 \item495 \Indexc{tree}\index{translator option!P@{©P©}!©tree©}\index{translator option!print@{©print©}!©tree©} \, parse tree496 \item497 \Indexc{tuple}\index{translator option!P@{©P©}!©tuple©}\index{translator option!print@{©print©}!©tuple©} \, after tuple expansion498 516 \end{description} 499 517 \item 500 518 \Indexc{preludedir} <directory> \, prelude directory for debug/nodebug 501 519 \item 502 \Indexc{S}\index{translator option!S@{©S©}!©counters,heap,time,all,none©}, \Indexc{statistics}\index{translator option!statistics@{©statistics©}!©counters,heap,time,all,none©} <optionlist> \, enable profiling information: 503 \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt] 504 \item 505 \Indexc{counters,heap,time,all,none} 506 \end{description} 520 \Indexc{S}\index{translator option!S@{©S©}!©counters,heap,time,all,none©}, \Indexc{statistics}\index{translator option!statistics@{©statistics©}!©counters,heap,time,all,none©} <optionlist> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none© 507 521 \item 508 522 \Indexc{t}\index{translator option!t@{©t©}}, \Indexc{tree}\index{translator option!tree@{©tree©}} build in tree … … 513 527 \label{s:BackquoteIdentifiers} 514 528 515 \CFA introduces several new keywords (see \VRef{s:CFAKeywords})that can clash with existing C variablenames in legacy code.529 \CFA introduces several new keywords \see{\VRef{s:CFAKeywords}} that can clash with existing C variablenames in legacy code. 516 530 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escapemechanism: 517 531 \begin{cfa} 518 int ®``®otype = 3; §\C{// make keyword an identifier}§519 double ®``®forall = 3.5;532 int @``@otype = 3; $\C{// make keyword an identifier}$ 533 double @``@forall = 3.5; 520 534 \end{cfa} 521 535 522 536 Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a nonkeyword name. 523 \VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C headerfiles (see~\VRef{s:StandardHeaders})can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©I filename©.537 \VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C headerfiles \see{\VRef{s:StandardHeaders}} can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©I filename©. 524 538 Several common C headerfiles with keyword clashes are fixed in the standard \CFA headerlibrary, so there is a seamless programmingexperience. 525 539 … … 527 541 \begin{cfa} 528 542 // include file uses the CFA keyword "with". 529 #if ! defined( with ) §\C{// nesting ?}§530 #define with ®``®with §\C{// make keyword an identifier}§543 #if ! defined( with ) $\C{// nesting ?}$ 544 #define with @``@with $\C{// make keyword an identifier}$ 531 545 #define __CFA_BFD_H__ 532 546 #endif 533 §{\color{red}\#\textbf{include\_next} <bfdlink.h>}§ §\C{// must have internal check for multiple expansion}§ 534 #if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§547 $\R{\#include\_next} <bfdlink.h>$ $\C{// must have internal check for multiple expansion}$ 548 #if defined( with ) && defined( __CFA_BFD_H__ ) $\C{// reset only if set}$ 535 549 #undef with 536 550 #undef __CFA_BFD_H__ … … 544 558 \section{Constant Underscores} 545 559 546 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} , \eg:547 \begin{cfa} 548 2 ®_®147®_®483®_®648; §\C{// decimal constant}§549 56 ®_®ul; §\C{// decimal unsigned long constant}§550 0 ®_®377; §\C{// octal constant}§551 0x ®_®ff®_®ff; §\C{// hexadecimal constant}§552 0x ®_®ef3d®_®aa5c; §\C{// hexadecimal constant}§553 3.141 ®_®592®_®654; §\C{// floating constant}§554 10 ®_®e®_®+1®_®00; §\C{// floating constant}§555 0x ®_®ff®_®ff®_®p®_®3; §\C{// hexadecimal floating}§556 0x ®_®1.ffff®_®ffff®_®p®_®128®_®l; §\C{// hexadecimal floating long constant}§557 L ®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§; §\C{// wide character constant}§560 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg: 561 \begin{cfa} 562 2@_@147@_@483@_@648; $\C{// decimal constant}$ 563 56@_@ul; $\C{// decimal unsigned long constant}$ 564 0@_@377; $\C{// octal constant}$ 565 0x@_@ff@_@ff; $\C{// hexadecimal constant}$ 566 0x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$ 567 3.141@_@592@_@654; $\C{// floating constant}$ 568 10@_@e@_@+1@_@00; $\C{// floating constant}$ 569 0x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$ 570 0x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$ 571 L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$ 558 572 \end{cfa} 559 573 The rules for placement of underscores are: … … 574 588 It is significantly easier to read and enter long constants when they are broken up into smaller groupings (many cultures use comma and/or period among digits for the same purpose). 575 589 This extension is backwards compatible, matches with the use of underscore in variable names, and appears in \Index*{Ada} and \Index*{Java} 8. 590 \CC uses the single quote (©'©) as a separator, restricted within a sequence of digits, \eg ©0xaa©©'©©ff©, ©3.141©©'©©592E1©©'©©1©. 576 591 577 592 578 593 \section{Exponentiation Operator} 579 594 580 C, \CC, and Java (and manyother programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation.581 \CFA extends the basic operators with the exponentiation operator ©? ®\®?©\index{?\\?@©?®\®?©} and ©?\=?©\index{?\\=?@©®\®=?©}, as in, ©x ®\® y© and ©x ®\®= y©, which means $x^y$ and $x \leftarrow x^y$.582 The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©( (w * (((int)x) \ ((int)y))) * z)©.595 C, \CC, and Java (and other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation. 596 \CFA extends the basic operators with the exponentiation operator ©?©\R{©\\©}©?©\index{?\\?@©?@\@?©} and ©?©\R{©\\©}©=?©\index{?\\=?@©@\@=?©}, as in, ©x ©\R{©\\©}© y© and ©x ©\R{©\\©}©= y©, which means $x^y$ and $x \leftarrow x^y$. 597 The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©(w * (((int)x) \ ((int)y))) * z©. 583 598 584 599 There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. … … 587 602 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. 588 603 \begin{cfa} 589 sout  1 ®\® 0  1 ®\® 1  2 ®\® 8  4 ®\® 3  5 ®\® 3  5 ®\® 32  5L ®\® 32  5L ®\® 64  4 ®\® 3  4.0 ®\® 3  4.0 ®\®2.1590  (1.0f+2.0fi) ®\®(3.0f+2.0fi);591 1 1 256 64 125 ®0® 3273344365508751233 ®0® ®0®0.015625 18.3791736799526 0.2647151.1922i604 sout  1 @\@ 0  1 @\@ 1  2 @\@ 8  4 @\@ 3  5 @\@ 3  5 @\@ 32  5L @\@ 32  5L @\@ 64  4 @\@ 3  4.0 @\@ 3  4.0 @\@ 2.1 605  (1.0f+2.0fi) @\@ (3.0f+2.0fi); 606 1 1 256 64 125 @0@ 3273344365508751233 @0@ @0@ 0.015625 18.3791736799526 0.2647151.1922i 592 607 \end{cfa} 593 608 Note, ©5 \ 32© and ©5L \ 64© overflow, and ©4 \ 3© is a fraction but stored in an integer so all three computations generate an integral zero. 594 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©. 609 Because exponentiation has higher priority than ©+©, parenthesis are necessary for exponentiation of \Index{complex constant}s or the expression is parsed as ©1.0f+©\R{©(©}©2.0fi \ 3.0f©\R{©)©}©+2.0fi©, requiring \R{©(©}©1.0f+2.0fi©\R{©)©}© \ ©\R{©(©}©3.0f+2.0fi©\R{©)©}. 610 595 611 The exponentiation operator is available for all the basic types, but for userdefined types, only the integralcomputation version is available. 596 612 \begin{cfa} 597 forall( otype OT  { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )598 OT ?®\®?( OT ep, unsigned int y );599 forall( otype OT  { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )600 OT ?®\®?( OT ep, unsigned long int y );613 forall( otype T  { void ?{}( T & this, one_t ); T ?*?( T, T ); } ) 614 T ?@\@?( T ep, unsigned int y ); 615 forall( otype T  { void ?{}( T & this, one_t ); T ?*?( T, T ); } ) 616 T ?@\@?( T ep, unsigned long int y ); 601 617 \end{cfa} 602 618 The user type ©T© must define multiplication, one (©1©), and ©*©. … … 609 625 610 626 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}} 611 \subsection{\texorpdfstring{\LstKeywordStyle{if}/\LstKeywordStyle{while} Statement}{if/while Statement}} 612 613 The ©if©/©while© expression allows declarations, similar to ©for© declaration expression. 614 (Does not make sense for ©do©©while©.) 615 \begin{cfa} 616 if ( ®int x = f()® ) ... §\C{// x != 0}§ 617 if ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§ 618 if ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§ 619 if ( ®struct S { int i; } x = { f() }; x.i < 4® ) §\C{// relational expression}§ 620 621 while ( ®int x = f()® ) ... §\C{// x != 0}§ 622 while ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§ 623 while ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§ 624 while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... §\C{// relational expression}§ 625 \end{cfa} 626 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.\footnote{\CC only provides a single declaration always compared not equal to 0.} 627 The scope of the declaration(s) is local to the @if@ statement but exist within both the ``then'' and ``else'' clauses. 627 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}} 628 629 The ©if©/©while© expression allows declarations, similar to ©for© declaration expression.\footnote{ 630 Declarations in the ©do©©while© condition are not useful because they appear after the loop body.} 631 \begin{cfa} 632 if ( @int x = f()@ ) ... $\C{// x != 0}$ 633 if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$ 634 if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$ 635 if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$ 636 637 while ( @int x = f()@ ) ... $\C{// x != 0}$ 638 while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$ 639 while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$ 640 while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$ 641 \end{cfa} 642 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator. 643 The scope of the declaration(s) is local to the ©if© statement but exist within both the \emph{then} and \emph{else} clauses. 644 \CC only provides a single declaration always compared ©!=© to 0. 628 645 629 646 630 647 %\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}} 631 648 \subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}} 649 \label{s:caseClause} 632 650 633 651 C restricts the ©case© clause of a ©switch© statement to a single value. … … 640 658 \begin{cfa} 641 659 switch ( i ) { 642 case ®1, 3, 5®:660 case @1, 3, 5@: 643 661 ... 644 case ®2, 4, 6®:662 case @2, 4, 6@: 645 663 ... 646 664 } … … 670 688 \begin{cfa} 671 689 switch ( i ) { 672 case ®1~5:® §\C{// 1, 2, 3, 4, 5}§690 case @1~5:@ $\C{// 1, 2, 3, 4, 5}$ 673 691 ... 674 case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§692 case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$ 675 693 ... 676 694 } … … 678 696 Lists of subranges are also allowed. 679 697 \begin{cfa} 680 case ®1~5, 12~21, 35~42®:698 case @1~5, 12~21, 35~42@: 681 699 \end{cfa} 682 700 … … 722 740 if ( argc == 3 ) { 723 741 // open output file 724 ®// open input file725 ®} else if ( argc == 2 ) {726 ®// open input file (duplicate)727 728 ®} else {742 @// open input file 743 @} else if ( argc == 2 ) { 744 @// open input file (duplicate) 745 746 @} else { 729 747 // usage message 730 748 } … … 733 751 \end{cquote} 734 752 In this example, case 2 is always done if case 3 is done. 735 This control flow is difficult to simulate with ifstatements or a ©switch© statement without fallthrough as code must be duplicated or placed in a separate routine.753 This control flow is difficult to simulate with ©if© statements or a ©switch© statement without fallthrough as code must be duplicated or placed in a separate routine. 736 754 C also uses fallthrough to handle multiple casevalues resulting in the same action: 737 755 \begin{cfa} 738 756 switch ( i ) { 739 ®case 1: case 3: case 5:®// odd values757 @case 1: case 3: case 5:@ // odd values 740 758 // odd action 741 759 break; 742 ®case 2: case 4: case 6:®// even values760 @case 2: case 4: case 6:@ // even values 743 761 // even action 744 762 break; 745 763 } 746 764 \end{cfa} 747 However, this situation is handled in other languages without fallthrough by allowing a list of case values.748 While fallthrough itself is not a problem, the problem occurs when fallthrough is the default, as this semantics is unintuitive to many programmers and is different from virtually all otherprogramming languages with a ©switch© statement.765 This situation better handled without fallthrough by allowing a list of case values \see{\VRef{s:caseClause}}. 766 While fallthrough itself is not a problem, the problem occurs when fallthrough is the default, as this semantics is unintuitive to many programmers and is different from most programming languages with a ©switch© statement. 749 767 Hence, default fallthrough semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fallthrough. 750 768 … … 756 774 if ( j < k ) { 757 775 ... 758 ®case 1:®// transfer into "if" statement776 @case 1:@ // transfer into "if" statement 759 777 ... 760 778 } // if … … 762 780 while ( j < 5 ) { 763 781 ... 764 ®case 3:®// transfer into "while" statement782 @case 3:@ // transfer into "while" statement 765 783 ... 766 784 } // while 767 785 } // switch 768 786 \end{cfa} 769 Th e problem with this usage is branchinginto control structures, which is known to cause both comprehension and technical difficulties.770 The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.787 This usage branches into control structures, which is known to cause both comprehension and technical difficulties. 788 The comprehension problem results from the inability to determine how control reaches a particular point due to the number of branches leading to it. 771 789 The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning. 772 There are no positivearguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.790 There are few arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it. 773 791 Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}: 774 792 \begin{cfa} … … 794 812 \item 795 813 It is possible to place the ©default© clause anywhere in the list of labelled clauses for a ©switch© statement, rather than only at the end. 796 Virtually allprogramming languages with a ©switch© statement require the ©default© clause to appear last in the caseclause list.814 Most programming languages with a ©switch© statement require the ©default© clause to appear last in the caseclause list. 797 815 The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected; 798 816 hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics. … … 803 821 \begin{cfa} 804 822 switch ( x ) { 805 ®int y = 1;® §\C{// unreachable initialization}§806 ®x = 7;® §\C{// unreachable code without label/branch}§823 @int y = 1;@ $\C{// unreachable initialization}$ 824 @x = 7;@ $\C{// unreachable code without label/branch}$ 807 825 case 0: ... 808 826 ... 809 ®int z = 0;® §\C{// unreachable initialization, cannot appear after case}§827 @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$ 810 828 z = 2; 811 829 case 1: 812 ®x = z;® §\C{// without fall through, z is uninitialized}§830 @x = z;@ $\C{// without fall through, z is uninitialized}$ 813 831 } 814 832 \end{cfa} 815 833 While the declaration of the local variable ©y© is useful with a scope across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it. 816 Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, both of which are problematic.817 As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall 818 The key observation is that the ©switch© statement branches into control structure, \ie there are multiple entry points into its statement body.834 Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, where both are problematic. 835 As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fallthrough to case 3, ©z© is uninitialized. 836 The key observation is that the ©switch© statement branches into a control structure, \ie there are multiple entry points into its statement body. 819 837 \end{enumerate} 820 838 … … 842 860 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fallthrough semantics and an explicit fallthrough if the last statement of a caseclause ends with the new keyword ©fallthrough©/©fallthru©, \eg: 843 861 \begin{cfa} 844 ®choose®( i ) {862 @choose@ ( i ) { 845 863 case 1: case 2: case 3: 846 864 ... 847 ®// implicit end of switch (break)848 ®case 5:865 @// implicit end of switch (break) 866 @case 5: 849 867 ... 850 ®fallthru®; §\C{// explicit fall through}§868 @fallthru@; $\C{// explicit fall through}$ 851 869 case 7: 852 870 ... 853 ®break® §\C{// explicit end of switch (redundant)}§871 @break@ $\C{// explicit end of switch (redundant)}$ 854 872 default: 855 873 j = 3; 856 874 } 857 875 \end{cfa} 858 Like the ©switch© statement, the ©choose© statement retains the fallthrough semantics for a list of ©case© clauses ;876 Like the ©switch© statement, the ©choose© statement retains the fallthrough semantics for a list of ©case© clauses. 859 877 An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause. 860 878 An explicit ©fallthru© is retained because it is a Cidiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement. … … 872 890 \begin{cfa} 873 891 switch ( x ) { 874 ®int i = 0;® §\C{// allowed only at start}§892 @int i = 0;@ $\C{// allowed only at start}$ 875 893 case 0: 876 894 ... 877 ®int j = 0;® §\C{// disallowed}§895 @int j = 0;@ $\C{// disallowed}$ 878 896 case 1: 879 897 { 880 ®int k = 0;® §\C{// allowed at different nesting levels}§898 @int k = 0;@ $\C{// allowed at different nesting levels}$ 881 899 ... 882 ®case 2:® §\C{// disallow case in nested statements}§900 @case 2:@ $\C{// disallow case in nested statements}$ 883 901 } 884 902 ... … … 897 915 case 3: 898 916 if ( ... ) { 899 ... ®fallthru;®// goto case 4917 ... @fallthru;@ // goto case 4 900 918 } else { 901 919 ... … … 912 930 choose ( ... ) { 913 931 case 3: 914 ... ®fallthrough common;®932 ... @fallthrough common;@ 915 933 case 4: 916 ... ®fallthrough common;®917 918 ®common:®// below fallthrough934 ... @fallthrough common;@ 935 936 @common:@ // below fallthrough 919 937 // at caseclause level 920 938 ... // common code for cases 3/4 … … 932 950 for ( ... ) { 933 951 // multilevel transfer 934 ... ®fallthru common;®952 ... @fallthru common;@ 935 953 } 936 954 ... 937 955 } 938 956 ... 939 ®common:®// below fallthrough957 @common:@ // below fallthrough 940 958 // at caseclause level 941 959 \end{cfa} … … 948 966 949 967 \begin{figure} 950 \begin{tabular}{@{}l l@{}}951 \multicolumn{1}{ c}{loop control} & \multicolumn{1}{c}{output} \\968 \begin{tabular}{@{}l@{\hspace{25pt}}l@{}} 969 \multicolumn{1}{@{}c@{\hspace{25pt}}}{loop control} & \multicolumn{1}{c@{}}{output} \\ 952 970 \hline 953 \begin{cfa} [xleftmargin=0pt]954 while ®()®{ sout  "empty"; break; }955 do { sout  "empty"; break; } while ®()®;956 for ®()®{ sout  "empty"; break; }957 for ( ®0®) { sout  "A"; } sout  "zero";958 for ( ®1®) { sout  "A"; }959 for ( ®10®) { sout  "A"; }960 for ( ®= 10®) { sout  "A"; }961 for ( ®1 ~= 10 ~ 2®) { sout  "B"; }962 for ( ®10 ~= 1 ~ 2®) { sout  "C"; }963 for ( ®0.5 ~ 5.5®) { sout  "D"; }964 for ( ®5.5 ~ 0.5®) { sout  "E"; }965 for ( ®i; 10®) { sout  i; }966 for ( ®i; = 10®) { sout  i; }967 for ( ®i; 1 ~= 10 ~ 2®) { sout  i; }968 for ( ®i; 10 ~= 1 ~ 2®) { sout  i; }969 for ( ®i; 0.5 ~ 5.5®) { sout  i; }970 for ( ®i; 5.5 ~ 0.5®) { sout  i; }971 for ( ®ui; 2u ~= 10u ~ 2u®) { sout  ui; }972 for ( ®ui; 10u ~= 2u ~ 2u®) { sout  ui; }971 \begin{cfa} 972 while @()@ { sout  "empty"; break; } 973 do { sout  "empty"; break; } while @()@; 974 for @()@ { sout  "empty"; break; } 975 for ( @0@ ) { sout  "A"; } sout  "zero"; 976 for ( @1@ ) { sout  "A"; } 977 for ( @10@ ) { sout  "A"; } 978 for ( @= 10@ ) { sout  "A"; } 979 for ( @1 ~= 10 ~ 2@ ) { sout  "B"; } 980 for ( @10 ~= 1 ~ 2@ ) { sout  "C"; } 981 for ( @0.5 ~ 5.5@ ) { sout  "D"; } 982 for ( @5.5 ~ 0.5@ ) { sout  "E"; } 983 for ( @i; 10@ ) { sout  i; } 984 for ( @i; = 10@ ) { sout  i; } 985 for ( @i; 1 ~= 10 ~ 2@ ) { sout  i; } 986 for ( @i; 10 ~= 1 ~ 2@ ) { sout  i; } 987 for ( @i; 0.5 ~ 5.5@ ) { sout  i; } 988 for ( @i; 5.5 ~ 0.5@ ) { sout  i; } 989 for ( @ui; 2u ~= 10u ~ 2u@ ) { sout  ui; } 990 for ( @ui; 10u ~= 2u ~ 2u@ ) { sout  ui; } 973 991 enum { N = 10 }; 974 for ( ®N®) { sout  "N"; }975 for ( ®i; N®) { sout  i; }976 for ( ®i; N ~ 0®) { sout  i; }992 for ( @N@ ) { sout  "N"; } 993 for ( @i; N@ ) { sout  i; } 994 for ( @i; N ~ 0@ ) { sout  i; } 977 995 const int start = 3, comp = 10, inc = 2; 978 for ( ®i; start ~ comp ~ inc + 1®) { sout  i; }979 for ( i; 1 ~ ®@®) { if ( i > 10 ) break; sout  i; }980 for ( i; 10 ~ ®@®) { if ( i < 0 ) break; sout  i; }981 for ( i; 2 ~ ®@®~ 2 ) { if ( i > 10 ) break; sout  i; }982 for ( i; 2.1 ~ ®@® ~ ®@®) { if ( i > 10.5 ) break; sout  i; i += 1.7; }983 for ( i; 10 ~ ®@®~ 2 ) { if ( i < 0 ) break; sout  i; }984 for ( i; 12.1 ~ ®@® ~ ®@®) { if ( i < 2.5 ) break; sout  i; i = 1.7; }985 for ( i; 5 ®:® j; 5 ~ @) { sout  i  j; }986 for ( i; 5 ®:® j; 5 ~ @) { sout  i  j; }987 for ( i; 5 ®:® j; 5 ~ @~ 2 ) { sout  i  j; }988 for ( i; 5 ®:® j; 5 ~ @~ 2 ) { sout  i  j; }989 for ( i; 5 ®:® j; 5 ~ @) { sout  i  j; }990 for ( i; 5 ®:® j; 5 ~ @) { sout  i  j; }991 for ( i; 5 ®:® j; 5 ~ @~ 2 ) { sout  i  j; }992 for ( i; 5 ®:® j; 5 ~ @~ 2 ) { sout  i  j; }993 for ( i; 5 ®:® j; 5 ~ @ ~ 2 ®:® k; 1.5 ~ @) { sout  i  j  k; }994 for ( i; 5 ®:® j; 5 ~ @ ~ 2 ®:® k; 1.5 ~ @) { sout  i  j  k; }995 for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; 5 ~ @~ 2 ) { sout  i  j  k; }996 for ( @i; start ~ comp ~ inc + 1@ ) { sout  i; } 997 for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout  i; } 998 for ( i; 10 ~ $\R{@}$ ) { if ( i < 0 ) break; sout  i; } 999 for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout  i; } 1000 for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout  i; i += 1.7; } 1001 for ( i; 10 ~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout  i; } 1002 for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout  i; i = 1.7; } 1003 for ( i; 5 @:@ j; 5 ~ $@$ ) { sout  i  j; } 1004 for ( i; 5 @:@ j; 5 ~ $@$ ) { sout  i  j; } 1005 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 ) { sout  i  j; } 1006 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 ) { sout  i  j; } 1007 for ( i; 5 @:@ j; 5 ~ $@$ ) { sout  i  j; } 1008 for ( i; 5 @:@ j; 5 ~ $@$ ) { sout  i  j; } 1009 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 ) { sout  i  j; } 1010 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 ) { sout  i  j; } 1011 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout  i  j  k; } 1012 for ( i; 5 @:@ j; 5 ~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout  i  j  k; } 1013 for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; 5 ~ $@$ ~ 2 ) { sout  i  j  k; } 996 1014 \end{cfa} 997 1015 & … … 1056 1074 \subsection{Loop Control} 1057 1075 1058 The ©for©/©while©/©dowhile© loopcontrol allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}). 1059 \begin{itemize} 1076 Looping a fixed number of times, possibly with a loop index, occurs frequently. 1077 \CFA condenses simply looping to facilitate coding speed and safety. 1078 The ©for©/©while©/©dowhile© loopcontrol is augmented as follows \see{examples in \VRef[Figure]{f:LoopControlExamples}}: 1079 \begin{itemize}[itemsep=0pt] 1080 \item 1081 ©0© is the implicit start value; 1082 \item 1083 ©1© is the implicit increment value. 1084 \item 1085 The upto range uses operator ©+=© for increment; 1086 \item 1087 The downto range uses operator ©=© for decrement. 1060 1088 \item 1061 1089 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M. 1090 \begin{cfa} 1091 for ( i; @5@ ) $\C[2.5in]{// typeof(5) i; 5 is comparison value}$ 1092 for ( i; @1.5@~5.5~0.5 ) $\C{// typeof(1.5) i; 1.5 is start value}$ 1093 \end{cfa} 1062 1094 \item 1063 1095 An empty conditional implies comparison value of ©1© (true). 1064 \item 1065 A comparison N is implicit upto exclusive range [0,N©®)®©. 1066 \item 1067 A comparison ©=© N is implicit upto inclusive range [0,N©®]®©. 1068 \item 1069 The upto range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©. 1070 \item 1071 The upto range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©. 1072 \item 1073 The downto range M ©~©\index{~@©~©} N means exclusive range [N,M©®)®©. 1074 \item 1075 The downto range M ©~=©\index{~=@©~=©} N means inclusive range [N,M©®]®©. 1076 \item 1077 ©0© is the implicit start value; 1078 \item 1079 ©1© is the implicit increment value. 1080 \item 1081 The upto range uses operator ©+=© for increment; 1082 \item 1083 The downto range uses operator ©=© for decrement. 1096 \begin{cfa} 1097 while ( $\R{/*empty*/}$ ) $\C{// while ( true )}$ 1098 for ( $\R{/*empty*/}$ ) $\C{// for ( ; true; )}$ 1099 do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$ 1100 \end{cfa} 1101 \item 1102 A comparison N is implicit upto exclusive range [0,N\R{)}. 1103 \begin{cfa} 1104 for ( @5@ ) $\C{// for ( typeof(5) i; i < 5; i += 1 )}$ 1105 \end{cfa} 1106 \item 1107 A comparison ©=© N is implicit upto inclusive range [0,N\R{]}. 1108 \begin{cfa} 1109 for ( @=@5 ) $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$ 1110 \end{cfa} 1111 \item 1112 The upto range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}. 1113 \begin{cfa} 1114 for ( 1@~@5 ) $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$ 1115 \end{cfa} 1116 \item 1117 The upto range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}. 1118 \begin{cfa} 1119 for ( 1@~=@5 ) $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$ 1120 \end{cfa} 1121 \item 1122 The downto range M ©~©\index{~@©~©} N means exclusive range [N,M\R{)}. 1123 \begin{cfa} 1124 for ( 1@~@5 ) $\C{// for ( typeof(1) i = 5; i > 0; i = 1 )}$ 1125 \end{cfa} 1126 \item 1127 The downto range M ©~=©\index{~=@©~=©} N means inclusive range [N,M\R{]}. 1128 \begin{cfa} 1129 for ( 1@~=@5 ) $\C{// for ( typeof(1) i = 5; i >= 0; i = 1 )}$ 1130 \end{cfa} 1084 1131 \item 1085 1132 ©@© means put nothing in this field. 1133 \begin{cfa} 1134 for ( 1~$\R{@}$~2 ) $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$ 1135 \end{cfa} 1086 1136 \item 1087 1137 ©:© means start another index. 1138 \begin{cfa} 1139 for ( i; 5 @:@ j; 2~12~3 ) $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$ 1140 \end{cfa} 1088 1141 \end{itemize} 1089 1142 … … 1104 1157 \begin{lrbox}{\myboxA} 1105 1158 \begin{cfa}[tabsize=3] 1106 ®Compound:®{1107 ®Try:®try {1108 ®For:®for ( ... ) {1109 ®While:®while ( ... ) {1110 ®Do:®do {1111 ®If:®if ( ... ) {1112 ®Switch:®switch ( ... ) {1159 @Compound:@ { 1160 @Try:@ try { 1161 @For:@ for ( ... ) { 1162 @While:@ while ( ... ) { 1163 @Do:@ do { 1164 @If:@ if ( ... ) { 1165 @Switch:@ switch ( ... ) { 1113 1166 case 3: 1114 ®break Compound®;1115 ®break Try®;1116 ®break For®; /* or */ ®continue For®;1117 ®break While®; /* or */ ®continue While®;1118 ®break Do®; /* or */ ®continue Do®;1119 ®break If®;1120 ®break Switch®;1167 @break Compound@; 1168 @break Try@; 1169 @break For@; /* or */ @continue For@; 1170 @break While@; /* or */ @continue While@; 1171 @break Do@; /* or */ @continue Do@; 1172 @break If@; 1173 @break Switch@; 1121 1174 } // switch 1122 1175 } else { 1123 ... ®break If®; ... // terminate if1176 ... @break If@; ... // terminate if 1124 1177 } // if 1125 1178 } while ( ... ); // do 1126 1179 } // while 1127 1180 } // for 1128 } ®finally®{ // always executed1181 } @finally@ { // always executed 1129 1182 } // try 1130 1183 } // compound … … 1136 1189 { 1137 1190 1138 ®ForC:®for ( ... ) {1139 ®WhileC:®while ( ... ) {1140 ®DoC:®do {1191 @ForC:@ for ( ... ) { 1192 @WhileC:@ while ( ... ) { 1193 @DoC:@ do { 1141 1194 if ( ... ) { 1142 1195 switch ( ... ) { 1143 1196 case 3: 1144 ®goto Compound®;1145 ®goto Try®;1146 ®goto ForB®; /* or */ ®goto ForC®;1147 ®goto WhileB®; /* or */ ®goto WhileC®;1148 ®goto DoB®; /* or */ ®goto DoC®;1149 ®goto If®;1150 ®goto Switch®;1151 } ®Switch:®;1197 @goto Compound@; 1198 @goto Try@; 1199 @goto ForB@; /* or */ @goto ForC@; 1200 @goto WhileB@; /* or */ @goto WhileC@; 1201 @goto DoB@; /* or */ @goto DoC@; 1202 @goto If@; 1203 @goto Switch@; 1204 } @Switch:@ ; 1152 1205 } else { 1153 ... ®goto If®; ... // terminate if1154 } ®If:®;1155 } while ( ... ); ®DoB:®;1156 } ®WhileB:®;1157 } ®ForB:®;1158 1159 1160 } ®Compound:®;1206 ... @goto If@; ... // terminate if 1207 } @If:@; 1208 } while ( ... ); @DoB:@ ; 1209 } @WhileB:@ ; 1210 } @ForB:@ ; 1211 1212 1213 } @Compound:@ ; 1161 1214 \end{cfa} 1162 1215 \end{lrbox} 1163 1216 1217 \hspace*{10pt} 1164 1218 \subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA} 1165 1219 \hspace{2pt} 1166 1220 \vrule 1167 \hspace{2pt}1168 1221 \subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB} 1169 1222 \caption{Multilevel Exit} … … 1193 1246 Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers: 1194 1247 \begin{cfa} 1195 struct S { §\C{// aggregate}§1196 char c; §\C{// fields}§1248 struct S { $\C{// aggregate}$ 1249 char c; $\C{// fields}$ 1197 1250 int i; 1198 1251 double d; … … 1203 1256 \begin{cfa} 1204 1257 void f( S s ) { 1205 ®s.®c; ®s.®i; ®s.®d; §\C{// access containing fields}§1258 @s.@c; @s.@i; @s.@d; $\C{// access containing fields}$ 1206 1259 } 1207 1260 \end{cfa} … … 1210 1263 \begin{C++} 1211 1264 struct S { 1212 char c; §\C{// fields}§1265 char c; $\C{// fields}$ 1213 1266 int i; 1214 1267 double d; 1215 void f() { §\C{// implicit ``this'' aggregate}§1216 ®this>®c; ®this>®i; ®this>®d; §\C{// access containing fields}§1268 void f() { $\C{// implicit ``this'' aggregate}$ 1269 @this>@c; @this>@i; @this>@d; $\C{// access containing fields}$ 1217 1270 } 1218 1271 } … … 1222 1275 \begin{cfa} 1223 1276 struct T { double m, n; }; 1224 int S::f( T & t ) { §\C{// multiple aggregate parameters}§1225 c; i; d; §\C{\color{red}// this{\textgreater}.c, this{\textgreater}.i, this{\textgreater}.d}§1226 ®t.®m; ®t.®n; §\C{// must qualify}§1227 } 1228 \end{cfa} 1229 1230 To simplify the programmer experience, \CFA provides a ©with© statement (see Pascal~\cite[\S~4.F]{Pascal})to elide aggregate qualification to fields by opening a scope containing the field identifiers.1277 int S::f( T & t ) { $\C{// multiple aggregate parameters}$ 1278 c; i; d; $\C{\R{// this{\textgreater}c, this{\textgreater}i, this{\textgreater}d}}$ 1279 @t.@m; @t.@n; $\C{// must qualify}$ 1280 } 1281 \end{cfa} 1282 1283 To simplify the programmer experience, \CFA provides a ©with© statement \see{Pascal~\cite[\S~4.F]{Pascal}} to elide aggregate qualification to fields by opening a scope containing the field identifiers. 1231 1284 Hence, the qualified fields become variables with the sideeffect that it is easier to optimizing field references in a block. 1232 1285 \begin{cfa} 1233 void f( S & this ) ®with ( this )® { §\C{// with statement}§1234 c; i; d; §\C{\color{red}// this.c, this.i, this.d}§1286 void f( S & this ) @with ( this )@ { $\C{// with statement}$ 1287 c; i; d; $\C{\R{// this.c, this.i, this.d}}$ 1235 1288 } 1236 1289 \end{cfa} 1237 1290 with the generality of opening multiple aggregateparameters: 1238 1291 \begin{cfa} 1239 void f( S & s, T & t ) ®with ( s, t )® { §\C{// multiple aggregate parameters}§1240 c; i; d; §\C{\color{red}// s.c, s.i, s.d}§1241 m; n; §\C{\color{red}// t.m, t.n}§1292 void f( S & s, T & t ) @with ( s, t )@ { $\C{// multiple aggregate parameters}$ 1293 c; i; d; $\C{\R{// s.c, s.i, s.d}}$ 1294 m; n; $\C{\R{// t.m, t.n}}$ 1242 1295 } 1243 1296 \end{cfa} … … 1245 1298 In detail, the ©with© statement has the form: 1246 1299 \begin{cfa} 1247 §\emph{withstatement}§:1248 'with' '(' §\emph{expressionlist}§ ')' §\emph{compoundstatement}§1300 $\emph{withstatement}$: 1301 'with' '(' $\emph{expressionlist}$ ')' $\emph{compoundstatement}$ 1249 1302 \end{cfa} 1250 1303 and may appear as the body of a function or nested within a function body. … … 1258 1311 The difference between parallel and nesting occurs for fields with the same name and type: 1259 1312 \begin{cfa} 1260 struct S { int ®i®; int j; double m; } s, w;1261 struct T { int ®i®; int k; int m; } t, w;1313 struct S { int @i@; int j; double m; } s, w; 1314 struct T { int @i@; int k; int m; } t, w; 1262 1315 with ( s, t ) { 1263 j + k; §\C{// unambiguous, s.j + t.k}§1264 m = 5.0; §\C{// unambiguous, t.m = 5.0}§1265 m = 1; §\C{// unambiguous, s.m = 1}§1266 int a = m; §\C{// unambiguous, a = s.i }§1267 double b = m; §\C{// unambiguous, b = t.m}§1268 int c = s.i + t.i; §\C{// unambiguous, qualification}§1269 (double)m; §\C{// unambiguous, cast}§1316 j + k; $\C{// unambiguous, s.j + t.k}$ 1317 m = 5.0; $\C{// unambiguous, t.m = 5.0}$ 1318 m = 1; $\C{// unambiguous, s.m = 1}$ 1319 int a = m; $\C{// unambiguous, a = s.i }$ 1320 double b = m; $\C{// unambiguous, b = t.m}$ 1321 int c = s.i + t.i; $\C{// unambiguous, qualification}$ 1322 (double)m; $\C{// unambiguous, cast}$ 1270 1323 } 1271 1324 \end{cfa} … … 1277 1330 There is an interesting problem between parameters and the functionbody ©with©, \eg: 1278 1331 \begin{cfa} 1279 void ?{}( S & s, int i ) with ( s ) { §\C{// constructor}§1280 ®s.i = i;® j = 3; m = 5.5; §\C{// initialize fields}§1332 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$ 1333 @s.i = i;@ j = 3; m = 5.5; $\C{// initialize fields}$ 1281 1334 } 1282 1335 \end{cfa} … … 1291 1344 and implicitly opened \emph{after} a functionbody open, to give them higher priority: 1292 1345 \begin{cfa} 1293 void ?{}( S & s, int ®i® ) with ( s ) ®with( §\emph{\color{red}params}§ )®{1294 s.i = ®i®; j = 3; m = 5.5;1346 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { 1347 s.i = @i@; j = 3; m = 5.5; 1295 1348 } 1296 1349 \end{cfa} 1297 1350 Finally, a cast may be used to disambiguate among overload variables in a ©with© expression: 1298 1351 \begin{cfa} 1299 with ( w ) { ... } §\C{// ambiguous, same name and no context}§1300 with ( (S)w ) { ... } §\C{// unambiguous, cast}§1301 \end{cfa} 1302 and ©with© expressions may be complex expressions with type reference (see Section~\ref{s:References})to aggregate:1352 with ( w ) { ... } $\C{// ambiguous, same name and no context}$ 1353 with ( (S)w ) { ... } $\C{// unambiguous, cast}$ 1354 \end{cfa} 1355 and ©with© expressions may be complex expressions with type reference \see{\VRef{s:References}} to aggregate: 1303 1356 % \begin{cfa} 1304 1357 % struct S { int i, j; } sv; 1305 % with ( sv ) { §\C{// implicit reference}§1358 % with ( sv ) { $\C{// implicit reference}$ 1306 1359 % S & sr = sv; 1307 % with ( sr ) { §\C{// explicit reference}§1360 % with ( sr ) { $\C{// explicit reference}$ 1308 1361 % S * sp = &sv; 1309 % with ( *sp ) { §\C{// computed reference}§1310 % i = 3; j = 4; §\C{\color{red}// sp{\textgreater}i, sp{\textgreater}j}§1362 % with ( *sp ) { $\C{// computed reference}$ 1363 % i = 3; j = 4; $\C{\color{red}// sp{\textgreater}i, sp{\textgreater}j}$ 1311 1364 % } 1312 % i = 2; j = 3; §\C{\color{red}// sr.i, sr.j}§1365 % i = 2; j = 3; $\C{\color{red}// sr.i, sr.j}$ 1313 1366 % } 1314 % i = 1; j = 2; §\C{\color{red}// sv.i, sv.j}§1367 % i = 1; j = 2; $\C{\color{red}// sv.i, sv.j}$ 1315 1368 % } 1316 1369 % \end{cfa} … … 1320 1373 class C { 1321 1374 int i, j; 1322 int mem() { §\C{\color{red}// implicit "this" parameter}§1323 i = 1; §\C{\color{red}// this>i}§1324 j = 2; §\C{\color{red}// this>j}§1375 int mem() { $\C{\R{// implicit "this" parameter}}$ 1376 i = 1; $\C{\R{// this>i}}$ 1377 j = 2; $\C{\R{// this>j}}$ 1325 1378 } 1326 1379 } … … 1329 1382 \begin{cfa} 1330 1383 struct S { int i, j; }; 1331 int mem( S & ®this® ) { §\C{// explicit "this" parameter}§1332 ®this.®i = 1; §\C{// "this" is not elided}§1333 ®this.®j = 2;1384 int mem( S & @this@ ) { $\C{// explicit "this" parameter}$ 1385 @this.@i = 1; $\C{// "this" is not elided}$ 1386 @this.@j = 2; 1334 1387 } 1335 1388 \end{cfa} 1336 1389 but it is cumbersome having to write ``©this.©'' many times in a member. 1337 1390 1338 \CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal})to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.1339 \begin{cfa} 1340 int mem( S & this ) ®with( this )® { §\C{// with clause}§1341 i = 1; §\C{\color{red}// this.i}§1342 j = 2; §\C{\color{red}// this.j}§1391 \CFA provides a ©with© clause/statement \see{Pascal~\cite[\S~4.F]{Pascal}} to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references. 1392 \begin{cfa} 1393 int mem( S & this ) @with( this )@ { $\C{// with clause}$ 1394 i = 1; $\C{\R{// this.i}}$ 1395 j = 2; $\C{\R{// this.j}}$ 1343 1396 } 1344 1397 \end{cfa} … … 1346 1399 \begin{cfa} 1347 1400 struct T { double m, n; }; 1348 int mem2( S & this1, T & this2 ) ®with( this1, this2 )®{1401 int mem2( S & this1, T & this2 ) @with( this1, this2 )@ { 1349 1402 i = 1; j = 2; 1350 1403 m = 1.0; n = 2.0; … … 1357 1410 struct S1 { ... } s1; 1358 1411 struct S2 { ... } s2; 1359 ®with( s1 )® { §\C{// with statement}§1412 @with( s1 )@ { $\C{// with statement}$ 1360 1413 // access fields of s1 without qualification 1361 ®with s2® { §\C{// nesting}§1414 @with s2@ { $\C{// nesting}$ 1362 1415 // access fields of s1 and s2 without qualification 1363 1416 } 1364 1417 } 1365 ®with s1, s2®{1418 @with s1, s2@ { 1366 1419 // access unambiguous fields of s1 and s2 without qualification 1367 1420 } … … 1414 1467 Nonlocal transfer can cause stack unwinding, \ie nonlocal routine termination, depending on the kind of raise. 1415 1468 \begin{cfa} 1416 exception_t E {}; §\C{// exception type}§1469 exception_t E {}; $\C{// exception type}$ 1417 1470 void f(...) { 1418 ... throw E{}; ... §\C{// termination}§1419 ... throwResume E{}; ... §\C{// resumption}§1471 ... throw E{}; ... $\C{// termination}$ 1472 ... throwResume E{}; ... $\C{// resumption}$ 1420 1473 } 1421 1474 try { 1422 1475 f(...); 1423 } catch( E e ; §booleanpredicate§ ) { §\C{// termination handler}§1476 } catch( E e ; $booleanpredicate$ ) { $\C{// termination handler}$ 1424 1477 // recover and continue 1425 } catchResume( E e ; §booleanpredicate§ ) { §\C{// resumption handler}§1478 } catchResume( E e ; $booleanpredicate$ ) { $\C{// resumption handler}$ 1426 1479 // repair and return 1427 1480 } finally { … … 1430 1483 \end{cfa} 1431 1484 The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©. 1432 Then the exception type must match along with any addit onal predicate must be true.1485 Then the exception type must match along with any additional predicate must be true. 1433 1486 The ©catch© and ©catchResume© handlers may appear in any oder. 1434 1487 However, the ©finally© clause must appear at the end of the ©try© statement. … … 1483 1536 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way: 1484 1537 \begin{cfa} 1485 int ®(*®f®())[®5®]® {...}; §\C{// definition}§1486 ... ®(*®f®())[®3®]® += 1; §\C{// usage}§1538 int @(*@f@())[@5@]@ {...}; $\C{// definition}$ 1539 ... @(*@f@())[@3@]@ += 1; $\C{// usage}$ 1487 1540 \end{cfa} 1488 1541 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}). … … 1499 1552 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1500 1553 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1501 \begin{cfa} 1502 ß[5] *ß ®int®x1;1503 ß* [5]ß ®int®x2;1504 ß[* [5] int]ß f®( int p )®;1554 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}] 1555 #[5] *# @int@ x1; 1556 #* [5]# @int@ x2; 1557 #[* [5] int]# f@( int p )@; 1505 1558 \end{cfa} 1506 1559 & 1507 \begin{cfa} 1508 ®int® ß*ß x1 ß[5]ß;1509 ®int® ß(*ßx2ß)[5]ß;1510 ßint (*ßf®( int p )®ß)[5]ß;1560 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}] 1561 @int@ #*# x1 #[5]#; 1562 @int@ #(*#x2#)[5]#; 1563 #int (*#f@( int p )@#)[5]#; 1511 1564 \end{cfa} 1512 1565 \end{tabular} … … 1520 1573 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1521 1574 \begin{cfa} 1522 ®*®int x, y;1575 @*@ int x, y; 1523 1576 \end{cfa} 1524 1577 & 1525 1578 \begin{cfa} 1526 int ®*®x, ®*®y;1579 int @*@x, @*@y; 1527 1580 \end{cfa} 1528 1581 \end{tabular} … … 1533 1586 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1534 1587 \begin{cfa} 1535 ®*®int x;1588 @*@ int x; 1536 1589 int y; 1537 1590 \end{cfa} 1538 1591 & 1539 1592 \begin{cfa} 1540 int ®*®x, y;1593 int @*@x, y; 1541 1594 1542 1595 \end{cfa} … … 1647 1700 1648 1701 \section{Pointer / Reference} 1702 \label{s:PointerReference} 1649 1703 1650 1704 C provides a \newterm{pointer type}; … … 1673 1727 & 1674 1728 \begin{cfa} 1675 int * ®const®x = (int *)1001729 int * @const@ x = (int *)100 1676 1730 *x = 3; // implicit dereference 1677 int * ®const®y = (int *)104;1731 int * @const@ y = (int *)104; 1678 1732 *y = *x; // implicit dereference 1679 1733 \end{cfa} … … 1713 1767 \begin{tabular}{@{}l@{\hspace{2em}}l@{}} 1714 1768 \begin{cfa} 1715 int x, y, ®*® p1, ®*® p2, ®**®p3;1716 p1 = ®&®x; // p1 points to x1769 int x, y, @*@ p1, @*@ p2, @**@ p3; 1770 p1 = @&@x; // p1 points to x 1717 1771 p2 = p1; // p2 points to x 1718 p1 = ®&®y; // p1 points to y1772 p1 = @&@y; // p1 points to y 1719 1773 p3 = &p2; // p3 points to p2 1720 1774 \end{cfa} … … 1728 1782 For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage 1729 1783 \begin{cfa} 1730 p2 = p1 + x; §\C{// compiler infers *p2 = *p1 + x;}§1784 p2 = p1 + x; $\C{// compiler infers *p2 = *p1 + x;}$ 1731 1785 \end{cfa} 1732 1786 Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation. … … 1736 1790 In C, objects of pointer type always manipulate the pointer object's address: 1737 1791 \begin{cfa} 1738 p1 = p2; §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§1739 p2 = p1 + x; §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§1792 p1 = p2; $\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}$ 1793 p2 = p1 + x; $\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}$ 1740 1794 \end{cfa} 1741 1795 even though the assignment to ©p2© is likely incorrect, and the programmer probably meant: 1742 1796 \begin{cfa} 1743 p1 = p2; §\C{// pointer address assignment}§1744 ®*®p2 = ®*®p1 + x; §\C{// pointedto value assignment / operation}§ 1797 p1 = p2; $\C{// pointer address assignment}$ 1798 @*@p2 = @*@p1 + x; $\C{// pointedto value assignment / operation}$ 1745 1799 \end{cfa} 1746 1800 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©). … … 1758 1812 To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointedto location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s). 1759 1813 \begin{cfa} 1760 int x, y, ®&® r1, ®&® r2, ®&&®r3;1761 ®&®r1 = &x; §\C{// r1 points to x}§ 1762 ®&®r2 = &r1; §\C{// r2 points to x}§ 1763 ®&®r1 = &y; §\C{// r1 points to y}§ 1764 ®&&®r3 = ®&®&r2; §\C{// r3 points to r2}§ 1765 r2 = ((r1 + r2) * (r3  r1)) / (r3  15); §\C{// implicit dereferencing}§1814 int x, y, @&@ r1, @&@ r2, @&&@ r3; 1815 @&@r1 = &x; $\C{// r1 points to x}$ 1816 @&@r2 = &r1; $\C{// r2 points to x}$ 1817 @&@r1 = &y; $\C{// r1 points to y}$ 1818 @&&@r3 = @&@&r2; $\C{// r3 points to r2}$ 1819 r2 = ((r1 + r2) * (r3  r1)) / (r3  15); $\C{// implicit dereferencing}$ 1766 1820 \end{cfa} 1767 1821 Except for autodereferencing by the compiler, this reference example is the same as the previous pointer example. … … 1769 1823 One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in a declaration, so the previous example becomes: 1770 1824 \begin{cfa} 1771 ®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3  ®*®r1)) / (®**®r3  15);1825 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3  @*@r1)) / (@**@r3  15); 1772 1826 \end{cfa} 1773 1827 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out. … … 1778 1832 For a \CFA reference type, the cancellation on the lefthand side of assignment leaves the reference as an address (\Index{lvalue}): 1779 1833 \begin{cfa} 1780 (& ®*®)r1 = &x; §\C{// (\&*) cancel giving address in r1 not variable pointedto by r1}§1834 (&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointedto by r1}$ 1781 1835 \end{cfa} 1782 1836 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}): 1783 1837 \begin{cfa} 1784 (&(& ®*®)®*®)r3 = &(&®*®)r2; §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§1838 (&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$ 1785 1839 \end{cfa} 1786 1840 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth. … … 1790 1844 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, 1791 1845 &r1 = x, &&r2 = r1, &&&r3 = r2; 1792 ***p3 = 3; §\C{// change x}§1793 r3 = 3; §\C{// change x, ***r3}§1794 **p3 = ...; §\C{// change p1}§1795 &r3 = ...; §\C{// change r1, (\&*)**r3, 1 cancellation}§1796 *p3 = ...; §\C{// change p2}§1797 &&r3 = ...; §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§1798 &&&r3 = p3; §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§1846 ***p3 = 3; $\C{// change x}$ 1847 r3 = 3; $\C{// change x, ***r3}$ 1848 **p3 = ...; $\C{// change p1}$ 1849 &r3 = ...; $\C{// change r1, (\&*)**r3, 1 cancellation}$ 1850 *p3 = ...; $\C{// change p2}$ 1851 &&r3 = ...; $\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}$ 1852 &&&r3 = p3; $\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}$ 1799 1853 \end{cfa} 1800 1854 Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types. … … 1803 1857 As for a pointer type, a reference type may have qualifiers: 1804 1858 \begin{cfa} 1805 const int cx = 5; §\C{// cannot change cx;}§1806 const int & cr = cx; §\C{// cannot change what cr points to}§1807 ®&®cr = &cx; §\C{// can change cr}§ 1808 cr = 7; §\C{// error, cannot change cx}§1809 int & const rc = x; §\C{// must be initialized}§1810 ®&®rc = &x; §\C{// error, cannot change rc}§ 1811 const int & const crc = cx; §\C{// must be initialized}§1812 crc = 7; §\C{// error, cannot change cx}§1813 ®&®crc = &cx; §\C{// error, cannot change crc}§ 1859 const int cx = 5; $\C{// cannot change cx;}$ 1860 const int & cr = cx; $\C{// cannot change what cr points to}$ 1861 @&@cr = &cx; $\C{// can change cr}$ 1862 cr = 7; $\C{// error, cannot change cx}$ 1863 int & const rc = x; $\C{// must be initialized}$ 1864 @&@rc = &x; $\C{// error, cannot change rc}$ 1865 const int & const crc = cx; $\C{// must be initialized}$ 1866 crc = 7; $\C{// error, cannot change cx}$ 1867 @&@crc = &cx; $\C{// error, cannot change crc}$ 1814 1868 \end{cfa} 1815 1869 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}: 1816 1870 \begin{cfa} 1817 int & const cr = *0; §\C{// where 0 is the int * zero}§1871 int & const cr = *0; $\C{// where 0 is the int * zero}$ 1818 1872 \end{cfa} 1819 1873 Note, constant referencetypes do not prevent \Index{addressing errors} because of explicit storagemanagement: … … 1822 1876 cr = 5; 1823 1877 free( &cr ); 1824 cr = 7; §\C{// unsound pointer dereference}§1878 cr = 7; $\C{// unsound pointer dereference}$ 1825 1879 \end{cfa} 1826 1880 1827 1881 The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers. 1828 1882 The ©const© qualifier cannot be moved before the pointer/reference qualifier for C styledeclarations; 1829 \CFAstyle declarations (see \VRef{s:AlternativeDeclarations})attempt to address this issue:1883 \CFAstyle declarations \see{\VRef{s:AlternativeDeclarations}} attempt to address this issue: 1830 1884 \begin{cquote} 1831 1885 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1832 1886 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1833 1887 \begin{cfa} 1834 ®const® * ®const®* const int ccp;1835 ®const® & ®const®& const int ccr;1888 @const@ * @const@ * const int ccp; 1889 @const@ & @const@ & const int ccr; 1836 1890 \end{cfa} 1837 1891 & 1838 1892 \begin{cfa} 1839 const int * ®const® * ®const®ccp;1893 const int * @const@ * @const@ ccp; 1840 1894 1841 1895 \end{cfa} … … 1846 1900 Finally, like pointers, references are usable and composable with other type operators and generators. 1847 1901 \begin{cfa} 1848 int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§1849 &ar[1] = &w; §\C{// change reference array element}§1850 typeof( ar[1] ) p; §\C{// (gcc) is int, \ie the type of referenced object}§1851 typeof( &ar[1] ) q; §\C{// (gcc) is int \&, \ie the type of reference}§1852 sizeof( ar[1] ) == sizeof( int ); §\C{// is true, \ie the size of referenced object}§1853 sizeof( &ar[1] ) == sizeof( int *) §\C{// is true, \ie the size of a reference}§1902 int w, x, y, z, & ar[3] = { x, y, z }; $\C{// initialize array of references}$ 1903 &ar[1] = &w; $\C{// change reference array element}$ 1904 typeof( ar[1] ) p; $\C{// (gcc) is int, \ie the type of referenced object}$ 1905 typeof( &ar[1] ) q; $\C{// (gcc) is int \&, \ie the type of reference}$ 1906 sizeof( ar[1] ) == sizeof( int ); $\C{// is true, \ie the size of referenced object}$ 1907 sizeof( &ar[1] ) == sizeof( int *) $\C{// is true, \ie the size of a reference}$ 1854 1908 \end{cfa} 1855 1909 1856 1910 In contrast to \CFA reference types, \Index*[C++]{\CC{}}'s reference types are all ©const© references, preventing changes to the reference address, so only value assignment is possible, which eliminates half of the \Index{address duality}. 1857 1911 Also, \CC does not allow \Index{array}s\index{array!reference} of reference\footnote{ 1858 The reason for disallowing arrays of reference is unknown, but possibly comes from references being ethereal (like a textual macro), and hence, replaceable by the refer ant object.}1912 The reason for disallowing arrays of reference is unknown, but possibly comes from references being ethereal (like a textual macro), and hence, replaceable by the referent object.} 1859 1913 \Index*{Java}'s reference types to objects (all Java objects are on the heap) are like C pointers, which always manipulate the address, and there is no (bitwise) object assignment, so objects are explicitly cloned by shallow or deep copying, which eliminates half of the address duality. 1860 1914 … … 1868 1922 Therefore, for pointer/reference initialization, the initializing value must be an address not a value. 1869 1923 \begin{cfa} 1870 int * p = &x; §\C{// assign address of x}§1871 ®int * p = x;® §\C{// assign value of x}§ 1872 int & r = x; §\C{// must have address of x}§1924 int * p = &x; $\C{// assign address of x}$ 1925 @int * p = x;@ $\C{// assign value of x}$ 1926 int & r = x; $\C{// must have address of x}$ 1873 1927 \end{cfa} 1874 1928 Like the previous example with C pointerarithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given). … … 1879 1933 Similarly, when a reference type is used for a parameter/return type, the callsite argument does not require a reference operator for the same reason. 1880 1934 \begin{cfa} 1881 int & f( int & r ); §\C{// reference parameter and return}§1882 z = f( x ) + f( y ); §\C{// reference operator added, temporaries needed for call results}§1935 int & f( int & r ); $\C{// reference parameter and return}$ 1936 z = f( x ) + f( y ); $\C{// reference operator added, temporaries needed for call results}$ 1883 1937 \end{cfa} 1884 1938 Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©. … … 1893 1947 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions. 1894 1948 \begin{cfa} 1895 void f( ®const®int & cr );1896 void g( ®const®int * cp );1897 f( 3 ); g( ®&®3 );1898 f( x + y ); g( ®&®(x + y) );1949 void f( @const@ int & cr ); 1950 void g( @const@ int * cp ); 1951 f( 3 ); g( @&@3 ); 1952 f( x + y ); g( @&@(x + y) ); 1899 1953 \end{cfa} 1900 1954 Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter. … … 1907 1961 void f( int & r ); 1908 1962 void g( int * p ); 1909 f( 3 ); g( ®&®3 ); §\C{// compiler implicit generates temporaries}§1910 f( x + y ); g( ®&®(x + y) ); §\C{// compiler implicit generates temporaries}§1963 f( 3 ); g( @&@3 ); $\C{// compiler implicit generates temporaries}$ 1964 f( x + y ); g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$ 1911 1965 \end{cfa} 1912 1966 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{ … … 1919 1973 \begin{cfa} 1920 1974 void f( int i ); 1921 void (* fp)( int ); §\C{// routine pointer}§1922 fp = f; §\C{// reference initialization}§1923 fp = &f; §\C{// pointer initialization}§1924 fp = *f; §\C{// reference initialization}§1925 fp(3); §\C{// reference invocation}§1926 (*fp)(3); §\C{// pointer invocation}§1975 void (* fp)( int ); $\C{// routine pointer}$ 1976 fp = f; $\C{// reference initialization}$ 1977 fp = &f; $\C{// pointer initialization}$ 1978 fp = *f; $\C{// reference initialization}$ 1979 fp(3); $\C{// reference invocation}$ 1980 (*fp)(3); $\C{// pointer invocation}$ 1927 1981 \end{cfa} 1928 1982 While C's treatment of routine objects has similarity to inferring a reference type in initialization contexts, the examples are assignment not initialization, and all possible forms of assignment are possible (©f©, ©&f©, ©*f©) without regard for type. 1929 1983 Instead, a routine object should be referenced by a ©const© reference: 1930 1984 \begin{cfa} 1931 ®const® void (®&® fr)( int ) = f; §\C{// routine reference}§ 1932 fr = ... §\C{// error, cannot change code}§1933 &fr = ...; §\C{// changing routine reference}§1934 fr( 3 ); §\C{// reference call to f}§1935 (*fr)(3); §\C{// error, incorrect type}§1985 @const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$ 1986 fr = ... $\C{// error, cannot change code}$ 1987 &fr = ...; $\C{// changing routine reference}$ 1988 fr( 3 ); $\C{// reference call to f}$ 1989 (*fr)(3); $\C{// error, incorrect type}$ 1936 1990 \end{cfa} 1937 1991 because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{ … … 1946 2000 \begin{itemize} 1947 2001 \item 1948 if ©R© is an \Index{rvalue} of type ©T &©$_1\cdots$ ©&©$_r$, where $r \ge 1$ references (©&© symbols), than ©&R© has type ©T ®*®&©$_{\color{red}2}\cdots$ ©&©$_{\color{red}r}$, \ie ©T© pointer with $r1$ references (©&© symbols).1949 1950 \item 1951 if ©L© is an \Index{lvalue} of type ©T &©$_1\cdots$ ©&©$_l$, where $l \ge 0$ references (©&© symbols), than ©&L© has type ©T ®*®&©$_{\color{red}1}\cdots$ ©&©$_{\color{red}l}$, \ie ©T© pointer with $l$ references (©&© symbols).2002 if ©R© is an \Index{rvalue} of type ©T &©$_1\cdots$ ©&©$_r$, where $r \ge 1$ references (©&© symbols), than ©&R© has type ©T ©\R{©*©}©&©\R{$_2$}$\cdots$ ©&©\R{$_r$}, \ie ©T© pointer with $r1$ references (©&© symbols). 2003 2004 \item 2005 if ©L© is an \Index{lvalue} of type ©T &©$_1\cdots$ ©&©$_l$, where $l \ge 0$ references (©&© symbols), than ©&L© has type ©T ©\R{©*©}©&©\R{$_1$}$\cdots$ ©&©\R{$_l$}, \ie ©T© pointer with $l$ references (©&© symbols). 1952 2006 \end{itemize} 1953 2007 The following example shows the first rule applied to different \Index{rvalue} contexts: … … 1955 2009 int x, * px, ** ppx, *** pppx, **** ppppx; 1956 2010 int & rx = x, && rrx = rx, &&& rrrx = rrx ; 1957 x = rrrx; §\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§1958 px = &rrrx; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}§1959 ppx = &&rrrx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}§1960 pppx = &&&rrrx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}§1961 ppppx = &&&&rrrx; §\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}§2011 x = rrrx; $\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$ 2012 px = &rrrx; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}$ 2013 ppx = &&rrrx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}$ 2014 pppx = &&&rrrx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}$ 2015 ppppx = &&&&rrrx; $\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}$ 1962 2016 \end{cfa} 1963 2017 The following example shows the second rule applied to different \Index{lvalue} contexts: … … 1965 2019 int x, * px, ** ppx, *** pppx; 1966 2020 int & rx = x, && rrx = rx, &&& rrrx = rrx ; 1967 rrrx = 2; §\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§1968 &rrrx = px; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}§1969 &&rrrx = ppx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}§1970 &&&rrrx = pppx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT§2021 rrrx = 2; $\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$ 2022 &rrrx = px; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}$ 2023 &&rrrx = ppx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}$ 2024 &&&rrrx = pppx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT$ 1971 2025 \end{cfa} 1972 2026 … … 1981 2035 \begin{cfa} 1982 2036 int x; 1983 x + 1; §\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}§2037 x + 1; $\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}$ 1984 2038 \end{cfa} 1985 2039 An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped. … … 1991 2045 \begin{cfa} 1992 2046 int x, &r = x, f( int p ); 1993 x = ®r® + f( ®r® ); §\C{// lvalue reference converts to rvalue}§2047 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$ 1994 2048 \end{cfa} 1995 2049 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped. … … 1998 2052 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvaluetype cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references. 1999 2053 \begin{cfa} 2000 int x, &r = ®x®, f( int & p ); §\C{// lvalue variable (int) convert to reference (int \&)}§2001 f( ®x® ); §\C{// lvalue variable (int) convert to reference (int \&)}§2054 int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$ 2055 f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$ 2002 2056 \end{cfa} 2003 2057 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost. … … 2009 2063 \begin{cfa} 2010 2064 int x, & f( int & p ); 2011 f( ®x + 3® ); §\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}§2012 ®&f®(...) = &x; §\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT§ 2065 f( @x + 3@ ); $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$ 2066 @&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$ 2013 2067 \end{cfa} 2014 2068 In both case, modifications to the temporary are inaccessible (\Index{warning}). … … 2182 2236 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg: 2183 2237 \begin{cfa} 2184 ®[ int o1, int o2, char o3 ]®f( int i1, char i2, char i3 ) {2185 §\emph{routine body}§2238 @[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) { 2239 $\emph{routine body}$ 2186 2240 } 2187 2241 \end{cfa} … … 2194 2248 Declaration qualifiers can only appear at the start of a routine definition, \eg: 2195 2249 \begin{cfa} 2196 ®extern® [ int x ] g( int y ) {§\,§}2250 @extern@ [ int x ] g( int y ) {$\,$} 2197 2251 \end{cfa} 2198 2252 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified; 2199 2253 in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in: 2200 2254 \begin{cfa} 2201 [ §\,§] g(); §\C{// no input or output parameters}§2202 [ void ] g( void ); §\C{// no input or output parameters}§2255 [$\,$] g(); $\C{// no input or output parameters}$ 2256 [ void ] g( void ); $\C{// no input or output parameters}$ 2203 2257 \end{cfa} 2204 2258 … … 2218 2272 \begin{cfa} 2219 2273 typedef int foo; 2220 int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§2274 int f( int (* foo) ); $\C{// foo is redefined as a parameter name}$ 2221 2275 \end{cfa} 2222 2276 The string ``©int (* foo)©'' declares a Cstyle namedparameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo. … … 2226 2280 Cstyle declarations can be used to declare parameters for \CFA style routine definitions, \eg: 2227 2281 \begin{cfa} 2228 [ int ] f( * int, int * ); §\C{// returns an integer, accepts 2 pointers to integers}§2229 [ * int, int * ] f( int ); §\C{// returns 2 pointers to integers, accepts an integer}§2282 [ int ] f( * int, int * ); $\C{// returns an integer, accepts 2 pointers to integers}$ 2283 [ * int, int * ] f( int ); $\C{// returns 2 pointers to integers, accepts an integer}$ 2230 2284 \end{cfa} 2231 2285 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate Cstyle declarationsyntax, as in: 2232 2286 \begin{cfa} 2233 2287 #define ptoa( n, d ) int (*n)[ d ] 2234 int f( ptoa( p, 5 ) ) ... §\C{// expands to int f( int (*p)[ 5 ] )}§2235 [ int ] f( ptoa( p, 5 ) ) ... §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§2288 int f( ptoa( p, 5 ) ) ... $\C{// expands to int f( int (*p)[ 5 ] )}$ 2289 [ int ] f( ptoa( p, 5 ) ) ... $\C{// expands to [ int ] f( int (*p)[ 5 ] )}$ 2236 2290 \end{cfa} 2237 2291 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms. … … 2252 2306 \begin{minipage}{\linewidth} 2253 2307 \begin{cfa} 2254 ®[ int x, int y ]®f() {2308 @[ int x, int y ]@ f() { 2255 2309 int z; 2256 2310 ... x = 0; ... y = z; ... 2257 ®return;® §\C{// implicitly return x, y}§2311 @return;@ $\C{// implicitly return x, y}$ 2258 2312 } 2259 2313 \end{cfa} … … 2265 2319 [ int x, int y ] f() { 2266 2320 ... 2267 } §\C{// implicitly return x, y}§2321 } $\C{// implicitly return x, y}$ 2268 2322 \end{cfa} 2269 2323 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered. … … 2274 2328 [ int x, int y ] f( int, x, int y ) { 2275 2329 ... 2276 } §\C{// implicitly return x, y}§2330 } $\C{// implicitly return x, y}$ 2277 2331 \end{cfa} 2278 2332 This notation allows the compiler to eliminate temporary variables in nested routine calls. 2279 2333 \begin{cfa} 2280 [ int x, int y ] f( int, x, int y ); §\C{// prototype declaration}§2334 [ int x, int y ] f( int, x, int y ); $\C{// prototype declaration}$ 2281 2335 int a, b; 2282 2336 [a, b] = f( f( f( a, b ) ) ); … … 2292 2346 as well, parameter names are optional, \eg: 2293 2347 \begin{cfa} 2294 [ int x ] f (); §\C{// returning int with no parameters}§2295 [ * int ] g (int y); §\C{// returning pointer to int with int parameter}§2296 [ ] h ( int, char ); §\C{// returning no result with int and char parameters}§2297 [ * int, int ] j ( int ); §\C{// returning pointer to int and int, with int parameter}§2348 [ int x ] f (); $\C{// returning int with no parameters}$ 2349 [ * int ] g (int y); $\C{// returning pointer to int with int parameter}$ 2350 [ ] h ( int, char ); $\C{// returning no result with int and char parameters}$ 2351 [ * int, int ] j ( int ); $\C{// returning pointer to int and int, with int parameter}$ 2298 2352 \end{cfa} 2299 2353 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa). 2300 Like C, it is possible to declare multiple routineprototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:AlternativeDeclarations}), \eg:2354 Like C, it is possible to declare multiple routineprototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list \see{\VRef{s:AlternativeDeclarations}}, \eg: 2301 2355 \begin{cfa} 2302 2356 C : const double bar1(), bar2( int ), bar3( double ); 2303 §\CFA§: [const double] foo(), foo( int ), foo( double ) { return 3.0; }2357 $\CFA$: [const double] foo(), foo( int ), foo( double ) { return 3.0; } 2304 2358 \end{cfa} 2305 2359 \CFA allows the last routine in the list to define its body. … … 2316 2370 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg: 2317 2371 \begin{cfa} 2318 * [ int x ] () fp; §\C{// pointer to routine returning int with no parameters}§2319 * [ * int ] (int y) gp; §\C{// pointer to routine returning pointer to int with int parameter}§2320 * [ ] (int,char) hp; §\C{// pointer to routine returning no result with int and char parameters}§2321 * [ * int,int ] ( int ) jp; §\C{// pointer to routine returning pointer to int and int, with int parameter}§2372 * [ int x ] () fp; $\C[2.25in]{// pointer to routine returning int with no parameters}$ 2373 * [ * int ] (int y) gp; $\C{// pointer to routine returning pointer to int with int parameter}$ 2374 * [ ] (int,char) hp; $\C{// pointer to routine returning no result with int and char parameters}$ 2375 * [ * int,int ] ( int ) jp; $\C{// pointer to routine returning pointer to int and int, with int parameter}\CRT$ 2322 2376 \end{cfa} 2323 2377 While parameter names are optional, \emph{a routine name cannot be specified}; 2324 2378 for example, the following is incorrect: 2325 2379 \begin{cfa} 2326 * [ int x ] f () fp; §\C{// routine name "f" is not allowed}§2380 * [ int x ] f () fp; $\C{// routine name "f" is not allowed}$ 2327 2381 \end{cfa} 2328 2382 … … 2347 2401 whereas a named (keyword) call may be: 2348 2402 \begin{cfa} 2349 p( z : 3, x : 4, y : 7 ); §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§2403 p( z : 3, x : 4, y : 7 ); $\C{// rewrite \(\Rightarrow\) p( 4, 7, 3 )}$ 2350 2404 \end{cfa} 2351 2405 Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters. … … 2364 2418 For example, the following routine prototypes and definition are all valid. 2365 2419 \begin{cfa} 2366 void p( int, int, int ); §\C{// equivalent prototypes}§2420 void p( int, int, int ); $\C{// equivalent prototypes}$ 2367 2421 void p( int x, int y, int z ); 2368 2422 void p( int y, int x, int z ); 2369 2423 void p( int z, int y, int x ); 2370 void p( int q, int r, int s ) {} §\C{// match with this definition}§2424 void p( int q, int r, int s ) {} $\C{// match with this definition}$ 2371 2425 \end{cfa} 2372 2426 Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming. … … 2380 2434 int f( int x, double y ); 2381 2435 2382 f( j : 3, i : 4 ); §\C{// 1st f}§2383 f( x : 7, y : 8.1 ); §\C{// 2nd f}§2384 f( 4, 5 ); §\C{// ambiguous call}§2436 f( j : 3, i : 4 ); $\C{// 1st f}$ 2437 f( x : 7, y : 8.1 ); $\C{// 2nd f}$ 2438 f( 4, 5 ); $\C{// ambiguous call}$ 2385 2439 \end{cfa} 2386 2440 However, named arguments compound routine resolution in conjunction with conversions: 2387 2441 \begin{cfa} 2388 f( i : 3, 5.7 ); §\C{// ambiguous call ?}§2442 f( i : 3, 5.7 ); $\C{// ambiguous call ?}$ 2389 2443 \end{cfa} 2390 2444 Depending on the cost associated with named arguments, this call could be resolvable or ambiguous. … … 2400 2454 the allowable positional calls are: 2401 2455 \begin{cfa} 2402 p(); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§2403 p( 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§2404 p( 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§2405 p( 4, 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§2456 p(); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$ 2457 p( 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$ 2458 p( 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$ 2459 p( 4, 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 4 )}$ 2406 2460 // empty arguments 2407 p( , 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§2408 p( 4, , 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§2409 p( 4, 4, ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§2410 p( 4, , ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§2411 p( , 4, ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§2412 p( , , 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§2413 p( , , ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§2461 p( , 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 4 )}$ 2462 p( 4, , 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 4 )}$ 2463 p( 4, 4, ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$ 2464 p( 4, , ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$ 2465 p( , 4, ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 3 )}$ 2466 p( , , 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 4 )}$ 2467 p( , , ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$ 2414 2468 \end{cfa} 2415 2469 Here the missing arguments are inserted from the default values in the parameter list. … … 2435 2489 Default values may only appear in a prototype versus definition context: 2436 2490 \begin{cfa} 2437 void p( int x, int y = 2, int z = 3 ); §\C{// prototype: allowed}§2438 void p( int, int = 2, int = 3 ); §\C{// prototype: allowed}§2439 void p( int x, int y = 2, int z = 3 ) {} §\C{// definition: not allowed}§2491 void p( int x, int y = 2, int z = 3 ); $\C{// prototype: allowed}$ 2492 void p( int, int = 2, int = 3 ); $\C{// prototype: allowed}$ 2493 void p( int x, int y = 2, int z = 3 ) {} $\C{// definition: not allowed}$ 2440 2494 \end{cfa} 2441 2495 The reason for this restriction is to allow separate compilation. … … 2452 2506 \begin{cfa} 2453 2507 p( int x, int y, int z, ... ); 2454 p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§2455 p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§2508 p( 1, 4, 5, 6, z : 3, y : 2 ); $\C{// assume p( /* positional */, ... , /* named */ );}$ 2509 p( 1, z : 3, y : 2, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$ 2456 2510 \end{cfa} 2457 2511 In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin. … … 2462 2516 \begin{cfa} 2463 2517 void p( int x, int y = 2, int z = 3... ); 2464 p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, ... , /* named */ );}§2465 p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§2518 p( 1, 4, 5, 6, z : 3 ); $\C{// assume p( /* positional */, ... , /* named */ );}$ 2519 p( 1, z : 3, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$ 2466 2520 \end{cfa} 2467 2521 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments; … … 2469 2523 In the second call, the default value for y is implicitly inserted after argument 1 and the named arguments separate the positional and ellipse arguments, making it trivial to read the call. 2470 2524 For these reasons, \CFA requires named arguments before ellipse arguments. 2471 Finally, while ellipse arguments are needed for a small set of existing C routines, like printf, the extended \CFA type system largely eliminates the need for ellipse arguments (see Section 24), making much of this discussion moot.2472 2473 Default arguments and overloading (see Section 24)are complementary.2525 Finally, while ellipse arguments are needed for a small set of existing C routines, like ©printf©, the extended \CFA type system largely eliminates the need for ellipse arguments \see{\VRef{s:Overloading}}, making much of this discussion moot. 2526 2527 Default arguments and overloading \see{\VRef{s:Overloading}} are complementary. 2474 2528 While in theory default arguments can be simulated with overloading, as in: 2475 2529 \begin{cquote} … … 2493 2547 Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as: 2494 2548 \begin{cfa} 2495 p( 1, /* default */, 5 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§2549 p( 1, /* default */, 5 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 5 )}$ 2496 2550 \end{cfa} 2497 2551 … … 2506 2560 \begin{cfa} 2507 2561 struct { 2508 int f1; §\C{// named field}§2509 int f2 : 4; §\C{// named field with bit field size}§2510 int : 3; §\C{// unnamed field for basic type with bit field size}§2511 int ; §\C{// disallowed, unnamed field}§2512 int *; §\C{// disallowed, unnamed field}§2513 int (*)( int ); §\C{// disallowed, unnamed field}§2562 int f1; $\C{// named field}$ 2563 int f2 : 4; $\C{// named field with bit field size}$ 2564 int : 3; $\C{// unnamed field for basic type with bit field size}$ 2565 int ; $\C{// disallowed, unnamed field}$ 2566 int *; $\C{// disallowed, unnamed field}$ 2567 int (*)( int ); $\C{// disallowed, unnamed field}$ 2514 2568 }; 2515 2569 \end{cfa} … … 2519 2573 \begin{cfa} 2520 2574 struct { 2521 int , , ; §\C{// 3 unnamed fields}§2575 int , , ; $\C{// 3 unnamed fields}$ 2522 2576 } 2523 2577 \end{cfa} … … 2531 2585 \subsection{Type Nesting} 2532 2586 2533 \CFA allows \Index{type nesting}, and type qualification of the nested types (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.2587 \CFA allows \Index{type nesting}, and type qualification of the nested types \see{\VRef[Figure]{f:TypeNestingQualification}}, where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification. 2534 2588 \begin{figure} 2535 2589 \centering … … 2587 2641 2588 2642 int fred() { 2589 s.t.c = ®S.®R; // type qualification2590 struct ®S.®T t = { ®S.®R, 1, 2 };2591 enum ®S.®C c;2592 union ®S.T.®U u;2643 s.t.c = @S.@R; // type qualification 2644 struct @S.@T t = { @S.@R, 1, 2 }; 2645 enum @S.@C c; 2646 union @S.T.@U u; 2593 2647 } 2594 2648 \end{cfa} … … 2613 2667 const unsigned int size = 5; 2614 2668 int ia[size]; 2615 ... §\C{// assign values to array ia}§2616 qsort( ia, size ); §\C{// sort ascending order using builtin ?<?}§2669 ... $\C{// assign values to array ia}$ 2670 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$ 2617 2671 { 2618 ®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§2619 qsort( ia, size ); §\C{// sort descending order by local redefinition}§2672 @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$ 2673 qsort( ia, size ); $\C{// sort descending order by local redefinition}$ 2620 2674 } 2621 2675 \end{cfa} … … 2625 2679 The following program in undefined in \CFA (and Indexc{gcc}) 2626 2680 \begin{cfa} 2627 [* [int]( int )] foo() { §\C{// int (* foo())( int )}§2628 int ®i®= 7;2681 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$ 2682 int @i@ = 7; 2629 2683 int bar( int p ) { 2630 ®i® += 1; §\C{// dependent on local variable}§2631 sout  ®i®;2684 @i@ += 1; $\C{// dependent on local variable}$ 2685 sout  @i@; 2632 2686 } 2633 return bar; §\C{// undefined because of local dependence}§2687 return bar; $\C{// undefined because of local dependence}$ 2634 2688 } 2635 2689 int main() { 2636 * [int]( int ) fp = foo(); §\C{// int (* fp)( int )}§2690 * [int]( int ) fp = foo(); $\C{// int (* fp)( int )}$ 2637 2691 sout  fp( 3 ); 2638 2692 } … … 2647 2701 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call. 2648 2702 \begin{cfa} 2649 f( ®2, x, 3 + i® ); §\C{// element list}§2703 f( @2, x, 3 + i@ ); $\C{// element list}$ 2650 2704 \end{cfa} 2651 2705 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}. … … 2656 2710 2657 2711 In C and most programming languages, functions return at most one value; 2658 however, many operations have multiple outcomes, some exceptional (see~\VRef{s:ExceptionHandling}).2712 however, many operations have multiple outcomes, some exceptional \see{\VRef{s:ExceptionHandling}}. 2659 2713 To emulate functions with multiple return values, \emph{\Index{aggregation}} and/or \emph{\Index{aliasing}} is used. 2660 2714 … … 2662 2716 For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value. 2663 2717 \begin{cfa} 2664 typedef struct { int quot, rem; } div_t; §\C[7cm]{// from include stdlib.h}§2718 typedef struct { int quot, rem; } div_t; $\C[7cm]{// from include stdlib.h}$ 2665 2719 div_t div( int num, int den ); 2666 div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§2667 printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§2720 div_t qr = div( 13, 5 ); $\C{// return quotient/remainder aggregate}$ 2721 printf( "%d %d\n", qr.quot, qr.rem ); $\C{// print quotient/remainder}$ 2668 2722 \end{cfa} 2669 2723 This approach requires a name for the return type and fields, where \Index{naming} is a common programminglanguage issue. … … 2675 2729 For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value. 2676 2730 \begin{cfa} 2677 double modf( double x, double * i ); §\C{// from include math.h}§2678 double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§2679 printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§2731 double modf( double x, double * i ); $\C{// from include math.h}$ 2732 double intp, frac = modf( 13.5, &intp ); $\C{// return integral and fractional components}$ 2733 printf( "%g %g\n", intp, frac ); $\C{// print integral/fractional components}$ 2680 2734 \end{cfa} 2681 2735 This approach requires allocating storage for the return values, which complicates the call site with a sequence of variable declarations leading to the call. … … 2704 2758 When a function call is passed as an argument to another call, the best match of actual arguments to formal parameters is evaluated given all possible expression interpretations in the current scope. 2705 2759 \begin{cfa} 2706 void g( int, int ); §\C{// 1}§2707 void g( double, double ); §\C{// 2}§2708 g( div( 13, 5 ) ); §\C{// select 1}§2709 g( modf( 13.5 ) ); §\C{// select 2}§2760 void g( int, int ); $\C{// 1}$ 2761 void g( double, double ); $\C{// 2}$ 2762 g( div( 13, 5 ) ); $\C{// select 1}$ 2763 g( modf( 13.5 ) ); $\C{// select 2}$ 2710 2764 \end{cfa} 2711 2765 In this case, there are two overloaded ©g© routines. … … 2716 2770 The previous examples can be rewritten passing the multiple returnedvalues directly to the ©printf© function call. 2717 2771 \begin{cfa} 2718 [ int, int ] div( int x, int y ); §\C{// from include stdlib}§2719 printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§2720 2721 [ double, double ] modf( double x ); §\C{// from include math}§2722 printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§2772 [ int, int ] div( int x, int y ); $\C{// from include stdlib}$ 2773 printf( "%d %d\n", div( 13, 5 ) ); $\C{// print quotient/remainder}$ 2774 2775 [ double, double ] modf( double x ); $\C{// from include math}$ 2776 printf( "%g %g\n", modf( 13.5 ) ); $\C{// print integral/fractional components}$ 2723 2777 \end{cfa} 2724 2778 This approach provides the benefits of compiletime checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type. … … 2730 2784 \begin{cfa} 2731 2785 int quot, rem; 2732 [ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§2733 printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§2786 [ quot, rem ] = div( 13, 5 ); $\C{// assign multiple variables}$ 2787 printf( "%d %d\n", quot, rem ); $\C{// print quotient/remainder}\CRT$ 2734 2788 \end{cfa} 2735 2789 Here, the multiple returnvalues are matched in much the same way as passing multiple returnvalues to multiple parameters in a call. … … 2760 2814 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}. 2761 2815 \begin{cfa} 2762 [int, int] ®qr® = div( 13, 5 ); §\C{// initialize tuple variable}§2763 printf( "%d %d\n", ®qr® ); §\C{// print quotient/remainder}§2816 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$ 2817 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$ 2764 2818 \end{cfa} 2765 2819 It is now possible to match the multiple returnvalues to a single variable, in much the same way as \Index{aggregation}. … … 2767 2821 One way to access the individual components of a tuple variable is with assignment. 2768 2822 \begin{cfa} 2769 [ quot, rem ] = qr; §\C{// assign multiple variables}§2823 [ quot, rem ] = qr; $\C{// assign multiple variables}$ 2770 2824 \end{cfa} 2771 2825 … … 2790 2844 [int, double] * p; 2791 2845 2792 int y = x.0; §\C{// access int component of x}§2793 y = f().1; §\C{// access int component of f}§2794 p>0 = 5; §\C{// access int component of tuple pointedto by p}§2795 g( x.1, x.0 ); §\C{// rearrange x to pass to g}§2796 double z = [ x, f() ].0.1; §\C{// access second component of first component of tuple expression}§2846 int y = x.0; $\C{// access int component of x}$ 2847 y = f().1; $\C{// access int component of f}$ 2848 p>0 = 5; $\C{// access int component of tuple pointedto by p}$ 2849 g( x.1, x.0 ); $\C{// rearrange x to pass to g}$ 2850 double z = [ x, f() ].0.1; $\C{// access second component of first component of tuple expression}$ 2797 2851 \end{cfa} 2798 2852 Tupleindex expressions can occur on any tupletyped expression, including tuplereturning functions, squarebracketed tuple expressions, and other tupleindex expressions, provided the retrieved component is also a tuple. … … 2801 2855 2802 2856 \subsection{Flattening and Structuring} 2857 \label{s:FlatteningStructuring} 2803 2858 2804 2859 As evident in previous examples, tuples in \CFA do not have a rigid structure. … … 2861 2916 double y; 2862 2917 [int, double] z; 2863 [y, x] = 3.14; §\C{// mass assignment}§2864 [x, y] = z; §\C{// multiple assignment}§2865 z = 10; §\C{// mass assignment}§2866 z = [x, y]; §\C{// multiple assignment}§2918 [y, x] = 3.14; $\C{// mass assignment}$ 2919 [x, y] = z; $\C{// multiple assignment}$ 2920 z = 10; $\C{// mass assignment}$ 2921 z = [x, y]; $\C{// multiple assignment}$ 2867 2922 \end{cfa} 2868 2923 Let $L_i$ for $i$ in $[0, n)$ represent each component of the flattened left side, $R_i$ represent each component of the flattened right side of a multiple assignment, and $R$ represent the right side of a mass assignment. … … 2872 2927 \begin{cfa} 2873 2928 [ int, int ] x, y, z; 2874 [ x, y ] = z; §\C{// multiple assignment, invalid 4 != 2}§2929 [ x, y ] = z; $\C{// multiple assignment, invalid 4 != 2}$ 2875 2930 \end{cfa} 2876 2931 Multiple assignment assigns $R_i$ to $L_i$ for each $i$. … … 2908 2963 double c, d; 2909 2964 [ void ] f( [ int, int ] ); 2910 f( [ c, a ] = [ b, d ] = 1.5 ); §\C{// assignments in parameter list}§2965 f( [ c, a ] = [ b, d ] = 1.5 ); $\C{// assignments in parameter list}$ 2911 2966 \end{cfa} 2912 2967 The tuple expression begins with a mass assignment of ©1.5© into ©[b, d]©, which assigns ©1.5© into ©b©, which is truncated to ©1©, and ©1.5© into ©d©, producing the tuple ©[1, 1.5]© as a result. … … 2921 2976 \begin{cfa} 2922 2977 struct S; 2923 void ?{}(S *); §\C{// (1)}§2924 void ?{}(S *, int); §\C{// (2)}§2925 void ?{}(S * double); §\C{// (3)}§2926 void ?{}(S *, S); §\C{// (4)}§2927 2928 [S, S] x = [3, 6.28]; §\C{// uses (2), (3), specialized constructors}§2929 [S, S] y; §\C{// uses (1), (1), default constructor}§2930 [S, S] z = x.0; §\C{// uses (4), (4), copy constructor}§2978 void ?{}(S *); $\C{// (1)}$ 2979 void ?{}(S *, int); $\C{// (2)}$ 2980 void ?{}(S * double); $\C{// (3)}$ 2981 void ?{}(S *, S); $\C{// (4)}$ 2982 2983 [S, S] x = [3, 6.28]; $\C{// uses (2), (3), specialized constructors}$ 2984 [S, S] y; $\C{// uses (1), (1), default constructor}$ 2985 [S, S] z = x.0; $\C{// uses (4), (4), copy constructor}$ 2931 2986 \end{cfa} 2932 2987 In this example, ©x© is initialized by the multiple constructor calls ©?{}(&x.0, 3)© and ©?{}(&x.1, 6.28)©, while ©y© is initialized by two default constructor calls ©?{}(&y.0)© and ©?{}(&y.1)©. … … 2969 3024 A memberaccess tuple may be used anywhere a tuple can be used, \eg: 2970 3025 \begin{cfa} 2971 s.[ y, z, x ] = [ 3, 3.2, 'x' ]; §\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}§2972 f( s.[ y, z ] ); §\C{// equivalent to f( s.y, s.z )}§3026 s.[ y, z, x ] = [ 3, 3.2, 'x' ]; $\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}$ 3027 f( s.[ y, z ] ); $\C{// equivalent to f( s.y, s.z )}$ 2973 3028 \end{cfa} 2974 3029 Note, the fields appearing in a recordfield tuple may be specified in any order; … … 2980 3035 void f( double, long ); 2981 3036 2982 f( x.[ 0, 3 ] ); §\C{// f( x.0, x.3 )}§2983 x.[ 0, 1 ] = x.[ 1, 0 ]; §\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}§3037 f( x.[ 0, 3 ] ); $\C{// f( x.0, x.3 )}$ 3038 x.[ 0, 1 ] = x.[ 1, 0 ]; $\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}$ 2984 3039 [ long, int, long ] y = x.[ 2, 0, 2 ]; 2985 3040 \end{cfa} … … 2998 3053 \begin{cfa} 2999 3054 [ int, float, double ] f(); 3000 [ double, float ] x = f().[ 2, 1 ]; §\C{// f() called once}§3055 [ double, float ] x = f().[ 2, 1 ]; $\C{// f() called once}$ 3001 3056 \end{cfa} 3002 3057 … … 3011 3066 That is, a cast can be used to select the type of an expression when it is ambiguous, as in the call to an overloaded function. 3012 3067 \begin{cfa} 3013 int f(); §\C{// (1)}§3014 double f(); §\C{// (2)}§3015 3016 f(); §\C{// ambiguous  (1),(2) both equally viable}§3017 (int)f(); §\C{// choose (2)}§3068 int f(); $\C{// (1)}$ 3069 double f(); $\C{// (2)}$ 3070 3071 f(); $\C{// ambiguous  (1),(2) both equally viable}$ 3072 (int)f(); $\C{// choose (2)}$ 3018 3073 \end{cfa} 3019 3074 Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples. … … 3023 3078 void g(); 3024 3079 3025 (void)f(); §\C{// valid, ignore results}§3026 (int)g(); §\C{// invalid, void cannot be converted to int}§3080 (void)f(); $\C{// valid, ignore results}$ 3081 (int)g(); $\C{// invalid, void cannot be converted to int}$ 3027 3082 3028 3083 struct A { int x; }; 3029 (struct A)f(); §\C{// invalid, int cannot be converted to A}§3084 (struct A)f(); $\C{// invalid, int cannot be converted to A}$ 3030 3085 \end{cfa} 3031 3086 In C, line 4 is a valid cast, which calls ©f© and discards its result. … … 3043 3098 [int, [int, int], int] g(); 3044 3099 3045 ([int, double])f(); §\C{// (1) valid}§3046 ([int, int, int])g(); §\C{// (2) valid}§3047 ([void, [int, int]])g(); §\C{// (3) valid}§3048 ([int, int, int, int])g(); §\C{// (4) invalid}§3049 ([int, [int, int, int]])g(); §\C{// (5) invalid}§3100 ([int, double])f(); $\C{// (1) valid}$ 3101 ([int, int, int])g(); $\C{// (2) valid}$ 3102 ([void, [int, int]])g(); $\C{// (3) valid}$ 3103 ([int, int, int, int])g(); $\C{// (4) invalid}$ 3104 ([int, [int, int, int]])g(); $\C{// (5) invalid}$ 3050 3105 \end{cfa} 3051 3106 … … 3107 3162 void f([int, int], int, int); 3108 3163 3109 f([0, 0], 0, 0); §\C{// no cost}§3110 f(0, 0, 0, 0); §\C{// cost for structuring}§3111 f([0, 0,], [0, 0]); §\C{// cost for flattening}§3112 f([0, 0, 0], 0); §\C{// cost for flattening and structuring}§3164 f([0, 0], 0, 0); $\C{// no cost}$ 3165 f(0, 0, 0, 0); $\C{// cost for structuring}$ 3166 f([0, 0,], [0, 0]); $\C{// cost for flattening}$ 3167 f([0, 0, 0], 0); $\C{// cost for flattening and structuring}$ 3113 3168 \end{cfa} 3114 3169 … … 3146 3201 The general syntax of a lexical list is: 3147 3202 \begin{cfa} 3148 [ §\emph{exprlist}§]3203 [ $\emph{exprlist}$ ] 3149 3204 \end{cfa} 3150 3205 where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas. … … 3158 3213 Tuples are permitted to contain subtuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2element tuple whose first element is itself a tuple. 3159 3214 Note, a tuple is not a record (structure); 3160 a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure (see flattening coercion in Section 12.1).3215 a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure \see{flattening coercion in \VRef{s:FlatteningStructuring}}. 3161 3216 In essence, tuples are largely a compile time phenomenon, having little or no runtime presence. 3162 3217 … … 3166 3221 The general syntax of a tuple type is: 3167 3222 \begin{cfa} 3168 [ §\emph{typelist}§]3223 [ $\emph{typelist}$ ] 3169 3224 \end{cfa} 3170 3225 where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications. … … 3173 3228 [ unsigned int, char ] 3174 3229 [ double, double, double ] 3175 [ * int, int * ] §\C{// mix of CFA and ANSI}§3230 [ * int, int * ] $\C{// mix of CFA and ANSI}$ 3176 3231 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ] 3177 3232 \end{cfa} … … 3180 3235 Examples of declarations using tuple types are: 3181 3236 \begin{cfa} 3182 [ int, int ] x; §\C{// 2 element tuple, each element of type int}§3183 * [ char, char ] y; §\C{// pointer to a 2 element tuple}§3237 [ int, int ] x; $\C{// 2 element tuple, each element of type int}$ 3238 * [ char, char ] y; $\C{// pointer to a 2 element tuple}$ 3184 3239 [ [ int, int ] ] z ([ int, int ]); 3185 3240 \end{cfa} … … 3198 3253 [ int, int ] w1; 3199 3254 [ int, int, int ] w2; 3200 [ void ] f (int, int, int); §\C{// three input parameters of type int}§3201 [ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§3255 [ void ] f (int, int, int); $\C{// three input parameters of type int}$ 3256 [ void ] g ([ int, int, int ]); $\C{3 element tuple as input}$ 3202 3257 f( [ 1, 2, 3 ] ); 3203 3258 f( w1, 3 ); … … 3279 3334 [ int, int, int, int ] w = [ 1, 2, 3, 4 ]; 3280 3335 int x = 5; 3281 [ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§3336 [ x, w ] = [ w, x ]; $\C{// all four tuple coercions}$ 3282 3337 \end{cfa} 3283 3338 Starting on the righthand tuple in the last assignment statement, w is opened, producing a tuple of four values; … … 3285 3340 This tuple is then flattened, yielding ©[ 1, 2, 3, 4, 5 ]©, which is structured into ©[ 1, [ 2, 3, 4, 5 ] ]© to match the tuple type of the lefthand side. 3286 3341 The tuple ©[ 2, 3, 4, 5 ]© is then closed to create a tuple value. 3287 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using multiple assignment (see Section 14).3342 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using \Index{multiple assignment} \see{\VRef{s:TupleAssignment}}. 3288 3343 \begin{rationale} 3289 3344 A possible additional language extension is to use the structuring coercion for tuples to initialize a complex record with a tuple. … … 3296 3351 Mass assignment has the following form: 3297 3352 \begin{cfa} 3298 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;3353 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$; 3299 3354 \end{cfa} 3300 3355 \index{lvalue} … … 3336 3391 Multiple assignment has the following form: 3337 3392 \begin{cfa} 3338 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§];3393 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$ ]; 3339 3394 \end{cfa} 3340 3395 \index{lvalue} … … 3367 3422 both these examples produce indeterminate results: 3368 3423 \begin{cfa} 3369 f( x++, x++ ); §\C{// C routine call with side effects in arguments}§3370 [ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in righthand side of multiple assignment}§3424 f( x++, x++ ); $\C{// C routine call with side effects in arguments}$ 3425 [ v1, v2 ] = [ x++, x++ ]; $\C{// side effects in righthand side of multiple assignment}$ 3371 3426 \end{cfa} 3372 3427 … … 3377 3432 Cascade assignment has the following form: 3378 3433 \begin{cfa} 3379 §\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;3434 $\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$; 3380 3435 \end{cfa} 3381 3436 and it has the same parallel semantics as for mass and multiple assignment. … … 3424 3479 \begin{cfa} 3425 3480 int x = 1, y = 2, z = 3; 3426 sout  x ®® y ®®z;3481 sout  x @@ y @@ z; 3427 3482 \end{cfa} 3428 3483 & 3429 3484 \begin{cfa} 3430 3485 3431 cout << x ®<< " "® << y ®<< " "®<< z << endl;3486 cout << x @<< " "@ << y @<< " "@ << z << endl; 3432 3487 \end{cfa} 3433 3488 & … … 3438 3493 \\ 3439 3494 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3440 1 ® ®2® ®33495 1@ @2@ @3 3441 3496 \end{cfa} 3442 3497 & 3443 3498 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3444 1 ® ®2® ®33499 1@ @2@ @3 3445 3500 \end{cfa} 3446 3501 & 3447 3502 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3448 1 ® ®2® ®33503 1@ @2@ @3 3449 3504 \end{cfa} 3450 3505 \end{tabular} … … 3454 3509 \begin{cfa} 3455 3510 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ]; 3456 sout  t1  t2; §\C{// print tuples}§3511 sout  t1  t2; $\C{// print tuples}$ 3457 3512 \end{cfa} 3458 3513 \begin{cfa}[showspaces=true,aboveskip=0pt] 3459 1 ®, ®2®, ®3 4®, ®5®, ®63514 1@, @2@, @3 4@, @5@, @6 3460 3515 \end{cfa} 3461 3516 Finally, \CFA uses the logicalor operator for I/O as it is the lowestpriority \emph{overloadable} operator, other than assignment. … … 3466 3521 & 3467 3522 \begin{cfa} 3468 sout  x * 3  y + 1  z << 2  x == y  ®(®x  y®)®  ®(®x  y®)®  ®(®x > z ? 1 : 2®)®;3523 sout  x * 3  y + 1  z << 2  x == y  @(@x  y@)@  @(@x  y@)@  @(@x > z ? 1 : 2@)@; 3469 3524 \end{cfa} 3470 3525 \\ … … 3472 3527 & 3473 3528 \begin{cfa} 3474 cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x  y®)® << ®(®x  y®)® << ®(®x > z ? 1 : 2®)®<< endl;3529 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x  y@)@ << @(@x  y@)@ << @(@x > z ? 1 : 2@)@ << endl; 3475 3530 \end{cfa} 3476 3531 \\ … … 3507 3562 \\ 3508 3563 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3509 ®1® ®2.5® ®A® 3564 @1@ @2.5@ @A@ 3510 3565 3511 3566 … … 3513 3568 & 3514 3569 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3515 ®1® ®2.5® ®A® 3570 @1@ @2.5@ @A@ 3516 3571 3517 3572 … … 3519 3574 & 3520 3575 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3521 ®1® 3522 ®2.5® 3523 ®A® 3576 @1@ 3577 @2.5@ 3578 @A@ 3524 3579 \end{cfa} 3525 3580 \end{tabular} … … 3557 3612 3558 3613 \item 3559 {\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}} 3560 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@, where \lstinline[basicstyle=\tt]@»@ is a closing citation mark. 3561 \begin{cfa}[belowskip=0pt] 3614 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} a closing citation mark. 3615 \begin{cfa} 3562 3616 sout  1  ", x"  2  ". x"  3  "; x"  4  "! x"  5  "? x"  6  "% x" 3563  7  "¢ x"  8  "»x"  9  ") x"  10  "] x"  11  "} x";3564 \end{cfa} 3565 \begin{cfa}[ basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]3566 1 ®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}®x3567 \end{cfa} }%3568 3569 \item 3570 A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \ lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@, where \lstinline[basicstyle=\tt]@¡¿@ are inverted opening exclamation and question marks, and \lstinline[basicstyle=\tt]@«@is an opening citation mark.3617  7  "$\LstStringStyle{\textcent}$ x"  8  "$\LstStringStyle{\guillemotright}$ x"  9  ") x"  10  "] x"  11  "} x"; 3618 \end{cfa} 3619 \begin{cfa}[showspaces=true] 3620 1@,@ x 2@.@ x 3@;@ x 4@!@ x 5@?@ x 6@%@ x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9@)@ x 10@]@ x 11@}@ x 3621 \end{cfa} 3622 3623 \item 3624 A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{([\{=\$\textsterling\textyen\textexclamdown\textquestiondown\guillemotleft}, where \LstStringStyle{\textexclamdown\textquestiondown} are inverted opening exclamation and question marks, and \LstStringStyle{\guillemotleft} is an opening citation mark. 3571 3625 %$ 3572 \begin{cfa} [mathescape=off]3573 sout  "x ("  1  "x ["  2  "x {"  3  "x ="  4  "x $"  5  "x £"  6  "x ¥"3574  7  "x ¡"  8  "x ¿"  9  "x «"  10;3626 \begin{cfa} 3627 sout  "x ("  1  "x ["  2  "x {"  3  "x ="  4  "x $"  5  "x $\LstStringStyle{\textsterling}$"  6  "x $\LstStringStyle{\textyen}$" 3628  7  "x $\LstStringStyle{\textexclamdown}$"  8  "x $\LstStringStyle{\textquestiondown}$"  9  "x $\LstStringStyle{\guillemotleft}$"  10; 3575 3629 \end{cfa} 3576 3630 %$ 3577 \begin{cfa}[ mathescape=off,basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]3578 x ®(®1 x ®[®2 x ®{®3 x ®=®4 x ®$®5 x ®£®6 x ®¥®7 x ®¡®8 x ®¿®9 x ®«®103631 \begin{cfa}[showspaces=true] 3632 x @(@1 x @[@2 x @{@3 x @=@4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10 3579 3633 \end{cfa} 3580 3634 %$ 3581 3635 3582 3636 \item 3583 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true] @`'": \t\v\f\r\n@3584 \begin{cfa} [belowskip=0pt]3637 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n} 3638 \begin{cfa} 3585 3639 sout  "x`"  1  "`x'"  2  "'x\""  3  "\"x:"  4  ":x "  5  " x\t"  6  "\tx"; 3586 3640 \end{cfa} 3587 \begin{cfa}[ basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]3588 x ®`®1®`®x§\color{red}\texttt{'}§2§\color{red}\texttt{'}§x§\color{red}\texttt{"}§3§\color{red}\texttt{"}§x®:®4®:®x® ®5® ®x® ®6® ®x3641 \begin{cfa}[showspaces=true,showtabs=true] 3642 x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@ @6@ @x 3589 3643 \end{cfa} 3590 3644 3591 3645 \item 3592 3646 If a space is desired before or after one of the special string start/end characters, simply insert a space. 3593 \begin{cfa} [belowskip=0pt]3594 sout  "x ( §\color{red}\texttt{\textvisiblespace}§"  1  "§\color{red}\texttt{\textvisiblespace}§) x"  2  "§\color{red}\texttt{\textvisiblespace}§, x"  3  "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§"  4;3595 \end{cfa} 3596 \begin{cfa}[ basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]3597 x ( ® ®1® ®) x 2® ®, x 3® ®:x:® ®43647 \begin{cfa} 3648 sout  "x ($\R{\texttt{\textvisiblespace}}$"  1  "$\R{\texttt{\textvisiblespace}}$) x"  2  "$\R{\texttt{\textvisiblespace}}$, x"  3  "$\R{\texttt{\textvisiblespace}}$:x:$\R{\texttt{\textvisiblespace}}$"  4; 3649 \end{cfa} 3650 \begin{cfa}[showspaces=true,showtabs=true] 3651 x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4 3598 3652 \end{cfa} 3599 3653 \end{enumerate} … … 3608 3662 \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string. 3609 3663 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). 3610 \begin{cfa}[ mathescape=off,belowskip=0pt]3611 sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§3612 sout  1  2  3  " \""  ®sep® "\"";3664 \begin{cfa}[escapechar=off,belowskip=0pt] 3665 sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$ 3666 sout  1  2  3  " \""  @sep@  "\""; 3613 3667 \end{cfa} 3614 3668 %$ 3615 3669 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] 3616 1 ®, $®2®, $®3 ®", $"®3670 1@, $@2@, $@3 @", $"@ 3617 3671 \end{cfa} 3618 3672 %$ 3619 3673 \begin{cfa}[belowskip=0pt] 3620 sepSet( sout, " " ); §\C{// reset separator to " "}§3621 sout  1  2  3  " \""  ®sepGet( sout )® "\"";3674 sepSet( sout, " " ); $\C{// reset separator to " "}$ 3675 sout  1  2  3  " \""  @sepGet( sout )@  "\""; 3622 3676 \end{cfa} 3623 3677 \begin{cfa}[showspaces=true,aboveskip=0pt] 3624 1 ® ®2® ®3 ®" "®3678 1@ @2@ @3 @" "@ 3625 3679 \end{cfa} 3626 3680 ©sepGet© can be used to store a separator and then restore it: 3627 3681 \begin{cfa}[belowskip=0pt] 3628 char store[ ®sepSize®]; §\C{// sepSize is the maximum separator size}§3629 strcpy( store, sepGet( sout ) ); §\C{// copy current separator}§3630 sepSet( sout, "_" ); §\C{// change separator to underscore}§3682 char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$ 3683 strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$ 3684 sepSet( sout, "_" ); $\C{// change separator to underscore}$ 3631 3685 sout  1  2  3; 3632 3686 \end{cfa} 3633 3687 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3634 1 ®_®2®_®33688 1@_@2@_@3 3635 3689 \end{cfa} 3636 3690 \begin{cfa}[belowskip=0pt] 3637 sepSet( sout, store ); §\C{// change separator back to original}§3691 sepSet( sout, store ); $\C{// change separator back to original}$ 3638 3692 sout  1  2  3; 3639 3693 \end{cfa} 3640 3694 \begin{cfa}[showspaces=true,aboveskip=0pt] 3641 1 ® ®2® ®33695 1@ @2@ @3 3642 3696 \end{cfa} 3643 3697 … … 3646 3700 The tuple separatorstring can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). 3647 3701 \begin{cfa}[belowskip=0pt] 3648 sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§3649 sout  t1  t2  " \""  ®sepTuple® "\"";3702 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$ 3703 sout  t1  t2  " \""  @sepTuple@  "\""; 3650 3704 \end{cfa} 3651 3705 \begin{cfa}[showspaces=true,aboveskip=0pt] 3652 1 2 3 4 5 6 ®" "®3706 1 2 3 4 5 6 @" "@ 3653 3707 \end{cfa} 3654 3708 \begin{cfa}[belowskip=0pt] 3655 sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§3656 sout  t1  t2  " \""  ®sepGetTuple( sout )® "\"";3709 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$ 3710 sout  t1  t2  " \""  @sepGetTuple( sout )@  "\""; 3657 3711 \end{cfa} 3658 3712 \begin{cfa}[showspaces=true,aboveskip=0pt] 3659 1, 2, 3 4, 5, 6 ®", "®3713 1, 2, 3 4, 5, 6 @", "@ 3660 3714 \end{cfa} 3661 3715 As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it. … … 3664 3718 \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} toggle printing the separator. 3665 3719 \begin{cfa}[belowskip=0pt] 3666 sout  sepDisable  1  2  3; §\C{// turn off implicit separator}§3720 sout  sepDisable  1  2  3; $\C{// turn off implicit separator}$ 3667 3721 \end{cfa} 3668 3722 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3670 3724 \end{cfa} 3671 3725 \begin{cfa}[belowskip=0pt] 3672 sout  sepEnable  1  2  3; §\C{// turn on implicit separator}§3726 sout  sepEnable  1  2  3; $\C{// turn on implicit separator}$ 3673 3727 \end{cfa} 3674 3728 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3679 3733 \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} toggle printing the separator with respect to the next printed item, and then return to the global seperator setting. 3680 3734 \begin{cfa}[belowskip=0pt] 3681 sout  1  sepOff  2  3; §\C{// turn off implicit separator for the next item}§3735 sout  1  sepOff  2  3; $\C{// turn off implicit separator for the next item}$ 3682 3736 \end{cfa} 3683 3737 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3685 3739 \end{cfa} 3686 3740 \begin{cfa}[belowskip=0pt] 3687 sout  sepDisable  1  sepOn  2  3; §\C{// turn on implicit separator for the next item}§3741 sout  sepDisable  1  sepOn  2  3; $\C{// turn on implicit separator for the next item}$ 3688 3742 \end{cfa} 3689 3743 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3692 3746 The tuple separator also responses to being turned on and off. 3693 3747 \begin{cfa}[belowskip=0pt] 3694 sout  t1  sepOff  t2; §\C{// turn off implicit separator for the next item}§3748 sout  t1  sepOff  t2; $\C{// turn off implicit separator for the next item}$ 3695 3749 \end{cfa} 3696 3750 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3700 3754 use ©sep© to accomplish this functionality. 3701 3755 \begin{cfa}[belowskip=0pt] 3702 sout  sepOn  1  2  3  sepOn; §\C{// sepOn does nothing at start/end of line}§3756 sout  sepOn  1  2  3  sepOn; $\C{// sepOn does nothing at start/end of line}$ 3703 3757 \end{cfa} 3704 3758 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3706 3760 \end{cfa} 3707 3761 \begin{cfa}[belowskip=0pt] 3708 sout  sep  1  2  3  sep ; §\C{// use sep to print separator at start/end of line}§3762 sout  sep  1  2  3  sep ; $\C{// use sep to print separator at start/end of line}$ 3709 3763 \end{cfa} 3710 3764 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3711 ® ®1 2 3® ® 3765 @ @1 2 3@ @ 3712 3766 \end{cfa} 3713 3767 \end{enumerate} … … 3721 3775 \begin{enumerate}[parsep=0pt] 3722 3776 \item 3723 \Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, i.e.,ignore the remaining characters in the line.3777 \Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, \ie ignore the remaining characters in the line. 3724 3778 \item 3725 3779 \Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} reads the newline character, when reading single characters. … … 3729 3783 For example, in: 3730 3784 \begin{cfa} 3731 sin  i  ®nl® j;3732 1 ®2®3785 sin  i  @nl@  j; 3786 1 @2@ 3733 3787 3 3734 3788 \end{cfa} … … 3740 3794 \Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline. 3741 3795 \begin{cfa} 3742 sout  nl; §\C{// only print newline}§3743 sout  2; §\C{// implicit newline}§3744 sout  3  nl  4  nl; §\C{// terminating nl merged with implicit newline}§3745 sout  5  nl  nl; §\C{// again terminating nl merged with implicit newline}§3746 sout  6; §\C{// implicit newline}§3796 sout  nl; $\C{// only print newline}$ 3797 sout  2; $\C{// implicit newline}$ 3798 sout  3  nl  4  nl; $\C{// terminating nl merged with implicit newline}$ 3799 sout  5  nl  nl; $\C{// again terminating nl merged with implicit newline}$ 3800 sout  6; $\C{// implicit newline}$ 3747 3801 3748 3802 2 … … 3771 3825 0b0 0b11011 0b11011 0b11011 0b11011 3772 3826 sout  bin( 27HH )  bin( 27H )  bin( 27 )  bin( 27L ); 3773 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b ®(58 1s)®1001013827 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101 3774 3828 \end{cfa} 3775 3829 … … 3810 3864 \begin{cfa}[belowskip=0pt] 3811 3865 sout  upcase( bin( 27 ) )  upcase( hex( 27 ) )  upcase( 27.5e10 )  upcase( hex( 27.5 ) ); 3812 0 ®B®11011 0®X®1®B® 2.75®E®09 0®X®1.®B®8®P®+43866 0@B@11011 0@X@1@B@ 2.75@E@09 0@X@1.@B@8@P@+4 3813 3867 \end{cfa} 3814 3868 … … 3826 3880 \begin{cfa}[belowskip=0pt] 3827 3881 sout  0.  nodp( 0. )  27.0  nodp( 27.0 )  nodp( 27.5 ); 3828 0.0 ®0® 27.0 ®27®27.53882 0.0 @0@ 27.0 @27@ 27.5 3829 3883 \end{cfa} 3830 3884 … … 3833 3887 \begin{cfa}[belowskip=0pt] 3834 3888 sout  sign( 27 )  sign( 27 )  sign( 27. )  sign( 27. )  sign( 27.5 )  sign( 27.5 ); 3835 ®+®27 27 ®+®27.0 27.0 ®+®27.5 27.53889 @+@27 27 @+@27.0 27.0 @+@27.5 27.5 3836 3890 \end{cfa} 3837 3891 … … 3846 3900 \end{cfa} 3847 3901 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3848 ® ®34 ® ®34 343849 ® ®4.000000 ® ®4.000000 4.0000003850 ® ®ab ® ®ab ab3902 @ @34 @ @34 34 3903 @ @4.000000 @ @4.000000 4.000000 3904 @ @ab @ @ab ab 3851 3905 \end{cfa} 3852 3906 If the value is larger, it is printed without truncation, ignoring the ©minimum©. … … 3857 3911 \end{cfa} 3858 3912 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3859 3456 ®7® 345®67® 34®567®3860 3456 ®.® 345®6.® 34®56.®3861 abcd ®e® abc®de® ab®cde®3913 3456@7@ 345@67@ 34@567@ 3914 3456@.@ 345@6.@ 34@56.@ 3915 abcd@e@ abc@de@ ab@cde@ 3862 3916 \end{cfa} 3863 3917 … … 3868 3922 \end{cfa} 3869 3923 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3870 ®0®34 ®00®34 ®00000000®343924 @0@34 @00@34 @00000000@34 3871 3925 \end{cfa} 3872 3926 If the value is larger, it is printed without truncation, ignoring the ©precision©. … … 3883 3937 \end{cfa} 3884 3938 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3885 ® ® ®00000000®343939 @ @ @00000000@34 3886 3940 \end{cfa} 3887 3941 For floatingpoint types, ©precision© is the minimum number of digits after the decimal point. … … 3890 3944 \end{cfa} 3891 3945 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3892 27. ®500® 27.®5® 28. 27.®50000000®3893 \end{cfa} 3894 For the Cstring type, ©precision© is the maximum number of printed characters, so the string is trunca red if it exceeds the maximum.3946 27.@500@ 27.@5@ 28. 27.@50000000@ 3947 \end{cfa} 3948 For the Cstring type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum. 3895 3949 \begin{cfa}[belowskip=0pt] 3896 3950 sout  wd( 6,8, "abcd" )  wd( 6,8, "abcdefghijk" )  wd( 6,3, "abcd" ); … … 3908 3962 \end{cfa} 3909 3963 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3910 234.567 234.5 ®7® 234.®6® 23®5®3964 234.567 234.5@7@ 234.@6@ 23@5@ 3911 3965 \end{cfa} 3912 3966 If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits. … … 3915 3969 \end{cfa} 3916 3970 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3917 234567. 2.3457 ®e+05® 2.346®e+05® 2.35®e+05®3971 234567. 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@ 3918 3972 \end{cfa} 3919 3973 If ©significant© is greater than ©minimum©, it defines the number of printed characters. … … 3931 3985 \end{cfa} 3932 3986 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3933 27 ® ® 27.000000 27.500000 027 27.500® ®3987 27@ @ 27.000000 27.500000 027 27.500@ @ 3934 3988 \end{cfa} 3935 3989 … … 3938 3992 \begin{cfa}[belowskip=0pt] 3939 3993 sout  pad0( wd( 4, 27 ) )  pad0( wd( 4,3, 27 ) )  pad0( wd( 8,3, 27.5 ) ); 3940 ®00®27 ®0®27 ®00®27.5003994 @00@27 @0@27 @00@27.500 3941 3995 \end{cfa} 3942 3996 \end{enumerate} … … 4034 4088 \end{cfa} 4035 4089 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4036 ®abc ® 4037 ®abc ® 4038 ®xx® 4090 @abc @ 4091 @abc @ 4092 @xx@ 4039 4093 \end{cfa} 4040 4094 … … 4047 4101 \end{cfa} 4048 4102 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4049 ®abcd1233.456E+2® 4103 @abcd1233.456E+2@ 4050 4104 \end{cfa} 4051 4105 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types. … … 4060 4114 \end{cfa} 4061 4115 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4062 ® 75.35e4®254116 @ 75.35e4@ 25 4063 4117 \end{cfa} 4064 4118 … … 4072 4126 \end{cfa} 4073 4127 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4074 ®bca®xyz4128 @bca@xyz 4075 4129 \end{cfa} 4076 4130 … … 4084 4138 \end{cfa} 4085 4139 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4086 ®xyz®bca4140 @xyz@bca 4087 4141 \end{cfa} 4088 4142 \end{enumerate} … … 4101 4155 4102 4156 A type definition is different from a typedef in C because a typedef just creates an alias for a type, while Do.s type definition creates a distinct type. 4103 This means that users can define distinct function overloads for the new type (see Overloading for more information).4157 This means that users can define distinct function overloads for the new type \see{\VRef{s:Overloading} for more information}. 4104 4158 For example: 4105 4159 … … 4207 4261 \CFA supports C initialization of structures, but it also adds constructors for more advanced initialization. 4208 4262 Additionally, \CFA adds destructors that are called when a variable is deallocated (variable goes out of scope or object is deleted). 4209 These functions take a reference to the structure as a parameter (see References for more information).4263 These functions take a reference to the structure as a parameter \see{\VRef{s:PointerReference} for more information}. 4210 4264 4211 4265 \begin{figure} … … 4258 4312 4259 4313 \section{Overloading} 4314 \label{s:Overloading} 4260 4315 4261 4316 Overloading refers to the capability of a programmer to define and use multiple objects in a program with the same name. … … 4468 4523 For example, given 4469 4524 \begin{cfa} 4470 auto j = ®...®4525 auto j = @...@ 4471 4526 \end{cfa} 4472 4527 and the need to write a routine to compute using ©j© 4473 4528 \begin{cfa} 4474 void rtn( ®...®parm );4529 void rtn( @...@ parm ); 4475 4530 rtn( j ); 4476 4531 \end{cfa} … … 4713 4768 4714 4769 coroutine Fibonacci { 4715 int fn; §\C{// used for communication}§4770 int fn; $\C{// used for communication}$ 4716 4771 }; 4717 4772 void ?{}( Fibonacci * this ) { … … 4719 4774 } 4720 4775 void main( Fibonacci * this ) { 4721 int fn1, fn2; §\C{// retained between resumes}§4722 this>fn = 0; §\C{// case 0}§4776 int fn1, fn2; $\C{// retained between resumes}$ 4777 this>fn = 0; $\C{// case 0}$ 4723 4778 fn1 = this>fn; 4724 suspend(); §\C{// return to last resume}§4725 4726 this>fn = 1; §\C{// case 1}§4779 suspend(); $\C{// return to last resume}$ 4780 4781 this>fn = 1; $\C{// case 1}$ 4727 4782 fn2 = fn1; 4728 4783 fn1 = this>fn; 4729 suspend(); §\C{// return to last resume}§4730 4731 for ( ;; ) { §\C{// general case}§4784 suspend(); $\C{// return to last resume}$ 4785 4786 for ( ;; ) { $\C{// general case}$ 4732 4787 this>fn = fn1 + fn2; 4733 4788 fn2 = fn1; 4734 4789 fn1 = this>fn; 4735 suspend(); §\C{// return to last resume}§4790 suspend(); $\C{// return to last resume}$ 4736 4791 } // for 4737 4792 } 4738 4793 int next( Fibonacci * this ) { 4739 resume( this ); §\C{// transfer to last suspend}§4794 resume( this ); $\C{// transfer to last suspend}$ 4740 4795 return this>fn; 4741 4796 } … … 4964 5019 When building a \CFA module which needs to be callable from C code, users can use the tools to generate a header file suitable for including in these C files with all of the needed declarations. 4965 5020 4966 In order to interoperate with existing C code, \CFA files can still include header files, the contents of which will be enclosed in a C linkage section to indicate C calling conventions (see Interoperability for more information).5021 In order to interoperate with existing C code, \CFA files can still include header files, the contents of which will be enclosed in a C linkage section to indicate C calling conventions \see{\VRef{s:Interoperability} for more information}. 4967 5022 4968 5023 … … 6282 6337 In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as: 6283 6338 \begin{cfa} 6284 *? §\color{red}\textvisiblespace§*? §\C{// dereference operator, dereference operator}§6285 * §\color{red}\textvisiblespace§?*? §\C{// dereference, multiplication operator}§6339 *?$\R{\textvisiblespace}$*? $\C{// dereference operator, dereference operator}$ 6340 *$\R{\textvisiblespace}$?*? $\C{// dereference, multiplication operator}$ 6286 6341 \end{cfa} 6287 6342 By default, the first interpretation is selected, which does not yield a meaningful parse. … … 6292 6347 The ambiguity occurs when the deference operator has no parameters: 6293 6348 \begin{cfa} 6294 *?() §\color{red}\textvisiblespace...§;6295 *?() §\color{red}\textvisiblespace...§(...) ;6349 *?()$\R{\textvisiblespace...}$ ; 6350 *?()$\R{\textvisiblespace...}$(...) ; 6296 6351 \end{cfa} 6297 6352 requiring arbitrary whitespace lookahead for the routinecall parameterlist to disambiguate. … … 6301 6356 The remaining cases are with the increment/decrement operators and conditional expression, \eg: 6302 6357 \begin{cfa} 6303 i++? §\color{red}\textvisiblespace...§(...);6304 i?++ §\color{red}\textvisiblespace...§(...);6358 i++?$\R{\textvisiblespace...}$(...); 6359 i?++$\R{\textvisiblespace...}$(...); 6305 6360 \end{cfa} 6306 6361 requiring arbitrary whitespace lookahead for the operator parameterlist, even though that interpretation is an incorrect expression (juxtaposed identifiers). 6307 6362 Therefore, it is necessary to disambiguate these cases with a space: 6308 6363 \begin{cfa} 6309 i++ §\color{red}\textvisiblespace§? i : 0;6310 i? §\color{red}\textvisiblespace§++i : 0;6364 i++$\R{\textvisiblespace}$? i : 0; 6365 i?$\R{\textvisiblespace}$++i : 0; 6311 6366 \end{cfa} 6312 6367 … … 6321 6376 \begin{description} 6322 6377 \item[Change:] add new keywords \\ 6323 New keywords are added to \CFA (see~\VRef{s:CFAKeywords}).6378 New keywords are added to \CFA \see{\VRef{s:CFAKeywords}}. 6324 6379 \item[Rationale:] keywords added to implement new semantics of \CFA. 6325 6380 \item[Effect on original feature:] change to semantics of welldefined feature. \\ 6326 6381 Any \Celeven programs using these keywords as identifiers are invalid \CFA programs. 6327 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escapemechanism (see~\VRef{s:BackquoteIdentifiers}).6382 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escapemechanism \see{\VRef{s:BackquoteIdentifiers}}. 6328 6383 \item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare. 6329 6384 \end{description} … … 6335 6390 \eg: 6336 6391 \begin{cfa} 6337 x; §\C{// int x}§6338 *y; §\C{// int *y}§6339 f( p1, p2 ); §\C{// int f( int p1, int p2 );}§6340 g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§6392 x; $\C{// int x}$ 6393 *y; $\C{// int *y}$ 6394 f( p1, p2 ); $\C{// int f( int p1, int p2 );}$ 6395 g( p1, p2 ) int p1, p2; $\C{// int g( int p1, int p2 );}$ 6341 6396 \end{cfa} 6342 6397 \CFA continues to support K\&R routine definitions: 6343 6398 \begin{cfa} 6344 f( a, b, c ) §\C{// default int return}§6345 int a, b; char c §\C{// K\&R parameter declarations}§6399 f( a, b, c ) $\C{// default int return}$ 6400 int a, b; char c $\C{// K\&R parameter declarations}$ 6346 6401 { 6347 6402 ... … … 6362 6417 int rtn( int i ); 6363 6418 int rtn( char c ); 6364 rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§6419 rtn( 'x' ); $\C{// programmer expects 2nd rtn to be called}$ 6365 6420 \end{cfa} 6366 6421 \item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first. … … 6384 6439 \item[Change:] make string literals ©const©: 6385 6440 \begin{cfa} 6386 char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§6387 char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§6441 char * p = "abc"; $\C{// valid in C, deprecated in \CFA}$ 6442 char * q = expr ? "abc" : "de"; $\C{// valid in C, invalid in \CFA}$ 6388 6443 \end{cfa} 6389 6444 The type of a string literal is changed from ©[] char© to ©const [] char©. … … 6392 6447 \begin{cfa} 6393 6448 char * p = "abc"; 6394 p[0] = 'w'; §\C{// segment fault or change constant literal}§6449 p[0] = 'w'; $\C{// segment fault or change constant literal}$ 6395 6450 \end{cfa} 6396 6451 The same problem occurs when passing a string literal to a routine that changes its argument. … … 6404 6459 \item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope: 6405 6460 \begin{cfa} 6406 int i; §\C{// forward definition}§6407 int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§6408 int i = 0; §\C{// definition}§6461 int i; $\C{// forward definition}$ 6462 int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$ 6463 int i = 0; $\C{// definition}$ 6409 6464 \end{cfa} 6410 6465 is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed. … … 6412 6467 \begin{cfa} 6413 6468 struct X { int i; struct X *next; }; 6414 static struct X a; §\C{// forward definition}§6415 static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§6416 static struct X a = { 1, &b }; §\C{// definition}§6469 static struct X a; $\C{// forward definition}$ 6470 static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$ 6471 static struct X a = { 1, &b }; $\C{// definition}$ 6417 6472 \end{cfa} 6418 6473 \item[Rationale:] avoids having different initialization rules for builtin types and userdefined types. … … 6426 6481 \item[Change:] have ©struct© introduce a scope for nested types: 6427 6482 \begin{cfa} 6428 enum ®Colour®{ R, G, B, Y, C, M };6483 enum @Colour@ { R, G, B, Y, C, M }; 6429 6484 struct Person { 6430 enum ®Colour® { R, G, B }; §\C[7cm]{// nested type}§6431 struct Face { §\C{// nested type}§6432 ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§6485 enum @Colour@ { R, G, B }; $\C[7cm]{// nested type}$ 6486 struct Face { $\C{// nested type}$ 6487 @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$ 6433 6488 }; 6434 ®.Colour® shirt; §\C{// type defined outside (top level)}§6435 ®Colour® pants; §\C{// type defined same level}§6436 Face looks[10]; §\C{// type defined same level}§6489 @.Colour@ shirt; $\C{// type defined outside (top level)}$ 6490 @Colour@ pants; $\C{// type defined same level}$ 6491 Face looks[10]; $\C{// type defined same level}$ 6437 6492 }; 6438 ®Colour® c = R; §\C{// type/enum defined same level}§ 6439 Person ®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§6440 Person ®.®Face pretty; §\C{// type defined inside}\CRT§6493 @Colour@ c = R; $\C{// type/enum defined same level}$ 6494 Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$ 6495 Person@.@Face pretty; $\C{// type defined inside}\CRT$ 6441 6496 \end{cfa} 6442 6497 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outermost type, which is not useful and confusing. … … 6455 6510 \item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example: 6456 6511 \begin{cfa} 6457 struct Y; §\C{// struct Y and struct X are at the same scope}§6512 struct Y; $\C{// struct Y and struct X are at the same scope}$ 6458 6513 struct X { 6459 6514 struct Y { /* ... */ } y; … … 6470 6525 \begin{cfa} 6471 6526 void foo() { 6472 int * b = malloc( sizeof(int) ); §\C{// implicitly convert void * to int *}§6473 char * c = b; §\C{// implicitly convert int * to void *, and then void * to char *}§6527 int * b = malloc( sizeof(int) ); $\C{// implicitly convert void * to int *}$ 6528 char * c = b; $\C{// implicitly convert int * to void *, and then void * to char *}$ 6474 6529 } 6475 6530 \end{cfa} 6476 6531 \item[Rationale:] increase type safety 6477 6532 \item[Effect on original feature:] deletion of semantically welldefined feature. 6478 \item[Difficulty of converting:] requires adding a cast (see \VRef{s:StorageManagement} for better alternatives):6533 \item[Difficulty of converting:] requires adding a cast \see{\VRef{s:StorageManagement} for better alternatives}: 6479 6534 \begin{cfa} 6480 6535 int * b = (int *)malloc( sizeof(int) ); … … 6586 6641 \end{cquote} 6587 6642 For the prescribed headfiles, \CFA uses header interposition to wraps these includes in an ©extern "C"©; 6588 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).6643 hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}. 6589 6644 All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling. 6590 6645 This approach is different from \Index*[C++]{\CC{}} where the namemangling issue is handled internally in C headerfiles through checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers. … … 6649 6704 Typesafe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in 6650 6705 \begin{cfa} 6651 int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§6652 int * ip = malloc(); §\C{// \CFA typesafe version of C malloc}§6653 int * ip = alloc(); §\C{// \CFA typesafe uniform alloc}§6706 int * ip = (int *)malloc( sizeof(int) ); $\C{// C}$ 6707 int * ip = malloc(); $\C{// \CFA typesafe version of C malloc}$ 6708 int * ip = alloc(); $\C{// \CFA typesafe uniform alloc}$ 6654 6709 \end{cfa} 6655 6710 the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©. … … 6658 6713 \begin{cfa} 6659 6714 struct S { int i; } __attribute__(( aligned( 128 ) )); // cacheline alignment 6660 S * sp = malloc(); §\C{// honour type alignment}§6715 S * sp = malloc(); $\C{// honour type alignment}$ 6661 6716 \end{cfa} 6662 6717 the storage allocation is implicitly aligned to 128 rather than the default 16. … … 6673 6728 \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in 6674 6729 \begin{cfa} 6675 struct S { int i; }; §\C{// cacheline aglinment}§6730 struct S { int i; }; $\C{// cacheline alignment}$ 6676 6731 void ?{}( S & s, int i ) { s.i = i; } 6677 6732 // assume ?? operator for printing an S 6678 6733 6679 S & sp = * ®new®( 3 ); §\C{// call constructor after allocation}§6734 S & sp = *@new@( 3 ); $\C{// call constructor after allocation}$ 6680 6735 sout  sp.i; 6681 ®delete®( &sp );6682 6683 S * spa = ®anew®( 10, 5 ); §\C{// allocate array and initialize each array element}§6736 @delete@( &sp ); 6737 6738 S * spa = @anew@( 10, 5 ); $\C{// allocate array and initialize each array element}$ 6684 6739 for ( i; 10 ) sout  spa[i]  nonl; 6685 6740 sout  nl; 6686 ®adelete®( 10, spa );6741 @adelete@( 10, spa ); 6687 6742 \end{cfa} 6688 6743 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor. … … 6693 6748 extern "C" { 6694 6749 // C unsafe allocation 6695 void * malloc( size_t size ); §\indexc{malloc}§6696 void * calloc( size_t dim, size_t size ); §\indexc{calloc}§6697 void * realloc( void * ptr, size_t size ); §\indexc{realloc}§6698 void * memalign( size_t align, size_t size ); §\indexc{memalign}§6699 void * aligned_alloc( size_t align, size_t size ); §\indexc{aligned_alloc}§6700 int posix_memalign( void ** ptr, size_t align, size_t size ); §\indexc{posix_memalign}§6701 void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); §\indexc{cmemalign}§// CFA6750 void * malloc( size_t size );$\indexc{malloc}$ 6751 void * calloc( size_t dim, size_t size );$\indexc{calloc}$ 6752 void * realloc( void * ptr, size_t size );$\indexc{realloc}$ 6753 void * memalign( size_t align, size_t size );$\indexc{memalign}$ 6754 void * aligned_alloc( size_t align, size_t size );$\indexc{aligned_alloc}$ 6755 int posix_memalign( void ** ptr, size_t align, size_t size );$\indexc{posix_memalign}$ 6756 void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );$\indexc{cmemalign}$ // CFA 6702 6757 6703 6758 // C unsafe initialization/copy 6704 void * memset( void * dest, int c, size_t size ); §\indexc{memset}§6705 void * memcpy( void * dest, const void * src, size_t size ); §\indexc{memcpy}§6759 void * memset( void * dest, int c, size_t size );$\indexc{memset}$ 6760 void * memcpy( void * dest, const void * src, size_t size );$\indexc{memcpy}$ 6706 6761 } 6707 6762 … … 6709 6764 6710 6765 forall( dtype T  sized(T) ) { 6711 // §\CFA§safe equivalents, i.e., implicit size specification6766 // $\CFA$ safe equivalents, i.e., implicit size specification 6712 6767 T * malloc( void ); 6713 6768 T * calloc( size_t dim ); … … 6718 6773 int posix_memalign( T ** ptr, size_t align ); 6719 6774 6720 // §\CFA§safe general allocation, fill, resize, alignment, array6721 T * alloc( void ); §\indexc{alloc}§ §\C[3.5in]{// variable, T size}§6722 T * alloc( size_t dim ); §\C{// array[dim], T size elements}§6723 T * alloc( T ptr[], size_t dim ); §\C{// realloc array[dim], T size elements}§6724 6725 T * alloc_set( char fill ); §\indexc{alloc_set}§ §\C{// variable, T size, fill bytes with value}§6726 T * alloc_set( T fill ); §\C{// variable, T size, fill with value}§6727 T * alloc_set( size_t dim, char fill ); §\C{// array[dim], T size elements, fill bytes with value}§6728 T * alloc_set( size_t dim, T fill ); §\C{// array[dim], T size elements, fill elements with value}§6729 T * alloc_set( size_t dim, const T fill[] ); §\C{// array[dim], T size elements, fill elements with array}§6730 T * alloc_set( T ptr[], size_t dim, char fill ); §\C{// realloc array[dim], T size elements, fill bytes with value}§6731 6732 T * alloc_align( size_t align ); §\C{// aligned variable, T size}§6733 T * alloc_align( size_t align, size_t dim ); §\C{// aligned array[dim], T size elements}§6734 T * alloc_align( T ptr[], size_t align ); §\C{// realloc new aligned array}§6735 T * alloc_align( T ptr[], size_t align, size_t dim ); §\C{// realloc new aligned array[dim]}§6736 6737 T * alloc_align_set( size_t align, char fill ); §\C{// aligned variable, T size, fill bytes with value}§6738 T * alloc_align_set( size_t align, T fill ); §\C{// aligned variable, T size, fill with value}§6739 T * alloc_align_set( size_t align, size_t dim, char fill ); §\C{// aligned array[dim], T size elements, fill bytes with value}§6740 T * alloc_align_set( size_t align, size_t dim, T fill ); §\C{// aligned array[dim], T size elements, fill elements with value}§6741 T * alloc_align_set( size_t align, size_t dim, const T fill[] ); §\C{// aligned array[dim], T size elements, fill elements with array}§6742 T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§6743 6744 // §\CFA§safe initialization/copy, i.e., implicit size specification6745 T * memset( T * dest, char fill ); §\indexc{memset}§6746 T * memcpy( T * dest, const T * src ); §\indexc{memcpy}§6747 6748 // §\CFA§safe initialization/copy, i.e., implicit size specification, array types6775 // $\CFA$ safe general allocation, fill, resize, alignment, array 6776 T * alloc( void );$\indexc{alloc}$ $\C[3.5in]{// variable, T size}$ 6777 T * alloc( size_t dim ); $\C{// array[dim], T size elements}$ 6778 T * alloc( T ptr[], size_t dim ); $\C{// realloc array[dim], T size elements}$ 6779 6780 T * alloc_set( char fill );$\indexc{alloc_set}$ $\C{// variable, T size, fill bytes with value}$ 6781 T * alloc_set( T fill ); $\C{// variable, T size, fill with value}$ 6782 T * alloc_set( size_t dim, char fill ); $\C{// array[dim], T size elements, fill bytes with value}$ 6783 T * alloc_set( size_t dim, T fill ); $\C{// array[dim], T size elements, fill elements with value}$ 6784 T * alloc_set( size_t dim, const T fill[] ); $\C{// array[dim], T size elements, fill elements with array}$ 6785 T * alloc_set( T ptr[], size_t dim, char fill ); $\C{// realloc array[dim], T size elements, fill bytes with value}$ 6786 6787 T * alloc_align( size_t align ); $\C{// aligned variable, T size}$ 6788 T * alloc_align( size_t align, size_t dim ); $\C{// aligned array[dim], T size elements}$ 6789 T * alloc_align( T ptr[], size_t align ); $\C{// realloc new aligned array}$ 6790 T * alloc_align( T ptr[], size_t align, size_t dim ); $\C{// realloc new aligned array[dim]}$ 6791 6792 T * alloc_align_set( size_t align, char fill ); $\C{// aligned variable, T size, fill bytes with value}$ 6793 T * alloc_align_set( size_t align, T fill ); $\C{// aligned variable, T size, fill with value}$ 6794 T * alloc_align_set( size_t align, size_t dim, char fill ); $\C{// aligned array[dim], T size elements, fill bytes with value}$ 6795 T * alloc_align_set( size_t align, size_t dim, T fill ); $\C{// aligned array[dim], T size elements, fill elements with value}$ 6796 T * alloc_align_set( size_t align, size_t dim, const T fill[] ); $\C{// aligned array[dim], T size elements, fill elements with array}$ 6797 T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); $\C{// realloc new aligned array[dim], fill new bytes with value}$ 6798 6799 // $\CFA$ safe initialization/copy, i.e., implicit size specification 6800 T * memset( T * dest, char fill );$\indexc{memset}$ 6801 T * memcpy( T * dest, const T * src );$\indexc{memcpy}$ 6802 6803 // $\CFA$ safe initialization/copy, i.e., implicit size specification, array types 6749 6804 T * amemset( T dest[], char fill, size_t dim ); 6750 6805 T * amemcpy( T dest[], const T src[], size_t dim ); 6751 6806 } 6752 6807 6753 // §\CFA§allocation/deallocation and constructor/destructor, nonarray types6754 forall( dtype T  sized(T), ttype Params  { void ?{}( T &, Params ); } ) T * new( Params p ); §\indexc{new}§6755 forall( dtype T  sized(T)  { void ^?{}( T & ); } ) void delete( T * ptr ); §\indexc{delete}§6808 // $\CFA$ allocation/deallocation and constructor/destructor, nonarray types 6809 forall( dtype T  sized(T), ttype Params  { void ?{}( T &, Params ); } ) T * new( Params p );$\indexc{new}$ 6810 forall( dtype T  sized(T)  { void ^?{}( T & ); } ) void delete( T * ptr );$\indexc{delete}$ 6756 6811 forall( dtype T, ttype Params  sized(T)  { void ^?{}( T & ); void delete( Params ); } ) 6757 6812 void delete( T * ptr, Params rest ); 6758 6813 6759 // §\CFA§allocation/deallocation and constructor/destructor, array types6760 forall( dtype T  sized(T), ttype Params  { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p ); §\indexc{anew}§6761 forall( dtype T  sized(T)  { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] ); §\indexc{adelete}§6814 // $\CFA$ allocation/deallocation and constructor/destructor, array types 6815 forall( dtype T  sized(T), ttype Params  { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );$\indexc{anew}$ 6816 forall( dtype T  sized(T)  { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );$\indexc{adelete}$ 6762 6817 forall( dtype T  sized(T)  { void ^?{}( T & ); }, ttype Params  { void adelete( Params ); } ) 6763 6818 void adelete( size_t dim, T arr[], Params rest ); … … 6769 6824 \leavevmode 6770 6825 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6771 int ato( const char * ptr ); §\indexc{ato}§6826 int ato( const char * ptr );$\indexc{ato}$ 6772 6827 unsigned int ato( const char * ptr ); 6773 6828 long int ato( const char * ptr ); … … 6801 6856 \leavevmode 6802 6857 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6803 forall( otype T  { int ?<?( T, T ); } ) §\C{// location}§6804 T * bsearch( T key, const T * arr, size_t dim ); §\indexc{bsearch}§6805 6806 forall( otype T  { int ?<?( T, T ); } ) §\C{// position}§6858 forall( otype T  { int ?<?( T, T ); } ) $\C{// location}$ 6859 T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$ 6860 6861 forall( otype T  { int ?<?( T, T ); } ) $\C{// position}$ 6807 6862 unsigned int bsearch( T key, const T * arr, size_t dim ); 6808 6863 6809 6864 forall( otype T  { int ?<?( T, T ); } ) 6810 void qsort( const T * arr, size_t dim ); §\indexc{qsort}§6865 void qsort( const T * arr, size_t dim );$\indexc{qsort}$ 6811 6866 6812 6867 forall( otype E  { int ?<?( E, E ); } ) { 6813 E * bsearch( E key, const E * vals, size_t dim ); §\indexc{bsearch}§ §\C{// location}§6814 size_t bsearch( E key, const E * vals, size_t dim ); §\C{// position}§6815 E * bsearchl( E key, const E * vals, size_t dim ); §\indexc{bsearchl}§6868 E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ $\C{// location}$ 6869 size_t bsearch( E key, const E * vals, size_t dim );$\C{// position}$ 6870 E * bsearchl( E key, const E * vals, size_t dim );$\indexc{bsearchl}$ 6816 6871 size_t bsearchl( E key, const E * vals, size_t dim ); 6817 E * bsearchu( E key, const E * vals, size_t dim ); §\indexc{bsearchu}§6872 E * bsearchu( E key, const E * vals, size_t dim );$\indexc{bsearchu}$ 6818 6873 size_t bsearchu( E key, const E * vals, size_t dim ); 6819 6874 } … … 6829 6884 6830 6885 forall( otype E  { int ?<?( E, E ); } ) { 6831 void qsort( E * vals, size_t dim ); §\indexc{qsort}§6886 void qsort( E * vals, size_t dim );$\indexc{qsort}$ 6832 6887 } 6833 6888 \end{cfa} … … 6838 6893 \leavevmode 6839 6894 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6840 unsigned char abs( signed char ); §\indexc{abs}§6895 unsigned char abs( signed char );$\indexc{abs}$ 6841 6896 int abs( int ); 6842 6897 unsigned long int abs( long int ); … … 6857 6912 \leavevmode 6858 6913 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6859 void srandom( unsigned int seed ); §\indexc{srandom}§6860 char random( void ); §\indexc{random}§6861 char random( char u ); §\C{// [0,u)}§6862 char random( char l, char u ); §\C{// [l,u)}§6914 void srandom( unsigned int seed );$\indexc{srandom}$ 6915 char random( void );$\indexc{random}$ 6916 char random( char u ); $\C{// [0,u)}$ 6917 char random( char l, char u ); $\C{// [l,u)}$ 6863 6918 int random( void ); 6864 int random( int u ); §\C{// [0,u)}§6865 int random( int l, int u ); §\C{// [l,u)}§6919 int random( int u ); $\C{// [0,u)}$ 6920 int random( int l, int u ); $\C{// [l,u)}$ 6866 6921 unsigned int random( void ); 6867 unsigned int random( unsigned int u ); §\C{// [0,u)}§6868 unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u)}§6922 unsigned int random( unsigned int u ); $\C{// [0,u)}$ 6923 unsigned int random( unsigned int l, unsigned int u ); $\C{// [l,u)}$ 6869 6924 long int random( void ); 6870 long int random( long int u ); §\C{// [0,u)}§6871 long int random( long int l, long int u ); §\C{// [l,u)}§6925 long int random( long int u ); $\C{// [0,u)}$ 6926 long int random( long int l, long int u ); $\C{// [l,u)}$ 6872 6927 unsigned long int random( void ); 6873 unsigned long int random( unsigned long int u ); §\C{// [0,u)}§6874 unsigned long int random( unsigned long int l, unsigned long int u ); §\C{// [l,u)}§6875 float random( void ); §\C{// [0.0, 1.0)}§6876 double random( void ); §\C{// [0.0, 1.0)}§6877 float _Complex random( void ); §\C{// [0.0, 1.0)+[0.0, 1.0)i}§6878 double _Complex random( void ); §\C{// [0.0, 1.0)+[0.0, 1.0)i}§6879 long double _Complex random( void ); §\C{// [0.0, 1.0)+[0.0, 1.0)i}§6928 unsigned long int random( unsigned long int u ); $\C{// [0,u)}$ 6929 unsigned long int random( unsigned long int l, unsigned long int u ); $\C{// [l,u)}$ 6930 float random( void ); $\C{// [0.0, 1.0)}$ 6931 double random( void ); $\C{// [0.0, 1.0)}$ 6932 float _Complex random( void ); $\C{// [0.0, 1.0)+[0.0, 1.0)i}$ 6933 double _Complex random( void ); $\C{// [0.0, 1.0)+[0.0, 1.0)i}$ 6934 long double _Complex random( void ); $\C{// [0.0, 1.0)+[0.0, 1.0)i}$ 6880 6935 \end{cfa} 6881 6936 … … 6885 6940 \leavevmode 6886 6941 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6887 forall( otype T  { int ?<?( T, T ); } ) T min( T t1, T t2 ); §\indexc{min}§6888 forall( otype T  { int ?>?( T, T ); } ) T max( T t1, T t2 ); §\indexc{max}§6889 forall( otype T  { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val ); §\indexc{clamp}§6890 forall( otype T ) void swap( T * t1, T * t2 ); §\indexc{swap}§6942 forall( otype T  { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$ 6943 forall( otype T  { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$ 6944 forall( otype T  { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$ 6945 forall( otype T ) void swap( T * t1, T * t2 );$\indexc{swap}$ 6891 6946 \end{cfa} 6892 6947 … … 6902 6957 \leavevmode 6903 6958 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6904 float ?%?( float, float ); §\indexc{fmod}§6959 float ?%?( float, float );$\indexc{fmod}$ 6905 6960 float fmod( float, float ); 6906 6961 double ?%?( double, double ); … … 6909 6964 long double fmod( long double, long double ); 6910 6965 6911 float remainder( float, float ); §\indexc{remainder}§6966 float remainder( float, float );$\indexc{remainder}$ 6912 6967 double remainder( double, double ); 6913 6968 long double remainder( long double, long double ); 6914 6969 6915 float remquo( float, float, int * ); §\indexc{remquo}§6970 float remquo( float, float, int * );$\indexc{remquo}$ 6916 6971 double remquo( double, double, int * ); 6917 6972 long double remquo( long double, long double, int * ); … … 6920 6975 [ int, long double ] remquo( long double, long double ); 6921 6976 6922 float div( float, float, int * ); §\indexc{div}§ §\C{// alternative name for remquo}§6977 float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$ 6923 6978 double div( double, double, int * ); 6924 6979 long double div( long double, long double, int * ); … … 6927 6982 [ int, long double ] div( long double, long double ); 6928 6983 6929 float fma( float, float, float ); §\indexc{fma}§6984 float fma( float, float, float );$\indexc{fma}$ 6930 6985 double fma( double, double, double ); 6931 6986 long double fma( long double, long double, long double ); 6932 6987 6933 float fdim( float, float ); §\indexc{fdim}§6988 float fdim( float, float );$\indexc{fdim}$ 6934 6989 double fdim( double, double ); 6935 6990 long double fdim( long double, long double ); 6936 6991 6937 float nan( const char * ); §\indexc{nan}§6992 float nan( const char * );$\indexc{nan}$ 6938 6993 double nan( const char * ); 6939 6994 long double nan( const char * ); … … 6945 7000 \leavevmode 6946 7001 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6947 float exp( float ); §\indexc{exp}§7002 float exp( float );$\indexc{exp}$ 6948 7003 double exp( double ); 6949 7004 long double exp( long double ); … … 6952 7007 long double _Complex exp( long double _Complex ); 6953 7008 6954 float exp2( float ); §\indexc{exp2}§7009 float exp2( float );$\indexc{exp2}$ 6955 7010 double exp2( double ); 6956 7011 long double exp2( long double ); … … 6959 7014 // long double _Complex exp2( long double _Complex ); 6960 7015 6961 float expm1( float ); §\indexc{expm1}§7016 float expm1( float );$\indexc{expm1}$ 6962 7017 double expm1( double ); 6963 7018 long double expm1( long double ); 6964 7019 6965 float pow( float, float ); §\indexc{pow}§7020 float pow( float, float );$\indexc{pow}$ 6966 7021 double pow( double, double ); 6967 7022 long double pow( long double, long double ); … … 6976 7031 \leavevmode 6977 7032 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6978 float log( float ); §\indexc{log}§7033 float log( float );$\indexc{log}$ 6979 7034 double log( double ); 6980 7035 long double log( long double ); … … 6983 7038 long double _Complex log( long double _Complex ); 6984 7039 6985 float log2( float ); §\indexc{log2}§7040 float log2( float );$\indexc{log2}$ 6986 7041 double log2( double ); 6987 7042 long double log2( long double ); … … 6990 7045 // long double _Complex log2( long double _Complex ); 6991 7046 6992 float log10( float ); §\indexc{log10}§7047 float log10( float );$\indexc{log10}$ 6993 7048 double log10( double ); 6994 7049 long double log10( long double ); … … 6997 7052 // long double _Complex log10( long double _Complex ); 6998 7053 6999 float log1p( float ); §\indexc{log1p}§7054 float log1p( float );$\indexc{log1p}$ 7000 7055 double log1p( double ); 7001 7056 long double log1p( long double ); 7002 7057 7003 int ilogb( float ); §\indexc{ilogb}§7058 int ilogb( float );$\indexc{ilogb}$ 7004 7059 int ilogb( double ); 7005 7060 int ilogb( long double ); 7006 7061 7007 float logb( float ); §\indexc{logb}§7062 float logb( float );$\indexc{logb}$ 7008 7063 double logb( double ); 7009 7064 long double logb( long double ); 7010 7065 7011 float sqrt( float ); §\indexc{sqrt}§7066 float sqrt( float );$\indexc{sqrt}$ 7012 7067 double sqrt( double ); 7013 7068 long double sqrt( long double ); … … 7016 7071 long double _Complex sqrt( long double _Complex ); 7017 7072 7018 float cbrt( float ); §\indexc{cbrt}§7073 float cbrt( float );$\indexc{cbrt}$ 7019 7074 double cbrt( double ); 7020 7075 long double cbrt( long double ); 7021 7076 7022 float hypot( float, float ); §\indexc{hypot}§7077 float hypot( float, float );$\indexc{hypot}$ 7023 7078 double hypot( double, double ); 7024 7079 long double hypot( long double, long double ); … … 7030 7085 \leavevmode 7031 7086 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7032 float sin( float ); §\indexc{sin}§7087 float sin( float );$\indexc{sin}$ 7033 7088 double sin( double ); 7034 7089 long double sin( long double ); … … 7037 7092 long double _Complex sin( long double _Complex ); 7038 7093 7039 float cos( float ); §\indexc{cos}§7094 float cos( float );$\indexc{cos}$ 7040 7095 double cos( double ); 7041 7096 long double cos( long double ); … … 7044 7099 long double _Complex cos( long double _Complex ); 7045 7100 7046 float tan( float ); §\indexc{tan}§7101 float tan( float );$\indexc{tan}$ 7047 7102 double tan( double ); 7048 7103 long double tan( long double ); … … 7051 7106 long double _Complex tan( long double _Complex ); 7052 7107 7053 float asin( float ); §\indexc{asin}§7108 float asin( float );$\indexc{asin}$ 7054 7109 double asin( double ); 7055 7110 long double asin( long double ); … … 7058 7113 long double _Complex asin( long double _Complex ); 7059 7114 7060 float acos( float ); §\indexc{acos}§7115 float acos( float );$\indexc{acos}$ 7061 7116 double acos( double ); 7062 7117 long double acos( long double ); … … 7065 7120 long double _Complex acos( long double _Complex ); 7066 7121 7067 float atan( float ); §\indexc{atan}§7122 float atan( float );$\indexc{atan}$ 7068 7123 double atan( double ); 7069 7124 long double atan( long double ); … … 7072 7127 long double _Complex atan( long double _Complex ); 7073 7128 7074 float atan2( float, float ); §\indexc{atan2}§7129 float atan2( float, float );$\indexc{atan2}$ 7075 7130 double atan2( double, double ); 7076 7131 long double atan2( long double, long double ); 7077 7132 7078 float atan( float, float ); §\C{// alternative name for atan2}§7079 double atan( double, double ); §\indexc{atan}§7133 float atan( float, float ); $\C{// alternative name for atan2}$ 7134 double atan( double, double );$\indexc{atan}$ 7080 7135 long double atan( long double, long double ); 7081 7136 \end{cfa} … … 7086 7141 \leavevmode 7087 7142 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7088 float sinh( float ); §\indexc{sinh}§7143 float sinh( float );$\indexc{sinh}$ 7089 7144 double sinh( double ); 7090 7145 long double sinh( long double ); … … 7093 7148 long double _Complex sinh( long double _Complex ); 7094 7149 7095 float cosh( float ); §\indexc{cosh}§7150 float cosh( float );$\indexc{cosh}$ 7096 7151 double cosh( double ); 7097 7152 long double cosh( long double ); … … 7100 7155 long double _Complex cosh( long double _Complex ); 7101 7156 7102 float tanh( float ); §\indexc{tanh}§7157 float tanh( float );$\indexc{tanh}$ 7103 7158 double tanh( double ); 7104 7159 long double tanh( long double ); … … 7107 7162 long double _Complex tanh( long double _Complex ); 7108 7163 7109 float asinh( float ); §\indexc{asinh}§7164 float asinh( float );$\indexc{asinh}$ 7110 7165 double asinh( double ); 7111 7166 long double asinh( long double ); … … 7114 7169 long double _Complex asinh( long double _Complex ); 7115 7170 7116 float acosh( float ); §\indexc{acosh}§7171 float acosh( float );$\indexc{acosh}$ 7117 7172 double acosh( double ); 7118 7173 long double acosh( long double ); … … 7121 7176 long double _Complex acosh( long double _Complex ); 7122 7177 7123 float atanh( float ); §\indexc{atanh}§7178 float atanh( float );$\indexc{atanh}$ 7124 7179 double atanh( double ); 7125 7180 long double atanh( long double ); … … 7134 7189 \leavevmode 7135 7190 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7136 float erf( float ); §\indexc{erf}§7191 float erf( float );$\indexc{erf}$ 7137 7192 double erf( double ); 7138 7193 long double erf( long double ); … … 7141 7196 long double _Complex erf( long double _Complex ); 7142 7197 7143 float erfc( float ); §\indexc{erfc}§7198 float erfc( float );$\indexc{erfc}$ 7144 7199 double erfc( double ); 7145 7200 long double erfc( long double ); … … 7148 7203 long double _Complex erfc( long double _Complex ); 7149 7204 7150 float lgamma( float ); §\indexc{lgamma}§7205 float lgamma( float );$\indexc{lgamma}$ 7151 7206 double lgamma( double ); 7152 7207 long double lgamma( long double ); … … 7155 7210 long double lgamma( long double, int * ); 7156 7211 7157 float tgamma( float ); §\indexc{tgamma}§7212 float tgamma( float );$\indexc{tgamma}$ 7158 7213 double tgamma( double ); 7159 7214 long double tgamma( long double ); … … 7165 7220 \leavevmode 7166 7221 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7167 float floor( float ); §\indexc{floor}§7222 float floor( float );$\indexc{floor}$ 7168 7223 double floor( double ); 7169 7224 long double floor( long double ); 7170 7225 7171 float ceil( float ); §\indexc{ceil}§7226 float ceil( float );$\indexc{ceil}$ 7172 7227 double ceil( double ); 7173 7228 long double ceil( long double ); 7174 7229 7175 float trunc( float ); §\indexc{trunc}§7230 float trunc( float );$\indexc{trunc}$ 7176 7231 double trunc( double ); 7177 7232 long double trunc( long double ); 7178 7233 7179 float rint( float ); §\indexc{rint}§7234 float rint( float );$\indexc{rint}$ 7180 7235 long double rint( long double ); 7181 7236 long int rint( float ); … … 7186 7241 long long int rint( long double ); 7187 7242 7188 long int lrint( float ); §\indexc{lrint}§7243 long int lrint( float );$\indexc{lrint}$ 7189 7244 long int lrint( double ); 7190 7245 long int lrint( long double ); … … 7193 7248 long long int llrint( long double ); 7194 7249 7195 float nearbyint( float ); §\indexc{nearbyint}§7250 float nearbyint( float );$\indexc{nearbyint}$ 7196 7251 double nearbyint( double ); 7197 7252 long double nearbyint( long double ); 7198 7253 7199 float round( float ); §\indexc{round}§7254 float round( float );$\indexc{round}$ 7200 7255 long double round( long double ); 7201 7256 long int round( float ); … … 7206 7261 long long int round( long double ); 7207 7262 7208 long int lround( float ); §\indexc{lround}§7263 long int lround( float );$\indexc{lround}$ 7209 7264 long int lround( double ); 7210 7265 long int lround( long double ); … … 7219 7274 \leavevmode 7220 7275 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7221 float copysign( float, float ); §\indexc{copysign}§7276 float copysign( float, float );$\indexc{copysign}$ 7222 7277 double copysign( double, double ); 7223 7278 long double copysign( long double, long double ); 7224 7279 7225 float frexp( float, int * ); §\indexc{frexp}§7280 float frexp( float, int * );$\indexc{frexp}$ 7226 7281 double frexp( double, int * ); 7227 7282 long double frexp( long double, int * ); 7228 7283 7229 float ldexp( float, int ); §\indexc{ldexp}§7284 float ldexp( float, int );$\indexc{ldexp}$ 7230 7285 double ldexp( double, int ); 7231 7286 long double ldexp( long double, int ); 7232 7287 7233 [ float, float ] modf( float ); §\indexc{modf}§7288 [ float, float ] modf( float );$\indexc{modf}$ 7234 7289 float modf( float, float * ); 7235 7290 [ double, double ] modf( double ); … … 7238 7293 long double modf( long double, long double * ); 7239 7294 7240 float nextafter( float, float ); §\indexc{nextafter}§7295 float nextafter( float, float );$\indexc{nextafter}$ 7241 7296 double nextafter( double, double ); 7242 7297 long double nextafter( long double, long double ); 7243 7298 7244 float nexttoward( float, long double ); §\indexc{nexttoward}§7299 float nexttoward( float, long double );$\indexc{nexttoward}$ 7245 7300 double nexttoward( double, long double ); 7246 7301 long double nexttoward( long double, long double ); 7247 7302 7248 float scalbn( float, int ); §\indexc{scalbn}§7303 float scalbn( float, int );$\indexc{scalbn}$ 7249 7304 double scalbn( double, int ); 7250 7305 long double scalbn( long double, int ); 7251 7306 7252 float scalbln( float, long int ); §\indexc{scalbln}§7307 float scalbln( float, long int );$\indexc{scalbln}$ 7253 7308 double scalbln( double, long int ); 7254 7309 long double scalbln( long double, long int ); … … 7267 7322 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7268 7323 struct Duration { 7269 int64_t tv; §\C{// nanoseconds}§7324 int64_t tv; $\C{// nanoseconds}$ 7270 7325 }; 7271 7326 … … 7397 7452 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7398 7453 struct Time { 7399 uint64_t tv; §\C{// nanoseconds since UNIX epoch}§7454 uint64_t tv; $\C{// nanoseconds since UNIX epoch}$ 7400 7455 }; 7401 7456 … … 7468 7523 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7469 7524 struct Clock { 7470 Duration offset; §\C{// for virtual clock: contains offset from realtime}§7471 int clocktype; §\C{// implementation only 1 (virtual), CLOCK\_REALTIME}§7525 Duration offset; $\C{// for virtual clock: contains offset from realtime}$ 7526 int clocktype; $\C{// implementation only 1 (virtual), CLOCK\_REALTIME}$ 7472 7527 }; 7473 7528 … … 7477 7532 void ?{}( Clock & clk, Duration adj ); 7478 7533 7479 Duration getResNsec(); §\C{// with nanoseconds}§7480 Duration getRes(); §\C{// without nanoseconds}§7481 7482 Time getTimeNsec(); §\C{// with nanoseconds}§7483 Time getTime(); §\C{// without nanoseconds}§7534 Duration getResNsec(); $\C{// with nanoseconds}$ 7535 Duration getRes(); $\C{// without nanoseconds}$ 7536 7537 Time getTimeNsec(); $\C{// with nanoseconds}$ 7538 Time getTime(); $\C{// without nanoseconds}$ 7484 7539 Time getTime( Clock & clk ); 7485 7540 Time ?()( Clock & clk ); … … 7497 7552 7498 7553 \begin{cfa} 7499 void ?{}( Int * this ); §\C{// constructor/destructor}§7554 void ?{}( Int * this ); $\C{// constructor/destructor}$ 7500 7555 void ?{}( Int * this, Int init ); 7501 7556 void ?{}( Int * this, zero_t ); … … 7506 7561 void ^?{}( Int * this ); 7507 7562 7508 Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§7563 Int ?=?( Int * lhs, Int rhs ); $\C{// assignment}$ 7509 7564 Int ?=?( Int * lhs, long int rhs ); 7510 7565 Int ?=?( Int * lhs, unsigned long int rhs ); … … 7523 7578 unsigned long int narrow( Int val ); 7524 7579 7525 int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§7580 int ?==?( Int oper1, Int oper2 ); $\C{// comparison}$ 7526 7581 int ?==?( Int oper1, long int oper2 ); 7527 7582 int ?==?( long int oper2, Int oper1 ); … … 7559 7614 int ?>=?( unsigned long int oper1, Int oper2 ); 7560 7615 7561 Int +?( Int oper ); §\C{// arithmetic}§7616 Int +?( Int oper ); $\C{// arithmetic}$ 7562 7617 Int ?( Int oper ); 7563 7618 Int ~?( Int oper ); … … 7641 7696 Int ?>>=?( Int * lhs, mp_bitcnt_t shift ); 7642 7697 7643 Int abs( Int oper ); §\C{// number functions}§7698 Int abs( Int oper ); $\C{// number functions}$ 7644 7699 Int fact( unsigned long int N ); 7645 7700 Int gcd( Int oper1, Int oper2 ); … … 7653 7708 Int sqrt( Int oper ); 7654 7709 7655 forall( dtype istype  istream( istype ) ) istype * ??( istype * is, Int * mp ); §\C{// I/O}§7710 forall( dtype istype  istream( istype ) ) istype * ??( istype * is, Int * mp ); $\C{// I/O}$ 7656 7711 forall( dtype ostype  ostream( ostype ) ) ostype * ??( ostype * os, Int mp ); 7657 7712 \end{cfa} … … 7664 7719 \hline 7665 7720 \begin{cfa} 7666 #include <gmp> §\indexc{gmp}§7721 #include <gmp>$\indexc{gmp}$ 7667 7722 int main( void ) { 7668 7723 sout  "Factorial Numbers"; … … 7678 7733 & 7679 7734 \begin{cfa} 7680 #include <gmp.h> §\indexc{gmp.h}§7735 #include <gmp.h>$\indexc{gmp.h}$ 7681 7736 int main( void ) { 7682 ®gmp_printf®( "Factorial Numbers\n" );7683 ®mpz_t®fact;7684 ®mpz_init_set_ui®( fact, 1 );7685 ®gmp_printf®( "%d %Zd\n", 0, fact );7737 @gmp_printf@( "Factorial Numbers\n" ); 7738 @mpz_t@ fact; 7739 @mpz_init_set_ui@( fact, 1 ); 7740 @gmp_printf@( "%d %Zd\n", 0, fact ); 7686 7741 for ( unsigned int i = 1; i <= 40; i += 1 ) { 7687 ®mpz_mul_ui®( fact, fact, i );7688 ®gmp_printf®( "%d %Zd\n", i, fact );7742 @mpz_mul_ui@( fact, fact, i ); 7743 @gmp_printf@( "%d %Zd\n", i, fact ); 7689 7744 } 7690 7745 } … … 7751 7806 \begin{cfa}[belowskip=0pt] 7752 7807 // implementation 7753 struct Rational { §\indexc{Rational}§7754 long int numerator, denominator; §\C{// invariant: denominator > 0}§7808 struct Rational {$\indexc{Rational}$ 7809 long int numerator, denominator; $\C{// invariant: denominator > 0}$ 7755 7810 }; // Rational 7756 7811 7757 Rational rational(); §\C{// constructors}§7812 Rational rational(); $\C{// constructors}$ 7758 7813 Rational rational( long int n ); 7759 7814 Rational rational( long int n, long int d ); … … 7761 7816 void ?{}( Rational * r, one_t ); 7762 7817 7763 long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§7818 long int numerator( Rational r ); $\C{// numerator/denominator getter/setter}$ 7764 7819 long int numerator( Rational r, long int n ); 7765 7820 long int denominator( Rational r ); 7766 7821 long int denominator( Rational r, long int d ); 7767 7822 7768 int ?==?( Rational l, Rational r ); §\C{// comparison}§7823 int ?==?( Rational l, Rational r ); $\C{// comparison}$ 7769 7824 int ?!=?( Rational l, Rational r ); 7770 7825 int ?<?( Rational l, Rational r ); … … 7773 7828 int ?>=?( Rational l, Rational r ); 7774 7829 7775 Rational ?( Rational r ); §\C{// arithmetic}§7830 Rational ?( Rational r ); $\C{// arithmetic}$ 7776 7831 Rational ?+?( Rational l, Rational r ); 7777 7832 Rational ??( Rational l, Rational r ); … … 7779 7834 Rational ?/?( Rational l, Rational r ); 7780 7835 7781 double widen( Rational r ); §\C{// conversion}§7836 double widen( Rational r ); $\C{// conversion}$ 7782 7837 Rational narrow( double f, long int md ); 7783 7838
Note: See TracChangeset
for help on using the changeset viewer.