- Timestamp:
- Jun 14, 2016, 12:22:45 PM (8 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- 4c82a3c
- Parents:
- d2a182e
- Location:
- doc
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
doc/LaTeXmacros/common.tex
rd2a182e r45576af9 11 11 %% Created On : Sat Apr 9 10:06:17 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Fri Jun 3 09:32:19201614 %% Update Count : 6213 %% Last Modified On : Fri Jun 10 16:35:25 2016 14 %% Update Count : 101 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 56 56 % \belowdisplayskip \abovedisplayskip 57 57 %} 58 59 \usepackage{pslatex} % reduce size of san serif font 58 60 \usepackage{relsize} % must be after change to small or selects old size 59 61 … … 79 81 \vskip 50\p@ 80 82 }} 81 \renewcommand\section{\@startsection{section}{1}{\z@}{-3.5ex \@plus -1ex \@minus -.2ex}{ 2.3ex \@plus .2ex}{\normalfont\large\bfseries}}83 \renewcommand\section{\@startsection{section}{1}{\z@}{-3.5ex \@plus -1ex \@minus -.2ex}{1.75ex \@plus .2ex}{\normalfont\large\bfseries}} 82 84 \renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-3.25ex \@plus -1ex \@minus -.2ex}{1.5ex \@plus .2ex}{\normalfont\normalsize\bfseries}} 83 85 \renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}} … … 132 134 133 135 \newenvironment{quote2}{% 134 \list{}{\lstset{resetmargins=true }\leftmargin=\parindent\rightmargin\leftmargin}%136 \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}% 135 137 \item\relax 136 138 }{% … … 199 201 language=CFA, 200 202 columns=flexible, 201 basicstyle=\ sf,203 basicstyle=\linespread{0.9}\sf, 202 204 stringstyle=\tt, 203 205 tabsize=4, … … 210 212 showlines=true, 211 213 aboveskip=4pt, 212 belowskip= 2pt,214 belowskip=3pt, 213 215 moredelim=**[is][\color{red}]{®}{®}, % red highlighting 214 % moredelim=**[is][\color{blue}]{¢}{¢}, % blue highlighting 216 moredelim=**[is][\color{blue}]{ß}{ß}, % blue highlighting 217 moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting 215 218 moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords 216 % literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used for red highlighting 217 literate={...}{{$\dots$}}1 {<-}{{$\leftarrow$}}1 {=>}{{$\Rightarrow$}}1, 219 % replace/adjust listing characters that look bad in sanserif 220 literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1 221 {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1 222 {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {...}{$\dots$}2, 218 223 }% 219 224 220 225 \lstMakeShortInline© % single-character for \lstinline 221 222 \makeatletter223 % replace/adjust listings characters that look bad in sanserif224 \lst@CCPutMacro225 \lst@ProcessOther{"22}{\lst@ttfamily{"}{\raisebox{0.3ex}{\ttfamily\upshape "}}} % replace double quote226 \lst@ProcessOther{"27}{\lst@ttfamily{'}{\raisebox{0.3ex}{\ttfamily\upshape '\hspace*{-2pt}}}} % replace single quote227 \lst@ProcessOther{"2D}{\lst@ttfamily{-}{\textbf{\texttt{-}}}} % replace minus228 \lst@ProcessOther{"3C}{\lst@ttfamily{<}{\textbf{\texttt{<}}}} % replace less than229 \lst@ProcessOther{"3E}{\lst@ttfamily{>}{\textbf{\texttt{>}}}} % replace greater than230 \lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex231 \lst@ProcessOther{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore232 \lst@ProcessOther{"60}{\lst@ttfamily{`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}} % replace backquote233 \lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde234 %\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde235 \@empty\z@\@empty % NECESSARY DO NOT REMOVE236 \makeatother237 226 238 227 % Local Variables: % -
doc/user/Cdecl.fig
rd2a182e r45576af9 34 34 1 1 1.00 45.00 90.00 35 35 1950 1275 1950 1500 36 4 1 0 50 -1 4 90.0000 2 105 90 1350 1650 0\00137 4 1 0 50 -1 4 90.0000 2 105 90 1500 1650 1\00138 4 1 0 50 -1 4 90.0000 2 105 90 1650 1650 2\00139 4 1 0 50 -1 4 90.0000 2 105 90 1800 1650 3\00140 4 1 0 50 -1 4 90.0000 2 105 90 1950 1650 4\00141 4 1 0 50 -1 4 90.0000 2 75 75 1200 1325 x\00136 4 1 0 50 -1 4 10 0.0000 2 105 90 1350 1650 0\001 37 4 1 0 50 -1 4 10 0.0000 2 105 90 1500 1650 1\001 38 4 1 0 50 -1 4 10 0.0000 2 105 90 1650 1650 2\001 39 4 1 0 50 -1 4 10 0.0000 2 105 90 1800 1650 3\001 40 4 1 0 50 -1 4 10 0.0000 2 105 90 1950 1650 4\001 41 4 1 0 50 -1 4 10 0.0000 2 75 75 1200 1325 x\001 42 42 -6 43 43 6 2325 1200 3600 1350 … … 54 54 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 55 55 2850 1200 3600 1200 3600 1350 2850 1350 2850 1200 56 4 1 0 50 -1 4 90.0000 2 105 90 2925 1325 0\00157 4 1 0 50 -1 4 90.0000 2 105 90 3075 1325 1\00158 4 1 0 50 -1 4 90.0000 2 105 90 3225 1325 2\00159 4 1 0 50 -1 4 90.0000 2 105 90 3375 1325 3\00160 4 1 0 50 -1 4 90.0000 2 105 90 3525 1325 4\00156 4 1 0 50 -1 4 10 0.0000 2 105 90 2925 1325 0\001 57 4 1 0 50 -1 4 10 0.0000 2 105 90 3075 1325 1\001 58 4 1 0 50 -1 4 10 0.0000 2 105 90 3225 1325 2\001 59 4 1 0 50 -1 4 10 0.0000 2 105 90 3375 1325 3\001 60 4 1 0 50 -1 4 10 0.0000 2 105 90 3525 1325 4\001 61 61 -6 62 62 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 … … 66 66 2550 1275 2850 1275 67 67 -6 68 4 1 0 50 -1 4 90.0000 2 75 75 2400 1325 x\00168 4 1 0 50 -1 4 10 0.0000 2 75 75 2400 1325 x\001 69 69 -6 -
doc/user/user.tex
rd2a182e r45576af9 11 11 %% Created On : Wed Apr 6 14:53:29 2016 12 12 %% Last Modified By : Peter A. Buhr 13 %% Last Modified On : Fri Jun 3 09:49:31201614 %% Update Count : 28113 %% Last Modified On : Fri Jun 10 16:38:22 2016 14 %% Update Count : 394 15 15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 16 16 … … 18 18 19 19 % inline code ©...© (copyright symbol) emacs: C-q M-) 20 % red highlighting ®...® (registered trademark sumbol) emacs: C-q M-. 21 % latex escape §...§ (section symbol) emacs: C-q M-' 20 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-. 21 % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ 22 % green highlighting ¢...¢ (cent symbol) emacs: C-q M-" 23 % Latex escape §...§ (section symbol) emacs: C-q M-' 22 24 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ 23 25 % math escape $...$ (dollar symbol) 24 26 25 \documentclass[ openright,twoside]{article}27 \documentclass[twoside,11pt]{article} 26 28 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 27 29 … … 32 34 \usepackage{fullpage,times,comment} 33 35 \usepackage{epic,eepic} 34 \usepackage{upquote} % switch curled `' to straight `'36 \usepackage{upquote} % switch curled `'" to straight `'" 35 37 \usepackage{xspace} 36 38 \usepackage{varioref} % extended references 37 39 \usepackage{listings} % format program code 38 \usepackage {footmisc}% support label/reference in footnote40 \usepackage[flushmargin]{footmisc} % support label/reference in footnote 39 41 \usepackage{latexsym} % \Box glyph 40 42 \usepackage{mathptmx} % better math font with "times" 43 \usepackage[usenames]{color} 41 44 \usepackage[pagewise]{lineno} 42 45 \renewcommand{\linenumberfont}{\scriptsize\sffamily} 46 \input{common} % bespoke macros used in the document 43 47 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref} 44 48 \usepackage{breakurl} 45 49 \renewcommand{\UrlFont}{\small\sf} 46 50 47 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%48 49 % Bespoke macros used in the document.50 \input{common}51 52 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%53 54 51 % Names used in the document. 55 52 56 53 \newcommand{\Version}{1.0.0} 57 54 \newcommand{\CS}{C\raisebox{-0.9ex}{\large$^\sharp$}\xspace} 55 56 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}} 57 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}} 58 \newcommand{\R}[1]{\Textbf{#1}} 59 \newcommand{\B}[1]{{\Textbf[blue]{#1}}} 60 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}} 58 61 59 62 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% … … 110 113 111 114 \CFA\footnote{Pronounced ``C-for-all'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed an as evolutionary step forward from the C programming language. 112 The syntax of the \CFA language builds from C, and should look immediately familiar to C programmers.115 The syntax of the \CFA language builds from C, and should look immediately familiar to C/\CC programmers. 113 116 % Any language feature that is not described here can be assumed to be using the standard C11 syntax. 114 \CFA adds many modern programming-language features that directly lead sto increased \emph{safety} and \emph{productivity}, while maintaining interoperability with existing C programs and achieving C performance.117 \CFA adds many modern programming-language features that directly lead to increased \emph{safety} and \emph{productivity}, while maintaining interoperability with existing C programs and achieving C performance. 115 118 Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global garbage-collection. 116 119 The primary new features include parametric-polymorphism routines and types, exceptions, concurrency, and modules. … … 123 126 New programs can be written in \CFA using a combination of C and \CFA features. 124 127 \CC had a similar goal 30 years ago, but has struggled over the intervening time to incorporate modern programming-language features because of early design choices. 125 \CFA has 30 years of hindsight and clean starting point.128 \CFA has 30 years of hindsight and a clean starting point. 126 129 127 130 Like \CC, there may be both an old and new ways to achieve the same effect. 128 131 For example, the following programs compare the \CFA and C I/O mechanisms. 129 132 \begin{quote2} 130 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}131 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\133 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 134 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 132 135 \begin{lstlisting} 133 136 #include <fstream> 134 137 int main( void ) { 135 138 int x = 0, y = 1, z = 2; 136 sout | x | y | z | endl;139 ®sout | x | y | z | endl;® 137 140 } 138 141 \end{lstlisting} … … 142 145 int main( void ) { 143 146 int x = 0, y = 1, z = 2; 144 printf( "%d %d %d\n", x, y, z );147 ®printf( "%d %d %d\n", x, y, z );® 145 148 } 146 149 \end{lstlisting} … … 148 151 \end{quote2} 149 152 Both programs output the same result. 150 While the \CFA I/O looks similar to the \CC output style, there are severalimportant differences, such as automatic spacing between variables as in Python (see also~\VRef{s:IOLibrary}).151 152 This document is a referencemanual for the \CFA programming language, targeted at \CFA programmers.153 While the \CFA I/O looks similar to the \CC output style, there are important differences, such as automatic spacing between variables as in Python (see also~\VRef{s:IOLibrary}). 154 155 This document is a user manual for the \CFA programming language, targeted at \CFA programmers. 153 156 Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics. 154 157 In its current state, this document covers the intended core features of the language. … … 159 162 \section{History} 160 163 161 The \CFA project started with K-W C~\cite{ Till89,Buhr94a}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.164 The \CFA project started with K-W C~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples. 162 165 (See~\cite{Werther96} for some similar work, but for \CC.) 163 166 The original \CFA project~\cite{Ditchfield92} extended the C type system with parametric polymorphism and overloading, as opposed to the \CC approach of object-oriented extensions to the C type-system. 164 167 A first implementation of the core Cforall language was created~\cite{Bilson03,Esteves04}, but at the time there was little interesting in extending C, so work did not continue. 165 As the saying goes, ``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.168 As the saying goes, ``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. 166 169 167 170 … … 169 172 170 173 Even with all its problems, C is a very popular programming language because it allows writing software at virtually any level in a computer system without restriction. 171 For system sprogramming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.174 For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice. 172 175 As well, there are millions of lines of C legacy code, forming the base for many software development projects (especially on UNIX systems). 173 176 The TIOBE index (\url{http://www.tiobe.com/tiobe_index}) for March 2016 shows programming-language popularity, with Java 20.5\%, C 14.5\%, \CC 6.7\%, \CS 4.3\%, Python 4.3\%, and all other programming languages below 3\%. 177 As well, for 30 years, C has been the number 1 and 2 most popular programming language: 178 \begin{center} 179 \setlength{\tabcolsep}{1.5ex} 180 \begin{tabular}{@{}r|c|c|c|c|c|c|c@{}} 181 Ranking & 2016 & 2011 & 2006 & 2001 & 1996 & 1991 & 1986 \\ 182 \hline 183 Java & 1 & 1 & 1 & 3 & 29 & - & - \\ 184 \hline 185 \R{C} & \R{2} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} \\ 186 \hline 187 \CC & 3 & 3 & 3 & 2 & 2 & 2 & 7 \\ 188 \end{tabular} 189 \end{center} 174 190 Hence, C is still an extremely important programming language, with double the usage of \CC, where \CC itself is largely C code. 175 191 Finally, love it or hate it, C has been an important and influential part of computer science for 40 years and it appears it will continue to be for many more years. … … 178 194 The goal of this project is to engineer modern language features into C in an evolutionary rather than revolutionary way. 179 195 \CC~\cite{c++,ANSI14:C++} is an example of a similar project; 180 however, it largely extended the language, and did not address existing problems.\footnote{%196 however, it largely extended the language, and did not address many existing problems.\footnote{% 181 197 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.} 182 Fortran~\cite{Fortran08}, Ada~\cite{Ada12}, and Cobol~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features are added and problems fixed within the framework of the existing language.198 Fortran~\cite{Fortran08}, Ada~\cite{Ada12}, and Cobol~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (e.g., objects, concurrency) are added and problems fixed within the framework of the existing language. 183 199 Java~\cite{Java8}, Go~\cite{Go}, Rust~\cite{Rust} and D~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent. 184 200 These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection. 185 201 As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten. 186 These costs can be prohibitive for many companies with a large software base in C/\CC, and many programmers that requireretraining to a new programming language.187 188 The result of this project is a language that is largely backwards compatible with C11~\cite{C11}, but containing many modern language features and fixing some of the well known C problems.189 Without significant extension to the C programming language, C will beunable to cope with the needs of modern programming problems and programmers;202 These costs can be prohibitive for many companies with a large software base in C/\CC, and a significant number of programmers requiring retraining to a new programming language. 203 204 The result of this project is a language that is largely backwards compatible with C11~\cite{C11}, but fixing some of the well known C problems and containing many modern language features. 205 Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers; 190 206 as a result, it will fade into disuse. 191 207 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language. … … 200 216 This feature allows users of \CFA to take advantage of the existing panoply of C libraries from inside their \CFA code. 201 217 In fact, one of the biggest issues for any new programming language is establishing a minimum level of library code to support a large body of activities. 202 Programming-language developers often state that adequate library support takes more work than designing and implementing the language itself.218 Language developers often state that adequate library support takes more work than designing and implementing the language itself. 203 219 Like \CC, \CFA 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. 220 Hence, \CFA begins by leveraging the large repository of C libraries with little cost. 204 221 205 222 However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC. 206 For example, the C math-library provides the following routines for computing the absolute value of the basic type : ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.207 Whereas, \CFA wraps each of these routines into one with the common name ©abs©.223 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©. 224 Whereas, \CFA wraps each of these routines into ones with the common name ©abs©: 208 225 \begin{lstlisting} 209 226 char abs( char ); 210 227 extern "C" { 211 int abs( int ); // use default C routine for int228 int abs( int ); // use default C routine for int 212 229 } // extern "C" 213 230 long int abs( long int ); … … 233 250 \section[Compiling CFA Program]{Compiling \CFA Program} 234 251 235 The command ©cfa© is used to compile \CFA program(s). 236 This command works like the GNU ©gcc©\index{gcc} command, e.g.: 252 The command ©cfa© is used to compile \CFA program(s), and is based on the GNU ©gcc©\index{gcc} command, e.g.: 237 253 \begin{lstlisting} 238 254 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ] … … 240 256 By default, \CFA programs having the following ©gcc© flags turned on: 241 257 \begin{description} 242 \item\hspace*{- 4pt}\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}}258 \item\hspace*{-0.6ex}\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}} 243 259 The 1999 C standard plus GNU extensions. 244 \item\hspace*{- 4pt}\Indexc{-fgnu89-¶inline¶}\index{compilation option!-fgnu89-inline@{©-fgnu89-¶inline¶©}}260 \item\hspace*{-0.6ex}\Indexc{-fgnu89-¶inline¶}\index{compilation option!-fgnu89-inline@{©-fgnu89-¶inline¶©}} 245 261 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files. 246 262 \end{description} 247 263 The following new \CFA option is available: 248 264 \begin{description} 249 \item\hspace*{- 4pt}\Indexc{-CFA}\index{compilation option!-CFA@{©-CFA©}}265 \item\hspace*{-0.6ex}\Indexc{-CFA}\index{compilation option!-CFA@{©-CFA©}} 250 266 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. 251 267 \end{description} … … 253 269 The following preprocessor variables are available: 254 270 \begin{description} 255 \item\hspace*{- 4pt}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@{©__CFA__©}}271 \item\hspace*{-0.6ex}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@{©__CFA__©}} 256 272 is always available during preprocessing and its value is the current major \Index{version number} of \CFA.\footnote{ 257 273 The C preprocessor allows only integer values in a preprocessor variable so a value like ``\Version'' is not allowed. 258 274 Hence, the need to have three variables for the major, minor and patch version number.} 259 275 260 \item\hspace*{- 4pt}\Indexc{__CFA_MINOR__}\index{preprocessor variables!__CFA_MINOR__@{©__CFA_MINOR__©}}276 \item\hspace*{-0.6ex}\Indexc{__CFA_MINOR__}\index{preprocessor variables!__CFA_MINOR__@{©__CFA_MINOR__©}} 261 277 is always available during preprocessing and its value is the current minor \Index{version number} of \CFA. 262 278 263 \item\hspace*{- 4pt}\Indexc{__CFA_PATCH__}\index{preprocessor variables!__CFA_PATCH__@©__CFA_PATCH__©}279 \item\hspace*{-0.6ex}\Indexc{__CFA_PATCH__}\index{preprocessor variables!__CFA_PATCH__@©__CFA_PATCH__©} 264 280 is always available during preprocessing and its value is the current patch \Index{version number} of \CFA. 265 281 266 \item\hspace*{- 4pt}\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}267 is always available during preprocessing and it hasno value.282 \item\hspace*{-0.6ex}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©} and \Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©} 283 are always available during preprocessing and have no value. 268 284 \end{description} 269 285 … … 272 288 \begin{lstlisting} 273 289 #ifndef __CFORALL__ 274 #include <stdio.h> // C header file290 #include <stdio.h> // C header file 275 291 #else 276 #include <fstream> // §\CFA{}§ header file292 #include <fstream> // §\CFA{}§ header file 277 293 #endif 278 294 \end{lstlisting} … … 284 300 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.: 285 301 \begin{lstlisting} 286 2®_®147®_®483®_®648; // decimal constant287 56_ul; // decimal unsigned long constant288 0_377; // octal constant289 0x_ff_ff; // hexadecimal constant290 0x_ef3d_aa5c; // hexadecimal constant291 3.141_592_654; // floating point constant292 10_e_+1_00; // floating point constant293 0x_ff_ff_p_3; // hexadecimal floating point294 0x_1.ffff_ffff_p_128_l; // hexadecimal floating point long constant295 L_"\x_ff_ee"; // wide character constant302 2®_®147®_®483®_®648; // decimal constant 303 56_ul; // decimal unsigned long constant 304 0_377; // octal constant 305 0x_ff_ff; // hexadecimal constant 306 0x_ef3d_aa5c; // hexadecimal constant 307 3.141_592_654; // floating point constant 308 10_e_+1_00; // floating point constant 309 0x_ff_ff_p_3; // hexadecimal floating point 310 0x_1.ffff_ffff_p_128_l; // hexadecimal floating point long constant 311 L_"\x_ff_ee"; // wide character constant 296 312 \end{lstlisting} 297 313 The rules for placement of underscores is as follows: … … 311 327 \end{enumerate} 312 328 It is significantly easier to read and enter long constants when they are broken up into smaller groupings (most cultures use comma or period among digits for the same purpose). 313 This extension is backwards compatible, matches with the use of underscore in variable names, and appears in Ada and Java .329 This extension is backwards compatible, matches with the use of underscore in variable names, and appears in Ada and Java 8. 314 330 315 331 … … 321 337 \begin{quote2} 322 338 \begin{tabular}{@{}ll@{}} 323 \begin{lstlisting} [aboveskip=0pt,belowskip=0pt]324 int *x[ 5]339 \begin{lstlisting} 340 int *x[5] 325 341 \end{lstlisting} 326 342 & … … 332 348 For example, a routine returning a pointer to an array of integers is defined and used in the following way: 333 349 \begin{lstlisting} 334 int (*f())[ 5 ] {...};// definition mimics usage335 ... (*f())[ 3] += 1;350 int (*f())[5] {...}; // definition mimics usage 351 ... (*f())[3] += 1; 336 352 \end{lstlisting} 337 353 Essentially, the return type is wrapped around the routine name in successive layers (like an onion). 338 354 While attempting to make the two contexts consistent was a laudable goal, it has not worked out in practice. 339 355 340 \CFA provides its own type, variable and routine declarations, using a slightly different syntax. 341 The new declarations place modifiers to the left of the base type, while C declarations place modifiers to the right of the base type. 356 \CFA provides its own type, variable and routine declarations, using a different syntax. 357 The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type. 358 In the following example, \R{red} is for the base type and \B{blue} is for the qualifiers. 359 The \CFA declarations move the qualifiers to the left of the base type, i.e., blue to the left of the red, while the qualifiers have the same meaning but are ordered left to left to right to specify the variable's type. 360 \begin{quote2} 361 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 362 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 363 \begin{lstlisting} 364 ß[5] *ß ®int® x1; 365 ß* [5]ß ®int® x2; 366 ß[* [5] int]ß f®( int p )®; 367 \end{lstlisting} 368 & 369 \begin{lstlisting} 370 ®int® ß*ß x1 ß[5]ß; 371 ®int® ß(*ßx2ß)[5]ß; 372 ßint (*ßf®( int p )®ß)[5]ß; 373 \end{lstlisting} 374 \end{tabular} 375 \end{quote2} 342 376 The only exception is bit field specification, which always appear to the right of the base type. 343 C and the new \CFA declarations may appear together in the same program block, but cannot be mixed within a specific declaration. 344 345 In \CFA declarations, the same tokens are used as in C: the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array, and parentheses ©()© are used to indicate a routine parameter. 346 However, unlike C, \CFA type declaration tokens are specified from left to right and the entire type specification is distributed across all variables in the declaration list. 377 % Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter. 378 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list. 347 379 For instance, variables ©x© and ©y© of type pointer to integer are defined in \CFA as follows: 348 380 \begin{quote2} 349 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}350 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\351 \begin{lstlisting} 352 ®* int x, y;®381 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 382 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 383 \begin{lstlisting} 384 ®*® int x, y; 353 385 \end{lstlisting} 354 386 & 355 387 \begin{lstlisting} 356 int *x, *y;388 int ®*®x, ®*®y; 357 389 \end{lstlisting} 358 390 \end{tabular} … … 360 392 Other examples are: 361 393 \begin{quote2} 362 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{\hspace{20pt}}l@{}}363 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}} \\394 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} 395 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ 364 396 \begin{lstlisting} 365 397 [ 5 ] int z; … … 397 429 \end{quote2} 398 430 399 All type qualifiers, i.e., ©const© and ©volatile©, are used in the normal way with the new declarations butappear left to right, e.g.:431 All type qualifiers, e.g., ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, e.g.: 400 432 \begin{quote2} 401 \begin{tabular}{@{}l@{\hspace{ 30pt}}l@{\hspace{20pt}}l@{}}402 \multicolumn{1}{c@{\hspace{ 30pt}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}} \\433 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}} 434 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\ 403 435 \begin{lstlisting} 404 436 const * const int x; … … 417 449 \end{tabular} 418 450 \end{quote2} 419 All declaration qualifiers, i.e., ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}451 All declaration qualifiers, e.g., ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier} 420 452 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} e.g.: 421 453 \begin{quote2} 422 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{\hspace{20pt}}l@{}}423 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}} \\454 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} 455 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ 424 456 \begin{lstlisting} 425 457 extern [ 5 ] int x; … … 443 475 e.g.: 444 476 \begin{lstlisting} 445 x; // int x446 *y; // int *y447 f( p1, p2 ); // int f( int p1, int p2 );448 f( p1, p2 ) {} // int f( int p1, int p2 ) {}449 \end{lstlisting} 450 451 As stated above, the two styles of declaration may appear together in the same block.477 x; // int x 478 *y; // int *y 479 f( p1, p2 ); // int f( int p1, int p2 ); 480 f( p1, p2 ) {} // int f( int p1, int p2 ) {} 481 \end{lstlisting} 482 483 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration. 452 484 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style. 453 485 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems. … … 458 490 The new declaration syntax can be used in other contexts where types are required, e.g., casts and the pseudo-routine ©sizeof©: 459 491 \begin{quote2} 460 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}461 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\462 \begin{lstlisting} 463 y = ( * int)x;464 i = sizeof( [ 5 ] * int);492 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 493 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 494 \begin{lstlisting} 495 y = (®* int®)x; 496 i = sizeof(®[ 5 ] * int®); 465 497 \end{lstlisting} 466 498 & 467 499 \begin{lstlisting} 468 y = ( int *)x;469 i = sizeof( int *[ 5 ]);500 y = (®int *®)x; 501 i = sizeof(®int *[ 5 ]®); 470 502 \end{lstlisting} 471 503 \end{tabular} … … 476 508 477 509 \CFA also supports a new syntax for routine definition, as well as ISO C and K\&R routine syntax. 478 The point of the new syntax is to allow returning multiple values from a routine~\cite{ CLU,Galletly96}, e.g.:510 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, e.g.: 479 511 \begin{lstlisting} 480 512 ®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) { … … 490 522 Declaration qualifiers can only appear at the start of a routine definition, e.g.: 491 523 \begin{lstlisting} 492 extern[ int x ] g( int y ) {§\,§}524 ®extern® [ int x ] g( int y ) {§\,§} 493 525 \end{lstlisting} 494 526 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified; 495 527 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: 496 528 \begin{lstlisting} 497 [§\,§] g(); // no input or output parameters498 [ void ] g( void ); // no input or output parameters529 [§\,§] g(); // no input or output parameters 530 [ void ] g( void ); // no input or output parameters 499 531 \end{lstlisting} 500 532 … … 503 535 [ i, j, ch ] = f( 3, 'a', ch ); 504 536 \end{lstlisting} 505 The list of return values from f and the grouping on the left-hand side of the assignment is called a tupleand discussed in Section 12.537 The list of return values from f and the grouping on the left-hand side of the assignment is called a \newterm{return list} and discussed in Section 12. 506 538 507 539 \CFA style declarations cannot be used to declare parameters for K\&R style routine definitions because of the following ambiguity: … … 514 546 \begin{lstlisting} 515 547 typedef int foo; 516 int f( int (* foo) ); // foo is redefined as a parameter name548 int f( int (* foo) ); // foo is redefined as a parameter name 517 549 \end{lstlisting} 518 550 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. 519 The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type modifier characters appearing to the right of the type name.551 The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type qualifier characters appearing to the right of the type name. 520 552 The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts. 521 553 522 554 C-style declarations can be used to declare parameters for \CFA style routine definitions, e.g.: 523 555 \begin{lstlisting} 524 [ int ] f( * int, int * ); // returns an integer, accepts 2 pointers to integers525 [ * int, int * ] f( int ); // returns 2 pointers to integers, accepts an integer556 [ int ] f( * int, int * ); // returns an integer, accepts 2 pointers to integers 557 [ * int, int * ] f( int ); // returns 2 pointers to integers, accepts an integer 526 558 \end{lstlisting} 527 559 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: 528 560 \begin{lstlisting} 529 561 #define ptoa( n, d ) int (*n)[ d ] 530 int f( ptoa( p,5) ) ... // expands to int f( int (*p)[ 5 ] )531 [ int ] f( ptoa( p,5) ) ... // expands to [ int ] f( int (*p)[ 5 ] )562 int f( ptoa( p, 5 ) ) ... // expands to int f( int (*p)[ 5 ] ) 563 [ int ] f( ptoa( p, 5 ) ) ... // expands to [ int ] f( int (*p)[ 5 ] ) 532 564 \end{lstlisting} 533 565 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms. 534 566 535 567 536 \subsection{ ReturningValues}537 538 Named return valueshandle the case where it is necessary to define a local variable whose value is then returned in a ©return© statement, as in:568 \subsection{Named Return Values} 569 570 \Index{Named return values} handle the case where it is necessary to define a local variable whose value is then returned in a ©return© statement, as in: 539 571 \begin{lstlisting} 540 572 int f() { … … 545 577 \end{lstlisting} 546 578 Because the value in the return variable is automatically returned when a \CFA routine terminates, the ©return© statement \emph{does not} contain an expression, as in: 547 \begin{lstlisting} 548 ®[ int x ]® f() { 549 ... x = 0; ... x = y; ... 550 ®return;® // implicitly return x 551 } 552 \end{lstlisting} 553 When the return is encountered, the current value of ©x© is returned to the calling routine. 579 \newline 580 \begin{minipage}{\linewidth} 581 \begin{lstlisting} 582 ®[ int x, int y ]® f() { 583 int z; 584 ... x = 0; ... y = z; ... 585 ®return;® // implicitly return x, y 586 } 587 \end{lstlisting} 588 \end{minipage} 589 \newline 590 When the return is encountered, the current values of ©x© and ©y© are returned to the calling routine. 554 591 As well, ``falling off the end'' of a routine without a ©return© statement is permitted, as in: 555 592 \begin{lstlisting} 556 [ int x ] f() {557 ... x = 0; ... x = y; ...558 } // implicitly return x 559 \end{lstlisting} 560 In this case, the current value of ©x© isreturned to the calling routine just as if a ©return© had been encountered.593 [ int x, int y ] f() { 594 ... 595 } // implicitly return x, y 596 \end{lstlisting} 597 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered. 561 598 562 599 … … 566 603 as well, parameter names are optional, e.g.: 567 604 \begin{lstlisting} 568 [ int x ] f (); // returning int with no parameters569 [ * int ] g (int y); // returning pointer to int with int parameter570 [ ] h (int,char); // returning no result with int and char parameters571 [ * int,int ] j (int); // returning pointer to int and int, with int parameter605 [ int x ] f (); // returning int with no parameters 606 [ * int ] g (int y); // returning pointer to int with int parameter 607 [ ] h (int,char); // returning no result with int and char parameters 608 [ * int,int ] j (int); // returning pointer to int and int, with int parameter 572 609 \end{lstlisting} 573 610 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa). 574 611 It is possible to declare multiple routine-prototypes in a single declaration, but the entire type specification is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), e.g.: 575 612 \begin{quote2} 576 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}577 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\613 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 614 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 578 615 \begin{lstlisting} 579 616 [ int ] f(int), g; … … 604 641 for example, the following is incorrect: 605 642 \begin{lstlisting} 606 * [ int x ] f () fp; // routine name "f" is not allowed643 * [ int x ] f () fp; // routine name "f" is not allowed 607 644 \end{lstlisting} 608 645 … … 737 774 While in theory default arguments can be simulated with overloading, as in: 738 775 \begin{quote2} 739 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}740 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{default arguments}} & \multicolumn{1}{c}{\textbf{overloading}} \\776 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 777 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}} & \multicolumn{1}{c}{\textbf{overloading}} \\ 741 778 \begin{lstlisting} 742 779 void p( int x, int y = 2, int z = 3 ) {...} … … 773 810 \CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification. 774 811 \begin{quote2} 775 \begin{tabular}{@{}l@{\hspace{3 0pt}}l|l@{}}776 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{C Type Nesting}} & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}} & \multicolumn{1}{|c}{\textbf{\CFA}} \\812 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}} 813 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}} & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}} & \multicolumn{1}{|c}{\textbf{\CFA}} \\ 777 814 \hline 778 815 \begin{lstlisting} … … 880 917 881 918 882 \section{ Tuples}919 \section{Lexical List} 883 920 884 921 In C and \CFA, lists of elements appear in several contexts, such as the parameter list for a routine call. 885 922 (More contexts are added shortly.) 886 A list of such elements is called a tuple.887 The general syntax of a tupleis:923 A list of such elements is called a \newterm{lexical list}. 924 The general syntax of a lexical list is: 888 925 \begin{lstlisting} 889 926 [ §\emph{exprlist}§ ] 890 927 \end{lstlisting} 891 928 where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas. 892 The brackets, ©[]©, allow differentiating between tuples and expressions containing the C comma operator.893 The following are examples of tuples:929 The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator. 930 The following are examples of lexical lists: 894 931 \begin{lstlisting} 895 932 [ x, y, z ] … … 1180 1217 \begin{figure} 1181 1218 \centering 1182 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}1183 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\1219 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1220 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1184 1221 \begin{lstlisting} 1185 1222 ®L1:® for ( ... ) { … … 1211 1248 \vspace*{0.25in} 1212 1249 1213 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}1214 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\1250 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 1251 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ 1215 1252 \begin{lstlisting} 1216 1253 ®L1®: for ( ... ) { … … 1453 1490 Therefore, the ©case© clause is extended with a list of values, as in: 1454 1491 \begin{quote2} 1455 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{\hspace{20pt}}l@{}}1456 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}} \\1492 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} 1493 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ 1457 1494 \begin{lstlisting} 1458 1495 switch ( i ) { … … 1485 1522 In addition, two forms of subranges are allowed to specify case values: the GNU C form and a new \CFA form. 1486 1523 \begin{quote2} 1487 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{\hspace{20pt}}l@{}}1488 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{GNU C}} \\1524 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} 1525 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}} \\ 1489 1526 \begin{lstlisting} 1490 1527 switch ( i ) { … … 2007 2044 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type. 2008 2045 \begin{quote2} 2009 \begin{tabular}{@{}l@{\hspace{3 0pt}}ll@{}}2010 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CC}} & \multicolumn{1}{c}{©gcc©}\index{gcc} \\2046 \begin{tabular}{@{}l@{\hspace{3em}}ll@{}} 2047 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CC}} & \multicolumn{1}{c}{©gcc©}\index{gcc} \\ 2011 2048 \begin{lstlisting} 2012 2049 … … 4110 4147 The general case is printing out a sequence of variables separated by whitespace. 4111 4148 \begin{quote2} 4112 \begin{tabular}{@{}l@{\hspace{3 0pt}}l@{}}4113 \multicolumn{1}{c@{\hspace{3 0pt}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\4149 \begin{tabular}{@{}l@{\hspace{3em}}l@{}} 4150 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ 4114 4151 \begin{lstlisting} 4115 4152 int x = 0, y = 1, z = 2;
Note: See TracChangeset
for help on using the changeset viewer.