Changeset 49eb6a2 for doc/papers/general


Ignore:
Timestamp:
Mar 11, 2018, 11:51:09 PM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
53dece1
Parents:
200b2b5
Message:

switch to SPE latex macros

Location:
doc/papers/general
Files:
117 added
2 edited

Legend:

Unmodified
Added
Removed

  • doc/papers/general/Makefile

    r200b2b5 r49eb6a2  
    33Build = build
    44Figures = figures
    5 Macros = ../../LaTeXmacros
     5Macros = AMA/AMA-stix/ama
    66TeXLIB = .:${Macros}:${Build}:../../bibliography:
    77LaTeX  = TEXINPUTS=${TeXLIB} && export TEXINPUTS && latex -halt-on-error -output-directory=${Build}
    88BibTeX = BIBINPUTS=${TeXLIB} && export BIBINPUTS && bibtex
    99
    10 MAKEFLAGS = --no-print-directory --silent #
     10MAKEFLAGS = --no-print-directory # --silent
    1111VPATH = ${Build} ${Figures} evaluation
    1212
    … …  
    5050
    5151${basename ${DOCUMENT}}.ps : ${basename ${DOCUMENT}}.dvi
    52         dvips ${Build}/$< -o $@
     52        dvips -h ${Build}/Paper.out.ps -o $@ ${Build}/$<
    5353
    5454${basename ${DOCUMENT}}.dvi : Makefile ${Build} ${GRAPHS} ${PROGRAMS} ${PICTURES} ${FIGURES} ${SOURCES} \
    55                 ${Macros}/common.tex ${Macros}/indexstyle ../../bibliography/pl.bib
     55                ../../bibliography/pl.bib
    5656        # Must have *.aux file containing citations for bibtex
    5757        if [ ! -r ${basename $@}.aux ] ; then ${LaTeX} ${basename $@}.tex ; fi
    58         -${BibTeX} ${Build}/${basename $@}
     58        ${BibTeX} ${Build}/${basename $@}
    5959        # Some citations reference others so run again to resolve these citations
    6060        ${LaTeX} ${basename $@}.tex
    61         -${BibTeX} ${Build}/${basename $@}
     61        ${BibTeX} ${Build}/${basename $@}
    6262        # Run again to finish citations
    6363        ${LaTeX} ${basename $@}.tex

  • doc/papers/general/Paper.tex

    r200b2b5 r49eb6a2  
    1 \documentclass{article}
     1\documentclass[AMA,STIX1COL]{WileyNJD-v2}
     2%\documentclass{article}
     3
     4\articletype{RESEARCH ARTICLE}%
     5
     6\received{26 April 2016}
     7\revised{6 June 2016}
     8\accepted{6 June 2016}
     9
     10\raggedbottom
    211
    312\usepackage{fullpage}
    … …  
    817\usepackage{enumitem}
    918\setlist[itemize]{topsep=3pt,itemsep=2pt,parsep=0pt}% global
    10 \usepackage[flushmargin]{footmisc}                      % support label/reference in footnote
    1119\usepackage{rotating}
    12 \usepackage[usenames]{color}
    13 \usepackage{pslatex}                                            % reduce size of san serif font
    14 \usepackage[plainpages=false,pdfpagelabels,pdfpagemode=UseNone,pagebackref=true,breaklinks=true,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
    15 \urlstyle{sf}
    16 \usepackage{breakurl}
    17 
    18 \setlength{\textheight}{9in}
    19 %\oddsidemargin 0.0in
    20 \renewcommand{\topfraction}{0.8}                        % float must be greater than X of the page before it is forced onto its own page
    21 \renewcommand{\bottomfraction}{0.8}                     % float must be greater than X of the page before it is forced onto its own page
    22 \renewcommand{\floatpagefraction}{0.8}          % float must be greater than X of the page before it is forced onto its own page
    23 \renewcommand{\textfraction}{0.0}                       % the entire page maybe devoted to floats with no text on the page at all
     20\definecolor{ForestGreen}{cmyk}{1, 0, 0.99995, 0}
     21\hypersetup{breaklinks=true}
     22
     23\usepackage[pagewise]{lineno}
     24\renewcommand{\linenumberfont}{\scriptsize\sffamily}
     25
     26\setlength{\topmargin}{-0.75in}\setlength{\headsep}{0.5in}\setlength{\footskip}{0.25in}
     27\setlength{\textheight}{9.325in}
     28\setlength{\textwidth}{6.75in}
     29\setlength{\evensidemargin}{-0.25in}
     30\setlength{\oddsidemargin}{-0.25in}
    2431
    2532\lefthyphenmin=4                                                        % hyphen only after 4 characters
    … …  
    6471\newlength{\gcolumnposn}                                        % temporary hack because lstlisting does not handle tabs correctly
    6572\newlength{\columnposn}
    66 \setlength{\gcolumnposn}{2.75in}
     73\setlength{\gcolumnposn}{3.5in}
    6774\setlength{\columnposn}{\gcolumnposn}
    6875\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
    … …  
    96103        {\ETC.\xspace}%
    97104}%
    98 \newcommand{\ETAL}{\abbrevFont{et}~\abbrevFont{al}}
    99 \newcommand*{\etal}{%
    100         \@ifnextchar{.}{\protect\ETAL}%
    101                 {\protect\ETAL.\xspace}%
    102 }%
     105%\newcommand{\ETAL}{\abbrevFont{et}~\abbrevFont{al}}
     106%\newcommand*{\etal}{%
     107%       \@ifnextchar{.}{\protect\ETAL}%
     108%               {\protect\ETAL.\xspace}%
     109%}%
    103110\newcommand{\VIZ}{\abbrevFont{viz}}
    104111\newcommand*{\viz}{%
    … …  
    145152belowskip=3pt,
    146153% replace/adjust listing characters that look bad in sanserif
    147 literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
    148         {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {@}{\small{@}}1 {<}{\small{\textless}}1 {>}{\small{\textgreater}}1  % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
    149         {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\small\textgreater}}2,
     154literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
     155        {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
     156        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
    150157moredelim=**[is][\color{red}]{`}{`},
    151158}% lstset
    152 
    153 % inline code @...@
    154 \lstMakeShortInline@%
    155159
    156160\lstnewenvironment{cfa}[1][]
    … …  
    162166
    163167
    164 \title{\protect\CFA : Adding Modern Programming Language Features to C}
    165 
    166 \author{Aaron Moss, Robert Schluntz, Peter Buhr}
    167 % \email{a3moss@uwaterloo.ca}
    168 % \email{rschlunt@uwaterloo.ca}
    169 % \email{pabuhr@uwaterloo.ca}
    170 % \affiliation{%
    171 %       \institution{University of Waterloo}
    172 %       \department{David R. Cheriton School of Computer Science}
    173 %       \streetaddress{Davis Centre, University of Waterloo}
    174 %       \city{Waterloo}
    175 %       \state{ON}
    176 %       \postcode{N2L 3G1}
    177 %       \country{Canada}
    178 % }
    179 
    180 %\terms{generic, tuple, variadic, types}
    181 %\keywords{generic types, tuple types, variadic types, polymorphic functions, C, Cforall}
    182 
    183168\begin{document}
    184 \maketitle
    185 
    186 
    187 \begin{abstract}
     169\linenumbers                                            % comment out to turn off line numbering
     170
     171\title{\texorpdfstring{\protect\CFA : Adding Modern Programming Language Features to C}{Cforall : Adding Modern Programming Language Features to C}}
     172
     173\author[1]{Aaron Moss}
     174\author[1]{Robert Schluntz}
     175\author[1]{Peter A. Buhr*}
     176
     177\address[1]{\orgdiv{David R. Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Ontario}, \country{Canada}}}
     178
     179%\corres{*Aaron Moss, \email{a3moss@uwaterloo.ca}}
     180\corres{*Peter A. Buhr, \email{pabuhr@uwaterloo.ca}}
     181\presentaddress{David R. Cheriton School of Computer Science, University of Waterloo, Waterloo, ON, N2L 3G1, Canada}
     182
     183% inline code @...@
     184\lstMakeShortInline@%
     185
     186
     187\abstract[Summary]{
    188188The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
    189189This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
    … …  
    195195This paper presents a quick tour of \CFA features showing how their design avoids shortcomings of similar features in C and other C-like languages.
    196196Finally, experimental results are presented to validate several of the new features.
    197 \end{abstract}
     197}%
     198
     199\keywords{generic types, tuple types, variadic types, polymorphic functions, C, Cforall}
     200
     201\maketitle
    198202
    199203
    … …  
    230234\CFA is currently implemented as a source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
    231235Ultimately, a compiler is necessary for advanced features and optimal performance.
    232 All of the features discussed in this paper are working, unless a feature states it is a future feature for completion.
     236All features discussed in this paper are working, unless otherwise stated as under construction.
    233237
    234238Finally, it is impossible to describe a programming language without usages before definitions.
    … …  
    258262
    259263\begin{cfa}
    260 int max = 2147483647;                                           $\C[3.75in]{// (1)}$
     264int max = 2147483647;                                   $\C[4in]{// (1)}$
    261265double max = 1.7976931348623157E+308;   $\C{// (2)}$
    262266int max( int a, int b ) { return a < b ? b : a; }  $\C{// (3)}$
    263267double max( double a, double b ) { return a < b ? b : a; }  $\C{// (4)}\CRT$
    264 max( 7, -max );                                                         $\C{// uses (3) and (1), by matching int from constant 7}$
    265 max( max, 3.14 );                                                       $\C{// uses (4) and (2), by matching double from constant 3.14}$
    266 max( max, -max );                                                       $\C{// ERROR: ambiguous}$
    267 int m = max( max, -max );                                       $\C{// uses (3) and (1) twice, by matching return type}$
     268max( 7, -max );                                         $\C[2.75in]{// uses (3) and (1), by matching int from constant 7}$
     269max( max, 3.14 );                                       $\C{// uses (4) and (2), by matching double from constant 3.14}$
     270max( max, -max );                                       $\C{// ERROR: ambiguous}$
     271int m = max( max, -max );                       $\C{// uses (3) and (1) twice, by matching return type}\CRT$
    268272\end{cfa}
    269273
    … …  
    292296\begin{cfa}
    293297`forall( otype T )` T identity( T val ) { return val; }
    294 int forty_two = identity( 42 );                         $\C{// T is bound to int, forty\_two == 42}$
     298int forty_two = identity( 42 );         $\C{// T is bound to int, forty\_two == 42}$
    295299\end{cfa}
    296300This @identity@ function can be applied to any complete \newterm{object type} (or @otype@).
    … …  
    306310For example, the function @twice@ can be defined using the \CFA syntax for operator overloading:
    307311\begin{cfa}
    308 forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; }       $\C{// ? denotes operands}$
     312forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; }  $\C{// ? denotes operands}$
    309313int val = twice( twice( 3.7 ) );
    310314\end{cfa}
    … …  
    325329}
    326330double key = 5.0, vals[10] = { /* 10 sorted float values */ };
    327 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
     331double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$
    328332\end{cfa}
    329333which can be augmented simply with a generalized, type-safe, \CFA-overloaded wrappers:
    … …  
    335339forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
    336340        T * result = bsearch( key, arr, size ); $\C{// call first version}$
    337         return result ? result - arr : size;    $\C{// pointer subtraction includes sizeof(T)}$
    338 }
    339 double * val = bsearch( 5.0, vals, 10 );        $\C{// selection based on return type}$
     341        return result ? result - arr : size; $\C{// pointer subtraction includes sizeof(T)}$
     342}
     343double * val = bsearch( 5.0, vals, 10 ); $\C{// selection based on return type}$
    340344int posn = bsearch( 5.0, vals, 10 );
    341345\end{cfa}
    … …  
    361365forall( otype T | { int ?<?( T, T ); } ) void qsort( const T * arr, size_t size ) { /* use C qsort */ }
    362366{
    363         int ?<?( double x, double y ) { return x `>` y; }       $\C{// locally override behaviour}$
     367        int ?<?( double x, double y ) { return x `>` y; } $\C{// locally override behaviour}$
    364368        qsort( vals, size );                                    $\C{// descending sort}$
    365369}
    … …  
    368372Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
    369373
    370 Unconstruction is a mechanism to distribute @forall@ over related routines/types (see @stack@ examples in Section~\ref{sec:eval}):
    371 \begin{cfa}
    372 forall( otype T ) {                                                     $\C{// forall block}$
    373         struct stack { stack_node(T) * head; }; $\C{// generic type}$
    374         void push( stack(T) & s, T value ) ...  $\C{// generic operations}$
    375         T pop( stack(T) & s ) ...
    376 }
    377 \end{cfa}
    378 Each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication.
     374Under construction is a mechanism to distribute @forall@ over routines/types, where each block declaration is prefixed with the initial @forall@ clause significantly reducing duplication (see @stack@ examples in Section~\ref{sec:eval}):
     375\begin{cfa}
     376forall( otype `T` ) {                                                   $\C{// forall block}$
     377        struct stack { stack_node(`T`) * head; };       $\C{// generic type}$
     378        void push( stack(`T`) & s, `T` value ) ...      $\C{// generic operations}$
     379        T pop( stack(`T`) & s ) ...
     380}
     381\end{cfa}
    379382
    380383
    … …  
    388391        T ?+=?( T *, T );
    389392        T ++?( T * );
    390         T ?++( T * ); };
    391 
     393        T ?++( T * );
     394};
    392395forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {  // use trait
    393396        `T` total = { `0` };                                    $\C{// instantiate T from 0 by calling its constructor}$
    394397        for ( unsigned int i = 0; i < size; i += 1 ) total `+=` a[i]; $\C{// select appropriate +}$
    395         return total; }
     398        return total;
     399}
    396400\end{cfa}
    397401
    … …  
    402406        void ?{}( T &, T );                                             $\C{// copy constructor}$
    403407        void ?=?( T &, T );                                             $\C{// assignment operator}$
    404         void ^?{}( T & ); };                                    $\C{// destructor}$
     408        void ^?{}( T & );                                               $\C{// destructor}$
     409};
    405410\end{cfa}
    406411Given the information provided for an @otype@, variables of polymorphic type can be treated as if they were a complete type: stack-allocatable, default or copy-initialized, assigned, and deleted.
    … …  
    654659p`->0` = 5;                                                                     $\C{// change quotient}$
    655660bar( qr`.1`, qr );                                                      $\C{// pass remainder and quotient/remainder}$
    656 rem = [div( 13, 5 ), 42]`.0.1`;                         $\C{// access 2nd component of 1st component of tuple expression}$
     661rem = [div( 13, 5 ), 42]`.0.1`;                         $\C{// access 2nd component of 1st component}$
    657662\end{cfa}
    658663
    … …  
    663668Tuple flattening recursively expands a tuple into the list of its basic components.
    664669Tuple structuring packages a list of expressions into a value of tuple type, \eg:
    665 %\lstDeleteShortInline@%
    666 %\par\smallskip
    667 %\begin{tabular}{@{}l@{\hspace{1.5\parindent}}||@{\hspace{1.5\parindent}}l@{}}
    668670\begin{cfa}
    669671int f( int, int );
    … …  
    672674[int, int] x;
    673675int y;
    674 f( x );                 $\C{// flatten}$
    675 g( y, 10 );             $\C{// structure}$
    676 h( x, y );              $\C{// flatten and structure}$
    677 \end{cfa}
    678 %\end{cfa}
    679 %&
    680 %\begin{cfa}
    681 %\end{tabular}
    682 %\smallskip\par\noindent
    683 %\lstMakeShortInline@%
     676f( x );                                                                         $\C{// flatten}$
     677g( y, 10 );                                                                     $\C{// structure}$
     678h( x, y );                                                                      $\C{// flatten and structure}$
     679\end{cfa}
    684680In the call to @f@, @x@ is implicitly flattened so the components of @x@ are passed as the two arguments.
    685681In the call to @g@, the values @y@ and @10@ are structured into a single argument of type @[int, int]@ to match the parameter type of @g@.
    … …  
    692688An assignment where the left side is a tuple type is called \newterm{tuple assignment}.
    693689There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a non-tuple type, called \newterm{multiple} and \newterm{mass assignment}, respectively.
    694 %\lstDeleteShortInline@%
    695 %\par\smallskip
    696 %\begin{tabular}{@{}l@{\hspace{1.5\parindent}}||@{\hspace{1.5\parindent}}l@{}}
    697690\begin{cfa}
    698691int x = 10;
    … …  
    704697[y, x] = 3.14;                                                          $\C{// mass assignment}$
    705698\end{cfa}
    706 %\end{cfa}
    707 %&
    708 %\begin{cfa}
    709 %\end{tabular}
    710 %\smallskip\par\noindent
    711 %\lstMakeShortInline@%
    712699Both kinds of tuple assignment have parallel semantics, so that each value on the left and right side is evaluated before any assignments occur.
    713700As a result, it is possible to swap the values in two variables without explicitly creating any temporary variables or calling a function, \eg, @[x, y] = [y, x]@.
    … …  
    733720Here, the mass assignment sets all members of @s@ to zero.
    734721Since tuple-index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member tuple expressions to manually restructure a tuple (\eg rearrange, drop, and duplicate components).
    735 %\lstDeleteShortInline@%
    736 %\par\smallskip
    737 %\begin{tabular}{@{}l@{\hspace{1.5\parindent}}||@{\hspace{1.5\parindent}}l@{}}
    738722\begin{cfa}
    739723[int, int, long, double] x;
    … …  
    743727[int, int, int] y = x.[2, 0, 2];                        $\C{// duplicate: [y.0, y.1, y.2] = [x.2, x.0.x.2]}$
    744728\end{cfa}
    745 %\end{cfa}
    746 %&
    747 %\begin{cfa}
    748 %\end{tabular}
    749 %\smallskip\par\noindent
    750 %\lstMakeShortInline@%
    751729It is also possible for a member access to contain other member accesses, \eg:
    752730\begin{cfa}
    … …  
    11461124\end{figure}
    11471125
    1148 Finally, @fallthrough@ may appear in contexts other than terminating a @case@ clause, and have an explicit transfer label allowing separate cases but common final-code for a set of cases:
    1149 \begin{cquote}
     1126Finally, Figure~\ref{f:FallthroughStatement} shows @fallthrough@ may appear in contexts other than terminating a @case@ clause, and have an explicit transfer label allowing separate cases but common final-code for a set of cases.
     1127The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structure, \ie it must be at the same level as the @case@ clauses;
     1128the target label may be case @default@.
     1129
     1130\begin{figure}
     1131\centering
    11501132\lstDeleteShortInline@%
    11511133\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
    … …  
    11691151  case 4:
    11701152        ... `fallthrough common;`
    1171   common: // below fallthrough and at same level as case clauses
     1153  common: // below fallthrough at same level as case clauses
    11721154        ...      // common code for cases 3 and 4
    11731155        // implicit break
    … …  
    11761158\end{tabular}
    11771159\lstMakeShortInline@%
    1178 \end{cquote}
    1179 The target label must be below the @fallthrough@, \ie @fallthrough@ cannot form a loop, and the label may not be nested in a control structure, \ie it must be at the same level as the @case@ clauses;
    1180 the target label may be case @default@.
     1160\caption{\lstinline|fallthrough| Statement}
     1161\label{f:FallthroughStatement}
     1162\end{figure}
    11811163
    11821164Collectively, these control-structure enhancements reduce programmer burden and increase readability and safety.
    … …  
    13101292        R r;
    13111293        ... `resume( r );` ...
    1312         ... r.fix // control does return here after handler
     1294        ... r.fix // control returns here after handler
    13131295}
    13141296`try` {
    … …  
    14231405
    14241406
    1425 \subsection{\texorpdfstring{\protect\lstinline{with} Clause / Statement}{with Clause / Statement}}
    1426 \label{s:WithClauseStatement}
     1407\subsection{\texorpdfstring{\protect\lstinline{with} Statement}{with Statement}}
     1408\label{s:WithStatement}
    14271409
    14281410Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
    … …  
    14441426A similar situation occurs in object-oriented programming, \eg \CC:
    14451427\begin{C++}
    1446 class C {
     1428struct S {
    14471429        char c;                                                                 $\C{// fields}$
    14481430        int i;
    14491431        double d;
    1450         int f() {                                                               $\C{// implicit ``this'' aggregate}$
     1432        void f() {                                                              $\C{// implicit ``this'' aggregate}$
    14511433                `this->`c; `this->`i; `this->`d;        $\C{// access containing fields}$
    14521434        }
    14531435}
    14541436\end{C++}
    1455 Object-oriented nesting of member functions in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
     1437Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
    14561438However, for other aggregate parameters, qualification is necessary:
    14571439\begin{cfa}
    14581440struct T { double m, n; };
    1459 int C::f( T & t ) {                                                     $\C{// multiple aggregate parameters}$
    1460         c; i; d;                                                                $\C{\color{red}// this--{\small\textgreater}.c, this--{\small\textgreater}.i, this--{\small\textgreater}.d}$
     1441int S::f( T & t ) {                                                     $\C{// multiple aggregate parameters}$
     1442        c; i; d;                                                                $\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}$
    14611443        `t.`m; `t.`n;                                                   $\C{// must qualify}$
    14621444}
    … …  
    14721454with the generality of opening multiple aggregate-parameters:
    14731455\begin{cfa}
    1474 int f( S & s, T & t ) `with ( s, t )` {         $\C{// multiple aggregate parameters}$
     1456void f( S & s, T & t ) `with ( s, t )` {                $\C{// multiple aggregate parameters}$
    14751457        c; i; d;                                                                $\C{\color{red}// s.c, s.i, s.d}$
    14761458        m; n;                                                                   $\C{\color{red}// t.m, t.n}$
    … …  
    15381520\begin{cfa}
    15391521struct S { int i, j; } sv;
    1540 with ( sv ) {                                                           $\C{implicit reference}$
     1522with ( sv ) {                                                           $\C{// implicit reference}$
    15411523        S & sr = sv;
    1542         with ( sr ) {                                                   $\C{explicit reference}$
     1524        with ( sr ) {                                                   $\C{// explicit reference}$
    15431525                S * sp = &sv;
    1544                 with ( *sp ) {                                          $\C{computed reference}$
    1545                         i = 3; j = 4;                                   $\C{\color{red}// sp--{\small\textgreater}i, sp--{\small\textgreater}j}$
     1526                with ( *sp ) {                                          $\C{// computed reference}$
     1527                        i = 3; j = 4;                                   $\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}$
    15461528                }
    15471529                i = 2; j = 3;                                           $\C{\color{red}// sr.i, sr.j}$
    … …  
    16091591\begin{cfa}
    16101592// array of 5 pointers to int
    1611 // pointer to an array of 5 int
    1612 // function returning pointer to an array of 5 int and taking an int
     1593// pointer to array of 5 int
     1594// function returning pointer to array of 5 int and taking int
    16131595\end{cfa}
    16141596\end{tabular}
    … …  
    16871669\begin{cfa}
    16881670extern const * const int x;
    1689 static const * [ 5 ] const int y;
     1671static const * [5] const int y;
    16901672\end{cfa}
    16911673&
    16921674\begin{cfa}
    16931675int extern const * const x;
    1694 static const int (* const y)[ 5 ]
     1676static const int (* const y)[5]
    16951677\end{cfa}
    16961678&
    … …  
    17261708as well, parameter names are optional, \eg:
    17271709\begin{cfa}
    1728 [ int x ] f ( /* void */ );                                     $\C{// returning int with no parameters}$
    1729 [ int x ] f (...);                                                      $\C{// returning int with unknown parameters}$
    1730 [ * int ] g ( int y );                                          $\C{// returning pointer to int with int parameter}$
    1731 [ void ] h ( int, char );                                       $\C{// returning no result with int and char parameters}$
    1732 [ * int, int ] j ( int );                                       $\C{// returning pointer to int and int, with int parameter}$
     1710[ int x ] f ( /* void */ );             $\C[2in]{// returning int with no parameters}$
     1711[ int x ] f (...);                              $\C{// returning int with unknown parameters}$
     1712[ * int ] g ( int y );                  $\C{// returning pointer to int with int parameter}$
     1713[ void ] h ( int, char );               $\C{// returning no result with int and char parameters}$
     1714[ * int, int ] j ( int );               $\C{// returning pointer to int and int with int parameter}$
    17331715\end{cfa}
    17341716This syntax allows a prototype declaration to be created by cutting and pasting source text from the function-definition header (or vice versa).
    … …  
    17521734The syntax for pointers to \CFA functions specifies the pointer name on the right, \eg:
    17531735\begin{cfa}
    1754 * [ int x ] () fp;                                                      $\C{// pointer to function returning int with no parameters}$
    1755 * [ * int ] ( int y ) gp;                                       $\C{// pointer to function returning pointer to int with int parameter}$
    1756 * [ ] ( int, char ) hp;                                         $\C{// pointer to function returning no result with int and char parameters}$
    1757 * [ * int, int ] ( int ) jp;                            $\C{// pointer to function returning pointer to int and int, with int parameter}$
     1736* [ int x ] () fp;                              $\C{// pointer to function returning int with no parameters}$
     1737* [ * int ] ( int y ) gp;               $\C{// pointer to function returning pointer to int with int parameter}$
     1738* [ ] ( int, char ) hp;                 $\C{// pointer to function returning no result with int and char parameters}$
     1739* [ * int, int ] ( int ) jp;    $\C{// pointer to function returning pointer to int and int with int parameter}$
    17581740\end{cfa}
    17591741Note, a function name cannot be specified:
    17601742\begin{cfa}
    1761 * [ int x ] f () fp;                                            $\C{// function name "f" is disallowed}$
     1743* [ int x ] f () fp;                    $\C{// function name "f" is disallowed}\CRT$
    17621744\end{cfa}
    17631745
    … …  
    21472129        return (W){ l.stones + r.stones };
    21482130}
    2149 W |?`st|( double w ) { return (W){ w }; }
    2150 W |?`lb|( double w ) { return (W){ w / 14.0 }; }
    2151 W |?`kg|( double w ) { return (W) { w * 0.16 }; }
     2131W |?`st|(double w) { return (W){ w }; }
     2132W |?`lb|(double w) { return (W){ w/14.0 }; }
     2133W |?`kg|(double w) { return (W){ w*0.16 }; }
    21522134
    21532135
    … …  
    21722154        return W( l.stones + r.stones );
    21732155}
    2174 W |operator"" _st|( unsigned long long int w ) { return W( w ); }
    2175 W |operator"" _lb|( unsigned long long int w ) { return W( w / 14.0 ); }
    2176 W |operator"" _kg|( unsigned long long int w ) { return W( w * 0.16 ); }
    2177 W |operator"" _st|( long double w ) { return W( w ); }
    2178 W |operator"" _lb|( long double w ) { return W( w / 14.0 ); }
    2179 W |operator"" _kg|( long double w ) { return W( w * 0.16 ); }
     2156W |operator""_st|(unsigned long long int w) {return W(w); }
     2157W |operator""_lb|(unsigned long long int w) {return W(w/14.0); }
     2158W |operator""_kg|(unsigned long long int w) {return W(w*0.16); }
     2159W |operator""_st|(long double w ) { return W( w ); }
     2160W |operator""_lb|(long double w ) { return W( w / 14.0 ); }
     2161W |operator""_kg|(long double w ) { return W( w * 0.16 ); }
    21802162int main() {
    21812163        W w, heavy = { 20 };
    … …  
    22102192\begin{cquote}
    22112193\lstDeleteShortInline@%
    2212 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2213 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
     2194\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2195\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}      & \multicolumn{1}{c}{\textbf{Usage}}    \\
    22142196\begin{cfa}
    22152197const short int `MIN` = -32768;
    … …  
    22292211\begin{cquote}
    22302212\lstDeleteShortInline@%
    2231 \lstset{basicstyle=\linespread{0.9}\sf\small}
    2232 \begin{tabular}{@{}l@{\hspace{0.5\parindentlnth}}l@{}}
    2233 \multicolumn{1}{c@{\hspace{0.5\parindentlnth}}}{\textbf{\CFA}}  & \multicolumn{1}{c}{\textbf{C}}        \\
     2213\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2214\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{c}{\textbf{C}}        \\
    22342215\begin{cfa}
    22352216MIN
     2217
    22362218MAX
     2219
    22372220PI
    22382221E
    … …  
    22402223&
    22412224\begin{cfa}
    2242 SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN
    2243 SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX
     2225SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
     2226                FLT_MIN, DBL_MIN, LDBL_MIN
     2227SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
     2228                FLT_MAX, DBL_MAX, LDBL_MAX
    22442229M_PI, M_PIl
    22452230M_E, M_El
    … …  
    22562241\begin{cquote}
    22572242\lstDeleteShortInline@%
    2258 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2259 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
     2243\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2244\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}      & \multicolumn{1}{c}{\textbf{Usage}}    \\
    22602245\begin{cfa}
    22612246float `log`( float x );
    … …  
    22752260\begin{cquote}
    22762261\lstDeleteShortInline@%
    2277 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2278 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     2262\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2263\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{c}{\textbf{C}}        \\
    22792264\begin{cfa}
    22802265log
    … …  
    23032288\begin{cquote}
    23042289\lstDeleteShortInline@%
    2305 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2306 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
     2290\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2291\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}      & \multicolumn{1}{c}{\textbf{Usage}}    \\
    23072292\begin{cfa}
    23082293unsigned int `abs`( int );
    … …  
    23222307\begin{cquote}
    23232308\lstDeleteShortInline@%
    2324 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
    2325 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
     2309\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
     2310\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{c}{\textbf{C}}        \\
    23262311\begin{cfa}
    23272312abs
    … …  
    24142399ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
    24152400ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
    2416 ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
    2417 
     2401ip = (int *)realloc( ip, 4 * dim * sizeof( int ) );
     2402                        memset( ip, fill, 4 * dim * sizeof( int ) );
    24182403ip = memalign( 16, sizeof( int ) );
    24192404ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
    … …  
    27882773\section{Acknowledgments}
    27892774
    2790 The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, Thierry Delisle, and Andrew Beach on the features described in this paper, and thank Magnus Madsen for feedback in the writing.
    2791 This work is supported through a corporate partnership with Huawei Ltd.\ (\url{http://www.huawei.com}), and Aaron Moss and Peter Buhr are partially funded by the Natural Sciences and Engineering Research Council of Canada.
    2792 
    2793 % the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship.
    2794 
    2795 
    2796 \bibliographystyle{plain}
     2775The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, Thierry Delisle, Andrew Beach and Brice Dobry on the features described in this paper, and thank Magnus Madsen for feedback on the writing.
     2776This work is supported by a corporate partnership with Huawei Ltd.\ (\url{http://www.huawei.com}), and Aaron Moss and Peter Buhr are partially funded by the Natural Sciences and Engineering Research Council of Canada.
     2777
     2778
    27972779\bibliography{pl}
    27982780
    … …  
    28022784\section{Benchmark Stack Implementation}
    28032785\label{sec:BenchmarkStackImplementation}
    2804 
    2805 \lstset{basicstyle=\linespread{0.9}\sf\small}
    28062786
    28072787Throughout, @/***/@ designates a counted redundant type annotation; code reformatted for brevity.
Note: See TracChangeset for help on using the changeset viewer.