Changes in / [d27e340:b69ea6b]


Ignore:
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/common.tex

    rd27e340 rb69ea6b  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue Feb 13 08:19:07 2018
    14 %% Update Count     : 367
     13%% Last Modified On : Sun Feb  4 10:38:26 2018
     14%% Update Count     : 365
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    177177\makeatother
    178178
    179 \newenvironment{cquote}{%
    180         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
     179\newenvironment{quote2}{%
     180        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
    181181        \item\relax
    182182}{%
    183183        \endlist
    184 }% cquote
     184}% quote2
    185185
    186186\newenvironment{rationale}{%
    187   \begin{cquote}\noindent$\Box$\enspace
     187  \begin{quote2}\noindent$\Box$\enspace
    188188}{%
    189   \hfill\enspace$\Box$\end{cquote}
     189  \hfill\enspace$\Box$\end{quote2}
    190190}%
    191191
    … …  
    201201\newenvironment{syntax}{
    202202\paragraph{Syntax}
    203 \begin{cquote}
     203\begin{quote2}
    204204\begin{description}[noitemsep,leftmargin=\parindentlnth]
    205205}{
    206206\end{description}
    207 \end{cquote}
     207\end{quote2}
    208208}
    209209% \def\syntax{\paragraph{Syntax}\trivlist\parindent=.5in\item[\hskip.5in]}

  • doc/papers/general/Paper.tex

    rd27e340 rb69ea6b  
    44\usepackage{epic,eepic}
    55\usepackage{xspace,calc,comment}
    6 \usepackage{upquote}                                            % switch curled `'" to straight
    7 \usepackage{listings}                                           % format program code
    8 \usepackage{enumitem}
    9 \usepackage[flushmargin]{footmisc}                      % support label/reference in footnote
     6\usepackage{upquote}                                                                    % switch curled `'" to straight
     7\usepackage{listings}                                                                   % format program code
    108\usepackage{rotating}
    119\usepackage[usenames]{color}
    12 \usepackage{pslatex}                                            % reduce size of san serif font
     10\usepackage{pslatex}                                    % reduce size of san serif font
    1311\usepackage[plainpages=false,pdfpagelabels,pdfpagemode=UseNone,pagebackref=true,breaklinks=true,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
    1412
    1513\setlength{\textheight}{9in}
    1614%\oddsidemargin 0.0in
    17 \renewcommand{\topfraction}{0.8}                        % float must be greater than X of the page before it is forced onto its own page
    18 \renewcommand{\bottomfraction}{0.8}                     % float must be greater than X of the page before it is forced onto its own page
    19 \renewcommand{\floatpagefraction}{0.8}          % float must be greater than X of the page before it is forced onto its own page
    20 \renewcommand{\textfraction}{0.0}                       % the entire page maybe devoted to floats with no text on the page at all
    21 
    22 \lefthyphenmin=4                                                        % hyphen only after 4 characters
     15\renewcommand{\topfraction}{0.8}                % float must be greater than X of the page before it is forced onto its own page
     16\renewcommand{\bottomfraction}{0.8}             % float must be greater than X of the page before it is forced onto its own page
     17\renewcommand{\floatpagefraction}{0.8}  % float must be greater than X of the page before it is forced onto its own page
     18\renewcommand{\textfraction}{0.0}               % the entire page maybe devoted to floats with no text on the page at all
     19
     20\lefthyphenmin=4                                                % hyphen only after 4 characters
    2321\righthyphenmin=4
    2422
    … …  
    2624
    2725\newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
    28 \newcommand{\CFA}{\protect\CFAIcon}             % safe for section/caption
    29 \newcommand{\CFL}{\textrm{Cforall}\xspace}      % Cforall symbolic name
    30 \newcommand{\Celeven}{\textrm{C11}\xspace}      % C11 symbolic name
     26\newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
     27\newcommand{\CFL}{\textrm{Cforall}\xspace} % Cforall symbolic name
     28\newcommand{\Celeven}{\textrm{C11}\xspace} % C11 symbolic name
    3129\newcommand{\CC}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}\xspace} % C++ symbolic name
    3230\newcommand{\CCeleven}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
    … …  
    5856\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
    5957
    60 \newlength{\gcolumnposn}                                        % temporary hack because lstlisting does not handle tabs correctly
     58\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
    6159\newlength{\columnposn}
    6260\setlength{\gcolumnposn}{2.75in}
    … …  
    7472
    7573% Latin abbreviation
    76 \newcommand{\abbrevFont}{\textit}                       % set empty for no italics
     74\newcommand{\abbrevFont}{\textit}       % set empty for no italics
    7775\newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
    7876\newcommand*{\eg}{%
    … …  
    105103
    106104\newenvironment{cquote}{%
    107         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
     105        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
    108106        \item\relax
    109107}{%
    … …  
    195193The TIOBE~\cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail.
    196194The top 3 rankings over the past 30 years are:
     195\lstDeleteShortInline@%
    197196\begin{center}
    198197\setlength{\tabcolsep}{10pt}
    199 \lstDeleteShortInline@%
    200198\begin{tabular}{@{}rccccccc@{}}
    201199                & 2017  & 2012  & 2007  & 2002  & 1997  & 1992  & 1987          \\ \hline
    … …  
    204202\CC             & 3             & 3             & 3             & 3             & 2             & 2             & 4                     \\
    205203\end{tabular}
     204\end{center}
    206205\lstMakeShortInline@%
    207 \end{center}
    208206Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
    209207In many cases, \CC is often used solely as a better C.
    … …  
    259257Crucial to the design of a new programming language are the libraries to access thousands of external software features.
    260258Like \CC, \CFA inherits a massive compatible library-base, where other programming languages must rewrite or provide fragile inter-language communication with C.
    261 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
     259A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted floating-point array:
    262260\begin{lstlisting}
    263261void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
    … …  
    265263int comp( const void * t1, const void * t2 ) { return *(double *)t1 < *(double *)t2 ? -1 :
    266264                                *(double *)t2 < *(double *)t1 ? 1 : 0; }
    267 double key = 5.0, vals[10] = { /* 10 sorted float values */ };
     265double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
    268266double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
    269267\end{lstlisting}
    … …  
    507505In many languages, functions can return at most one value;
    508506however, many operations have multiple outcomes, some exceptional.
    509 Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and float values, respectively.
     507Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and floating-point values, respectively.
    510508\begin{lstlisting}
    511509typedef struct { int quo, rem; } div_t;         $\C{// from include stdlib.h}$
    … …  
    938936
    939937\section{Control Structures}
    940 
    941 \CFA identifies missing and problematic control structures in C, and extends and modifies these control structures to increase functionality and safety.
    942938
    943939
    … …  
    10481044The implicit targets of the current @continue@ and @break@, \ie the closest enclosing loop or @switch@, change as certain constructs are added or removed.
    10491045
    1050 
    10511046\subsection{\texorpdfstring{Enhanced \LstKeywordStyle{switch} Statement}{Enhanced switch Statement}}
    10521047
    1053 There are a number of deficiencies with the C @switch@ statements: enumerating @case@ lists, placement of @case@ clauses, scope of the switch body, and fall through between case clauses.
    1054 
    1055 C has no shorthand for specifying a list of case values, whether the list is non-contiguous or contiguous\footnote{C provides this mechanism via fall through.}.
    1056 \CFA provides a shorthand for a non-contiguous list:
    1057 \begin{cquote}
    1058 \lstDeleteShortInline@%
    1059 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1060 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1061 \begin{cfa}
    1062 case 2, 10, 34, 42:
    1063 \end{cfa}
    1064 &
    1065 \begin{cfa}
    1066 case 2: case 10: case 34: case 42:
    1067 \end{cfa}
    1068 \end{tabular}
    1069 \lstMakeShortInline@%
    1070 \end{cquote}
    1071 for a contiguous list:\footnote{gcc provides the same mechanism with awkward syntax, \lstinline@2 ... 42@, where spaces are required around the ellipse.}
    1072 \begin{cquote}
    1073 \lstDeleteShortInline@%
    1074 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1075 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1076 \begin{cfa}
    1077 case 2~42:
    1078 \end{cfa}
    1079 &
    1080 \begin{cfa}
    1081 case 2: case 3: ... case 41: case 42:
    1082 \end{cfa}
    1083 \end{tabular}
    1084 \lstMakeShortInline@%
    1085 \end{cquote}
    1086 and a combination:
    1087 \begin{cfa}
    1088 case -12~-4, -1~5, 14~21, 34~42:
    1089 \end{cfa}
    1090 
    1091 C allows placement of @case@ clauses \emph{within} statements nested in the @switch@ body (see Duff's device~\cite{Duff83});
    1092 \begin{cfa}
    1093 switch ( i ) {
    1094   case 0:
    1095         for ( int i = 0; i < 10; i += 1 ) {
    1096                 ...
    1097   `case 1:`             // no initialization of loop index
    1098                 ...
    1099         }
    1100 }
    1101 \end{cfa}
    1102 \CFA precludes this form of transfer into a control structure because it causes undefined behaviour, especially with respect to missed initialization, and provides very limited functionality.
    1103 
    1104 C allows placement of declaration within the @switch@ body and unreachable code at the start, resulting in undefined behaviour:
    1105 \begin{cfa}
    1106 switch ( x ) {
    1107         `int y = 1;`                            $\C{// unreachable initialization}$
    1108         `x = 7;`                                        $\C{// unreachable code without label/branch}$
    1109   case 0:
    1110         ...
    1111         `int z = 0;`                            $\C{// unreachable initialization, cannot appear after case}$
    1112         z = 2;
    1113   case 1:
    1114         `x = z;`                                        $\C{// without fall through, z is undefined}$
    1115 }
    1116 \end{cfa}
    1117 \CFA allows the declaration of local variables, \eg @y@, at the start of the @switch@ with scope across the entire @switch@ body, \ie all @case@ clauses, but no statements.
    1118 \CFA disallows the declaration of local variable, \eg @z@, directly within the @switch@ body, because a declaration cannot occur immediately after a @case@ since a label can only be attached to a statement, and the use of @z@ is undefined in @case 1@ as neither storage allocation nor initialization may have occurred.
    1119 
    1120 C @switch@ provides multiple entry points into the statement body, but once an entry point is selected, control continues across \emph{all} @case@ clauses until the end of the @switch@ body, called \newterm{fall through};
    1121 @case@ clauses are made disjoint by the @break@ statement.
    1122 While the ability to fall through \emph{is} a useful form of control flow, it does not match well with programmer intuition, resulting in many errors from missing @break@ statements.
    1123 \CFA provides a new control structure, @choose@, which mimics @switch@, but reverses the meaning of fall through:
    1124 \begin{cquote}
    1125 \lstDeleteShortInline@%
    1126 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1127 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1128 \begin{cfa}
    1129 `choose` ( day ) {
    1130   case Mon~Thu:
    1131         // program
    1132 
    1133   case Fri:
    1134         // program
    1135         wallet += pay;
    1136         `fallthrough;`
    1137   case Sat:
    1138         // party
    1139         wallet -= party;
    1140 
    1141   case Sun:
    1142         // rest
    1143 
    1144   default:
    1145         // error
    1146 }
    1147 \end{cfa}
    1148 &
    1149 \begin{cfa}
    1150 switch ( day ) {
    1151   case Mon: case Tue: case Wed: case Thu:
    1152         // program
    1153         `break;`
    1154   case Fri:
    1155         // program
    1156         wallet += pay;
    1157 
    1158   case Sat:
    1159         // party
    1160         wallet -= party;
    1161         `break;`
    1162   case Sun:
    1163         // rest
    1164         `break;`
    1165   default:
    1166         // error
    1167 }
    1168 \end{cfa}
    1169 \end{tabular}
    1170 \lstMakeShortInline@%
    1171 \end{cquote}
    1172 Collectively, these enhancements reduce programmer burden and increase readability and safety.
    1173 
    1174 \begin{comment}
     1048\CFA also fixes a number of ergonomic defecits in the @switch@ statements of standard C.
     1049C can specify a number of equivalent cases by using the default ``fall-through'' semantics of @case@ clauses, \eg @case 1: case 2: case 3:@ -- this syntax is cluttered, however, so \CFA includes a more concise list syntax, @case 1, 2, 3:@.
     1050For contiguous ranges, \CFA provides an even more concise range syntax as well, @case 1~3:@; lists of ranges are also allowed in case selectors.
     1051
    11751052Forgotten @break@ statements at the end of @switch@ cases are a persistent sort of programmer error in C, and the @break@ statements themselves introduce visual clutter and an un-C-like keyword-based block delimiter.
    11761053\CFA addresses this error by introducing a @choose@ statement, which works identically to a @switch@ except that its default end-of-case behaviour is to break rather than to fall through for all non-empty cases.
    … …  
    11931070}
    11941071\end{cfa}
    1195 \end{comment}
    1196 
    11971072
    11981073\subsection{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
    … …  
    13801255\lstDeleteShortInline@%
    13811256\lstset{moredelim=**[is][\color{blue}]{+}{+}}
    1382 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1383 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     1257\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1258\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    13841259\begin{cfa}
    13851260+[5] *+ `int` x1;
    13861261+* [5]+ `int` x2;
    1387 `[* [5] int]` f+( int p )+;
     1262+[* [5] int]+ f`( int p )`;
    13881263\end{cfa}
    13891264&
    … …  
    13911266`int` +*+ x1 +[5]+;
    13921267`int` +(*+x2+)[5]+;
    1393 `int (*`f+( int p )+`)[5]`;
     1268+int (*+f`( int p )`+)[5]+;
    13941269\end{cfa}
    13951270\end{tabular}
    … …  
    14021277\begin{cquote}
    14031278\lstDeleteShortInline@%
    1404 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1405 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     1279\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1280\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    14061281\begin{cfa}
    14071282`*` int x, y;
    … …  
    14171292\begin{cquote}
    14181293\lstDeleteShortInline@%
    1419 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1420 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     1294\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1295\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    14211296\begin{cfa}
    14221297`*` int x;
    … …  
    14351310\begin{cquote}
    14361311\lstDeleteShortInline@%
    1437 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
    1438 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
     1312\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1313\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    14391314\begin{cfa}
    14401315[ 5 ] int z;
    … …  
    14761351\begin{cquote}
    14771352\lstDeleteShortInline@%
    1478 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
    1479 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
     1353\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
     1354\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
    14801355\begin{cfa}
    14811356const * const int x;
    … …  
    14991374\begin{cquote}
    15001375\lstDeleteShortInline@%
    1501 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
    1502 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
     1376\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1377\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    15031378\begin{cfa}
    15041379extern [ 5 ] int x;
    … …  
    15221397\begin{cquote}
    15231398\lstDeleteShortInline@%
    1524 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1525 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     1399\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1400\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    15261401\begin{cfa}
    15271402y = (* int)x;
    … …  
    15401415Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
    15411416Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
    1542 
    1543 The syntax of the new routine prototype declaration follows directly from the new routine definition syntax;
    1544 as well, parameter names are optional, \eg:
    1545 \begin{cfa}
    1546 [ int x ] f ();                                                 $\C{// returning int with no parameters}$
    1547 [ * int ] g (int y);                                    $\C{// returning pointer to int with int parameter}$
    1548 [ ] h ( int, char );                                    $\C{// returning no result with int and char parameters}$
    1549 [ * int, int ] j ( int );                               $\C{// returning pointer to int and int, with int parameter}$
    1550 \end{cfa}
    1551 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
    1552 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, \eg:
    1553 \begin{cquote}
    1554 \lstDeleteShortInline@%
    1555 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1556 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1557 \begin{cfa}
    1558 [double] foo(), foo( int ), foo( double ) {...}
    1559 \end{cfa}
    1560 &
    1561 \begin{cfa}
    1562 double foo1(), foo2( int ), foo3( double );
    1563 \end{cfa}
    1564 \end{tabular}
    1565 \lstMakeShortInline@%
    1566 \end{cquote}
    1567 \CFA allows the last routine in the list to define its body.
    1568 
    1569 Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
    1570 \begin{cfa}
    1571 extern [ int ] f ( int );
    1572 static [ int ] g ( int );
    1573 \end{cfa}
    1574 
    1575 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
    1576 \begin{cfa}
    1577 * [ int x ] () fp;                                              $\C{// pointer to routine returning int with no parameters}$
    1578 * [ * int ] (int y) gp;                                 $\C{// pointer to routine returning pointer to int with int parameter}$
    1579 * [ ] (int,char) hp;                                    $\C{// pointer to routine returning no result with int and char parameters}$
    1580 * [ * int,int ] ( int ) jp;                             $\C{// pointer to routine returning pointer to int and int, with int parameter}$
    1581 \end{cfa}
    1582 While parameter names are optional, \emph{a routine name cannot be specified};
    1583 for example, the following is incorrect:
    1584 \begin{cfa}
    1585 * [ int x ] f () fp;                                    $\C{// routine name "f" is not allowed}$
    1586 \end{cfa}
    15871417
    15881418
    … …  
    17631593In addition to the expressive power, \lstinline|@=| provides a simple path for migrating legacy C code to \CFA, by providing a mechanism to incrementally convert initializers; the \CFA design team decided to introduce a new syntax for this escape hatch because we believe that our RAII implementation will handle the vast majority of code in a desirable way, and we wished to maintain familiar syntax for this common case.
    17641594
    1765 
    1766 \subsection{Type Nesting}
    1767 
    1768 \CFA allows \newterm{type nesting}, and type qualification of the nested types (see Figure~\ref{f:TypeNestingQualification}), where as C hoists (refactors) nested types into the enclosing scope and has no type qualification.
    1769 \begin{figure}
    1770 \centering
    1771 \lstDeleteShortInline@%
    1772 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
    1773 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
    1774 \hline
    1775 \begin{cfa}
    1776 struct S {
    1777         enum C { R, G, B };
    1778         struct T {
    1779                 union U { int i, j; };
    1780                 enum C c;
    1781                 short int i, j;
    1782         };
    1783         struct T t;
    1784 } s;
    1785 
    1786 int rtn() {
    1787         s.t.c = R;
    1788         struct T t = { R, 1, 2 };
    1789         enum C c;
    1790         union U u;
    1791 }
    1792 \end{cfa}
    1793 &
    1794 \begin{cfa}
    1795 enum C { R, G, B };
    1796 union U { int i, j; };
    1797 struct T {
    1798         enum C c;
    1799         short int i, j;
    1800 };
    1801 struct S {
    1802         struct T t;
    1803 } s;
    1804        
    1805 
    1806 
    1807 
    1808 
    1809 
    1810 
    1811 \end{cfa}
    1812 &
    1813 \begin{cfa}
    1814 struct S {
    1815         enum C { R, G, B };
    1816         struct T {
    1817                 union U { int i, j; };
    1818                 enum C c;
    1819                 short int i, j;
    1820         };
    1821         struct T t;
    1822 } s;
    1823 
    1824 int rtn() {
    1825         s.t.c = `S.`R;  // type qualification
    1826         struct `S.`T t = { `S.`R, 1, 2 };
    1827         enum `S.`C c;
    1828         union `S.T.`U u;
    1829 }
    1830 \end{cfa}
    1831 \end{tabular}
    1832 \lstMakeShortInline@%
    1833 \caption{Type Nesting / Qualification}
    1834 \label{f:TypeNestingQualification}
    1835 \end{figure}
    1836 In the left example in C, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
    1837 In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@''.
    1838 
    1839 
    18401595\subsection{Default Parameters}
    18411596
    … …  
    18431598\section{Literals}
    18441599
    1845 C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and float types are very similar, differing from each other only in suffix.
     1600C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and floating-point types are very similar, differing from each other only in suffix.
    18461601In keeping with the general \CFA approach of adding features while respecting ``the C way'' of doing things, we have extended both C's polymorphic zero and typed literal syntax to interoperate with user-defined types, while maintaining a backwards-compatible semantics.
    18471602
    … …  
    18671622struct Weight { double stones; };
    18681623
    1869 void ?{}( Weight & w ) { w.stones = 0; }        $\C{// operations}$
     1624void ?{}( Weight & w ) { w.stones = 0; } $\C{// operations}$
    18701625void ?{}( Weight & w, double w ) { w.stones = w; }
    18711626Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; }
    … …  
    18761631
    18771632int main() {
    1878         Weight w, hw = { 14 };                                  $\C{// 14 stone}$
     1633        Weight w, hw = { 14 };                  $\C{// 14 stone}$
    18791634        w = 11@`st@ + 1@`lb@;
    18801635        w = 70.3@`kg@;
    18811636        w = 155@`lb@;
    1882         w = 0x_9b_u@`lb@;                                               $\C{// hexadecimal unsigned weight (155)}$
    1883         w = 0_233@`lb@;                                                 $\C{// octal weight (155)}$
     1637        w = 0x_9b_u@`lb@;                               $\C{// hexadecimal unsigned weight (155)}$
     1638        w = 0_233@`lb@;                                 $\C{// octal weight (155)}$
    18841639        w = 5@`st@ + 8@`kg@ + 25@`lb@ + hw;
    18851640}
    18861641\end{cfa}
    18871642}%
    1888 
    1889 
    1890 \section{Libraries}
    1891 
    1892 As stated in Section~\ref{sec:poly-fns}, \CFA inherits a large corpus of library code, where other programming languages must rewrite or provide fragile inter-language communication with C.
    1893 \CFA has replacement libraries condensing hundreds of existing C names into tens of \CFA overloaded names, all without rewriting the actual computations.
    1894 In many cases, the interface is an inline wrapper providing overloading during compilation but zero cost at runtime.
    1895 The following sections give a glimpse of the interface reduction to many C libraries.
    1896 In many cases, @signed@/@unsigned@ @char@ and @short@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results.
    1897 
    1898 
    1899 \subsection{Limits}
    1900 
    1901 C library @limits.h@ provides lower and upper bound constants for the basic types.
    1902 \CFA name overloading is used to condense these typed constants, \eg:
    1903 \begin{cquote}
    1904 \lstDeleteShortInline@%
    1905 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1906 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
    1907 \begin{cfa}
    1908 const short int `MIN` = -32768;
    1909 const int `MIN` = -2147483648;
    1910 const long int `MIN` = -9223372036854775808L;
    1911 \end{cfa}
    1912 &
    1913 \begin{cfa}
    1914 short int si = `MIN`;
    1915 int i = `MIN`;
    1916 long int li = `MIN`;
    1917 \end{cfa}
    1918 \end{tabular}
    1919 \lstMakeShortInline@%
    1920 \end{cquote}
    1921 The result is a significant reduction in names to access typed constants, \eg:
    1922 \begin{cquote}
    1923 \lstDeleteShortInline@%
    1924 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1925 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1926 \begin{cfa}
    1927 MIN
    1928 MAX
    1929 M_PI
    1930 M_E
    1931 \end{cfa}
    1932 &
    1933 \begin{cfa}
    1934 SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
    1935 SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
    1936 M_PI, M_PIl, M_CPI, M_CPIl,
    1937 M_E, M_El, M_CE, M_CEl
    1938 \end{cfa}
    1939 \end{tabular}
    1940 \lstMakeShortInline@%
    1941 \end{cquote}
    1942 
    1943 
    1944 \subsection{Math}
    1945 
    1946 C library @math.h@ provides many mathematical routines.
    1947 \CFA routine overloading is used to condense these mathematical routines, \eg:
    1948 \begin{cquote}
    1949 \lstDeleteShortInline@%
    1950 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1951 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
    1952 \begin{cfa}
    1953 float `log`( float x );
    1954 double `log`( double );
    1955 double _Complex `log`( double _Complex x );
    1956 \end{cfa}
    1957 &
    1958 \begin{cfa}
    1959 float f = `log`( 3.5 );
    1960 double d = `log`( 3.5 );
    1961 double _Complex dc = `log`( 3.5+0.5I );
    1962 \end{cfa}
    1963 \end{tabular}
    1964 \lstMakeShortInline@%
    1965 \end{cquote}
    1966 The result is a significant reduction in names to access math routines, \eg:
    1967 \begin{cquote}
    1968 \lstDeleteShortInline@%
    1969 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1970 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    1971 \begin{cfa}
    1972 log
    1973 sqrt
    1974 sin
    1975 \end{cfa}
    1976 &
    1977 \begin{cfa}
    1978 logf, log, logl, clogf, clog, clogl
    1979 sqrtf, sqrt, sqrtl, csqrtf, csqrt, csqrtl
    1980 sinf, sin, sinl, csinf, csin, csinl
    1981 \end{cfa}
    1982 \end{tabular}
    1983 \lstMakeShortInline@%
    1984 \end{cquote}
    1985 While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a routine name with a single set of floating type(s).
    1986 For example, it is not possible to overload @atan@ for both one and two arguments;
    1987 instead the names @atan@ and @atan2@ are required.
    1988 The key observation is that only a restricted set of type-generic macros are provided for a limited set of routine names, which do not generalize across the type system, as in \CFA.
    1989 
    1990 
    1991 \subsection{Standard}
    1992 
    1993 C library @stdlib.h@ provides many general routines.
    1994 \CFA routine overloading is used to condense these utility routines, \eg:
    1995 \begin{cquote}
    1996 \lstDeleteShortInline@%
    1997 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    1998 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
    1999 \begin{cfa}
    2000 unsigned int `abs`( int );
    2001 double `abs`( double );
    2002 double abs( double _Complex );
    2003 \end{cfa}
    2004 &
    2005 \begin{cfa}
    2006 unsigned int i = `abs`( -1 );
    2007 double d = `abs`( -1.5 );
    2008 double d = `abs`( -1.5+0.5I );
    2009 \end{cfa}
    2010 \end{tabular}
    2011 \lstMakeShortInline@%
    2012 \end{cquote}
    2013 The result is a significant reduction in names to access utility routines, \eg:
    2014 \begin{cquote}
    2015 \lstDeleteShortInline@%
    2016 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2017 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    2018 \begin{cfa}
    2019 abs
    2020 strto
    2021 random
    2022 \end{cfa}
    2023 &
    2024 \begin{cfa}
    2025 abs, labs, llabs, fabsf, fabs, fabsl, cabsf, cabs, cabsl
    2026 strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold
    2027 srand48, mrand48, lrand48, drand48
    2028 \end{cfa}
    2029 \end{tabular}
    2030 \lstMakeShortInline@%
    2031 \end{cquote}
    2032 In additon, there are polymorphic routines, like @min@ and @max@, which work on any type with operators @?<?@ or @?>?@.
    2033 
    2034 The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety.
    2035 C/\Celeven provide a number of complex and overlapping storage-management operation to support the following capabilities:
    2036 \begin{description}[itemsep=2pt,parsep=0pt]
    2037 \item[fill]
    2038 after allocation the storage is filled with a specified character.
    2039 \item[resize]
    2040 an existing allocation is decreased or increased in size.
    2041 In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
    2042 For an increase in storage size, new storage after the copied data may be filled.
    2043 \item[alignment]
    2044 an allocation starts on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes.
    2045 \item[array]
    2046 the allocation size is scaled to the specified number of array elements.
    2047 An array may be filled, resized, or aligned.
    2048 \end{description}
    2049 Table~\ref{t:StorageManagementOperations} shows the capabilities provided by C/\Celeven allocation-routines and how all the capabilities can be combined into two \CFA routines.
    2050 
    2051 \CFA storage-management routines extend the C equivalents by overloading, providing shallow type-safety, and removing the need to specify the base allocation-size.
    2052 The following example contrasts \CFA and C storage-allocation operation performing the same operations with the same type safety:
    2053 \begin{cquote}
    2054 \begin{cfa}[aboveskip=0pt]
    2055 size_t  dim = 10;                                                       $\C{// array dimension}$
    2056 char fill = '\xff';                                                     $\C{// initialization fill value}$
    2057 int * ip;
    2058 \end{cfa}
    2059 \lstDeleteShortInline@%
    2060 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2061 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
    2062 \begin{cfa}
    2063 ip = alloc();
    2064 ip = alloc( fill );
    2065 ip = alloc( dim );
    2066 ip = alloc( dim, fill );
    2067 ip = alloc( ip, 2 * dim );
    2068 ip = alloc( ip, 4 * dim, fill );
    2069 
    2070 ip = align_alloc( 16 );
    2071 ip = align_alloc( 16, fill );
    2072 ip = align_alloc( 16, dim );
    2073 ip = align_alloc( 16, dim, fill );
    2074 \end{cfa}
    2075 &
    2076 \begin{cfa}
    2077 ip = (int *)malloc( sizeof( int ) );
    2078 ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) );
    2079 ip = (int *)malloc( dim * sizeof( int ) );
    2080 ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
    2081 ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
    2082 ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
    2083 
    2084 ip = memalign( 16, sizeof( int ) );
    2085 ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
    2086 ip = memalign( 16, dim * sizeof( int ) );
    2087 ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
    2088 \end{cfa}
    2089 \end{tabular}
    2090 \lstMakeShortInline@%
    2091 \end{cquote}
    2092 Variadic @new@ (see Section~\ref{sec:variadic-tuples}) cannot support the same overloading because extra parameters are for initialization.
    2093 Hence, there are @new@ and @anew@ routines for single and array variables, and the fill value is the arguments to the constructor, \eg:
    2094 \begin{cfa}
    2095 struct S { int i, j; };
    2096 void ?{}( S & s, int i, int j ) { s.i = i; s.j = j; }
    2097 S * s = new( 2, 3 );                                            $\C{// allocate storage and run constructor}$
    2098 S * as = anew( dim, 2, 3 );                                     $\C{// each array element initialized to 2, 3}$
    2099 \end{cfa}
    2100 Note, \CC can only initialization array elements via the default constructor.
    2101 
    2102 Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap.
    2103 When a @realloc@ is performed, the sticky properties are respected, so that new storage is correctly aligned and initialized with the fill character.
    2104 
    2105 \begin{table}
    2106 \centering
    2107 \lstDeleteShortInline@%
    2108 \lstMakeShortInline~%
    2109 \begin{tabular}{@{}r|r|l|l|l|l@{}}
    2110 \multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
    2111 \hline
    2112 C               & ~malloc~                      & no                    & no            & no            & no    \\
    2113                 & ~calloc~                      & yes (0 only)  & no            & no            & yes   \\
    2114                 & ~realloc~                     & no/copy               & yes           & no            & no    \\
    2115                 & ~memalign~            & no                    & no            & yes           & no    \\
    2116                 & ~posix_memalign~      & no                    & no            & yes           & no    \\
    2117 \hline
    2118 C11             & ~aligned_alloc~       & no                    & no            & yes           & no    \\
    2119 \hline
    2120 \CFA    & ~alloc~                       & yes/copy              & no/yes        & no            & yes   \\
    2121                 & ~align_alloc~         & yes                   & no            & yes           & yes   \\
    2122 \end{tabular}
    2123 \lstDeleteShortInline~%
    2124 \lstMakeShortInline@%
    2125 \caption{Storage-Management Operations}
    2126 \label{t:StorageManagementOperations}
    2127 \end{table}
    2128 
    2129 
    2130 \subsection{I/O}
    2131 \label{s:IOLibrary}
    2132 
    2133 The goal of \CFA I/O is to simplify the common cases, while fully supporting polymorphism and user defined types in a consistent way.
    2134 The approach combines ideas from \CC and Python.
    2135 The \CFA header file for the I/O library is @fstream@.
    2136 
    2137 The common case is printing out a sequence of variables separated by whitespace.
    2138 \begin{cquote}
    2139 \lstDeleteShortInline@%
    2140 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2141 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
    2142 \begin{cfa}
    2143 int x = 1, y = 2, z = 3;
    2144 sout | x `|` y `|` z | endl;
    2145 \end{cfa}
    2146 &
    2147 \begin{cfa}
    2148 
    2149 cout << x `<< " "` << y `<< " "` << z << endl;
    2150 \end{cfa}
    2151 \\
    2152 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    2153 1` `2` `3
    2154 \end{cfa}
    2155 &
    2156 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    2157 1 2 3
    2158 \end{cfa}
    2159 \end{tabular}
    2160 \lstMakeShortInline@%
    2161 \end{cquote}
    2162 The \CFA form has half the characters of the \CC form, and is similar to Python I/O with respect to implicit separators.
    2163 Similar simplification occurs for tuple I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
    2164 \begin{cfa}
    2165 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
    2166 sout | t1 | t2 | endl;                                  $\C{// print tuples}$
    2167 \end{cfa}
    2168 \begin{cfa}[showspaces=true,aboveskip=0pt]
    2169 1`, `2`, `3 4`, `5`, `6
    2170 \end{cfa}
    2171 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
    2172 Therefore, fewer output expressions require parenthesis.
    2173 \begin{cquote}
    2174 \lstDeleteShortInline@%
    2175 \begin{tabular}{@{}ll@{}}
    2176 \textbf{\CFA:}
    2177 &
    2178 \begin{cfa}
    2179 sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
    2180 \end{cfa}
    2181 \\
    2182 \textbf{\CC:}
    2183 &
    2184 \begin{cfa}
    2185 cout << x * 3 << y + 1 << `(`z << 2`)` << `(`x == y`)` << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
    2186 \end{cfa}
    2187 \\
    2188 \textbf{output:}
    2189 &
    2190 \begin{cfa}[showspaces=true,aboveskip=0pt]
    2191 3 3 12 0 3 1 2
    2192 \end{cfa}
    2193 \end{tabular}
    2194 \lstMakeShortInline@%
    2195 \end{cquote}
    2196 There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
    2197 
    2198 The implicit separator character (space/blank) is a separator not a terminator.
    2199 The rules for implicitly adding the separator are:
    2200 \begin{itemize}[itemsep=2pt,parsep=0pt]
    2201 \item
    2202 A separator does not appear at the start or end of a line.
    2203 \item
    2204 A separator does not appear before or after a character literal or variable.
    2205 \item
    2206 A separator does not appear before or after a null (empty) C string, which is a local mechanism to disable insertion of the separator character.
    2207 \item
    2208 A separator does not appear before a C string starting with the characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$@
    2209 \item
    2210 A seperator does not appear after a C string ending with the characters: \lstinline[basicstyle=\tt]@,.;!?)]}%@
    2211 \item
    2212 {\lstset{language=CFA,deletedelim=**[is][]{`}{`}}
    2213 A seperator does not appear before or after a C string begining/ending with the quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
    2214 }%
    2215 \item
    2216 There are routines to set and get the separator string, and manipulators to toggle separation on and off in the middle of output.
    2217 \end{itemize}
    2218 
    2219 
    2220 \subsection{Multi-precision Integers}
    2221 \label{s:MultiPrecisionIntegers}
    2222 
    2223 \CFA has an interface to the GMP multi-precision signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP.
    2224 The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers.
    2225 The \CFA type name for multi-precision signed-integers is @Int@ and the header file is @gmp@.
    2226 The following multi-precision factorial programs contrast using GMP with the \CFA and C interfaces.
    2227 \begin{cquote}
    2228 \lstDeleteShortInline@%
    2229 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}@{\hspace{\parindentlnth}}l@{}}
    2230 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
    2231 \begin{cfa}
    2232 #include <gmp>
    2233 int main( void ) {
    2234         sout | "Factorial Numbers" | endl;
    2235         Int fact = 1;
    2236 
    2237         sout | 0 | fact | endl;
    2238         for ( unsigned int i = 1; i <= 40; i += 1 ) {
    2239                 fact *= i;
    2240                 sout | i | fact | endl;
    2241         }
    2242 }
    2243 \end{cfa}
    2244 &
    2245 \begin{cfa}
    2246 #include <gmp.h>
    2247 int main( void ) {
    2248         `gmp_printf`( "Factorial Numbers\n" );
    2249         `mpz_t` fact;
    2250         `mpz_init_set_ui`( fact, 1 );
    2251         `gmp_printf`( "%d %Zd\n", 0, fact );
    2252         for ( unsigned int i = 1; i <= 40; i += 1 ) {
    2253                 `mpz_mul_ui`( fact, fact, i );
    2254                 `gmp_printf`( "%d %Zd\n", i, fact );
    2255         }
    2256 }
    2257 \end{cfa}
    2258 \end{tabular}
    2259 \lstMakeShortInline@%
    2260 \end{cquote}
    2261 
    22621643
    22631644\section{Evaluation}
    … …  
    23231704
    23241705\begin{table}
    2325 \centering
    23261706\caption{Properties of benchmark code}
    23271707\label{tab:eval}

  • doc/user/user.tex

    rd27e340 rb69ea6b  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Tue Feb 13 08:31:21 2018
    14 %% Update Count     : 3161
     13%% Last Modified On : Wed Jan 31 22:29:25 2018
     14%% Update Count     : 3147
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    161161Like \Index*[C++]{\CC{}}, there may be both an old and new ways to achieve the same effect.
    162162For example, the following programs compare the \CFA, C, and \CC I/O mechanisms, where the programs output the same result.
    163 \begin{cquote}
     163\begin{quote2}
    164164\begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
    165165\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
    … …  
    191191\end{cfa}
    192192\end{tabular}
    193 \end{cquote}
     193\end{quote2}
    194194While 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}).
    195195
    … …  
    274274
    275275\begin{comment}
    276 A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating array:
     276A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating-point array:
    277277\begin{lstlisting}
    278278void * bsearch( const void * key, const void * base, size_t dim, size_t size,
    … …  
    282282                                *(double *)t2 < *(double *)t1 ? 1 : 0; }
    283283
    284 double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
     284double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
    285285double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
    286286\end{lstlisting}
    … …  
    4444440x®_®ff®_®ff;                                                   §\C{// hexadecimal constant}§
    4454450x®_®ef3d®_®aa5c;                                               §\C{// hexadecimal constant}§
    446 3.141®_®592®_®654;                                              §\C{// floating constant}§
    447 10®_®e®_®+1®_®00;                                               §\C{// floating constant}§
    448 0x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating}§
    449 0x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating long constant}§
     4463.141®_®592®_®654;                                              §\C{// floating point constant}§
     44710®_®e®_®+1®_®00;                                               §\C{// floating point constant}§
     4480x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating point}§
     4490x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating point long constant}§
    450450L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
    451451\end{cfa}
    … …  
    501501\label{f:HeaderFileInterposition}
    502502\end{figure}
    503 
    504 
    505 \section{Exponentiation Operator}
    506 
    507 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}, to perform the exponentiation operation.
    508 \CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
    509 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)©.
    510 
    511 As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
    512 Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2).
    513 Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$.
    514 Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result.
    515 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
    516 \begin{cfa}
    517 sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
    518 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
    519 \end{cfa}
    520 Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
    521 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
    522 For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
    523 for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
    524503
    525504
    … …  
    649628\end{cfa}
    650629The ability to fall-through to the next clause \emph{is} a useful form of control flow, specifically when a sequence of case actions compound:
    651 \begin{cquote}
     630\begin{quote2}
    652631\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    653632\begin{cfa}
    … …  
    677656\end{cfa}
    678657\end{tabular}
    679 \end{cquote}
     658\end{quote2}
    680659In this example, case 2 is always done if case 3 is done.
    681660This 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.
    … …  
    751730        ®int y = 1;®                            §\C{// unreachable initialization}§
    752731        ®x = 7;®                                        §\C{// unreachable code without label/branch}§
    753   case 0: ...
     732  case 3: ...
    754733        ...
    755734        ®int z = 0;®                            §\C{// unreachable initialization, cannot appear after case}§
    756735        z = 2;
    757   case 1:
     736  case 3:
    758737        ®x = z;®                                        §\C{// without fall through, z is uninitialized}§
    759738}
    … …  
    840819Requiring a ©case© clause for each value does not seem to be in the spirit of brevity normally associated with C.
    841820Therefore, the ©case© clause is extended with a list of values, as in:
    842 \begin{cquote}
     821\begin{quote2}
    843822\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    844823\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    … …  
    870849\end{cfa}
    871850\end{tabular}
    872 \end{cquote}
     851\end{quote2}
    873852In addition, two forms of subranges are allowed to specify case values: a new \CFA form and an existing GNU C form.\footnote{
    874853The GNU C form \emph{requires} spaces around the ellipse.}
    875 \begin{cquote}
     854\begin{quote2}
    876855\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    877856\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}}     \\
    … …  
    903882\end{cfa}
    904883\end{tabular}
    905 \end{cquote}
     884\end{quote2}
    906885Lists of subranges are also allowed.
    907886\begin{cfa}
    … …  
    923902}
    924903\end{C++}
    925 Since \CFA is non-object-oriented, the equivalent object-oriented program looks like:
     904Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
    926905\begin{cfa}
    927906struct S { int i, j; };
    928 int mem( S & ®this® ) {                 §\C{// explicit "this" parameter}§
     907int mem( S &®this® ) {                  §\C{// explicit "this" parameter}§
    929908        ®this.®i = 1;                           §\C{// "this" is not elided}§
    930909        ®this.®j = 2;
    931910}
    932911\end{cfa}
    933 but it is cumbersome having to write ``©this.©'' many times in a member.
     912but it is cumbersome having to write "©this.©" many times in a member.
    934913
    935914\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.
    936915\begin{cfa}
    937 int mem( S & this ) ®with this® { §\C{// with clause}§
    938         i = 1;                                          §\C{\color{red}// this.i}§
    939         j = 2;                                          §\C{\color{red}// this.j}§
     916int mem( S &this ) ®with this® { §\C{// with clause}§
     917        i = 1;                                          §\C{\color{red}// this->i}§
     918        j = 2;                                          §\C{\color{red}// this->j}§
    940919}
    941920\end{cfa}
    … …  
    943922\begin{cfa}
    944923struct T { double m, n; };
    945 int mem2( S & this1, T & this2 ) ®with this1, this2® {
     924int mem2( S &this1, T &this2 ) ®with this1, this2® {
    946925        i = 1; j = 2;
    947926        m = 1.0; n = 2.0;
    … …  
    954933        struct S1 { ... } s1;
    955934        struct S2 { ... } s2;
    956         ®with s1® {                                     §\C{// with statement}§
     935        ®with s1® {                     // with statement
    957936                // access fields of s1 without qualification
    958                 ®with s2® {                             §\C{// nesting}§
     937                ®with s2® {  // nesting
    959938                        // access fields of s1 and s2 without qualification
    960939                }
    … …  
    10661045
    10671046
    1068 \section{Alternative Declarations}
    1069 \label{s:AlternativeDeclarations}
     1047\section{Declarations}
     1048\label{s:Declarations}
    10701049
    10711050C declaration syntax is notoriously confusing and error prone.
    10721051For example, many C programmers are confused by a declaration as simple as:
    1073 \begin{cquote}
     1052\begin{quote2}
    10741053\begin{tabular}{@{}ll@{}}
    10751054\begin{cfa}
    … …  
    10791058\raisebox{-0.75\totalheight}{\input{Cdecl}}
    10801059\end{tabular}
    1081 \end{cquote}
     1060\end{quote2}
    10821061Is this an array of 5 pointers to integers or a \Index{pointer} to an array of 5 integers?
    1083 If there is any doubt, it implies \Index{productivity} and \Index{safety} issues even for basic programs.
     1062The fact this declaration is unclear to many C programmers means there are \Index{productivity} and \Index{safety} issues even for basic programs.
    10841063Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
    10851064For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
    10861065\begin{cfa}
    1087 int ®(*®f®())[®5®]® {...};                              §\C{// definition}§
    1088  ... ®(*®f®())[®3®]® += 1;                              §\C{// usage}§
     1066int ®(*®f®())[®5®]® {...};                              §\C{definition}§
     1067 ... ®(*®f®())[®3®]® += 1;                              §\C{usage}§
    10891068\end{cfa}
    10901069Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
    … …  
    10951074In the following example, \R{red} is the base type and \B{blue} is qualifiers.
    10961075The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
    1097 \begin{cquote}
     1076\begin{quote2}
    10981077\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    10991078\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    … …  
    11101089\end{cfa}
    11111090\end{tabular}
    1112 \end{cquote}
     1091\end{quote2}
    11131092The only exception is \Index{bit field} specification, which always appear to the right of the base type.
    11141093% 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.
    11151094However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
    11161095For instance, variables ©x© and ©y© of type \Index{pointer} to integer are defined in \CFA as follows:
    1117 \begin{cquote}
     1096\begin{quote2}
    11181097\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    11191098\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    … …  
    11261105\end{cfa}
    11271106\end{tabular}
    1128 \end{cquote}
     1107\end{quote2}
    11291108The downside of this semantics is the need to separate regular and \Index{pointer} declarations:
    1130 \begin{cquote}
     1109\begin{quote2}
    11311110\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    11321111\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    … …  
    11411120\end{cfa}
    11421121\end{tabular}
    1143 \end{cquote}
     1122\end{quote2}
    11441123which is \Index{prescribing} a safety benefit.
    11451124Other examples are:
    1146 \begin{cquote}
     1125\begin{quote2}
    11471126\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    11481127\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    … …  
    11801159\end{cfa}
    11811160\end{tabular}
    1182 \end{cquote}
     1161\end{quote2}
    11831162
    11841163All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
    1185 \begin{cquote}
     1164\begin{quote2}
    11861165\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
    11871166\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
    … …  
    12011180\end{cfa}
    12021181\end{tabular}
    1203 \end{cquote}
     1182\end{quote2}
    12041183All declaration qualifiers, \eg ©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}
    12051184The 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}} \eg:
    1206 \begin{cquote}
     1185\begin{quote2}
    12071186\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
    12081187\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
    … …  
    12221201\end{cfa}
    12231202\end{tabular}
    1224 \end{cquote}
     1203\end{quote2}
    12251204
    12261205The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
    1227 \begin{cquote}
     1206\begin{quote2}
    12281207\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    12291208\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    12301209\begin{cfa}
    1231 y = (* int)x;
    1232 i = sizeof([ 5 ] * int);
     1210y = (®* int®)x;
     1211i = sizeof(®[ 5 ] * int®);
    12331212\end{cfa}
    12341213&
    12351214\begin{cfa}
    1236 y = (int *)x;
    1237 i = sizeof(int * [ 5 ]);
     1215y = (®int *®)x;
     1216i = sizeof(®int * [ 5 ]®);
    12381217\end{cfa}
    12391218\end{tabular}
    1240 \end{cquote}
     1219\end{quote2}
    12411220
    12421221Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
    12431222Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
    1244 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
     1223Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
     1224
     1225
     1226\section{Exponentiation Operator}
     1227
     1228C, \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}, to perform the exponentiation operation.
     1229\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
     1230The 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)©.
     1231
     1232As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
     1233Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is optimized to $O(\log y)$.} (or shifting if the base is 2).
     1234Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $x^{-y}=1/x^y$.
     1235Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
     1236Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
     1237\begin{cfa}
     1238sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
     1239256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
     1240\end{cfa}
     1241Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
     1242The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
     1243For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
     1244for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
    12451245
    12461246
    … …  
    12601260A program \newterm{object} is a region of data storage in the execution environment, the contents of which can represent values.
    12611261In most cases, objects are located in memory at an address, and the variable name for an object is an implicit address to the object generated by the compiler and automatically dereferenced, as in:
    1262 \begin{cquote}
     1262\begin{quote2}
    12631263\begin{tabular}{@{}ll@{\hspace{2em}}l@{}}
    12641264\begin{cfa}
    … …  
    12781278\end{cfa}
    12791279\end{tabular}
    1280 \end{cquote}
     1280\end{quote2}
    12811281where the right example is how the compiler logically interprets the variables in the left example.
    12821282Since a variable name only points to one address during its lifetime, it is an \Index{immutable} \Index{pointer};
    … …  
    12841284In general, variable addresses are stored in instructions instead of loaded from memory, and hence may not occupy storage.
    12851285These approaches are contrasted in the following:
    1286 \begin{cquote}
     1286\begin{quote2}
    12871287\begin{tabular}{@{}l|l@{}}
    12881288\multicolumn{1}{c|}{explicit variable address} & \multicolumn{1}{c}{implicit variable address} \\
    … …  
    13021302\end{cfa}
    13031303\end{tabular}
    1304 \end{cquote}
     1304\end{quote2}
    13051305Finally, the immutable nature of a variable's address and the fact that there is no storage for the variable pointer means pointer assignment\index{pointer!assignment}\index{assignment!pointer} is impossible.
    13061306Therefore, the expression ©x = y© has only one meaning, ©*x = *y©, \ie manipulate values, which is why explicitly writing the dereferences is unnecessary even though it occurs implicitly as part of \Index{instruction decoding}.
    … …  
    13091309(Similarly, an integer variable can contain multiple integer literals during its lifetime versus an integer constant representing a single literal during its lifetime, and like a variable name, may not occupy storage if the literal is embedded directly into instructions.)
    13101310Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, \eg:
    1311 \begin{cquote}
     1311\begin{quote2}
    13121312\begin{tabular}{@{}l@{\hspace{2em}}l@{}}
    13131313\begin{cfa}
    … …  
    13211321\raisebox{-0.5\totalheight}{\input{pointer2.pstex_t}}
    13221322\end{tabular}
    1323 \end{cquote}
     1323\end{quote2}
    13241324
    13251325Notice, an address has a \Index{duality}\index{address!duality}: a location in memory or the value at that location.
    … …  
    14261426The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
    14271427The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
    1428 \CFA-style declarations (see \VRef{s:AlternativeDeclarations}) attempt to address this issue:
    1429 \begin{cquote}
     1428\CFA-style declarations (see \VRef{s:Declarations}) attempt to address this issue:
     1429\begin{quote2}
    14301430\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    14311431\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    … …  
    14401440\end{cfa}
    14411441\end{tabular}
    1442 \end{cquote}
     1442\end{quote2}
    14431443where the \CFA declaration is read left-to-right.
    14441444
    … …  
    15181518\begin{cfa}
    15191519void f( int i );
    1520 void (* fp)( int );                                     §\C{// routine pointer}§
     1520void (*fp)( int );                                      §\C{// routine pointer}§
    15211521fp = f;                                                         §\C{// reference initialization}§
    15221522fp = &f;                                                        §\C{// pointer initialization}§
    … …  
    18971897\end{cfa}
    18981898This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
    1899 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:
     1899Like 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:Declarations}), \eg:
    19001900\begin{cfa}
    19011901C :             const double bar1(), bar2( int ), bar3( double );
    … …  
    20722072Default arguments and overloading (see Section 24) are complementary.
    20732073While in theory default arguments can be simulated with overloading, as in:
    2074 \begin{cquote}
     2074\begin{quote2}
    20752075\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    20762076\multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}}   & \multicolumn{1}{c}{\textbf{overloading}}      \\
    … …  
    20872087\end{cfa}
    20882088\end{tabular}
    2089 \end{cquote}
     2089\end{quote2}
    20902090the number of required overloaded routines is linear in the number of default values, which is unacceptable growth.
    20912091In general, overloading should only be used over default arguments if the body of the routine is significantly different.
    … …  
    22242224The following program in undefined in \CFA (and Indexc{gcc})
    22252225\begin{cfa}
    2226 [* [int]( int )] foo() {                §\C{// int (* foo())( int )}§
     2226[* [int]( int )] foo() {                §\C{// int (*foo())( int )}§
    22272227        int ®i® = 7;
    22282228        int bar( int p ) {
    … …  
    22332233}
    22342234int main() {
    2235         * [int]( int ) fp = foo();      §\C{// int (* fp)( int )}§
     2235        * [int]( int ) fp = foo();      §\C{// int (*fp)( int )}§
    22362236        sout | fp( 3 ) | endl;
    22372237}
    … …  
    22722272In the latter approach, additional return values are passed as pointer parameters.
    22732273A pointer parameter is assigned inside the routine to emulate a return.
    2274 For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
     2274For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating-point value.
    22752275\begin{cfa}
    22762276double modf( double x, double * i );            §\C{// from include math.h}§
    … …  
    29952995
    29962996The common case is printing out a sequence of variables separated by whitespace.
    2997 \begin{cquote}
     2997\begin{quote2}
    29982998\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    29992999\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
    … …  
    30163016\end{cfa}
    30173017\end{tabular}
    3018 \end{cquote}
     3018\end{quote2}
    30193019The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators.
    30203020Similar simplification occurs for \Index{tuple} I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
    … …  
    30283028Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
    30293029Therefore, fewer output expressions require parenthesis.
    3030 \begin{cquote}
     3030\begin{quote2}
    30313031\begin{tabular}{@{}ll@{}}
    30323032\textbf{\CFA:}
    … …  
    30473047\end{cfa}
    30483048\end{tabular}
    3049 \end{cquote}
     3049\end{quote2}
    30503050There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
    30513051
    … …  
    34203420        int id;
    34213421        float size;
    3422         Parts * optionalParts;
     3422        Parts *optionalParts;
    34233423};
    34243424
    … …  
    36343634
    36353635Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization ex\-pression type.
    3636 \begin{cquote}
     3636\begin{quote2}
    36373637\begin{tabular}{@{}l@{\hspace{3em}}ll@{}}
    36383638\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CC}} & \multicolumn{1}{c}{\textbf{\Indexc{gcc}}} \\
    … …  
    36583658\end{cfa}
    36593659\end{tabular}
    3660 \end{cquote}
     3660\end{quote2}
    36613661The two important capabilities are:
    36623662\begin{itemize}
    … …  
    38063806
    38073807generic(type T)
    3808 typedef int (* predicate)(T);
     3808typedef int (*predicate)(T);
    38093809generic(type Captured, type T)
    3810 typedef void (* callback)(Captured, T);
     3810typedef void (*callback)(Captured, T);
    38113811
    38123812generic(type T)
    3813 void find(int length, T * array,
     3813void find(int length, T *array,
    38143814        predicate(T) p, callback(void *, T)f) {
    38153815        int i;
    … …  
    38353835struct LinkedListElem {
    38363836        T elem;
    3837         LinkedListElem(T) * next;
     3837        LinkedListElem(T) *next;
    38383838};
    38393839
    3840 LinkedListElem *++?(LinkedListElem ** elem) {
    3841         return * elem = elem->next;
     3840LinkedListElem *++?(LinkedListElem **elem) {
     3841        return *elem = elem->next;
    38423842}
    38433843
    38443844generic (type T)
    38453845struct LinkedList {
    3846         LinkedListElem(T) * head;
     3846        LinkedListElem(T) *head;
    38473847        unsigned int size;
    38483848}
    38493849
    38503850generic (type T | bool ?==?(T, T))
    3851 bool contains(LinkedList(T) * list, T elem) {
    3852         for(LinkedListElem * iter = list->head; iter != 0; ++iter) {
     3851bool contains(LinkedList(T) *list, T elem) {
     3852        for(LinkedListElem *iter = list->head; iter != 0; ++iter) {
    38533853        if (iter->elem == elem) return true;
    38543854        }
    … …  
    40634063// transferring requires mutual exclusion and calls deleteJob
    40644064
    4065 void transferJob(mutex Worker & from, Worker & to) {
     4065void transferJob(mutex Worker &from, Worker &to) {
    40664066        ...
    40674067        deleteJob(j);
    … …  
    50015001#include <unistd.h>
    50025002}
    5003 size_t fileSize( const char * path ) {
     5003size_t fileSize( const char *path ) {
    50045004        struct stat s;
    50055005        stat(path, &s);
    … …  
    50385038#[link(name = "libc")]
    50395039extern {
    5040         fn stat(path: * const u8,
    5041         buf: * mut stat_t) -> c_int;
    5042 }
    5043 fn fileSize(path: * const u8) -> size_t
     5040        fn stat(path: *const u8,
     5041        buf: *mut stat_t) -> c_int;
     5042}
     5043fn fileSize(path: *const u8) -> size_t
    50445044{
    50455045        unsafe {
    … …  
    50635063generic(type T, type N |
    50645064        { int ?<?(N, N); })
    5065 T * maximize(N (*f)(const T&),
     5065T *maximize(N (*f)(const T&),
    50665066        int n, T *a) {
    5067         T * bestX = NULL;
     5067        T *bestX = NULL;
    50685068        N bestN;
    50695069        for (int i = 0; i < n; i++) {
    … …  
    50775077}
    50785078
    5079 string * longest(int n, string *p)
     5079string *longest(int n, string *p)
    50805080{
    50815081        return maximize(length, n, p);
    … …  
    50855085\begin{cfa}
    50865086template<typename T, typename F>
    5087 T * maximize(const F &f,
     5087T *maximize(const F &f,
    50885088        int n, T *a) {
    50895089        typedef decltype(f(a[0])) N;
    5090         T * bestX = NULL;
     5090        T *bestX = NULL;
    50915091        N bestN;
    50925092        for (int i = 0; i < n; i++) {
    … …  
    51005100}
    51015101
    5102 string * longest(int n, string *p) {
     5102string *longest(int n, string *p) {
    51035103        return maximize(
    51045104        [](const string &s) {
    … …  
    52585258\begin{cfa}
    52595259task Nonzero {
    5260         int * data;
     5260        int *data;
    52615261        int start;
    52625262        int end;
    … …  
    57215721\CFA introduces the following new keywords.
    57225722
    5723 \begin{cquote}
     5723\begin{quote2}
    57245724\input{../refrat/keywords}
    5725 \end{cquote}
     5725\end{quote2}
    57265726
    57275727
    … …  
    57305730
    57315731\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
    5732 \begin{cquote}
     5732\begin{quote2}
    57335733\begin{tabular}{@{}llllll|l@{}}
    57345734\multicolumn{6}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
    … …  
    57905790\end{tabular}
    57915791\end{tabular}
    5792 \end{cquote}
     5792\end{quote2}
    57935793For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
    57945794hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
    … …  
    65316531The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
    65326532(Compile with flag \Indexc{-lgmp} to link with the GMP library.)
    6533 \begin{cquote}
     6533\begin{quote2}
    65346534\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
    65356535\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
    … …  
    65636563\end{cfa}
    65646564\end{tabular}
    6565 \end{cquote}
     6565\end{quote2}
    65666566
    65676567\begin{figure}

  • src/Parser/parser.yy

    rd27e340 rb69ea6b  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb 13 11:40:34 2018
    13 // Update Count     : 2999
     12// Last Modified On : Thu Dec 21 11:32:56 2017
     13// Update Count     : 2996
    1414//
    1515
    … …  
    482482                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
    483483        | type_name '.' no_attr_identifier                                      // CFA, nested type
    484                 { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
     484                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
    485485        | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
    486                 { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
     486                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
    487487        ;
    488488
    … …  
    767767        | unary_expression assignment_operator assignment_expression
    768768                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    769         | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
    770                 { $$ = nullptr; }
    771769        ;
    772770
    … …  
    10521050        | RETURN comma_expression_opt ';'
    10531051                { $$ = new StatementNode( build_return( $2 ) ); }
    1054         | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
    1055                 { $$ = nullptr; }
    10561052        | THROW assignment_expression_opt ';'                           // handles rethrow
    10571053                { $$ = new StatementNode( build_throw( $2 ) ); }

  • src/tests/alloc.c

    rd27e340 rb69ea6b  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 14 17:52:36 2018
    13 // Update Count     : 328
     12// Last Modified On : Mon Jan 22 21:26:40 2018
     13// Update Count     : 326
    1414//
    1515
    … …  
    2727int main( void ) {
    2828        size_t dim = 10;
    29         char fill = '\xff';
    3029        int * p;
     30        char fill = '\1';
    3131
    3232        // allocation, non-array types
Note: See TracChangeset for help on using the changeset viewer.