Index: doc/papers/general/Paper.tex =================================================================== --- doc/papers/general/Paper.tex (revision 48786bc83eabdac1ae1f86fedac9eabccbf9bcb5) +++ doc/papers/general/Paper.tex (revision e6e344569fc9081a8886ab65d5c710cbda3bfc79) @@ -103,5 +103,5 @@ \newenvironment{cquote}{% - \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}% + \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}% \item\relax }{% @@ -193,7 +193,7 @@ The 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. The top 3 rankings over the past 30 years are: -\lstDeleteShortInline@% \begin{center} \setlength{\tabcolsep}{10pt} +\lstDeleteShortInline@% \begin{tabular}{@{}rccccccc@{}} & 2017 & 2012 & 2007 & 2002 & 1997 & 1992 & 1987 \\ \hline @@ -202,6 +202,6 @@ \CC & 3 & 3 & 3 & 3 & 2 & 2 & 4 \\ \end{tabular} +\lstMakeShortInline@% \end{center} -\lstMakeShortInline@% Love it or hate it, C is extremely popular, highly used, and one of the few systems languages. In many cases, \CC is often used solely as a better C. @@ -257,5 +257,5 @@ Crucial to the design of a new programming language are the libraries to access thousands of external software features. Like \CC, \CFA inherits a massive compatible library-base, where other programming languages must rewrite or provide fragile inter-language communication with C. -A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted floating-point array: +A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array: \begin{lstlisting} void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, @@ -263,5 +263,5 @@ int comp( const void * t1, const void * t2 ) { return *(double *)t1 < *(double *)t2 ? -1 : *(double *)t2 < *(double *)t1 ? 1 : 0; } -double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ }; +double key = 5.0, vals[10] = { /* 10 sorted float values */ }; double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$ \end{lstlisting} @@ -505,5 +505,5 @@ In many languages, functions can return at most one value; however, many operations have multiple outcomes, some exceptional. -Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and floating-point values, respectively. +Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and float values, respectively. \begin{lstlisting} typedef struct { int quo, rem; } div_t; $\C{// from include stdlib.h}$ @@ -936,4 +936,6 @@ \section{Control Structures} + +\CFA identifies missing and problematic control structures in C, and extends and modifies these control structures to increase functionality and safety. @@ -1044,10 +1046,129 @@ The implicit targets of the current @continue@ and @break@, \ie the closest enclosing loop or @switch@, change as certain constructs are added or removed. + \subsection{\texorpdfstring{Enhanced \LstKeywordStyle{switch} Statement}{Enhanced switch Statement}} -\CFA also fixes a number of ergonomic defecits in the @switch@ statements of standard C. -C 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:@. -For contiguous ranges, \CFA provides an even more concise range syntax as well, @case 1~3:@; lists of ranges are also allowed in case selectors. - +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. + +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.}. +\CFA provides a shorthand for a non-contiguous list: +\begin{cquote} +\lstDeleteShortInline@% +\begin{tabular}{@{}l@{\hspace{3em}}l@{}} +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +case 2, 10, 34, 42: +\end{cfa} +& +\begin{cfa} +case 2: case 10: case 34: case 42: +\end{cfa} +\end{tabular} +\lstMakeShortInline@% +\end{cquote} +for a contiguous list:\footnote{gcc provides the same mechanism with awkward syntax, \lstinline@2 ... 42@, where spaces are required around the ellipse.} +\begin{cquote} +\lstDeleteShortInline@% +\begin{tabular}{@{}l@{\hspace{3em}}l@{}} +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +case 2~42: +\end{cfa} +& +\begin{cfa} +case 2: case 3: ... case 41: case 42: +\end{cfa} +\end{tabular} +\lstMakeShortInline@% +\end{cquote} +and a combination: +\begin{cfa} +case -12~-4, -1~5, 14~21, 34~42: +\end{cfa} + +C allows placement of @case@ clauses \emph{within} statements nested in the @switch@ body (see Duff's device~\cite{Duff83}); +\begin{cfa} +switch ( i ) { + case 0: + for ( int i = 0; i < 10; i += 1 ) { + ... + `case 1:` // no initialization of loop index + ... + } +} +\end{cfa} +\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. + +C allows placement of declaration within the @switch@ body and unreachable code at the start, resulting in undefined behaviour: +\begin{cfa} +switch ( x ) { + `int y = 1;` $\C{// unreachable initialization}$ + `x = 7;` $\C{// unreachable code without label/branch}$ + case 0: + ... + `int z = 0;` $\C{// unreachable initialization, cannot appear after case}$ + z = 2; + case 1: + `x = z;` $\C{// without fall through, z is undefined}$ +} +\end{cfa} +\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. +\CFA disallows the declaration of local variable, \eg @z@, 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. + +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}. +@case@ clauses are made disjoint by the @break@ statement. +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. +\CFA provides a new control structure, @choose@ that mimics the @switch@, but reverses the meaning of fall through: +\begin{cquote} +\lstDeleteShortInline@% +\begin{tabular}{@{}l@{\hspace{3em}}l@{}} +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{cfa} +`choose` ( day ) { + case Mon, Tue, Wed, Thu: + // program + + case Fri: + // program + wallet += pay; + `fallthrough;` + case Sat: + // party + wallet -= party; + + case Sun: + // rest + + default: + // error +} +\end{cfa} +& +\begin{cfa} +switch ( day ) { + case Mon: case Tue: case Wed: case Thu: + // program + `break;` + case Fri: + // program + wallet += pay; + + case Sat: + // party + wallet -= party; + `break;` + case Sun: + // rest + `break;` + default: + // error +} +\end{cfa} +\end{tabular} +\lstMakeShortInline@% +\end{cquote} +Collectively, these enhancements reduce programmer burden and increase readability and safety. + +\begin{comment} Forgotten @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. \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. @@ -1070,4 +1191,6 @@ } \end{cfa} +\end{comment} + \subsection{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}} @@ -1598,5 +1721,5 @@ \section{Literals} -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 floating-point types are very similar, differing from each other only in suffix. +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. In 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.