Changes in / [f4eb705:d4a4b17]
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/LaTeXmacros/common.tex
rf4eb705 rd4a4b17 11 11 %% Created On : Sat Apr 9 10:06:17 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Mon Feb 8 21:45:41202114 %% Update Count : 5 2213 %% Last Modified On : Wed Feb 3 10:57:33 2021 14 %% Update Count : 508 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 57 57 \pdfstringdefDisableCommands{ 58 58 \def\CFA{\CFL} 59 \def\Celeven{C11\xspace}60 59 \def\CC{C++\xspace} 61 60 \def\CCeleven{C++11\xspace} … … 64 63 \def\CCtwenty{C++20\xspace} 65 64 \def\Csharp{C\#\xspace} 66 \def\lstinline{\xspace} % must use {} as delimiters, e.g., \lstinline{...}65 \def\lstinline{\xspace} % must use {} as delimiters, e.g., \lstinline{...} 67 66 }{} 68 67 } … … 98 97 \vskip 50\p@ 99 98 }} 100 \renewcommand\section{\@startsection{section}{1}{\z@}{-3. 0ex \@plus -1ex \@minus -.2ex}{1.5ex \@plus .2ex}{\normalfont\large\bfseries}}101 \renewcommand\subsection{\@startsection{subsection}{2}{\z@}{- 2.75ex \@plus -1ex \@minus -.2ex}{1.25ex \@plus .2ex}{\normalfont\normalsize\bfseries}}99 \renewcommand\section{\@startsection{section}{1}{\z@}{-3.5ex \@plus -1ex \@minus -.2ex}{1.75ex \@plus .2ex}{\normalfont\large\bfseries}} 100 \renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-3.25ex \@plus -1ex \@minus -.2ex}{1.5ex \@plus .2ex}{\normalfont\normalsize\bfseries}} 102 101 \renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}} 103 102 \renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}} … … 252 251 \newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}} 253 252 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}} 254 \newcommand{\LstStringStyle}[1]{{\lst@basicstyle{\lst@stringstyle{#1}}}}255 253 256 254 \newlength{\gcolumnposn} % temporary hack because lstlisting does not handle tabs correctly … … 278 276 xleftmargin=\parindentlnth, % indent code to paragraph indentation 279 277 extendedchars=true, % allow ASCII characters in the range 128-255 280 escapechar= \$, % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-'281 mathescape= false, % LaTeX math escape in CFA code $...$278 escapechar=§, % LaTeX escape in CFA code §...§ (section symbol), emacs: C-q M-' 279 mathescape=true, % LaTeX math escape in CFA code $...$ 282 280 keepspaces=true, % 283 281 showstringspaces=false, % do not show spaces with cup … … 297 295 \lstset{ 298 296 language=CFA, 299 moredelim=**[is][\color{red}]{@}{@}, % red highlighting @...@ 300 %moredelim=**[is][\color{red}]{®}{®}, % red highlighting ®...® (registered trademark symbol) emacs: C-q M-. 301 %moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ 302 %moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting ¢...¢ (cent symbol) emacs: C-q M-" 303 %moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ 297 moredelim=**[is][\color{red}]{®}{®}, % red highlighting ®...® (registered trademark symbol) emacs: C-q M-. 298 moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ 299 moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting ¢...¢ (cent symbol) emacs: C-q M-" 300 moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ 301 % replace/adjust listing characters that look bad in sanserif 302 add to literate={`}{\ttfamily\upshape\hspace*{-0.1ex}`}1 304 303 }% lstset 305 304 \lstset{#1} -
doc/theses/fangren_yu_COOP_F20/Report.tex
rf4eb705 rd4a4b17 102 102 \CFA language, developed by the Programming Language Group at the University of Waterloo, has a long history, with the initial language design in 1992 by Glen Ditchfield~\cite{Ditchfield92} and the first proof-of-concept compiler built in 2003 by Richard Bilson~\cite{Bilson03}. Many new features have been added to the language over time, but the core of \CFA's type-system --- parametric functions introduced by the @forall@ clause (hence the name of the language) providing parametric overloading --- remains mostly unchanged. 103 103 104 The current \CFA reference compiler, @cfa-cc@, is designed using the visitor pattern~\cite{vistorpattern} over an abstract syntax tree (AST), where multiple passes over the AST modify it for subsequent passes. @cfa-cc@ still includes many parts taken directly from the original Bilson implementation, which served as the starting point for this enhancement work to the type system. Unfortunately, the prior implementation did not provide the efficiency required for the language to be practical: a \CFA source file of approximately 1000 lines of code can take multiple minutes to compile. The cause of the problem is that the old compiler used inefficient data structures and algorithms for expression resolution, which involved significant copying and redundant work.104 The current \CFA reference compiler, @cfa-cc@, is designed using the visitor pattern~\cite{vistorpattern} over an abstract syntax tree (AST), where multiple passes over the AST modify it for subsequent passes. @cfa-cc@ still includes many parts taken directly from the original Bilson implementation, which served as the starting point for this enhancement work to the type system. Unfortunately, the prior implementation did not provide the efficiency required for the language to be practical: a \CFA source file of approximately 1000 lines of code can take a multiple minutes to compile. The cause of the problem is that the old compiler used inefficient data structures and algorithms for expression resolution, which involved significant copying and redundant work. 105 105 106 106 This report presents a series of optimizations to the performance-critical parts of the resolver, with a major rework of the compiler data-structures using a functional-programming approach to reduce memory complexity. The improvements were suggested by running the compiler builds with a performance profiler against the \CFA standard-library source-code and a test suite to find the most underperforming components in the compiler algorithm. … … 122 122 \end{itemize} 123 123 124 The resolver algorithm, designed for overload resolution, allows a significant amount of codereused, and hence copying, for the intermediate representations, especially in the following two places:124 The resolver algorithm, designed for overload resolution, uses a significant amount of reused, and hence copying, for the intermediate representations, especially in the following two places: 125 125 \begin{itemize} 126 126 \item … … 301 301 forall( dtype T | sized( T ) ) 302 302 T * malloc( void ) { return (T *)malloc( sizeof(T) ); } // call C malloc 303 int * i = malloc(); // type deduced from left-hand size $\ (\Rightarrow\)$ no size argument or return cast303 int * i = malloc(); // type deduced from left-hand size $\Rightarrow$ no size argument or return cast 304 304 \end{cfa} 305 305 An unbound return-type is problematic in resolver complexity because a single match of a function call with an unbound return type may create multiple candidates. In the worst case, consider a function declared that returns any @otype@ (defined \VPageref{otype}): … … 432 432 \begin{cfa} 433 433 void f( int ); 434 double g$ \(_1\)$( int );435 int g$ \(_2\)$( long );434 double g$_1$( int ); 435 int g$_2$( long ); 436 436 f( g( 42 ) ); 437 437 \end{cfa} -
doc/user/figures/Cdecl.fig
rf4eb705 rd4a4b17 19 19 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 20 20 2850 1200 3600 1200 3600 1350 2850 1350 2850 1200 21 4 1 0 50 -1 4 1 10.0000 2 120 90 2925 1325 0\00122 4 1 0 50 -1 4 1 10.0000 2 120 90 3075 1325 1\00123 4 1 0 50 -1 4 1 10.0000 2 120 90 3225 1325 2\00124 4 1 0 50 -1 4 1 10.0000 2 120 90 3375 1325 3\00125 4 1 0 50 -1 4 1 10.0000 2 120 90 3525 1325 4\00121 4 1 0 50 -1 4 10 0.0000 2 120 90 2925 1325 0\001 22 4 1 0 50 -1 4 10 0.0000 2 120 90 3075 1325 1\001 23 4 1 0 50 -1 4 10 0.0000 2 120 90 3225 1325 2\001 24 4 1 0 50 -1 4 10 0.0000 2 120 90 3375 1325 3\001 25 4 1 0 50 -1 4 10 0.0000 2 120 90 3525 1325 4\001 26 26 -6 27 27 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 … … 55 55 1 1 1.00 45.00 60.00 56 56 2550 1275 2850 1275 57 4 1 0 50 -1 4 1 10.0000 2 120 90 1350 1650 0\00158 4 1 0 50 -1 4 1 10.0000 2 120 90 1500 1650 1\00159 4 1 0 50 -1 4 1 10.0000 2 120 90 1650 1650 2\00160 4 1 0 50 -1 4 1 10.0000 2 120 90 1800 1650 3\00161 4 1 0 50 -1 4 1 10.0000 2 120 90 1950 1650 4\00162 4 1 0 50 -1 4 1 10.0000 2 90 90 1200 1325 x\00163 4 1 0 50 -1 4 1 10.0000 2 90 90 2400 1325 x\00157 4 1 0 50 -1 4 10 0.0000 2 120 90 1350 1650 0\001 58 4 1 0 50 -1 4 10 0.0000 2 120 90 1500 1650 1\001 59 4 1 0 50 -1 4 10 0.0000 2 120 90 1650 1650 2\001 60 4 1 0 50 -1 4 10 0.0000 2 120 90 1800 1650 3\001 61 4 1 0 50 -1 4 10 0.0000 2 120 90 1950 1650 4\001 62 4 1 0 50 -1 4 10 0.0000 2 90 90 1200 1325 x\001 63 4 1 0 50 -1 4 10 0.0000 2 90 90 2400 1325 x\001 -
doc/user/user.tex
rf4eb705 rd4a4b17 11 11 %% Created On : Wed Apr 6 14:53:29 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Mon Feb 8 21:53:31 202114 %% Update Count : 432713 %% Last Modified On : Mon Oct 5 08:57:29 2020 14 %% Update Count : 3998 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 underscore50 % removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR51 % AFTER HYPERREF.52 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}53 54 \setlength{\topmargin}{-0.45in} % move running title into header55 \setlength{\headsep}{0.25in}56 57 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%58 59 39 \newcommand{\CFALatin}{} 60 40 % inline code ©...© (copyright symbol) emacs: C-q M-) … … 66 46 % math escape $...$ (dollar symbol) 67 47 \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 underscore 59 % removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR 60 % AFTER HYPERREF. 61 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}} 62 63 \setlength{\topmargin}{-0.45in} % move running title into header 64 \setlength{\headsep}{0.25in} 65 66 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 67 68 68 \CFAStyle % use default CFA format-style 69 \lstset{language=CFA} % CFA default lnaguage70 69 \lstnewenvironment{C++}[1][] % use C++ style 71 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{ @}{@},#1}}70 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}} 72 71 {} 73 72 … … 82 81 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}} 83 82 \newcommand{\R}[1]{\Textbf{#1}} 84 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}85 83 \newcommand{\B}[1]{{\Textbf[blue]{#1}}} 86 84 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}} … … 106 104 \author{ 107 105 \huge \CFA Team \medskip \\ 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 106 \Large Andrew Beach, Richard Bilson, Peter A. Buhr, Thierry Delisle, \smallskip \\ 107 \Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Rob Schluntz 111 108 }% author 112 109 … … 147 144 \section{Introduction} 148 145 149 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose concurrentprogramming-language, designed as an evolutionary step forward for the C programming language.146 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed as an evolutionary step forward for the C programming language. 150 147 The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers. 151 148 % Any language feature that is not described here can be assumed to be using the standard \Celeven syntax. 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.149 \CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance. 153 150 Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible. 154 151 The primary new features include polymorphic routines and types, exceptions, concurrency, and modules. … … 160 157 instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features. 161 158 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 control-flow capabilities on top of a highly popular programming language allowing immediate dissemination.163 159 164 160 \Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C. … … 169 165 For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result. 170 166 \begin{center} 171 \begin{tabular}{@{}l@{\hspace{1 em}}l@{\hspace{1em}}l@{}}172 \multicolumn{1}{c@{\hspace{1 em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\173 \begin{cfa} 174 #include <stdio.h> $\indexc{stdio.h}$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}§ 175 171 176 172 int main( void ) { 177 173 int x = 0, y = 1, z = 2; 178 @printf( "%d %d %d\n", x, y, z );@174 ®printf( "%d %d %d\n", x, y, z );® 179 175 } 180 176 \end{cfa} 181 177 & 182 178 \begin{cfa} 183 #include <fstream> $\indexc{fstream}$179 #include <fstream>§\indexc{fstream}§ 184 180 185 181 int main( void ) { 186 182 int x = 0, y = 1, z = 2; 187 @sout | x | y | z;@$\indexc{sout}$183 ®sout | x | y | z;®§\indexc{sout}§ 188 184 } 189 185 \end{cfa} 190 186 & 191 187 \begin{cfa} 192 #include <iostream> $\indexc{iostream}$188 #include <iostream>§\indexc{iostream}§ 193 189 using namespace std; 194 190 int main() { 195 191 int x = 0, y = 1, z = 2; 196 @cout<<x<<" "<<y<<" "<<z<<endl;@192 ®cout<<x<<" "<<y<<" "<<z<<endl;® 197 193 } 198 194 \end{cfa} 199 195 \end{tabular} 200 196 \end{center} 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}.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}). 202 198 203 199 … … 214 210 \section{Why fix C?} 215 211 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 operating-systems.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 operating-systems. 217 213 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more. 218 214 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. 219 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is the only language of choice.220 The TIOBE index~\cite{TIOBE} for February 202 1 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.215 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice. 216 The TIOBE index~\cite{TIOBE} for February 2020 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. 221 217 The top 4 rankings over the past 35 years are: 222 218 \begin{center} 223 219 \setlength{\tabcolsep}{10pt} 224 220 \begin{tabular}{@{}rcccccccc@{}} 225 & 202 1 & 2016 & 2011 & 2006 & 2001 & 1996 & 1991 & 1986\\ \hline226 \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\\221 & 2020 & 2015 & 2010 & 2005 & 2000 & 1995 & 1990 & 1985 \\ \hline 222 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 \\ 230 226 \end{tabular} 231 227 \end{center} … … 236 232 As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way. 237 233 \CC~\cite{C++14,C++} is an example of a similar project; 238 however, it largely extended the C language, and did not address m anyof C's existing problems.\footnote{%234 however, it largely extended the C language, and did not address most of C's existing problems.\footnote{% 239 235 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.} 240 236 \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 language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language. … … 245 241 246 242 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 language-features. 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. 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. 249 247 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 language-features. 250 248 While some may argue that modern language-features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today. … … 253 251 \section{History} 254 252 255 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \Index*{K-W 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{}}}. 253 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \Index*{K-W 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{}}.) 256 255 The first \CFA implementation of these extensions was by \Index*{Rodolfo Esteves}\index{Esteves, Rodolfo}~\cite{Esteves04}. 257 256 258 257 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name): 259 258 \begin{cfa} 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}$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}§ 262 261 \end{cfa} 263 262 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions. 264 263 \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}. 265 264 However, at that time, there was little interesting in extending C, so work did not continue. 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 code-base, so the \CFA project was restarted in 2015.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 code-bases, so the \CFA project has been restarted. 267 266 268 267 … … 274 273 This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features. 275 274 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself. 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 orvery low cost.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. 277 276 Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backward-compatible} features. 278 277 … … 287 286 288 287 double key = 5.0, vals[10] = { /* 10 sorted floating values */ }; 289 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$288 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§ 290 289 \end{cfa} 291 290 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers: … … 296 295 297 296 forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) { 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}$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}§ 302 301 int posn = bsearch( 5.0, vals, 10 ); 303 302 \end{cfa} … … 311 310 \begin{cfa} 312 311 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); } 313 int * ip = malloc(); $\C{// select type and size from left-hand side}$312 int * ip = malloc(); §\C{// select type and size from left-hand side}§ 314 313 double * dp = malloc(); 315 314 struct S {...} * sp = malloc(); … … 320 319 However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC. 321 320 For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©. 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}}. 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}}. 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 {\CFA Compilation}346 \section[Compiling a CFA Program]{Compiling a \CFA Program} 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©}$ [ gcc/$\CFA{}$-options ] [ C/$\CFA{}$ source-files ] [ 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] 350 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] [ C/§\CFA{}§ source-files ] [ assembler/loader files ] 351 \end{cfa} 352 \CFA programs having the following ©gcc© flags turned on: 353 \begin{description} 356 354 \item 357 355 \Indexc{-std=gnu11}\index{compilation option!-std=gnu11@{©-std=gnu11©}} … … 361 359 Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files. 362 360 \end{description} 363 364 \CFA has the following new options: 365 \begin{description}[topsep=0pt] 361 The following new \CFA options are available: 362 \begin{description} 366 363 \item 367 364 \Indexc{-CFA}\index{compilation option!-CFA@©-CFA©} 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.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. 369 366 The generated code starts with the standard \CFA \Index{prelude}. 370 371 \item372 \Indexc{-XCFA}\index{compilation option!-XCFA@©-XCFA©}373 Pass next flag as-is to the ©cfa-cpp© translator (see details below).374 367 375 368 \item 376 369 \Indexc{-debug}\index{compilation option!-debug@©-debug©} 377 370 The program is linked with the debugging version of the runtime system. 378 The debug version performs runtime checks to aidthe debugging phase of a \CFA program, but can substantially slow program execution.371 The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution. 379 372 The runtime checks should only be removed after the program is completely debugged. 380 373 \textbf{This option is the default.} … … 406 399 \item 407 400 \Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©} 408 Do not supply ©extern "C"© wrappers for \Celeven standard include files \see{\VRef{s:StandardHeaders}}.401 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}). 409 402 \textbf{This option is \emph{not} the default.} 410 403 \end{comment} … … 437 430 \begin{cfa} 438 431 #ifndef __CFORALL__ 439 #include <stdio.h> $\indexc{stdio.h}$ $\C{// C header file}$432 #include <stdio.h>§\indexc{stdio.h}§ §\C{// C header file}§ 440 433 #else 441 #include <fstream> $\indexc{fstream}$ $\C{// \CFA header file}$434 #include <fstream>§\indexc{fstream}§ §\C{// \CFA header file}§ 442 435 #endif 443 436 \end{cfa} … … 445 438 446 439 The \CFA translator has multiple steps. 447 The following flags control how the tran slator works, the stages run, and printing within a stage.440 The following flags control how the tranlator works, the stages run, and printing within a stage. 448 441 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 prelude452 cfa $test$.cfa -XCFA -P -XCFA parse -XCFA -n # show program parse without prelude453 \end{lstlisting}454 442 \begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt] 455 443 \item 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© 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 463 447 \item 464 448 \Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks … … 470 454 \Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude 471 455 \item 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{--deterministic-out}\index{translator option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output 456 \Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, generate prototypes for prelude functions 475 457 \item 476 458 \Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of: 477 459 \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt] 478 460 \item 461 \Indexc{altexpr}\index{translator option!-P@{©-P©}!©altexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, alternatives for expressions 462 \item 479 463 \Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, as codegen rather than AST 480 464 \item 465 \Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, AST after parsing 466 \item 467 \Indexc{astdecl}\index{translator option!-P@{©-P©}!©astdecl©}\index{translator option!--print@{©-print©}!©astdecl©} \, AST after declaration validation pass 468 \item 481 469 \Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, AST on error 482 470 \item 471 \Indexc{astexpr}\index{translator option!-P@{©-P©}!©astexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, AST after expression analysis 472 \item 473 \Indexc{astgen}\index{translator option!-P@{©-P©}!©astgen©}\index{translator option!--print@{©-print©}!©astgen©} \, AST after instantiate generics 474 \item 475 \Indexc{box}\index{translator option!-P@{©-P©}!©box©}\index{translator option!--print@{©-print©}!©box©} \, before box step 476 \item 477 \Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, after ctor/dtor are replaced 478 \item 479 \Indexc{codegen}\index{translator option!-P@{©-P©}!©codegen©}\index{translator option!--print@{©-print©}!©codegen©} \, before code generation 480 \item 483 481 \Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, code property statistics 484 482 \item 485 483 \Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, yacc (parsing) debug information 486 484 \item 487 \Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag 485 \Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ascodegen flag 486 \item 487 \Indexc{resolver}\index{translator option!-P@{©-P©}!©resolver©}\index{translator option!--print@{©-print©}!©resolver©} \, before resolver step 488 488 \item 489 489 \Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance … … 491 491 \Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, resolver steps 492 492 \item 493 \Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, symbol table events 494 \item 493 495 \Indexc{tree}\index{translator option!-P@{©-P©}!©tree©}\index{translator option!--print@{©-print©}!©tree©} \, parse tree 494 496 \item 495 \Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, AST after parsing496 \item497 \Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, symbol table events498 \item499 \Indexc{altexpr}\index{translator option!-P@{©-P©}!©altexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, alternatives for expressions500 \item501 \Indexc{astdecl}\index{translator option!-P@{©-P©}!©astdecl©}\index{translator option!--print@{©-print©}!©astdecl©} \, AST after declaration validation pass502 \item503 \Indexc{resolver}\index{translator option!-P@{©-P©}!©resolver©}\index{translator option!--print@{©-print©}!©resolver©} \, before resolver step504 \item505 \Indexc{astexpr}\index{translator option!-P@{©-P©}!©astexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, AST after expression analysis506 \item507 \Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, after ctor/dtor are replaced508 \item509 497 \Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, after tuple expansion 510 \item511 \Indexc{astgen}\index{translator option!-P@{©-P©}!©astgen©}\index{translator option!--print@{©-print©}!©astgen©} \, AST after instantiate generics512 \item513 \Indexc{box}\index{translator option!-P@{©-P©}!©box©}\index{translator option!--print@{©-print©}!©box©} \, before box step514 \item515 \Indexc{codegen}\index{translator option!-P@{©-P©}!©codegen©}\index{translator option!--print@{©-print©}!©codegen©} \, before code generation516 498 \end{description} 517 499 \item 518 500 \Indexc{--prelude-dir} <directory> \, prelude directory for debug/nodebug 519 501 \item 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©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none© 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©} <option-list> \, enable profiling information: 503 \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt] 504 \item 505 \Indexc{counters,heap,time,all,none} 506 \end{description} 521 507 \item 522 508 \Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree … … 527 513 \label{s:BackquoteIdentifiers} 528 514 529 \CFA introduces several new keywords \see{\VRef{s:CFAKeywords}}that can clash with existing C variable-names in legacy code.515 \CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code. 530 516 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism: 531 517 \begin{cfa} 532 int @``@otype = 3; $\C{// make keyword an identifier}$533 double @``@forall = 3.5;518 int ®``®otype = 3; §\C{// make keyword an identifier}§ 519 double ®``®forall = 3.5; 534 520 \end{cfa} 535 521 536 522 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 non-keyword name. 537 \VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files \see{\VRef{s:StandardHeaders}}can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.523 \VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©. 538 524 Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience. 539 525 … … 541 527 \begin{cfa} 542 528 // include file uses the CFA keyword "with". 543 #if ! defined( with ) $\C{// nesting ?}$544 #define with @``@with $\C{// make keyword an identifier}$529 #if ! defined( with ) §\C{// nesting ?}§ 530 #define with ®``®with §\C{// make keyword an identifier}§ 545 531 #define __CFA_BFD_H__ 546 532 #endif 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}$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}§ 549 535 #undef with 550 536 #undef __CFA_BFD_H__ … … 558 544 \section{Constant Underscores} 559 545 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}$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}§ 572 558 \end{cfa} 573 559 The rules for placement of underscores are: … … 588 574 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). 589 575 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©.591 576 592 577 593 578 \section{Exponentiation Operator} 594 579 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©.580 C, \CC, and Java (and many 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. 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)©. 598 583 599 584 There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. … … 602 587 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. 603 588 \begin{cfa} 604 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.1605 | (1.0f+2.0fi) @\@(3.0f+2.0fi);606 1 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@-0.015625 18.3791736799526 0.264715-1.1922i589 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 590 | (1.0f+2.0fi) ®\® (3.0f+2.0fi); 591 1 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i 607 592 \end{cfa} 608 593 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. 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 594 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©. 611 595 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available. 612 596 \begin{cfa} 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 );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 ); 617 601 \end{cfa} 618 602 The user type ©T© must define multiplication, one (©1©), and ©*©. … … 625 609 626 610 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}} 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. 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. 645 628 646 629 647 630 %\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}} 648 631 \subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}} 649 \label{s:caseClause}650 632 651 633 C restricts the ©case© clause of a ©switch© statement to a single value. … … 658 640 \begin{cfa} 659 641 switch ( i ) { 660 case @1, 3, 5@:642 case ®1, 3, 5®: 661 643 ... 662 case @2, 4, 6@:644 case ®2, 4, 6®: 663 645 ... 664 646 } … … 688 670 \begin{cfa} 689 671 switch ( i ) { 690 case @1~5:@ $\C{// 1, 2, 3, 4, 5}$672 case ®1~5:® §\C{// 1, 2, 3, 4, 5}§ 691 673 ... 692 case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$674 case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§ 693 675 ... 694 676 } … … 696 678 Lists of subranges are also allowed. 697 679 \begin{cfa} 698 case @1~5, 12~21, 35~42@:680 case ®1~5, 12~21, 35~42®: 699 681 \end{cfa} 700 682 … … 740 722 if ( argc == 3 ) { 741 723 // open output file 742 @// open input file743 @} else if ( argc == 2 ) {744 @// open input file (duplicate)745 746 @} else {724 ®// open input file 725 ®} else if ( argc == 2 ) { 726 ®// open input file (duplicate) 727 728 ®} else { 747 729 // usage message 748 730 } … … 751 733 \end{cquote} 752 734 In this example, case 2 is always done if case 3 is done. 753 This control flow is difficult to simulate with ©if©statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.735 This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine. 754 736 C also uses fall-through to handle multiple case-values resulting in the same action: 755 737 \begin{cfa} 756 738 switch ( i ) { 757 @case 1: case 3: case 5:@// odd values739 ®case 1: case 3: case 5:® // odd values 758 740 // odd action 759 741 break; 760 @case 2: case 4: case 6:@// even values742 ®case 2: case 4: case 6:® // even values 761 743 // even action 762 744 break; 763 745 } 764 746 \end{cfa} 765 This situation better handled without fall-through by allowing a list of case values \see{\VRef{s:caseClause}}.766 While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from mostprogramming languages with a ©switch© statement.747 However, this situation is handled in other languages without fall-through by allowing a list of case values. 748 While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement. 767 749 Hence, default fall-through 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 fall-through. 768 750 … … 774 756 if ( j < k ) { 775 757 ... 776 @case 1:@// transfer into "if" statement758 ®case 1:® // transfer into "if" statement 777 759 ... 778 760 } // if … … 780 762 while ( j < 5 ) { 781 763 ... 782 @case 3:@// transfer into "while" statement764 ®case 3:® // transfer into "while" statement 783 765 ... 784 766 } // while 785 767 } // switch 786 768 \end{cfa} 787 Th is usage branchesinto 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.769 The problem with this usage is branching into 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. 789 771 The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning. 790 There are fewarguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.772 There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it. 791 773 Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}: 792 774 \begin{cfa} … … 812 794 \item 813 795 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. 814 Mostprogramming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.796 Virtually all programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list. 815 797 The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected; 816 798 hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics. … … 821 803 \begin{cfa} 822 804 switch ( x ) { 823 @int y = 1;@ $\C{// unreachable initialization}$824 @x = 7;@ $\C{// unreachable code without label/branch}$805 ®int y = 1;® §\C{// unreachable initialization}§ 806 ®x = 7;® §\C{// unreachable code without label/branch}§ 825 807 case 0: ... 826 808 ... 827 @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$809 ®int z = 0;® §\C{// unreachable initialization, cannot appear after case}§ 828 810 z = 2; 829 811 case 1: 830 @x = z;@ $\C{// without fall through, z is uninitialized}$812 ®x = z;® §\C{// without fall through, z is uninitialized}§ 831 813 } 832 814 \end{cfa} 833 815 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. 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 fall -through to case 3, ©z© is uninitialized.836 The key observation is that the ©switch© statement branches into acontrol structure, \ie there are multiple entry points into its statement body.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 through to case 3, ©z© is uninitialized. 818 The key observation is that the ©switch© statement branches into control structure, \ie there are multiple entry points into its statement body. 837 819 \end{enumerate} 838 820 … … 860 842 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg: 861 843 \begin{cfa} 862 @choose@( i ) {844 ®choose® ( i ) { 863 845 case 1: case 2: case 3: 864 846 ... 865 @// implicit end of switch (break)866 @case 5:847 ®// implicit end of switch (break) 848 ®case 5: 867 849 ... 868 @fallthru@; $\C{// explicit fall through}$850 ®fallthru®; §\C{// explicit fall through}§ 869 851 case 7: 870 852 ... 871 @break@ $\C{// explicit end of switch (redundant)}$853 ®break® §\C{// explicit end of switch (redundant)}§ 872 854 default: 873 855 j = 3; 874 856 } 875 857 \end{cfa} 876 Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses .858 Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses; 877 859 An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause. 878 860 An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement. … … 890 872 \begin{cfa} 891 873 switch ( x ) { 892 @int i = 0;@ $\C{// allowed only at start}$874 ®int i = 0;® §\C{// allowed only at start}§ 893 875 case 0: 894 876 ... 895 @int j = 0;@ $\C{// disallowed}$877 ®int j = 0;® §\C{// disallowed}§ 896 878 case 1: 897 879 { 898 @int k = 0;@ $\C{// allowed at different nesting levels}$880 ®int k = 0;® §\C{// allowed at different nesting levels}§ 899 881 ... 900 @case 2:@ $\C{// disallow case in nested statements}$882 ®case 2:® §\C{// disallow case in nested statements}§ 901 883 } 902 884 ... … … 915 897 case 3: 916 898 if ( ... ) { 917 ... @fallthru;@// goto case 4899 ... ®fallthru;® // goto case 4 918 900 } else { 919 901 ... … … 930 912 choose ( ... ) { 931 913 case 3: 932 ... @fallthrough common;@914 ... ®fallthrough common;® 933 915 case 4: 934 ... @fallthrough common;@935 936 @common:@// below fallthrough916 ... ®fallthrough common;® 917 918 ®common:® // below fallthrough 937 919 // at case-clause level 938 920 ... // common code for cases 3/4 … … 950 932 for ( ... ) { 951 933 // multi-level transfer 952 ... @fallthru common;@934 ... ®fallthru common;® 953 935 } 954 936 ... 955 937 } 956 938 ... 957 @common:@// below fallthrough939 ®common:® // below fallthrough 958 940 // at case-clause level 959 941 \end{cfa} … … 966 948 967 949 \begin{figure} 968 \begin{tabular}{@{}l @{\hspace{25pt}}|l@{}}969 \multicolumn{1}{ @{}c@{\hspace{25pt}}|}{loop control} & \multicolumn{1}{c@{}}{output} \\950 \begin{tabular}{@{}l|l@{}} 951 \multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\ 970 952 \hline 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; }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; } 991 973 enum { N = 10 }; 992 for ( @N@) { sout | "N"; }993 for ( @i; N@) { sout | i; }994 for ( @i; N -~ 0@) { sout | i; }974 for ( ®N® ) { sout | "N"; } 975 for ( ®i; N® ) { sout | i; } 976 for ( ®i; N -~ 0® ) { sout | i; } 995 977 const int start = 3, comp = 10, inc = 2; 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; }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; } 1014 996 \end{cfa} 1015 997 & … … 1074 1056 \subsection{Loop Control} 1075 1057 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©/©do-while© loop-control is augmented as follows \see{examples in \VRef[Figure]{f:LoopControlExamples}}: 1079 \begin{itemize}[itemsep=0pt] 1058 The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}). 1059 \begin{itemize} 1060 \item 1061 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M. 1062 \item 1063 An empty conditional implies comparison value of ©1© (true). 1064 \item 1065 A comparison N is implicit up-to exclusive range [0,N©®)®©. 1066 \item 1067 A comparison ©=© N is implicit up-to inclusive range [0,N©®]®©. 1068 \item 1069 The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©. 1070 \item 1071 The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©. 1072 \item 1073 The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M©®)®©. 1074 \item 1075 The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M©®]®©. 1080 1076 \item 1081 1077 ©0© is the implicit start value; … … 1087 1083 The down-to range uses operator ©-=© for decrement. 1088 1084 \item 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}1094 \item1095 An empty conditional implies comparison value of ©1© (true).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 \item1102 A comparison N is implicit up-to exclusive range [0,N\R{)}.1103 \begin{cfa}1104 for ( @5@ ) $\C{// for ( typeof(5) i; i < 5; i += 1 )}$1105 \end{cfa}1106 \item1107 A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.1108 \begin{cfa}1109 for ( @=@5 ) $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$1110 \end{cfa}1111 \item1112 The up-to 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 \item1117 The up-to 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 \item1122 The down-to 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 \item1127 The down-to 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}1131 \item1132 1085 ©@© 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}1136 1086 \item 1137 1087 ©:© 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}1141 1088 \end{itemize} 1142 1089 … … 1157 1104 \begin{lrbox}{\myboxA} 1158 1105 \begin{cfa}[tabsize=3] 1159 @Compound:@{1160 @Try:@try {1161 @For:@for ( ... ) {1162 @While:@while ( ... ) {1163 @Do:@do {1164 @If:@if ( ... ) {1165 @Switch:@switch ( ... ) {1106 ®Compound:® { 1107 ®Try:® try { 1108 ®For:® for ( ... ) { 1109 ®While:® while ( ... ) { 1110 ®Do:® do { 1111 ®If:® if ( ... ) { 1112 ®Switch:® switch ( ... ) { 1166 1113 case 3: 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@;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®; 1174 1121 } // switch 1175 1122 } else { 1176 ... @break If@; ... // terminate if1123 ... ®break If®; ... // terminate if 1177 1124 } // if 1178 1125 } while ( ... ); // do 1179 1126 } // while 1180 1127 } // for 1181 } @finally@{ // always executed1128 } ®finally® { // always executed 1182 1129 } // try 1183 1130 } // compound … … 1189 1136 { 1190 1137 1191 @ForC:@for ( ... ) {1192 @WhileC:@while ( ... ) {1193 @DoC:@do {1138 ®ForC:® for ( ... ) { 1139 ®WhileC:® while ( ... ) { 1140 ®DoC:® do { 1194 1141 if ( ... ) { 1195 1142 switch ( ... ) { 1196 1143 case 3: 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:@;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:® ; 1205 1152 } else { 1206 ... @goto If@; ... // terminate if1207 } @If:@;1208 } while ( ... ); @DoB:@;1209 } @WhileB:@;1210 } @ForB:@;1211 1212 1213 } @Compound:@;1153 ... ®goto If®; ... // terminate if 1154 } ®If:®; 1155 } while ( ... ); ®DoB:® ; 1156 } ®WhileB:® ; 1157 } ®ForB:® ; 1158 1159 1160 } ®Compound:® ; 1214 1161 \end{cfa} 1215 1162 \end{lrbox} 1216 1163 1217 \hspace*{-10pt}1218 1164 \subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA} 1219 1165 \hspace{2pt} 1220 1166 \vrule 1167 \hspace{2pt} 1221 1168 \subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB} 1222 1169 \caption{Multi-level Exit} … … 1246 1193 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: 1247 1194 \begin{cfa} 1248 struct S { $\C{// aggregate}$1249 char c; $\C{// fields}$1195 struct S { §\C{// aggregate}§ 1196 char c; §\C{// fields}§ 1250 1197 int i; 1251 1198 double d; … … 1256 1203 \begin{cfa} 1257 1204 void f( S s ) { 1258 @s.@c; @s.@i; @s.@d; $\C{// access containing fields}$1205 ®s.®c; ®s.®i; ®s.®d; §\C{// access containing fields}§ 1259 1206 } 1260 1207 \end{cfa} … … 1263 1210 \begin{C++} 1264 1211 struct S { 1265 char c; $\C{// fields}$1212 char c; §\C{// fields}§ 1266 1213 int i; 1267 1214 double d; 1268 void f() { $\C{// implicit ``this'' aggregate}$1269 @this->@c; @this->@i; @this->@d; $\C{// access containing fields}$1215 void f() { §\C{// implicit ``this'' aggregate}§ 1216 ®this->®c; ®this->®i; ®this->®d; §\C{// access containing fields}§ 1270 1217 } 1271 1218 } … … 1275 1222 \begin{cfa} 1276 1223 struct T { double m, n; }; 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.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. 1284 1231 Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block. 1285 1232 \begin{cfa} 1286 void f( S & this ) @with ( this )@ { $\C{// with statement}$1287 c; i; d; $\C{\R{// this.c, this.i, this.d}}$1233 void f( S & this ) ®with ( this )® { §\C{// with statement}§ 1234 c; i; d; §\C{\color{red}// this.c, this.i, this.d}§ 1288 1235 } 1289 1236 \end{cfa} 1290 1237 with the generality of opening multiple aggregate-parameters: 1291 1238 \begin{cfa} 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}}$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}§ 1295 1242 } 1296 1243 \end{cfa} … … 1298 1245 In detail, the ©with© statement has the form: 1299 1246 \begin{cfa} 1300 $\emph{with-statement}$:1301 'with' '(' $\emph{expression-list}$ ')' $\emph{compound-statement}$1247 §\emph{with-statement}§: 1248 'with' '(' §\emph{expression-list}§ ')' §\emph{compound-statement}§ 1302 1249 \end{cfa} 1303 1250 and may appear as the body of a function or nested within a function body. … … 1311 1258 The difference between parallel and nesting occurs for fields with the same name and type: 1312 1259 \begin{cfa} 1313 struct S { int @i@; int j; double m; } s, w;1314 struct T { int @i@; int k; int m; } t, w;1260 struct S { int ®i®; int j; double m; } s, w; 1261 struct T { int ®i®; int k; int m; } t, w; 1315 1262 with ( s, t ) { 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}$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}§ 1323 1270 } 1324 1271 \end{cfa} … … 1330 1277 There is an interesting problem between parameters and the function-body ©with©, \eg: 1331 1278 \begin{cfa} 1332 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$1333 @s.i = i;@ j = 3; m = 5.5; $\C{// initialize fields}$1279 void ?{}( S & s, int i ) with ( s ) { §\C{// constructor}§ 1280 ®s.i = i;® j = 3; m = 5.5; §\C{// initialize fields}§ 1334 1281 } 1335 1282 \end{cfa} … … 1344 1291 and implicitly opened \emph{after} a function-body open, to give them higher priority: 1345 1292 \begin{cfa} 1346 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@{1347 s.i = @i@; j = 3; m = 5.5;1293 void ?{}( S & s, int ®i® ) with ( s ) ®with( §\emph{\color{red}params}§ )® { 1294 s.i = ®i®; j = 3; m = 5.5; 1348 1295 } 1349 1296 \end{cfa} 1350 1297 Finally, a cast may be used to disambiguate among overload variables in a ©with© expression: 1351 1298 \begin{cfa} 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: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: 1356 1303 % \begin{cfa} 1357 1304 % struct S { int i, j; } sv; 1358 % with ( sv ) { $\C{// implicit reference}$1305 % with ( sv ) { §\C{// implicit reference}§ 1359 1306 % S & sr = sv; 1360 % with ( sr ) { $\C{// explicit reference}$1307 % with ( sr ) { §\C{// explicit reference}§ 1361 1308 % S * sp = &sv; 1362 % with ( *sp ) { $\C{// computed reference}$1363 % i = 3; j = 4; $\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}$1309 % with ( *sp ) { §\C{// computed reference}§ 1310 % i = 3; j = 4; §\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}§ 1364 1311 % } 1365 % i = 2; j = 3; $\C{\color{red}// sr.i, sr.j}$1312 % i = 2; j = 3; §\C{\color{red}// sr.i, sr.j}§ 1366 1313 % } 1367 % i = 1; j = 2; $\C{\color{red}// sv.i, sv.j}$1314 % i = 1; j = 2; §\C{\color{red}// sv.i, sv.j}§ 1368 1315 % } 1369 1316 % \end{cfa} … … 1373 1320 class C { 1374 1321 int i, j; 1375 int mem() { $\C{\R{// implicit "this" parameter}}$1376 i = 1; $\C{\R{// this->i}}$1377 j = 2; $\C{\R{// this->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}§ 1378 1325 } 1379 1326 } … … 1382 1329 \begin{cfa} 1383 1330 struct S { int i, j; }; 1384 int mem( S & @this@ ) { $\C{// explicit "this" parameter}$1385 @this.@i = 1; $\C{// "this" is not elided}$1386 @this.@j = 2;1331 int mem( S & ®this® ) { §\C{// explicit "this" parameter}§ 1332 ®this.®i = 1; §\C{// "this" is not elided}§ 1333 ®this.®j = 2; 1387 1334 } 1388 1335 \end{cfa} 1389 1336 but it is cumbersome having to write ``©this.©'' many times in a member. 1390 1337 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}}$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}§ 1396 1343 } 1397 1344 \end{cfa} … … 1399 1346 \begin{cfa} 1400 1347 struct T { double m, n; }; 1401 int mem2( S & this1, T & this2 ) @with( this1, this2 )@{1348 int mem2( S & this1, T & this2 ) ®with( this1, this2 )® { 1402 1349 i = 1; j = 2; 1403 1350 m = 1.0; n = 2.0; … … 1410 1357 struct S1 { ... } s1; 1411 1358 struct S2 { ... } s2; 1412 @with( s1 )@ { $\C{// with statement}$1359 ®with( s1 )® { §\C{// with statement}§ 1413 1360 // access fields of s1 without qualification 1414 @with s2@ { $\C{// nesting}$1361 ®with s2® { §\C{// nesting}§ 1415 1362 // access fields of s1 and s2 without qualification 1416 1363 } 1417 1364 } 1418 @with s1, s2@{1365 ®with s1, s2® { 1419 1366 // access unambiguous fields of s1 and s2 without qualification 1420 1367 } … … 1467 1414 Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise. 1468 1415 \begin{cfa} 1469 exception_t E {}; $\C{// exception type}$1416 exception_t E {}; §\C{// exception type}§ 1470 1417 void f(...) { 1471 ... throw E{}; ... $\C{// termination}$1472 ... throwResume E{}; ... $\C{// resumption}$1418 ... throw E{}; ... §\C{// termination}§ 1419 ... throwResume E{}; ... §\C{// resumption}§ 1473 1420 } 1474 1421 try { 1475 1422 f(...); 1476 } catch( E e ; $boolean-predicate$ ) { $\C{// termination handler}$1423 } catch( E e ; §boolean-predicate§ ) { §\C{// termination handler}§ 1477 1424 // recover and continue 1478 } catchResume( E e ; $boolean-predicate$ ) { $\C{// resumption handler}$1425 } catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}§ 1479 1426 // repair and return 1480 1427 } finally { … … 1483 1430 \end{cfa} 1484 1431 The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©. 1485 Then the exception type must match along with any addit ional predicate must be true.1432 Then the exception type must match along with any additonal predicate must be true. 1486 1433 The ©catch© and ©catchResume© handlers may appear in any oder. 1487 1434 However, the ©finally© clause must appear at the end of the ©try© statement. … … 1536 1483 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way: 1537 1484 \begin{cfa} 1538 int @(*@f@())[@5@]@ {...}; $\C{// definition}$1539 ... @(*@f@())[@3@]@ += 1; $\C{// usage}$1485 int ®(*®f®())[®5®]® {...}; §\C{// definition}§ 1486 ... ®(*®f®())[®3®]® += 1; §\C{// usage}§ 1540 1487 \end{cfa} 1541 1488 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}). … … 1552 1499 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1553 1500 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1554 \begin{cfa} [moredelim={**[is][\color{blue}]{\#}{\#}}]1555 #[5] *# @int@x1;1556 #* [5]# @int@x2;1557 #[* [5] int]# f@( int p )@;1501 \begin{cfa} 1502 ß[5] *ß ®int® x1; 1503 ß* [5]ß ®int® x2; 1504 ß[* [5] int]ß f®( int p )®; 1558 1505 \end{cfa} 1559 1506 & 1560 \begin{cfa} [moredelim={**[is][\color{blue}]{\#}{\#}}]1561 @int@ #*# x1 #[5]#;1562 @int@ #(*#x2#)[5]#;1563 #int (*#f@( int p )@#)[5]#;1507 \begin{cfa} 1508 ®int® ß*ß x1 ß[5]ß; 1509 ®int® ß(*ßx2ß)[5]ß; 1510 ßint (*ßf®( int p )®ß)[5]ß; 1564 1511 \end{cfa} 1565 1512 \end{tabular} … … 1573 1520 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1574 1521 \begin{cfa} 1575 @*@int x, y;1522 ®*® int x, y; 1576 1523 \end{cfa} 1577 1524 & 1578 1525 \begin{cfa} 1579 int @*@x, @*@y;1526 int ®*®x, ®*®y; 1580 1527 \end{cfa} 1581 1528 \end{tabular} … … 1586 1533 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1587 1534 \begin{cfa} 1588 @*@int x;1535 ®*® int x; 1589 1536 int y; 1590 1537 \end{cfa} 1591 1538 & 1592 1539 \begin{cfa} 1593 int @*@x, y;1540 int ®*®x, y; 1594 1541 1595 1542 \end{cfa} … … 1700 1647 1701 1648 \section{Pointer / Reference} 1702 \label{s:PointerReference}1703 1649 1704 1650 C provides a \newterm{pointer type}; … … 1727 1673 & 1728 1674 \begin{cfa} 1729 int * @const@x = (int *)1001675 int * ®const® x = (int *)100 1730 1676 *x = 3; // implicit dereference 1731 int * @const@y = (int *)104;1677 int * ®const® y = (int *)104; 1732 1678 *y = *x; // implicit dereference 1733 1679 \end{cfa} … … 1767 1713 \begin{tabular}{@{}l@{\hspace{2em}}l@{}} 1768 1714 \begin{cfa} 1769 int x, y, @*@ p1, @*@ p2, @**@p3;1770 p1 = @&@x; // p1 points to x1715 int x, y, ®*® p1, ®*® p2, ®**® p3; 1716 p1 = ®&®x; // p1 points to x 1771 1717 p2 = p1; // p2 points to x 1772 p1 = @&@y; // p1 points to y1718 p1 = ®&®y; // p1 points to y 1773 1719 p3 = &p2; // p3 points to p2 1774 1720 \end{cfa} … … 1782 1728 For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage 1783 1729 \begin{cfa} 1784 p2 = p1 + x; $\C{// compiler infers *p2 = *p1 + x;}$1730 p2 = p1 + x; §\C{// compiler infers *p2 = *p1 + x;}§ 1785 1731 \end{cfa} 1786 1732 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. … … 1790 1736 In C, objects of pointer type always manipulate the pointer object's address: 1791 1737 \begin{cfa} 1792 p1 = p2; $\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}$1793 p2 = p1 + x; $\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}$1738 p1 = p2; §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§ 1739 p2 = p1 + x; §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§ 1794 1740 \end{cfa} 1795 1741 even though the assignment to ©p2© is likely incorrect, and the programmer probably meant: 1796 1742 \begin{cfa} 1797 p1 = p2; $\C{// pointer address assignment}$1798 @*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$ 1743 p1 = p2; §\C{// pointer address assignment}§ 1744 ®*®p2 = ®*®p1 + x; §\C{// pointed-to value assignment / operation}§ 1799 1745 \end{cfa} 1800 1746 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©). … … 1812 1758 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 pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s). 1813 1759 \begin{cfa} 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}$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}§ 1820 1766 \end{cfa} 1821 1767 Except for auto-dereferencing by the compiler, this reference example is the same as the previous pointer example. … … 1823 1769 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: 1824 1770 \begin{cfa} 1825 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);1771 ®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15); 1826 1772 \end{cfa} 1827 1773 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out. … … 1832 1778 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}): 1833 1779 \begin{cfa} 1834 (& @*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$1780 (&®*®)r1 = &x; §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§ 1835 1781 \end{cfa} 1836 1782 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}): 1837 1783 \begin{cfa} 1838 (&(& @*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$1784 (&(&®*®)®*®)r3 = &(&®*®)r2; §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§ 1839 1785 \end{cfa} 1840 1786 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth. … … 1844 1790 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, 1845 1791 &r1 = x, &&r2 = r1, &&&r3 = r2; 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}$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}§ 1853 1799 \end{cfa} 1854 1800 Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types. … … 1857 1803 As for a pointer type, a reference type may have qualifiers: 1858 1804 \begin{cfa} 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}$ 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}§ 1868 1814 \end{cfa} 1869 1815 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}: 1870 1816 \begin{cfa} 1871 int & const cr = *0; $\C{// where 0 is the int * zero}$1817 int & const cr = *0; §\C{// where 0 is the int * zero}§ 1872 1818 \end{cfa} 1873 1819 Note, constant reference-types do not prevent \Index{addressing errors} because of explicit storage-management: … … 1876 1822 cr = 5; 1877 1823 free( &cr ); 1878 cr = 7; $\C{// unsound pointer dereference}$1824 cr = 7; §\C{// unsound pointer dereference}§ 1879 1825 \end{cfa} 1880 1826 1881 1827 The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers. 1882 1828 The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations; 1883 \CFA-style declarations \see{\VRef{s:AlternativeDeclarations}}attempt to address this issue:1829 \CFA-style declarations (see \VRef{s:AlternativeDeclarations}) attempt to address this issue: 1884 1830 \begin{cquote} 1885 1831 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1886 1832 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1887 1833 \begin{cfa} 1888 @const@ * @const@* const int ccp;1889 @const@ & @const@& const int ccr;1834 ®const® * ®const® * const int ccp; 1835 ®const® & ®const® & const int ccr; 1890 1836 \end{cfa} 1891 1837 & 1892 1838 \begin{cfa} 1893 const int * @const@ * @const@ccp;1839 const int * ®const® * ®const® ccp; 1894 1840 1895 1841 \end{cfa} … … 1900 1846 Finally, like pointers, references are usable and composable with other type operators and generators. 1901 1847 \begin{cfa} 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}$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}§ 1908 1854 \end{cfa} 1909 1855 1910 1856 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}. 1911 1857 Also, \CC does not allow \Index{array}s\index{array!reference} of reference\footnote{ 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 refer ent object.}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 referant object.} 1913 1859 \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 (bit-wise) object assignment, so objects are explicitly cloned by shallow or deep copying, which eliminates half of the address duality. 1914 1860 … … 1922 1868 Therefore, for pointer/reference initialization, the initializing value must be an address not a value. 1923 1869 \begin{cfa} 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}$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}§ 1927 1873 \end{cfa} 1928 1874 Like the previous example with C pointer-arithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given). … … 1933 1879 Similarly, when a reference type is used for a parameter/return type, the call-site argument does not require a reference operator for the same reason. 1934 1880 \begin{cfa} 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}$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}§ 1937 1883 \end{cfa} 1938 1884 Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©. … … 1947 1893 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions. 1948 1894 \begin{cfa} 1949 void f( @const@int & cr );1950 void g( @const@int * cp );1951 f( 3 ); g( @&@3 );1952 f( x + y ); g( @&@(x + y) );1895 void f( ®const® int & cr ); 1896 void g( ®const® int * cp ); 1897 f( 3 ); g( ®&®3 ); 1898 f( x + y ); g( ®&®(x + y) ); 1953 1899 \end{cfa} 1954 1900 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. … … 1961 1907 void f( int & r ); 1962 1908 void g( int * p ); 1963 f( 3 ); g( @&@3 ); $\C{// compiler implicit generates temporaries}$1964 f( x + y ); g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$1909 f( 3 ); g( ®&®3 ); §\C{// compiler implicit generates temporaries}§ 1910 f( x + y ); g( ®&®(x + y) ); §\C{// compiler implicit generates temporaries}§ 1965 1911 \end{cfa} 1966 1912 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{ … … 1973 1919 \begin{cfa} 1974 1920 void f( int i ); 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}$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}§ 1981 1927 \end{cfa} 1982 1928 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. 1983 1929 Instead, a routine object should be referenced by a ©const© reference: 1984 1930 \begin{cfa} 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}$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}§ 1990 1936 \end{cfa} 1991 1937 because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{ … … 2000 1946 \begin{itemize} 2001 1947 \item 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 $r-1$ 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).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 $r-1$ 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). 2006 1952 \end{itemize} 2007 1953 The following example shows the first rule applied to different \Index{rvalue} contexts: … … 2009 1955 int x, * px, ** ppx, *** pppx, **** ppppx; 2010 1956 int & rx = x, && rrx = rx, &&& rrrx = rrx ; 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)}$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)}§ 2016 1962 \end{cfa} 2017 1963 The following example shows the second rule applied to different \Index{lvalue} contexts: … … 2019 1965 int x, * px, ** ppx, *** pppx; 2020 1966 int & rx = x, && rrx = rx, &&& rrrx = rrx ; 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$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§ 2025 1971 \end{cfa} 2026 1972 … … 2035 1981 \begin{cfa} 2036 1982 int x; 2037 x + 1; $\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}$1983 x + 1; §\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}§ 2038 1984 \end{cfa} 2039 1985 An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped. … … 2045 1991 \begin{cfa} 2046 1992 int x, &r = x, f( int p ); 2047 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$1993 x = ®r® + f( ®r® ); §\C{// lvalue reference converts to rvalue}§ 2048 1994 \end{cfa} 2049 1995 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped. … … 2052 1998 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references. 2053 1999 \begin{cfa} 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 \&)}$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 \&)}§ 2056 2002 \end{cfa} 2057 2003 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost. … … 2063 2009 \begin{cfa} 2064 2010 int x, & f( int & p ); 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$ 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§ 2067 2013 \end{cfa} 2068 2014 In both case, modifications to the temporary are inaccessible (\Index{warning}). … … 2236 2182 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg: 2237 2183 \begin{cfa} 2238 @[ int o1, int o2, char o3 ]@f( int i1, char i2, char i3 ) {2239 $\emph{routine body}$2184 ®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) { 2185 §\emph{routine body}§ 2240 2186 } 2241 2187 \end{cfa} … … 2248 2194 Declaration qualifiers can only appear at the start of a routine definition, \eg: 2249 2195 \begin{cfa} 2250 @extern@ [ int x ] g( int y ) {$\,$}2196 ®extern® [ int x ] g( int y ) {§\,§} 2251 2197 \end{cfa} 2252 2198 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified; 2253 2199 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: 2254 2200 \begin{cfa} 2255 [ $\,$] g(); $\C{// no input or output parameters}$2256 [ void ] g( void ); $\C{// no input or output parameters}$2201 [§\,§] g(); §\C{// no input or output parameters}§ 2202 [ void ] g( void ); §\C{// no input or output parameters}§ 2257 2203 \end{cfa} 2258 2204 … … 2272 2218 \begin{cfa} 2273 2219 typedef int foo; 2274 int f( int (* foo) ); $\C{// foo is redefined as a parameter name}$2220 int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§ 2275 2221 \end{cfa} 2276 2222 The string ``©int (* foo)©'' declares a C-style named-parameter 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. … … 2280 2226 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg: 2281 2227 \begin{cfa} 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}$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}§ 2284 2230 \end{cfa} 2285 2231 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in: 2286 2232 \begin{cfa} 2287 2233 #define ptoa( n, d ) int (*n)[ d ] 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 ] )}$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 ] )}§ 2290 2236 \end{cfa} 2291 2237 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms. … … 2306 2252 \begin{minipage}{\linewidth} 2307 2253 \begin{cfa} 2308 @[ int x, int y ]@f() {2254 ®[ int x, int y ]® f() { 2309 2255 int z; 2310 2256 ... x = 0; ... y = z; ... 2311 @return;@ $\C{// implicitly return x, y}$2257 ®return;® §\C{// implicitly return x, y}§ 2312 2258 } 2313 2259 \end{cfa} … … 2319 2265 [ int x, int y ] f() { 2320 2266 ... 2321 } $\C{// implicitly return x, y}$2267 } §\C{// implicitly return x, y}§ 2322 2268 \end{cfa} 2323 2269 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered. … … 2328 2274 [ int x, int y ] f( int, x, int y ) { 2329 2275 ... 2330 } $\C{// implicitly return x, y}$2276 } §\C{// implicitly return x, y}§ 2331 2277 \end{cfa} 2332 2278 This notation allows the compiler to eliminate temporary variables in nested routine calls. 2333 2279 \begin{cfa} 2334 [ int x, int y ] f( int, x, int y ); $\C{// prototype declaration}$2280 [ int x, int y ] f( int, x, int y ); §\C{// prototype declaration}§ 2335 2281 int a, b; 2336 2282 [a, b] = f( f( f( a, b ) ) ); … … 2346 2292 as well, parameter names are optional, \eg: 2347 2293 \begin{cfa} 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}$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}§ 2352 2298 \end{cfa} 2353 2299 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa). 2354 Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list \see{\VRef{s:AlternativeDeclarations}}, \eg:2300 Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:AlternativeDeclarations}), \eg: 2355 2301 \begin{cfa} 2356 2302 C : const double bar1(), bar2( int ), bar3( double ); 2357 $\CFA$: [const double] foo(), foo( int ), foo( double ) { return 3.0; }2303 §\CFA§: [const double] foo(), foo( int ), foo( double ) { return 3.0; } 2358 2304 \end{cfa} 2359 2305 \CFA allows the last routine in the list to define its body. … … 2370 2316 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg: 2371 2317 \begin{cfa} 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$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}§ 2376 2322 \end{cfa} 2377 2323 While parameter names are optional, \emph{a routine name cannot be specified}; 2378 2324 for example, the following is incorrect: 2379 2325 \begin{cfa} 2380 * [ int x ] f () fp; $\C{// routine name "f" is not allowed}$2326 * [ int x ] f () fp; §\C{// routine name "f" is not allowed}§ 2381 2327 \end{cfa} 2382 2328 … … 2401 2347 whereas a named (keyword) call may be: 2402 2348 \begin{cfa} 2403 p( z : 3, x : 4, y : 7 ); $\C{// rewrite \(\Rightarrow\) p( 4, 7, 3 )}$2349 p( z : 3, x : 4, y : 7 ); §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§ 2404 2350 \end{cfa} 2405 2351 Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters. … … 2418 2364 For example, the following routine prototypes and definition are all valid. 2419 2365 \begin{cfa} 2420 void p( int, int, int ); $\C{// equivalent prototypes}$2366 void p( int, int, int ); §\C{// equivalent prototypes}§ 2421 2367 void p( int x, int y, int z ); 2422 2368 void p( int y, int x, int z ); 2423 2369 void p( int z, int y, int x ); 2424 void p( int q, int r, int s ) {} $\C{// match with this definition}$2370 void p( int q, int r, int s ) {} §\C{// match with this definition}§ 2425 2371 \end{cfa} 2426 2372 Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming. … … 2434 2380 int f( int x, double y ); 2435 2381 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}$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}§ 2439 2385 \end{cfa} 2440 2386 However, named arguments compound routine resolution in conjunction with conversions: 2441 2387 \begin{cfa} 2442 f( i : 3, 5.7 ); $\C{// ambiguous call ?}$2388 f( i : 3, 5.7 ); §\C{// ambiguous call ?}§ 2443 2389 \end{cfa} 2444 2390 Depending on the cost associated with named arguments, this call could be resolvable or ambiguous. … … 2454 2400 the allowable positional calls are: 2455 2401 \begin{cfa} 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 )}$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 )}§ 2460 2406 // empty arguments 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 )}$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 )}§ 2468 2414 \end{cfa} 2469 2415 Here the missing arguments are inserted from the default values in the parameter list. … … 2489 2435 Default values may only appear in a prototype versus definition context: 2490 2436 \begin{cfa} 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}$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}§ 2494 2440 \end{cfa} 2495 2441 The reason for this restriction is to allow separate compilation. … … 2506 2452 \begin{cfa} 2507 2453 p( int x, int y, int z, ... ); 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 */, ... );}$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 */, ... );}§ 2510 2456 \end{cfa} 2511 2457 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. … … 2516 2462 \begin{cfa} 2517 2463 void p( int x, int y = 2, int z = 3... ); 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 */, ... );}$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 */, ... );}§ 2520 2466 \end{cfa} 2521 2467 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments; … … 2523 2469 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. 2524 2470 For these reasons, \CFA requires named arguments before ellipse arguments. 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.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. 2528 2474 While in theory default arguments can be simulated with overloading, as in: 2529 2475 \begin{cquote} … … 2547 2493 Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as: 2548 2494 \begin{cfa} 2549 p( 1, /* default */, 5 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 5 )}$2495 p( 1, /* default */, 5 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§ 2550 2496 \end{cfa} 2551 2497 … … 2560 2506 \begin{cfa} 2561 2507 struct { 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}$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}§ 2568 2514 }; 2569 2515 \end{cfa} … … 2573 2519 \begin{cfa} 2574 2520 struct { 2575 int , , ; $\C{// 3 unnamed fields}$2521 int , , ; §\C{// 3 unnamed fields}§ 2576 2522 } 2577 2523 \end{cfa} … … 2585 2531 \subsection{Type Nesting} 2586 2532 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.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. 2588 2534 \begin{figure} 2589 2535 \centering … … 2641 2587 2642 2588 int fred() { 2643 s.t.c = @S.@R; // type qualification2644 struct @S.@T t = { @S.@R, 1, 2 };2645 enum @S.@C c;2646 union @S.T.@U u;2589 s.t.c = ®S.®R; // type qualification 2590 struct ®S.®T t = { ®S.®R, 1, 2 }; 2591 enum ®S.®C c; 2592 union ®S.T.®U u; 2647 2593 } 2648 2594 \end{cfa} … … 2667 2613 const unsigned int size = 5; 2668 2614 int ia[size]; 2669 ... $\C{// assign values to array ia}$2670 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$2615 ... §\C{// assign values to array ia}§ 2616 qsort( ia, size ); §\C{// sort ascending order using builtin ?<?}§ 2671 2617 { 2672 @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$2673 qsort( ia, size ); $\C{// sort descending order by local redefinition}$2618 ®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§ 2619 qsort( ia, size ); §\C{// sort descending order by local redefinition}§ 2674 2620 } 2675 2621 \end{cfa} … … 2679 2625 The following program in undefined in \CFA (and Indexc{gcc}) 2680 2626 \begin{cfa} 2681 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$2682 int @i@= 7;2627 [* [int]( int )] foo() { §\C{// int (* foo())( int )}§ 2628 int ®i® = 7; 2683 2629 int bar( int p ) { 2684 @i@ += 1; $\C{// dependent on local variable}$2685 sout | @i@;2630 ®i® += 1; §\C{// dependent on local variable}§ 2631 sout | ®i®; 2686 2632 } 2687 return bar; $\C{// undefined because of local dependence}$2633 return bar; §\C{// undefined because of local dependence}§ 2688 2634 } 2689 2635 int main() { 2690 * [int]( int ) fp = foo(); $\C{// int (* fp)( int )}$2636 * [int]( int ) fp = foo(); §\C{// int (* fp)( int )}§ 2691 2637 sout | fp( 3 ); 2692 2638 } … … 2701 2647 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call. 2702 2648 \begin{cfa} 2703 f( @2, x, 3 + i@ ); $\C{// element list}$2649 f( ®2, x, 3 + i® ); §\C{// element list}§ 2704 2650 \end{cfa} 2705 2651 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}. … … 2710 2656 2711 2657 In C and most programming languages, functions return at most one value; 2712 however, many operations have multiple outcomes, some exceptional \see{\VRef{s:ExceptionHandling}}.2658 however, many operations have multiple outcomes, some exceptional (see~\VRef{s:ExceptionHandling}). 2713 2659 To emulate functions with multiple return values, \emph{\Index{aggregation}} and/or \emph{\Index{aliasing}} is used. 2714 2660 … … 2716 2662 For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value. 2717 2663 \begin{cfa} 2718 typedef struct { int quot, rem; } div_t; $\C[7cm]{// from include stdlib.h}$2664 typedef struct { int quot, rem; } div_t; §\C[7cm]{// from include stdlib.h}§ 2719 2665 div_t div( int num, int den ); 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}$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}§ 2722 2668 \end{cfa} 2723 2669 This approach requires a name for the return type and fields, where \Index{naming} is a common programming-language issue. … … 2729 2675 For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value. 2730 2676 \begin{cfa} 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}$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}§ 2734 2680 \end{cfa} 2735 2681 This approach requires allocating storage for the return values, which complicates the call site with a sequence of variable declarations leading to the call. … … 2758 2704 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. 2759 2705 \begin{cfa} 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}$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}§ 2764 2710 \end{cfa} 2765 2711 In this case, there are two overloaded ©g© routines. … … 2770 2716 The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call. 2771 2717 \begin{cfa} 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}$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}§ 2777 2723 \end{cfa} 2778 2724 This approach provides the benefits of compile-time checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type. … … 2784 2730 \begin{cfa} 2785 2731 int quot, rem; 2786 [ quot, rem ] = div( 13, 5 ); $\C{// assign multiple variables}$2787 printf( "%d %d\n", quot, rem ); $\C{// print quotient/remainder}\CRT$2732 [ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§ 2733 printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§ 2788 2734 \end{cfa} 2789 2735 Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call. … … 2814 2760 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}. 2815 2761 \begin{cfa} 2816 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$2817 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$2762 [int, int] ®qr® = div( 13, 5 ); §\C{// initialize tuple variable}§ 2763 printf( "%d %d\n", ®qr® ); §\C{// print quotient/remainder}§ 2818 2764 \end{cfa} 2819 2765 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}. … … 2821 2767 One way to access the individual components of a tuple variable is with assignment. 2822 2768 \begin{cfa} 2823 [ quot, rem ] = qr; $\C{// assign multiple variables}$2769 [ quot, rem ] = qr; §\C{// assign multiple variables}§ 2824 2770 \end{cfa} 2825 2771 … … 2844 2790 [int, double] * p; 2845 2791 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 pointed-to 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}$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 pointed-to 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}§ 2851 2797 \end{cfa} 2852 2798 Tuple-index expressions can occur on any tuple-typed expression, including tuple-returning functions, square-bracketed tuple expressions, and other tuple-index expressions, provided the retrieved component is also a tuple. … … 2855 2801 2856 2802 \subsection{Flattening and Structuring} 2857 \label{s:FlatteningStructuring}2858 2803 2859 2804 As evident in previous examples, tuples in \CFA do not have a rigid structure. … … 2916 2861 double y; 2917 2862 [int, double] z; 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}$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}§ 2922 2867 \end{cfa} 2923 2868 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. … … 2927 2872 \begin{cfa} 2928 2873 [ int, int ] x, y, z; 2929 [ x, y ] = z; $\C{// multiple assignment, invalid 4 != 2}$2874 [ x, y ] = z; §\C{// multiple assignment, invalid 4 != 2}§ 2930 2875 \end{cfa} 2931 2876 Multiple assignment assigns $R_i$ to $L_i$ for each $i$. … … 2963 2908 double c, d; 2964 2909 [ void ] f( [ int, int ] ); 2965 f( [ c, a ] = [ b, d ] = 1.5 ); $\C{// assignments in parameter list}$2910 f( [ c, a ] = [ b, d ] = 1.5 ); §\C{// assignments in parameter list}§ 2966 2911 \end{cfa} 2967 2912 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. … … 2976 2921 \begin{cfa} 2977 2922 struct S; 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}$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}§ 2986 2931 \end{cfa} 2987 2932 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)©. … … 3024 2969 A member-access tuple may be used anywhere a tuple can be used, \eg: 3025 2970 \begin{cfa} 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 )}$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 )}§ 3028 2973 \end{cfa} 3029 2974 Note, the fields appearing in a record-field tuple may be specified in any order; … … 3035 2980 void f( double, long ); 3036 2981 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 ]}$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 ]}§ 3039 2984 [ long, int, long ] y = x.[ 2, 0, 2 ]; 3040 2985 \end{cfa} … … 3053 2998 \begin{cfa} 3054 2999 [ int, float, double ] f(); 3055 [ double, float ] x = f().[ 2, 1 ]; $\C{// f() called once}$3000 [ double, float ] x = f().[ 2, 1 ]; §\C{// f() called once}§ 3056 3001 \end{cfa} 3057 3002 … … 3066 3011 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. 3067 3012 \begin{cfa} 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)}$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)}§ 3073 3018 \end{cfa} 3074 3019 Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples. … … 3078 3023 void g(); 3079 3024 3080 (void)f(); $\C{// valid, ignore results}$3081 (int)g(); $\C{// invalid, void cannot be converted to int}$3025 (void)f(); §\C{// valid, ignore results}§ 3026 (int)g(); §\C{// invalid, void cannot be converted to int}§ 3082 3027 3083 3028 struct A { int x; }; 3084 (struct A)f(); $\C{// invalid, int cannot be converted to A}$3029 (struct A)f(); §\C{// invalid, int cannot be converted to A}§ 3085 3030 \end{cfa} 3086 3031 In C, line 4 is a valid cast, which calls ©f© and discards its result. … … 3098 3043 [int, [int, int], int] g(); 3099 3044 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}$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}§ 3105 3050 \end{cfa} 3106 3051 … … 3162 3107 void f([int, int], int, int); 3163 3108 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}$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}§ 3168 3113 \end{cfa} 3169 3114 … … 3201 3146 The general syntax of a lexical list is: 3202 3147 \begin{cfa} 3203 [ $\emph{exprlist}$]3148 [ §\emph{exprlist}§ ] 3204 3149 \end{cfa} 3205 3150 where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas. … … 3213 3158 Tuples are permitted to contain sub-tuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple. 3214 3159 Note, a tuple is not a record (structure); 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}}.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). 3216 3161 In essence, tuples are largely a compile time phenomenon, having little or no runtime presence. 3217 3162 … … 3221 3166 The general syntax of a tuple type is: 3222 3167 \begin{cfa} 3223 [ $\emph{typelist}$]3168 [ §\emph{typelist}§ ] 3224 3169 \end{cfa} 3225 3170 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. … … 3228 3173 [ unsigned int, char ] 3229 3174 [ double, double, double ] 3230 [ * int, int * ] $\C{// mix of CFA and ANSI}$3175 [ * int, int * ] §\C{// mix of CFA and ANSI}§ 3231 3176 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ] 3232 3177 \end{cfa} … … 3235 3180 Examples of declarations using tuple types are: 3236 3181 \begin{cfa} 3237 [ int, int ] x; $\C{// 2 element tuple, each element of type int}$3238 * [ char, char ] y; $\C{// pointer to a 2 element tuple}$3182 [ int, int ] x; §\C{// 2 element tuple, each element of type int}§ 3183 * [ char, char ] y; §\C{// pointer to a 2 element tuple}§ 3239 3184 [ [ int, int ] ] z ([ int, int ]); 3240 3185 \end{cfa} … … 3253 3198 [ int, int ] w1; 3254 3199 [ int, int, int ] w2; 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}$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}§ 3257 3202 f( [ 1, 2, 3 ] ); 3258 3203 f( w1, 3 ); … … 3334 3279 [ int, int, int, int ] w = [ 1, 2, 3, 4 ]; 3335 3280 int x = 5; 3336 [ x, w ] = [ w, x ]; $\C{// all four tuple coercions}$3281 [ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§ 3337 3282 \end{cfa} 3338 3283 Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values; … … 3340 3285 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 left-hand side. 3341 3286 The tuple ©[ 2, 3, 4, 5 ]© is then closed to create a tuple value. 3342 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using \Index{multiple assignment} \see{\VRef{s:TupleAssignment}}.3287 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using multiple assignment (see Section 14). 3343 3288 \begin{rationale} 3344 3289 A possible additional language extension is to use the structuring coercion for tuples to initialize a complex record with a tuple. … … 3351 3296 Mass assignment has the following form: 3352 3297 \begin{cfa} 3353 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$;3298 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§; 3354 3299 \end{cfa} 3355 3300 \index{lvalue} … … 3391 3336 Multiple assignment has the following form: 3392 3337 \begin{cfa} 3393 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$];3338 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ]; 3394 3339 \end{cfa} 3395 3340 \index{lvalue} … … 3422 3367 both these examples produce indeterminate results: 3423 3368 \begin{cfa} 3424 f( x++, x++ ); $\C{// C routine call with side effects in arguments}$3425 [ v1, v2 ] = [ x++, x++ ]; $\C{// side effects in right-hand side of multiple assignment}$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}§ 3426 3371 \end{cfa} 3427 3372 … … 3432 3377 Cascade assignment has the following form: 3433 3378 \begin{cfa} 3434 $\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$;3379 §\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§; 3435 3380 \end{cfa} 3436 3381 and it has the same parallel semantics as for mass and multiple assignment. … … 3479 3424 \begin{cfa} 3480 3425 int x = 1, y = 2, z = 3; 3481 sout | x @|@ y @|@z;3426 sout | x ®|® y ®|® z; 3482 3427 \end{cfa} 3483 3428 & 3484 3429 \begin{cfa} 3485 3430 3486 cout << x @<< " "@ << y @<< " "@<< z << endl;3431 cout << x ®<< " "® << y ®<< " "® << z << endl; 3487 3432 \end{cfa} 3488 3433 & … … 3493 3438 \\ 3494 3439 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3495 1 @ @2@ @33440 1® ®2® ®3 3496 3441 \end{cfa} 3497 3442 & 3498 3443 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3499 1 @ @2@ @33444 1® ®2® ®3 3500 3445 \end{cfa} 3501 3446 & 3502 3447 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3503 1 @ @2@ @33448 1® ®2® ®3 3504 3449 \end{cfa} 3505 3450 \end{tabular} … … 3509 3454 \begin{cfa} 3510 3455 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ]; 3511 sout | t1 | t2; $\C{// print tuples}$3456 sout | t1 | t2; §\C{// print tuples}§ 3512 3457 \end{cfa} 3513 3458 \begin{cfa}[showspaces=true,aboveskip=0pt] 3514 1 @, @2@, @3 4@, @5@, @63459 1®, ®2®, ®3 4®, ®5®, ®6 3515 3460 \end{cfa} 3516 3461 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment. … … 3521 3466 & 3522 3467 \begin{cfa} 3523 sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;3468 sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®; 3524 3469 \end{cfa} 3525 3470 \\ … … 3527 3472 & 3528 3473 \begin{cfa} 3529 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@<< endl;3474 cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl; 3530 3475 \end{cfa} 3531 3476 \\ … … 3562 3507 \\ 3563 3508 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3564 @1@ @2.5@ @A@ 3509 ®1® ®2.5® ®A® 3565 3510 3566 3511 … … 3568 3513 & 3569 3514 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3570 @1@ @2.5@ @A@ 3515 ®1® ®2.5® ®A® 3571 3516 3572 3517 … … 3574 3519 & 3575 3520 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3576 @1@ 3577 @2.5@ 3578 @A@ 3521 ®1® 3522 ®2.5® 3523 ®A® 3579 3524 \end{cfa} 3580 3525 \end{tabular} … … 3612 3557 3613 3558 \item 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} 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] 3616 3562 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x" 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@}@x3621 \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.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®}® x 3567 \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. 3625 3571 %$ 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;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; 3629 3575 \end{cfa} 3630 3576 %$ 3631 \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}}$103577 \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 ®«®10 3633 3579 \end{cfa} 3634 3580 %$ 3635 3581 3636 3582 \item 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} 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] 3639 3585 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx"; 3640 3586 \end{cfa} 3641 \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@ @x3587 \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® ®x 3643 3589 \end{cfa} 3644 3590 3645 3591 \item 3646 3592 If a space is desired before or after one of the special string start/end characters, simply insert a space. 3647 \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:@ @43593 \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:® ®4 3652 3598 \end{cfa} 3653 3599 \end{enumerate} … … 3662 3608 \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. 3663 3609 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). 3664 \begin{cfa}[ escapechar=off,belowskip=0pt]3665 sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$3666 sout | 1 | 2 | 3 | " \"" | @sep@| "\"";3610 \begin{cfa}[mathescape=off,belowskip=0pt] 3611 sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§ 3612 sout | 1 | 2 | 3 | " \"" | ®sep® | "\""; 3667 3613 \end{cfa} 3668 3614 %$ 3669 3615 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt] 3670 1 @, $@2@, $@3 @", $"@3616 1®, $®2®, $®3 ®", $"® 3671 3617 \end{cfa} 3672 3618 %$ 3673 3619 \begin{cfa}[belowskip=0pt] 3674 sepSet( sout, " " ); $\C{// reset separator to " "}$3675 sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@| "\"";3620 sepSet( sout, " " ); §\C{// reset separator to " "}§ 3621 sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\""; 3676 3622 \end{cfa} 3677 3623 \begin{cfa}[showspaces=true,aboveskip=0pt] 3678 1 @ @2@ @3 @" "@3624 1® ®2® ®3 ®" "® 3679 3625 \end{cfa} 3680 3626 ©sepGet© can be used to store a separator and then restore it: 3681 3627 \begin{cfa}[belowskip=0pt] 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}$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}§ 3685 3631 sout | 1 | 2 | 3; 3686 3632 \end{cfa} 3687 3633 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3688 1 @_@2@_@33634 1®_®2®_®3 3689 3635 \end{cfa} 3690 3636 \begin{cfa}[belowskip=0pt] 3691 sepSet( sout, store ); $\C{// change separator back to original}$3637 sepSet( sout, store ); §\C{// change separator back to original}§ 3692 3638 sout | 1 | 2 | 3; 3693 3639 \end{cfa} 3694 3640 \begin{cfa}[showspaces=true,aboveskip=0pt] 3695 1 @ @2@ @33641 1® ®2® ®3 3696 3642 \end{cfa} 3697 3643 … … 3700 3646 The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters). 3701 3647 \begin{cfa}[belowskip=0pt] 3702 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$3703 sout | t1 | t2 | " \"" | @sepTuple@| "\"";3648 sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§ 3649 sout | t1 | t2 | " \"" | ®sepTuple® | "\""; 3704 3650 \end{cfa} 3705 3651 \begin{cfa}[showspaces=true,aboveskip=0pt] 3706 1 2 3 4 5 6 @" "@3652 1 2 3 4 5 6 ®" "® 3707 3653 \end{cfa} 3708 3654 \begin{cfa}[belowskip=0pt] 3709 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$3710 sout | t1 | t2 | " \"" | @sepGetTuple( sout )@| "\"";3655 sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§ 3656 sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\""; 3711 3657 \end{cfa} 3712 3658 \begin{cfa}[showspaces=true,aboveskip=0pt] 3713 1, 2, 3 4, 5, 6 @", "@3659 1, 2, 3 4, 5, 6 ®", "® 3714 3660 \end{cfa} 3715 3661 As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it. … … 3718 3664 \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} toggle printing the separator. 3719 3665 \begin{cfa}[belowskip=0pt] 3720 sout | sepDisable | 1 | 2 | 3; $\C{// turn off implicit separator}$3666 sout | sepDisable | 1 | 2 | 3; §\C{// turn off implicit separator}§ 3721 3667 \end{cfa} 3722 3668 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3724 3670 \end{cfa} 3725 3671 \begin{cfa}[belowskip=0pt] 3726 sout | sepEnable | 1 | 2 | 3; $\C{// turn on implicit separator}$3672 sout | sepEnable | 1 | 2 | 3; §\C{// turn on implicit separator}§ 3727 3673 \end{cfa} 3728 3674 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3733 3679 \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. 3734 3680 \begin{cfa}[belowskip=0pt] 3735 sout | 1 | sepOff | 2 | 3; $\C{// turn off implicit separator for the next item}$3681 sout | 1 | sepOff | 2 | 3; §\C{// turn off implicit separator for the next item}§ 3736 3682 \end{cfa} 3737 3683 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3739 3685 \end{cfa} 3740 3686 \begin{cfa}[belowskip=0pt] 3741 sout | sepDisable | 1 | sepOn | 2 | 3; $\C{// turn on implicit separator for the next item}$3687 sout | sepDisable | 1 | sepOn | 2 | 3; §\C{// turn on implicit separator for the next item}§ 3742 3688 \end{cfa} 3743 3689 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3746 3692 The tuple separator also responses to being turned on and off. 3747 3693 \begin{cfa}[belowskip=0pt] 3748 sout | t1 | sepOff | t2; $\C{// turn off implicit separator for the next item}$3694 sout | t1 | sepOff | t2; §\C{// turn off implicit separator for the next item}§ 3749 3695 \end{cfa} 3750 3696 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3754 3700 use ©sep© to accomplish this functionality. 3755 3701 \begin{cfa}[belowskip=0pt] 3756 sout | sepOn | 1 | 2 | 3 | sepOn; $\C{// sepOn does nothing at start/end of line}$3702 sout | sepOn | 1 | 2 | 3 | sepOn; §\C{// sepOn does nothing at start/end of line}§ 3757 3703 \end{cfa} 3758 3704 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] … … 3760 3706 \end{cfa} 3761 3707 \begin{cfa}[belowskip=0pt] 3762 sout | sep | 1 | 2 | 3 | sep ; $\C{// use sep to print separator at start/end of line}$3708 sout | sep | 1 | 2 | 3 | sep ; §\C{// use sep to print separator at start/end of line}§ 3763 3709 \end{cfa} 3764 3710 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3765 @ @1 2 3@ @ 3711 ® ®1 2 3® ® 3766 3712 \end{cfa} 3767 3713 \end{enumerate} … … 3775 3721 \begin{enumerate}[parsep=0pt] 3776 3722 \item 3777 \Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, \ieignore the remaining characters in the line.3723 \Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, i.e., ignore the remaining characters in the line. 3778 3724 \item 3779 3725 \Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} reads the newline character, when reading single characters. … … 3783 3729 For example, in: 3784 3730 \begin{cfa} 3785 sin | i | @nl@| j;3786 1 @2@3731 sin | i | ®nl® | j; 3732 1 ®2® 3787 3733 3 3788 3734 \end{cfa} … … 3794 3740 \Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline. 3795 3741 \begin{cfa} 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}$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}§ 3801 3747 3802 3748 2 … … 3825 3771 0b0 0b11011 0b11011 0b11011 0b11011 3826 3772 sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L ); 3827 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b @(58 1s)@1001013773 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101 3828 3774 \end{cfa} 3829 3775 … … 3864 3810 \begin{cfa}[belowskip=0pt] 3865 3811 sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) ); 3866 0 @B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+43812 0®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4 3867 3813 \end{cfa} 3868 3814 … … 3880 3826 \begin{cfa}[belowskip=0pt] 3881 3827 sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 ); 3882 0.0 @0@ 27.0 @27@27.53828 0.0 ®0® 27.0 ®27® 27.5 3883 3829 \end{cfa} 3884 3830 … … 3887 3833 \begin{cfa}[belowskip=0pt] 3888 3834 sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 ); 3889 @+@27 -27 @+@27.0 -27.0 @+@27.5 -27.53835 ®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5 3890 3836 \end{cfa} 3891 3837 … … 3900 3846 \end{cfa} 3901 3847 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3902 @ @34 @ @34 343903 @ @4.000000 @ @4.000000 4.0000003904 @ @ab @ @ab ab3848 ® ®34 ® ®34 34 3849 ® ®4.000000 ® ®4.000000 4.000000 3850 ® ®ab ® ®ab ab 3905 3851 \end{cfa} 3906 3852 If the value is larger, it is printed without truncation, ignoring the ©minimum©. … … 3911 3857 \end{cfa} 3912 3858 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3913 3456 @7@ 345@67@ 34@567@3914 3456 @.@ 345@6.@ 34@56.@3915 abcd @e@ abc@de@ ab@cde@3859 3456®7® 345®67® 34®567® 3860 3456®.® 345®6.® 34®56.® 3861 abcd®e® abc®de® ab®cde® 3916 3862 \end{cfa} 3917 3863 … … 3922 3868 \end{cfa} 3923 3869 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3924 @0@34 @00@34 @00000000@343870 ®0®34 ®00®34 ®00000000®34 3925 3871 \end{cfa} 3926 3872 If the value is larger, it is printed without truncation, ignoring the ©precision©. … … 3937 3883 \end{cfa} 3938 3884 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3939 @ @ @00000000@343885 ® ® ®00000000®34 3940 3886 \end{cfa} 3941 3887 For floating-point types, ©precision© is the minimum number of digits after the decimal point. … … 3944 3890 \end{cfa} 3945 3891 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3946 27. @500@ 27.@5@ 28. 27.@50000000@3947 \end{cfa} 3948 For the C-string type, ©precision© is the maximum number of printed characters, so the string is trunca ted if it exceeds the maximum.3892 27.®500® 27.®5® 28. 27.®50000000® 3893 \end{cfa} 3894 For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncared if it exceeds the maximum. 3949 3895 \begin{cfa}[belowskip=0pt] 3950 3896 sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" ); … … 3962 3908 \end{cfa} 3963 3909 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3964 234.567 234.5 @7@ 234.@6@ 23@5@3910 234.567 234.5®7® 234.®6® 23®5® 3965 3911 \end{cfa} 3966 3912 If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits. … … 3969 3915 \end{cfa} 3970 3916 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3971 234567. 2.3457 @e+05@ 2.346@e+05@ 2.35@e+05@3917 234567. 2.3457®e+05® 2.346®e+05® 2.35®e+05® 3972 3918 \end{cfa} 3973 3919 If ©significant© is greater than ©minimum©, it defines the number of printed characters. … … 3985 3931 \end{cfa} 3986 3932 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 3987 27 @ @ 27.000000 27.500000 027 27.500@ @3933 27® ® 27.000000 27.500000 027 27.500® ® 3988 3934 \end{cfa} 3989 3935 … … 3992 3938 \begin{cfa}[belowskip=0pt] 3993 3939 sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) ); 3994 @00@27 @0@27 @00@27.5003940 ®00®27 ®0®27 ®00®27.500 3995 3941 \end{cfa} 3996 3942 \end{enumerate} … … 4088 4034 \end{cfa} 4089 4035 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4090 @abc @ 4091 @abc @ 4092 @xx@ 4036 ®abc ® 4037 ®abc ® 4038 ®xx® 4093 4039 \end{cfa} 4094 4040 … … 4101 4047 \end{cfa} 4102 4048 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4103 @abcd1233.456E+2@ 4049 ®abcd1233.456E+2® 4104 4050 \end{cfa} 4105 4051 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types. … … 4114 4060 \end{cfa} 4115 4061 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4116 @ -75.35e-4@254062 ® -75.35e-4® 25 4117 4063 \end{cfa} 4118 4064 … … 4126 4072 \end{cfa} 4127 4073 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4128 @bca@xyz4074 ®bca®xyz 4129 4075 \end{cfa} 4130 4076 … … 4138 4084 \end{cfa} 4139 4085 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] 4140 @xyz@bca4086 ®xyz®bca 4141 4087 \end{cfa} 4142 4088 \end{enumerate} … … 4155 4101 4156 4102 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. 4157 This means that users can define distinct function overloads for the new type \see{\VRef{s:Overloading} for more information}.4103 This means that users can define distinct function overloads for the new type (see Overloading for more information). 4158 4104 For example: 4159 4105 … … 4261 4207 \CFA supports C initialization of structures, but it also adds constructors for more advanced initialization. 4262 4208 Additionally, \CFA adds destructors that are called when a variable is deallocated (variable goes out of scope or object is deleted). 4263 These functions take a reference to the structure as a parameter \see{\VRef{s:PointerReference} for more information}.4209 These functions take a reference to the structure as a parameter (see References for more information). 4264 4210 4265 4211 \begin{figure} … … 4312 4258 4313 4259 \section{Overloading} 4314 \label{s:Overloading}4315 4260 4316 4261 Overloading refers to the capability of a programmer to define and use multiple objects in a program with the same name. … … 4523 4468 For example, given 4524 4469 \begin{cfa} 4525 auto j = @...@4470 auto j = ®...® 4526 4471 \end{cfa} 4527 4472 and the need to write a routine to compute using ©j© 4528 4473 \begin{cfa} 4529 void rtn( @...@parm );4474 void rtn( ®...® parm ); 4530 4475 rtn( j ); 4531 4476 \end{cfa} … … 4768 4713 4769 4714 coroutine Fibonacci { 4770 int fn; $\C{// used for communication}$4715 int fn; §\C{// used for communication}§ 4771 4716 }; 4772 4717 void ?{}( Fibonacci * this ) { … … 4774 4719 } 4775 4720 void main( Fibonacci * this ) { 4776 int fn1, fn2; $\C{// retained between resumes}$4777 this->fn = 0; $\C{// case 0}$4721 int fn1, fn2; §\C{// retained between resumes}§ 4722 this->fn = 0; §\C{// case 0}§ 4778 4723 fn1 = this->fn; 4779 suspend(); $\C{// return to last resume}$4780 4781 this->fn = 1; $\C{// case 1}$4724 suspend(); §\C{// return to last resume}§ 4725 4726 this->fn = 1; §\C{// case 1}§ 4782 4727 fn2 = fn1; 4783 4728 fn1 = this->fn; 4784 suspend(); $\C{// return to last resume}$4785 4786 for ( ;; ) { $\C{// general case}$4729 suspend(); §\C{// return to last resume}§ 4730 4731 for ( ;; ) { §\C{// general case}§ 4787 4732 this->fn = fn1 + fn2; 4788 4733 fn2 = fn1; 4789 4734 fn1 = this->fn; 4790 suspend(); $\C{// return to last resume}$4735 suspend(); §\C{// return to last resume}§ 4791 4736 } // for 4792 4737 } 4793 4738 int next( Fibonacci * this ) { 4794 resume( this ); $\C{// transfer to last suspend}$4739 resume( this ); §\C{// transfer to last suspend}§ 4795 4740 return this->fn; 4796 4741 } … … 5019 4964 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. 5020 4965 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}.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). 5022 4967 5023 4968 … … 6337 6282 In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as: 6338 6283 \begin{cfa} 6339 *? $\R{\textvisiblespace}$*? $\C{// dereference operator, dereference operator}$6340 * $\R{\textvisiblespace}$?*? $\C{// dereference, multiplication operator}$6284 *?§\color{red}\textvisiblespace§*? §\C{// dereference operator, dereference operator}§ 6285 *§\color{red}\textvisiblespace§?*? §\C{// dereference, multiplication operator}§ 6341 6286 \end{cfa} 6342 6287 By default, the first interpretation is selected, which does not yield a meaningful parse. … … 6347 6292 The ambiguity occurs when the deference operator has no parameters: 6348 6293 \begin{cfa} 6349 *?() $\R{\textvisiblespace...}$;6350 *?() $\R{\textvisiblespace...}$(...) ;6294 *?()§\color{red}\textvisiblespace...§ ; 6295 *?()§\color{red}\textvisiblespace...§(...) ; 6351 6296 \end{cfa} 6352 6297 requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate. … … 6356 6301 The remaining cases are with the increment/decrement operators and conditional expression, \eg: 6357 6302 \begin{cfa} 6358 i++? $\R{\textvisiblespace...}$(...);6359 i?++ $\R{\textvisiblespace...}$(...);6303 i++?§\color{red}\textvisiblespace...§(...); 6304 i?++§\color{red}\textvisiblespace...§(...); 6360 6305 \end{cfa} 6361 6306 requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an incorrect expression (juxtaposed identifiers). 6362 6307 Therefore, it is necessary to disambiguate these cases with a space: 6363 6308 \begin{cfa} 6364 i++ $\R{\textvisiblespace}$? i : 0;6365 i? $\R{\textvisiblespace}$++i : 0;6309 i++§\color{red}\textvisiblespace§? i : 0; 6310 i?§\color{red}\textvisiblespace§++i : 0; 6366 6311 \end{cfa} 6367 6312 … … 6376 6321 \begin{description} 6377 6322 \item[Change:] add new keywords \\ 6378 New keywords are added to \CFA \see{\VRef{s:CFAKeywords}}.6323 New keywords are added to \CFA (see~\VRef{s:CFAKeywords}). 6379 6324 \item[Rationale:] keywords added to implement new semantics of \CFA. 6380 6325 \item[Effect on original feature:] change to semantics of well-defined feature. \\ 6381 6326 Any \Celeven programs using these keywords as identifiers are invalid \CFA programs. 6382 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism \see{\VRef{s:BackquoteIdentifiers}}.6327 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism (see~\VRef{s:BackquoteIdentifiers}). 6383 6328 \item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare. 6384 6329 \end{description} … … 6390 6335 \eg: 6391 6336 \begin{cfa} 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 );}$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 );}§ 6396 6341 \end{cfa} 6397 6342 \CFA continues to support K\&R routine definitions: 6398 6343 \begin{cfa} 6399 f( a, b, c ) $\C{// default int return}$6400 int a, b; char c $\C{// K\&R parameter declarations}$6344 f( a, b, c ) §\C{// default int return}§ 6345 int a, b; char c §\C{// K\&R parameter declarations}§ 6401 6346 { 6402 6347 ... … … 6417 6362 int rtn( int i ); 6418 6363 int rtn( char c ); 6419 rtn( 'x' ); $\C{// programmer expects 2nd rtn to be called}$6364 rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§ 6420 6365 \end{cfa} 6421 6366 \item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first. … … 6439 6384 \item[Change:] make string literals ©const©: 6440 6385 \begin{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}$6386 char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§ 6387 char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§ 6443 6388 \end{cfa} 6444 6389 The type of a string literal is changed from ©[] char© to ©const [] char©. … … 6447 6392 \begin{cfa} 6448 6393 char * p = "abc"; 6449 p[0] = 'w'; $\C{// segment fault or change constant literal}$6394 p[0] = 'w'; §\C{// segment fault or change constant literal}§ 6450 6395 \end{cfa} 6451 6396 The same problem occurs when passing a string literal to a routine that changes its argument. … … 6459 6404 \item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope: 6460 6405 \begin{cfa} 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}$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}§ 6464 6409 \end{cfa} 6465 6410 is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed. … … 6467 6412 \begin{cfa} 6468 6413 struct X { int i; struct X *next; }; 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}$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}§ 6472 6417 \end{cfa} 6473 6418 \item[Rationale:] avoids having different initialization rules for builtin types and user-defined types. … … 6481 6426 \item[Change:] have ©struct© introduce a scope for nested types: 6482 6427 \begin{cfa} 6483 enum @Colour@{ R, G, B, Y, C, M };6428 enum ®Colour® { R, G, B, Y, C, M }; 6484 6429 struct Person { 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)}$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)}§ 6488 6433 }; 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}$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}§ 6492 6437 }; 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$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§ 6496 6441 \end{cfa} 6497 6442 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 outer-most type, which is not useful and confusing. … … 6510 6455 \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: 6511 6456 \begin{cfa} 6512 struct Y; $\C{// struct Y and struct X are at the same scope}$6457 struct Y; §\C{// struct Y and struct X are at the same scope}§ 6513 6458 struct X { 6514 6459 struct Y { /* ... */ } y; … … 6525 6470 \begin{cfa} 6526 6471 void foo() { 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 *}$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 *}§ 6529 6474 } 6530 6475 \end{cfa} 6531 6476 \item[Rationale:] increase type safety 6532 6477 \item[Effect on original feature:] deletion of semantically well-defined feature. 6533 \item[Difficulty of converting:] requires adding a cast \see{\VRef{s:StorageManagement} for better alternatives}:6478 \item[Difficulty of converting:] requires adding a cast (see \VRef{s:StorageManagement} for better alternatives): 6534 6479 \begin{cfa} 6535 6480 int * b = (int *)malloc( sizeof(int) ); … … 6641 6586 \end{cquote} 6642 6587 For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©; 6643 hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}.6588 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}). 6644 6589 All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling. 6645 6590 This approach is different from \Index*[C++]{\CC{}} where the name-mangling issue is handled internally in C header-files through checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers. … … 6704 6649 Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in 6705 6650 \begin{cfa} 6706 int * ip = (int *)malloc( sizeof(int) ); $\C{// C}$6707 int * ip = malloc(); $\C{// \CFA type-safe version of C malloc}$6708 int * ip = alloc(); $\C{// \CFA type-safe uniform alloc}$6651 int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§ 6652 int * ip = malloc(); §\C{// \CFA type-safe version of C malloc}§ 6653 int * ip = alloc(); §\C{// \CFA type-safe uniform alloc}§ 6709 6654 \end{cfa} 6710 6655 the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©. … … 6713 6658 \begin{cfa} 6714 6659 struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment 6715 S * sp = malloc(); $\C{// honour type alignment}$6660 S * sp = malloc(); §\C{// honour type alignment}§ 6716 6661 \end{cfa} 6717 6662 the storage allocation is implicitly aligned to 128 rather than the default 16. … … 6728 6673 \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in 6729 6674 \begin{cfa} 6730 struct S { int i; }; $\C{// cache-line alignment}$6675 struct S { int i; }; §\C{// cache-line aglinment}§ 6731 6676 void ?{}( S & s, int i ) { s.i = i; } 6732 6677 // assume ?|? operator for printing an S 6733 6678 6734 S & sp = * @new@( 3 ); $\C{// call constructor after allocation}$6679 S & sp = *®new®( 3 ); §\C{// call constructor after allocation}§ 6735 6680 sout | sp.i; 6736 @delete@( &sp );6737 6738 S * spa = @anew@( 10, 5 ); $\C{// allocate array and initialize each array element}$6681 ®delete®( &sp ); 6682 6683 S * spa = ®anew®( 10, 5 ); §\C{// allocate array and initialize each array element}§ 6739 6684 for ( i; 10 ) sout | spa[i] | nonl; 6740 6685 sout | nl; 6741 @adelete@( 10, spa );6686 ®adelete®( 10, spa ); 6742 6687 \end{cfa} 6743 6688 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor. … … 6748 6693 extern "C" { 6749 6694 // C unsafe allocation 6750 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}$// CFA6695 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}§ // CFA 6757 6702 6758 6703 // C unsafe initialization/copy 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}$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}§ 6761 6706 } 6762 6707 … … 6764 6709 6765 6710 forall( dtype T | sized(T) ) { 6766 // $\CFA$safe equivalents, i.e., implicit size specification6711 // §\CFA§ safe equivalents, i.e., implicit size specification 6767 6712 T * malloc( void ); 6768 6713 T * calloc( size_t dim ); … … 6773 6718 int posix_memalign( T ** ptr, size_t align ); 6774 6719 6775 // $\CFA$safe general allocation, fill, resize, alignment, array6776 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 specification6800 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 types6720 // §\CFA§ safe general allocation, fill, resize, alignment, array 6721 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 specification 6745 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 types 6804 6749 T * amemset( T dest[], char fill, size_t dim ); 6805 6750 T * amemcpy( T dest[], const T src[], size_t dim ); 6806 6751 } 6807 6752 6808 // $\CFA$allocation/deallocation and constructor/destructor, non-array types6809 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}$6753 // §\CFA§ allocation/deallocation and constructor/destructor, non-array types 6754 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}§ 6811 6756 forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) 6812 6757 void delete( T * ptr, Params rest ); 6813 6758 6814 // $\CFA$allocation/deallocation and constructor/destructor, array types6815 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}$6759 // §\CFA§ allocation/deallocation and constructor/destructor, array types 6760 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}§ 6817 6762 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) 6818 6763 void adelete( size_t dim, T arr[], Params rest ); … … 6824 6769 \leavevmode 6825 6770 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6826 int ato( const char * ptr ); $\indexc{ato}$6771 int ato( const char * ptr );§\indexc{ato}§ 6827 6772 unsigned int ato( const char * ptr ); 6828 6773 long int ato( const char * ptr ); … … 6856 6801 \leavevmode 6857 6802 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 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}$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}§ 6862 6807 unsigned int bsearch( T key, const T * arr, size_t dim ); 6863 6808 6864 6809 forall( otype T | { int ?<?( T, T ); } ) 6865 void qsort( const T * arr, size_t dim ); $\indexc{qsort}$6810 void qsort( const T * arr, size_t dim );§\indexc{qsort}§ 6866 6811 6867 6812 forall( otype E | { int ?<?( E, E ); } ) { 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}$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}§ 6871 6816 size_t bsearchl( E key, const E * vals, size_t dim ); 6872 E * bsearchu( E key, const E * vals, size_t dim ); $\indexc{bsearchu}$6817 E * bsearchu( E key, const E * vals, size_t dim );§\indexc{bsearchu}§ 6873 6818 size_t bsearchu( E key, const E * vals, size_t dim ); 6874 6819 } … … 6884 6829 6885 6830 forall( otype E | { int ?<?( E, E ); } ) { 6886 void qsort( E * vals, size_t dim ); $\indexc{qsort}$6831 void qsort( E * vals, size_t dim );§\indexc{qsort}§ 6887 6832 } 6888 6833 \end{cfa} … … 6893 6838 \leavevmode 6894 6839 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6895 unsigned char abs( signed char ); $\indexc{abs}$6840 unsigned char abs( signed char );§\indexc{abs}§ 6896 6841 int abs( int ); 6897 6842 unsigned long int abs( long int ); … … 6912 6857 \leavevmode 6913 6858 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 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)}$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)}§ 6918 6863 int random( void ); 6919 int random( int u ); $\C{// [0,u)}$6920 int random( int l, int u ); $\C{// [l,u)}$6864 int random( int u ); §\C{// [0,u)}§ 6865 int random( int l, int u ); §\C{// [l,u)}§ 6921 6866 unsigned int random( void ); 6922 unsigned int random( unsigned int u ); $\C{// [0,u)}$6923 unsigned int random( unsigned int l, unsigned int u ); $\C{// [l,u)}$6867 unsigned int random( unsigned int u ); §\C{// [0,u)}§ 6868 unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u)}§ 6924 6869 long int random( void ); 6925 long int random( long int u ); $\C{// [0,u)}$6926 long int random( long int l, long int u ); $\C{// [l,u)}$6870 long int random( long int u ); §\C{// [0,u)}§ 6871 long int random( long int l, long int u ); §\C{// [l,u)}§ 6927 6872 unsigned long int random( void ); 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}$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}§ 6935 6880 \end{cfa} 6936 6881 … … 6940 6885 \leavevmode 6941 6886 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 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}$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}§ 6946 6891 \end{cfa} 6947 6892 … … 6957 6902 \leavevmode 6958 6903 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 6959 float ?%?( float, float ); $\indexc{fmod}$6904 float ?%?( float, float );§\indexc{fmod}§ 6960 6905 float fmod( float, float ); 6961 6906 double ?%?( double, double ); … … 6964 6909 long double fmod( long double, long double ); 6965 6910 6966 float remainder( float, float ); $\indexc{remainder}$6911 float remainder( float, float );§\indexc{remainder}§ 6967 6912 double remainder( double, double ); 6968 6913 long double remainder( long double, long double ); 6969 6914 6970 float remquo( float, float, int * ); $\indexc{remquo}$6915 float remquo( float, float, int * );§\indexc{remquo}§ 6971 6916 double remquo( double, double, int * ); 6972 6917 long double remquo( long double, long double, int * ); … … 6975 6920 [ int, long double ] remquo( long double, long double ); 6976 6921 6977 float div( float, float, int * ); $\indexc{div}$ $\C{// alternative name for remquo}$6922 float div( float, float, int * );§\indexc{div}§ §\C{// alternative name for remquo}§ 6978 6923 double div( double, double, int * ); 6979 6924 long double div( long double, long double, int * ); … … 6982 6927 [ int, long double ] div( long double, long double ); 6983 6928 6984 float fma( float, float, float ); $\indexc{fma}$6929 float fma( float, float, float );§\indexc{fma}§ 6985 6930 double fma( double, double, double ); 6986 6931 long double fma( long double, long double, long double ); 6987 6932 6988 float fdim( float, float ); $\indexc{fdim}$6933 float fdim( float, float );§\indexc{fdim}§ 6989 6934 double fdim( double, double ); 6990 6935 long double fdim( long double, long double ); 6991 6936 6992 float nan( const char * ); $\indexc{nan}$6937 float nan( const char * );§\indexc{nan}§ 6993 6938 double nan( const char * ); 6994 6939 long double nan( const char * ); … … 7000 6945 \leavevmode 7001 6946 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7002 float exp( float ); $\indexc{exp}$6947 float exp( float );§\indexc{exp}§ 7003 6948 double exp( double ); 7004 6949 long double exp( long double ); … … 7007 6952 long double _Complex exp( long double _Complex ); 7008 6953 7009 float exp2( float ); $\indexc{exp2}$6954 float exp2( float );§\indexc{exp2}§ 7010 6955 double exp2( double ); 7011 6956 long double exp2( long double ); … … 7014 6959 // long double _Complex exp2( long double _Complex ); 7015 6960 7016 float expm1( float ); $\indexc{expm1}$6961 float expm1( float );§\indexc{expm1}§ 7017 6962 double expm1( double ); 7018 6963 long double expm1( long double ); 7019 6964 7020 float pow( float, float ); $\indexc{pow}$6965 float pow( float, float );§\indexc{pow}§ 7021 6966 double pow( double, double ); 7022 6967 long double pow( long double, long double ); … … 7031 6976 \leavevmode 7032 6977 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7033 float log( float ); $\indexc{log}$6978 float log( float );§\indexc{log}§ 7034 6979 double log( double ); 7035 6980 long double log( long double ); … … 7038 6983 long double _Complex log( long double _Complex ); 7039 6984 7040 float log2( float ); $\indexc{log2}$6985 float log2( float );§\indexc{log2}§ 7041 6986 double log2( double ); 7042 6987 long double log2( long double ); … … 7045 6990 // long double _Complex log2( long double _Complex ); 7046 6991 7047 float log10( float ); $\indexc{log10}$6992 float log10( float );§\indexc{log10}§ 7048 6993 double log10( double ); 7049 6994 long double log10( long double ); … … 7052 6997 // long double _Complex log10( long double _Complex ); 7053 6998 7054 float log1p( float ); $\indexc{log1p}$6999 float log1p( float );§\indexc{log1p}§ 7055 7000 double log1p( double ); 7056 7001 long double log1p( long double ); 7057 7002 7058 int ilogb( float ); $\indexc{ilogb}$7003 int ilogb( float );§\indexc{ilogb}§ 7059 7004 int ilogb( double ); 7060 7005 int ilogb( long double ); 7061 7006 7062 float logb( float ); $\indexc{logb}$7007 float logb( float );§\indexc{logb}§ 7063 7008 double logb( double ); 7064 7009 long double logb( long double ); 7065 7010 7066 float sqrt( float ); $\indexc{sqrt}$7011 float sqrt( float );§\indexc{sqrt}§ 7067 7012 double sqrt( double ); 7068 7013 long double sqrt( long double ); … … 7071 7016 long double _Complex sqrt( long double _Complex ); 7072 7017 7073 float cbrt( float ); $\indexc{cbrt}$7018 float cbrt( float );§\indexc{cbrt}§ 7074 7019 double cbrt( double ); 7075 7020 long double cbrt( long double ); 7076 7021 7077 float hypot( float, float ); $\indexc{hypot}$7022 float hypot( float, float );§\indexc{hypot}§ 7078 7023 double hypot( double, double ); 7079 7024 long double hypot( long double, long double ); … … 7085 7030 \leavevmode 7086 7031 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7087 float sin( float ); $\indexc{sin}$7032 float sin( float );§\indexc{sin}§ 7088 7033 double sin( double ); 7089 7034 long double sin( long double ); … … 7092 7037 long double _Complex sin( long double _Complex ); 7093 7038 7094 float cos( float ); $\indexc{cos}$7039 float cos( float );§\indexc{cos}§ 7095 7040 double cos( double ); 7096 7041 long double cos( long double ); … … 7099 7044 long double _Complex cos( long double _Complex ); 7100 7045 7101 float tan( float ); $\indexc{tan}$7046 float tan( float );§\indexc{tan}§ 7102 7047 double tan( double ); 7103 7048 long double tan( long double ); … … 7106 7051 long double _Complex tan( long double _Complex ); 7107 7052 7108 float asin( float ); $\indexc{asin}$7053 float asin( float );§\indexc{asin}§ 7109 7054 double asin( double ); 7110 7055 long double asin( long double ); … … 7113 7058 long double _Complex asin( long double _Complex ); 7114 7059 7115 float acos( float ); $\indexc{acos}$7060 float acos( float );§\indexc{acos}§ 7116 7061 double acos( double ); 7117 7062 long double acos( long double ); … … 7120 7065 long double _Complex acos( long double _Complex ); 7121 7066 7122 float atan( float ); $\indexc{atan}$7067 float atan( float );§\indexc{atan}§ 7123 7068 double atan( double ); 7124 7069 long double atan( long double ); … … 7127 7072 long double _Complex atan( long double _Complex ); 7128 7073 7129 float atan2( float, float ); $\indexc{atan2}$7074 float atan2( float, float );§\indexc{atan2}§ 7130 7075 double atan2( double, double ); 7131 7076 long double atan2( long double, long double ); 7132 7077 7133 float atan( float, float ); $\C{// alternative name for atan2}$7134 double atan( double, double ); $\indexc{atan}$7078 float atan( float, float ); §\C{// alternative name for atan2}§ 7079 double atan( double, double );§\indexc{atan}§ 7135 7080 long double atan( long double, long double ); 7136 7081 \end{cfa} … … 7141 7086 \leavevmode 7142 7087 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7143 float sinh( float ); $\indexc{sinh}$7088 float sinh( float );§\indexc{sinh}§ 7144 7089 double sinh( double ); 7145 7090 long double sinh( long double ); … … 7148 7093 long double _Complex sinh( long double _Complex ); 7149 7094 7150 float cosh( float ); $\indexc{cosh}$7095 float cosh( float );§\indexc{cosh}§ 7151 7096 double cosh( double ); 7152 7097 long double cosh( long double ); … … 7155 7100 long double _Complex cosh( long double _Complex ); 7156 7101 7157 float tanh( float ); $\indexc{tanh}$7102 float tanh( float );§\indexc{tanh}§ 7158 7103 double tanh( double ); 7159 7104 long double tanh( long double ); … … 7162 7107 long double _Complex tanh( long double _Complex ); 7163 7108 7164 float asinh( float ); $\indexc{asinh}$7109 float asinh( float );§\indexc{asinh}§ 7165 7110 double asinh( double ); 7166 7111 long double asinh( long double ); … … 7169 7114 long double _Complex asinh( long double _Complex ); 7170 7115 7171 float acosh( float ); $\indexc{acosh}$7116 float acosh( float );§\indexc{acosh}§ 7172 7117 double acosh( double ); 7173 7118 long double acosh( long double ); … … 7176 7121 long double _Complex acosh( long double _Complex ); 7177 7122 7178 float atanh( float ); $\indexc{atanh}$7123 float atanh( float );§\indexc{atanh}§ 7179 7124 double atanh( double ); 7180 7125 long double atanh( long double ); … … 7189 7134 \leavevmode 7190 7135 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7191 float erf( float ); $\indexc{erf}$7136 float erf( float );§\indexc{erf}§ 7192 7137 double erf( double ); 7193 7138 long double erf( long double ); … … 7196 7141 long double _Complex erf( long double _Complex ); 7197 7142 7198 float erfc( float ); $\indexc{erfc}$7143 float erfc( float );§\indexc{erfc}§ 7199 7144 double erfc( double ); 7200 7145 long double erfc( long double ); … … 7203 7148 long double _Complex erfc( long double _Complex ); 7204 7149 7205 float lgamma( float ); $\indexc{lgamma}$7150 float lgamma( float );§\indexc{lgamma}§ 7206 7151 double lgamma( double ); 7207 7152 long double lgamma( long double ); … … 7210 7155 long double lgamma( long double, int * ); 7211 7156 7212 float tgamma( float ); $\indexc{tgamma}$7157 float tgamma( float );§\indexc{tgamma}§ 7213 7158 double tgamma( double ); 7214 7159 long double tgamma( long double ); … … 7220 7165 \leavevmode 7221 7166 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7222 float floor( float ); $\indexc{floor}$7167 float floor( float );§\indexc{floor}§ 7223 7168 double floor( double ); 7224 7169 long double floor( long double ); 7225 7170 7226 float ceil( float ); $\indexc{ceil}$7171 float ceil( float );§\indexc{ceil}§ 7227 7172 double ceil( double ); 7228 7173 long double ceil( long double ); 7229 7174 7230 float trunc( float ); $\indexc{trunc}$7175 float trunc( float );§\indexc{trunc}§ 7231 7176 double trunc( double ); 7232 7177 long double trunc( long double ); 7233 7178 7234 float rint( float ); $\indexc{rint}$7179 float rint( float );§\indexc{rint}§ 7235 7180 long double rint( long double ); 7236 7181 long int rint( float ); … … 7241 7186 long long int rint( long double ); 7242 7187 7243 long int lrint( float ); $\indexc{lrint}$7188 long int lrint( float );§\indexc{lrint}§ 7244 7189 long int lrint( double ); 7245 7190 long int lrint( long double ); … … 7248 7193 long long int llrint( long double ); 7249 7194 7250 float nearbyint( float ); $\indexc{nearbyint}$7195 float nearbyint( float );§\indexc{nearbyint}§ 7251 7196 double nearbyint( double ); 7252 7197 long double nearbyint( long double ); 7253 7198 7254 float round( float ); $\indexc{round}$7199 float round( float );§\indexc{round}§ 7255 7200 long double round( long double ); 7256 7201 long int round( float ); … … 7261 7206 long long int round( long double ); 7262 7207 7263 long int lround( float ); $\indexc{lround}$7208 long int lround( float );§\indexc{lround}§ 7264 7209 long int lround( double ); 7265 7210 long int lround( long double ); … … 7274 7219 \leavevmode 7275 7220 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7276 float copysign( float, float ); $\indexc{copysign}$7221 float copysign( float, float );§\indexc{copysign}§ 7277 7222 double copysign( double, double ); 7278 7223 long double copysign( long double, long double ); 7279 7224 7280 float frexp( float, int * ); $\indexc{frexp}$7225 float frexp( float, int * );§\indexc{frexp}§ 7281 7226 double frexp( double, int * ); 7282 7227 long double frexp( long double, int * ); 7283 7228 7284 float ldexp( float, int ); $\indexc{ldexp}$7229 float ldexp( float, int );§\indexc{ldexp}§ 7285 7230 double ldexp( double, int ); 7286 7231 long double ldexp( long double, int ); 7287 7232 7288 [ float, float ] modf( float ); $\indexc{modf}$7233 [ float, float ] modf( float );§\indexc{modf}§ 7289 7234 float modf( float, float * ); 7290 7235 [ double, double ] modf( double ); … … 7293 7238 long double modf( long double, long double * ); 7294 7239 7295 float nextafter( float, float ); $\indexc{nextafter}$7240 float nextafter( float, float );§\indexc{nextafter}§ 7296 7241 double nextafter( double, double ); 7297 7242 long double nextafter( long double, long double ); 7298 7243 7299 float nexttoward( float, long double ); $\indexc{nexttoward}$7244 float nexttoward( float, long double );§\indexc{nexttoward}§ 7300 7245 double nexttoward( double, long double ); 7301 7246 long double nexttoward( long double, long double ); 7302 7247 7303 float scalbn( float, int ); $\indexc{scalbn}$7248 float scalbn( float, int );§\indexc{scalbn}§ 7304 7249 double scalbn( double, int ); 7305 7250 long double scalbn( long double, int ); 7306 7251 7307 float scalbln( float, long int ); $\indexc{scalbln}$7252 float scalbln( float, long int );§\indexc{scalbln}§ 7308 7253 double scalbln( double, long int ); 7309 7254 long double scalbln( long double, long int ); … … 7322 7267 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7323 7268 struct Duration { 7324 int64_t tv; $\C{// nanoseconds}$7269 int64_t tv; §\C{// nanoseconds}§ 7325 7270 }; 7326 7271 … … 7452 7397 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7453 7398 struct Time { 7454 uint64_t tv; $\C{// nanoseconds since UNIX epoch}$7399 uint64_t tv; §\C{// nanoseconds since UNIX epoch}§ 7455 7400 }; 7456 7401 … … 7523 7468 \begin{cfa}[aboveskip=0pt,belowskip=0pt] 7524 7469 struct Clock { 7525 Duration offset; $\C{// for virtual clock: contains offset from real-time}$7526 int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$7470 Duration offset; §\C{// for virtual clock: contains offset from real-time}§ 7471 int clocktype; §\C{// implementation only -1 (virtual), CLOCK\_REALTIME}§ 7527 7472 }; 7528 7473 … … 7532 7477 void ?{}( Clock & clk, Duration adj ); 7533 7478 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}$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}§ 7539 7484 Time getTime( Clock & clk ); 7540 7485 Time ?()( Clock & clk ); … … 7552 7497 7553 7498 \begin{cfa} 7554 void ?{}( Int * this ); $\C{// constructor/destructor}$7499 void ?{}( Int * this ); §\C{// constructor/destructor}§ 7555 7500 void ?{}( Int * this, Int init ); 7556 7501 void ?{}( Int * this, zero_t ); … … 7561 7506 void ^?{}( Int * this ); 7562 7507 7563 Int ?=?( Int * lhs, Int rhs ); $\C{// assignment}$7508 Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§ 7564 7509 Int ?=?( Int * lhs, long int rhs ); 7565 7510 Int ?=?( Int * lhs, unsigned long int rhs ); … … 7578 7523 unsigned long int narrow( Int val ); 7579 7524 7580 int ?==?( Int oper1, Int oper2 ); $\C{// comparison}$7525 int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§ 7581 7526 int ?==?( Int oper1, long int oper2 ); 7582 7527 int ?==?( long int oper2, Int oper1 ); … … 7614 7559 int ?>=?( unsigned long int oper1, Int oper2 ); 7615 7560 7616 Int +?( Int oper ); $\C{// arithmetic}$7561 Int +?( Int oper ); §\C{// arithmetic}§ 7617 7562 Int -?( Int oper ); 7618 7563 Int ~?( Int oper ); … … 7696 7641 Int ?>>=?( Int * lhs, mp_bitcnt_t shift ); 7697 7642 7698 Int abs( Int oper ); $\C{// number functions}$7643 Int abs( Int oper ); §\C{// number functions}§ 7699 7644 Int fact( unsigned long int N ); 7700 7645 Int gcd( Int oper1, Int oper2 ); … … 7708 7653 Int sqrt( Int oper ); 7709 7654 7710 forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp ); $\C{// I/O}$7655 forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp ); §\C{// I/O}§ 7711 7656 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp ); 7712 7657 \end{cfa} … … 7719 7664 \hline 7720 7665 \begin{cfa} 7721 #include <gmp> $\indexc{gmp}$7666 #include <gmp>§\indexc{gmp}§ 7722 7667 int main( void ) { 7723 7668 sout | "Factorial Numbers"; … … 7733 7678 & 7734 7679 \begin{cfa} 7735 #include <gmp.h> $\indexc{gmp.h}$7680 #include <gmp.h>§\indexc{gmp.h}§ 7736 7681 int main( void ) { 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 );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 ); 7741 7686 for ( unsigned int i = 1; i <= 40; i += 1 ) { 7742 @mpz_mul_ui@( fact, fact, i );7743 @gmp_printf@( "%d %Zd\n", i, fact );7687 ®mpz_mul_ui®( fact, fact, i ); 7688 ®gmp_printf®( "%d %Zd\n", i, fact ); 7744 7689 } 7745 7690 } … … 7806 7751 \begin{cfa}[belowskip=0pt] 7807 7752 // implementation 7808 struct Rational { $\indexc{Rational}$7809 long int numerator, denominator; $\C{// invariant: denominator > 0}$7753 struct Rational {§\indexc{Rational}§ 7754 long int numerator, denominator; §\C{// invariant: denominator > 0}§ 7810 7755 }; // Rational 7811 7756 7812 Rational rational(); $\C{// constructors}$7757 Rational rational(); §\C{// constructors}§ 7813 7758 Rational rational( long int n ); 7814 7759 Rational rational( long int n, long int d ); … … 7816 7761 void ?{}( Rational * r, one_t ); 7817 7762 7818 long int numerator( Rational r ); $\C{// numerator/denominator getter/setter}$7763 long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§ 7819 7764 long int numerator( Rational r, long int n ); 7820 7765 long int denominator( Rational r ); 7821 7766 long int denominator( Rational r, long int d ); 7822 7767 7823 int ?==?( Rational l, Rational r ); $\C{// comparison}$7768 int ?==?( Rational l, Rational r ); §\C{// comparison}§ 7824 7769 int ?!=?( Rational l, Rational r ); 7825 7770 int ?<?( Rational l, Rational r ); … … 7828 7773 int ?>=?( Rational l, Rational r ); 7829 7774 7830 Rational -?( Rational r ); $\C{// arithmetic}$7775 Rational -?( Rational r ); §\C{// arithmetic}§ 7831 7776 Rational ?+?( Rational l, Rational r ); 7832 7777 Rational ?-?( Rational l, Rational r ); … … 7834 7779 Rational ?/?( Rational l, Rational r ); 7835 7780 7836 double widen( Rational r ); $\C{// conversion}$7781 double widen( Rational r ); §\C{// conversion}§ 7837 7782 Rational narrow( double f, long int md ); 7838 7783 -
src/main.cc
rf4eb705 rd4a4b17 9 9 // Author : Peter Buhr and Rob Schluntz 10 10 // Created On : Fri May 15 23:12:02 2015 11 // Last Modified By : Peter A. Buhr12 // Last Modified On : Mon Feb 8 21:10:16 202113 // Update Count : 6 4211 // Last Modified By : Andrew Beach 12 // Last Modified On : Mon Dec 7 15:29:00 2020 13 // Update Count : 639 14 14 // 15 15 … … 492 492 493 493 static const char * description[] = { 494 "diagnostic color: never, always, auto",// -c494 "diagnostic color: never, always, or auto.", // -c 495 495 "wait for gdb to attach", // -g 496 "print translator help message",// -h496 "print help message", // -h 497 497 "generate libcfa.c", // -l 498 498 "generate line marks", // -L … … 500 500 "do not generate line marks", // -N 501 501 "do not read prelude", // -n 502 " do not generate prelude prototypes => prelude not printed",// -p502 "generate prototypes for prelude functions", // -p 503 503 "only print deterministic output", // -d 504 504 "Use the old-ast", // -O … … 506 506 "print", // -P 507 507 "<directory> prelude directory for debug/nodebug", // no flag 508 "<option-list> enable profiling information: counters, heap, time, all,none", // -S508 "<option-list> enable profiling information:\n counters,heap,time,all,none", // -S 509 509 "building cfa standard lib", // -t 510 510 "", // -w
Note: See TracChangeset
for help on using the changeset viewer.