Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/user/user.tex

    r53ba273 r6c91065  
    1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
    2 %%
    3 %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    4 %%
    5 %% The contents of this file are covered under the licence agreement in the
    6 %% file "LICENCE" distributed with Cforall.
    7 %%
    8 %% user.tex --
    9 %%
    10 %% Author           : Peter A. Buhr
    11 %% Created On       : Wed Apr  6 14:53:29 2016
    12 %% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Wed Apr  6 17:37:39 2016
    14 %% Update Count     : 34
    15 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    16 
    171% requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
    182
    … …  
    215
    226% Latex packages used in the document.
    23 \usepackage[T1]{fontenc}
    24 \usepackage{textcomp}
    25 \usepackage[latin1]{inputenc}
    26 \usepackage{upquote}
     7
    278\usepackage{fullpage,times}
    289\usepackage{xspace}
    … …  
    4324% Names used in the document.
    4425
    45 \newcommand{\CFA}{C$\mathbf\forall$\xspace}     % set language symbolic name
     26\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
    4627\newcommand{\CFL}{Cforall\xspace}               % set language text name
    4728\newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
    … …  
    179160% CFA based on ANSI C
    180161\lstdefinelanguage{CFA}[ANSI]{C}%
    181 {morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
    182     _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    183         fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
    184         _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
    185   moredelim=**[is][\color{red}]{`}{`},
     162{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
     163        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
     164        _Thread_local,throw,throwResume,try,},
    186165}%
    187166
    … …  
    197176showstringspaces=false,
    198177showlines=true,
    199 aboveskip=6pt,
    200 belowskip=4pt,
    201 literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used to highlight in red
    202 %extendedchars=true,
    203178}%
    204179
    … …  
    206181% replace/adjust listings characters that look bad in sanserif
    207182\lst@CCPutMacro
    208 \lst@ProcessOther{"22}{\lst@ttfamily{"}{\raisebox{0.3ex}{\ttfamily\upshape "}}} % replace double quote
    209 \lst@ProcessOther{"27}{\lst@ttfamily{'}{\raisebox{0.3ex}{\ttfamily\upshape '\hspace*{-2pt}}}} % replace single quote
    210 \lst@ProcessOther{"2D}{\lst@ttfamily{-}{\ttfamily\upshape -}} % replace minus
     183\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
    211184\lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
    212185\lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
    213186\lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
    214 \lst@ProcessOther{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
    215 \lst@ProcessOther{"60}{\lst@ttfamily{`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}} % replace backquote
     187\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
    216188\lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde
    217189%\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
    … …  
    394366
    395367The command \lstinline@cfa@ is used to compile \CFA program(s).
    396 This command works like the GNU \lstinline@gcc@\index{gcc} command, e.g.:
     368This command works like the GNU \lstinline@gcc@ command, e.g.:
    397369\begin{lstlisting}
    398370cfa [ gcc-options ] C/@{\CFA}@-files [ assembler/loader-files ]
    399371\end{lstlisting}
    400 By default, \CFA programs having the following \lstinline@gcc@ flags turned on:
    401 \begin{description}
    402 \item
    403 \hspace*{-4pt}\lstinline@-std=gnu99@
    404 The 1999 C standard plus GNU extensions.
    405 \end{description}
    406 The following new \CFA option is available:
     372The following additional option is available:
    407373\begin{description}
    408374\item
    … …  
    416382Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
    417383\begin{lstlisting}
    418 2`_`147`_`483`_`648;                            // decimal constant
     3842_147_483_648;                          // decimal constant
    41938556_ul;                                          // decimal unsigned long constant
    4203860_377;                                          // octal constant
    … …  
    485451\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
    486452\begin{lstlisting}
    487 `* int x, y;`
     453* int x, y;
    488454\end{lstlisting}
    489455&
    … …  
    605571The point of the new syntax is to allow returning multiple values from a routine~\cite{CLU,Galletly96}, e.g.:
    606572\begin{lstlisting}
    607 `[ int o1, int o2, char o3 ]` f( int i1, char i2, char i3 ) {
     573[ int o1, int o2, char o3 ] f( int i1, char i2, char i3 ) {
    608574        @\emph{routine body}@
    609575}
    … …  
    673639Because the value in the return variable is automatically returned when a \CFA routine terminates, the \lstinline@return@ statement \emph{does not} contain an expression, as in:
    674640\begin{lstlisting}
    675 `[ int x ]` f() {
     641[ int x ] f() {
    676642        ... x = 0; ... x = y; ...
    677         `return;` // implicitly return x
     643        return; // implicitly return x
    678644}
    679645\end{lstlisting}
    … …  
    731697for example, the following is incorrect:
    732698\begin{lstlisting}
    733 * [ int x ] f () fp;            // routine name "f" is not allowed
     699* [ int x ] f () fp;            // routine name ``f'' is not allowed
    734700\end{lstlisting}
    735701
    … …  
    898864\subsection{Type Nesting}
    899865
    900 \CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type!hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
     866C allows \Index{type nesting}, but the nested types are hoisted\index{type!hoisting} (refactored) into the enclosing scope.
    901867\begin{quote2}
    902868\begin{tabular}{@{}l@{\hspace{30pt}}l|l@{}}
    … …  
    953919
    954920int fred() {
    955         s.t.c = `S.`R;  // type qualification
    956         struct `S.`T t = { `S.`R, 1, 2 };
    957         enum `S.`C c;
    958         union `S.T.`U u;
     921        s.t.c = S.R;
     922        struct S.T t = { S.R, 1, 2 };
     923        enum S.C c;
     924        union S.T.U u;
    959925}
    960926\end{lstlisting}
    961927\end{tabular}
    962928\end{quote2}
    963 In the left example in C, types \lstinline@C@, \lstinline@U@ and \lstinline@T@ are implicitly hoisted outside of type \lstinline@S@ into the containing block scope.
    964 In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``\lstinline@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``\lstinline@::@''.
     929
     930\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
     931Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
     932Given that nested types in C are equivalent to not using them, i.e., they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
    965933
    966934
    … …  
    976944\begin{lstlisting}
    977945const unsigned int size = 10;
    978 int ia[size];
    979 ...                                             // assign values to array ia
    980 qsort( ia, size );              // sort ascending order using builtin ?<?
    981 {
    982         `int ?<?( int x, int y ) { return x > y; }` // nested routine
    983         qsort( ia, size );      // sort descending order by local redefinition
    984 }
    985 \end{lstlisting}
    986 
    987 Nested routines are not first-class, meaning a nested routine cannot be returned if it has references to variables in its enclosing blocks;
    988 the only exception is references to the external block of the translation unit, as these variables persist for the duration of the program.
    989 The following program in undefined in \CFA (and \lstinline@gcc@\index{gcc})
    990 \begin{lstlisting}
    991 [* [int]( int )] foo() {                // int (*foo())( int )
    992         int `i` = 7;
    993         int bar( int p ) {
    994                 `i` += 1;                                       // dependent on local variable
    995                 sout | `i` | endl;
    996         }
    997         return bar;                                     // undefined because of local dependence
    998 }
    999 int main() {
    1000         * [int](int) fp = foo();        // int (*fp)(int)
    1001     sout | fp( 3 ) | endl;
    1002 }
    1003 \end{lstlisting}
    1004 because
    1005 
    1006 Currently, there are no \Index{lambda} expressions, i.e., unnamed routines because routine names are very important to properly select the correct routine.
     946int a[size];
     947
     948qsort( a, size );               // ascending order using built in ?<?
     949{                                               // descending order by local redefinition
     950        int ?<?( int a, int b ) { return a > b; } // nested routine
     951        qsort( a, size );
     952}
     953\end{lstlisting}
    1007954
    1008955
    … …  
    10661013
    10671014\item
    1068 Change: A struct is a scope in C++, not in C \\
    1069 Rationale: Class scope is crucial to C++, and a struct is a class. \\
    1070 Effect on original feature: Change to semantics of well-defined feature. \\
    1071 Difficulty of converting: Semantic transformation. \\
    1072 How widely used: C programs use struct extremely frequently, but the change is only noticeable when struct, enumeration, or enumerator names are referred to outside the struct.
    1073 The latter is probably rare.
    1074 
    1075 \CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
    1076 Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
    1077 Given that nested types in C are equivalent to not using them, i.e., they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
    1078 
     1015Change: A struct is a scope in C++, not in C
     1016Rationale: Class scope is crucial to C++, and a struct is a class.
     1017Effect on original feature: Change to semantics of well-defined feature.
     1018Difficulty of converting: Semantic transformation.
     1019How widely used: C programs use struct extremely frequently, but the change is only noticeable when
     1020struct, enumeration, or enumerator names are referred to outside the struct. The latter is probably
     1021rare.
    10791022
    10801023\item
    … …  
    12421185First the right-hand tuple is flattened and then the values are assigned individually.
    12431186Flattening is also performed on tuple types.
    1244 For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type \lstinline@[ int, int, int, int ]@.
     1187For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type lstinline@[ int, int, int, int ]@.
    12451188
    12461189A \newterm{structuring coercion} is the opposite of flattening;
    … …  
    14091352\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
    14101353\begin{lstlisting}
    1411 `L1:` for ( ... ) {
    1412         `L2:` for ( ... ) {
    1413                 `L3:` for ( ... ) {
    1414                         ... break `L1`; ...
    1415                         ... break `L2`; ...
    1416                         ... break `L3`; // or break
     1354L1: for ( ... ) {
     1355        L2: for ( ... ) {
     1356                L3: for ( ... ) {
     1357                        ... break L1; ...
     1358                        ... break L2; ...
     1359                        ... break L3; // or break
    14171360                }
    14181361        }
    … …  
    14391382\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
    14401383\begin{lstlisting}
    1441 `L1`: for ( ... ) {
    1442         `L2`: for ( ... ) {
    1443                 `L3`: for ( ... ) {
    1444                         ... continue `L1`; ...
    1445                         ... continue `L2`; ...
    1446                         ... continue `L3`; ...
     1384L1: for ( ... ) {
     1385        L2: for ( ... ) {
     1386                L3: for ( ... ) {
     1387                        ... continue L1; ...
     1388                        ... continue L2; ...
     1389                        ... continue L3; ...
    14471390
    14481391                }
    … …  
    16801623\begin{lstlisting}
    16811624switch ( i ) {
    1682   `case 1, 3, 5`:
     1625  case 1, 3, 5:
    16831626        ...
    1684   `case 2, 4, 6`:
     1627  case 2, 4, 6:
    16851628        ...
    16861629}
    … …  
    16911634  case 1: case 3 : case 5:
    16921635        ...
    1693   case 2: case 4 : case 6:
     1636  case 2: case 4 : case 6: /* even values */
    16941637        ...
    16951638}
    … …  
    17121655\begin{lstlisting}
    17131656switch ( i ) {
    1714   `case 1~5:`
     1657  case 1~5
    17151658        ...
    1716   `case 10~15:`
     1659  case 10~15
    17171660        ...
    17181661}
    … …  
    17291672&
    17301673\begin{lstlisting}
    1731 
    17321674// 1, 2, 3, 4, 5
    17331675
    … …  
    22262168
    22272169
    2228 \section{Auto Type-Inferencing}
    2229 
    2230 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type.
    2231 \begin{quote2}
    2232 \begin{tabular}{@{}l@{\hspace{30pt}}ll@{}}
    2233 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{\lstinline@gcc@}\index{gcc} \\
    2234 \begin{lstlisting}
    2235 
    2236 auto j = 3.0 * 4;
    2237 int i;
    2238 auto k = i;
    2239 \end{lstlisting}
    2240 &
    2241 \begin{lstlisting}
    2242 #define expr 3.0 * i
    2243 typeof(expr) j = expr;
    2244 int i;
    2245 typeof(i) k = i;
    2246 \end{lstlisting}
    2247 &
    2248 \begin{lstlisting}
    2249 
    2250 // use type of initialization expression
    2251 
    2252 // use type of primary variable
    2253 \end{lstlisting}
    2254 \end{tabular}
    2255 \end{quote2}
    2256 The two important capabilities are:
    2257 \begin{itemize}
    2258 \item
    2259 preventing having to determine or write out long generic types,
    2260 \item
    2261 ensure secondary variables, related to a primary variable, always have the same type.
    2262 \end{itemize}
    2263 
    2264 In \CFA, \lstinline@typedef@ provides a mechanism to alias long type names with short ones, both globally and locally, but not eliminate the use of the short name.
    2265 \lstinline@gcc@ provides \lstinline@typeof@ to declare a secondary variable from a primary variable.
    2266 \CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
    2267 Only for overloaded routines with the same return type is variable type-inferencing possible.
    2268 Finally, \lstinline@auto@ presents the programming problem of tracking down a type when the type is actually needed.
    2269 For example, given
    2270 \begin{lstlisting}
    2271 auto j = `...`
    2272 \end{lstlisting}
    2273 and the need to write a routine to compute using \lstinline@j@
    2274 \begin{lstlisting}
    2275 void rtn( `...` parm );
    2276 rtn( j );
    2277 \end{lstlisting}
    2278 A programmer must work backwards to determine the type of \lstinline@j@'s initialization expression, reconstructing the possibly long generic type-name.
    2279 In this situation, having the type name or a short alias is very useful.
    2280 
    2281 There is also the conundrum in type inferencing of when to \emph{\Index{brand}} a type.
    2282 That is, when is the type of the variable more important than the type of its initialization expression.
    2283 For example, if a change is made in an initialization expression, it can cause hundreds or thousands of cascading type changes and/or errors.
    2284 At some point, a programmer wants the type of the variable to remain constant and the expression to be in error when it changes.
    2285 
    2286 Given \lstinline@typedef@ and \lstinline@typeof@ in \CFA, and the strong need to use the type of left-hand side in inferencing, auto type-inferencing is not supported at this time.
    2287 Should a significant need arise, this feature can be revisited.
    2288 
    2289 
    2290 \section{Generics}
     2170\section{Generics }
    22912171
    22922172\CFA supports parametric polymorphism to allow users to define generic functions and types.
    … …  
    25772457
    25782458
    2579 \section{Syntactic Anomalies}
    2580 
    2581 The number 0 and 1 are treated specially in \CFA, and can be redefined as variables.
    2582 One syntactic anomaly is when a field in an structure is names 0 or 1:
    2583 \begin{lstlisting}
    2584 struct S {
    2585         int 0, 1;
    2586 } s;
    2587 \end{lstlisting}
    2588 The problem occurs in accesing these fields using the selection operation ``\lstinline@.@'':
    2589 \begin{lstlisting}
    2590 s.0 = 0;        // ambiguity with floating constant .0
    2591 s.1 = 1;        // ambiguity with floating constant .1
    2592 \end{lstlisting}
    2593 To make this work, a space is required after the field selection:
    2594 \begin{lstlisting}
    2595 `s.@\textvisiblespace@0` = 0;
    2596 `s.@\textvisiblespace@1` = 1;
    2597 \end{lstlisting}
    2598 While this sytact is awkward, it is unlikely many programers will name fields of a structure 0 or 1.
    2599 Like the \CC lexical problem with closing template-syntax, e.g, \lstinline@Foo<Bar<int`>>`@, this issue can be solved with a more powerful lexer/parser.
    2600 
    2601 There are several ambiguous cases with operator identifiers, e.g., \lstinline@int *?*?()@, where the string \lstinline@*?*?@ can be lexed as \lstinline@*@/\lstinline@?*?@ or \lstinline@*?@/\lstinline@*?@.
    2602 Since it is common practise to put a unary operator juxtaposed to an identifier, e.g., \lstinline@*i@, users will be annoyed if they cannot do this with respect to operator identifiers.
    2603 Even with this special hack, there are 5 general cases that cannot be handled.
    2604 The first case is for the function-call identifier \lstinline@?()@:
    2605 \begin{lstlisting}
    2606 int *@\textvisiblespace@?()();  // declaration: space required after '*'
    2607 *@\textvisiblespace@?()();              // expression: space required after '*'
    2608 \end{lstlisting}
    2609 Without the space, the string \lstinline@*?()@ is ambiguous without N character look ahead;
    2610 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument/parameter list.
    2611 
    2612 The 4 remaining cases occur in expressions:
    2613 \begin{lstlisting}
    2614 i++@\textvisiblespace@?i:0;             // space required before '?'
    2615 i--@\textvisiblespace@?i:0;             // space required before '?'
    2616 i@\textvisiblespace@?++i:0;             // space required after '?'
    2617 i@\textvisiblespace@?--i:0;             // space required after '?'
    2618 \end{lstlisting}
    2619 In the first two cases, the string \lstinline@i++?@ is ambiguous, where this string can be lexed as \lstinline@i@ / \lstinline@++?@ or \lstinline@i++@ / \lstinline@?@;
    2620 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
    2621 In the second two cases, the string \lstinline@?++x@ is ambiguous, where this string can be lexed as \lstinline@?++@ / \lstinline@x@ or \lstinline@?@ / y\lstinline@++x@;
    2622 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
     2459\section{I/O Library}
     2460\label{s:IOLibrary}
     2461
     2462The goal for \CFA I/O is to make I/O as simple as possible for the general case, while fully supporting polmorphism and user defined types in a consistent way.
     2463The general case is printing out a sequence of variables separated by whitespace.
     2464\begin{lstlisting}
     2465int x = 0, y = 1, z = 2;
     2466sout | x | y | z | endl;
     2467
     2468cout << x << " " << y << " " << z << endl;
     2469\end{lstlisting}
     2470The \CC form takes almost twice as many characters.
     2471
     2472The logical-or operator is used because it is the lowest priority overloadable operator, other than assignment.
     2473Therefore, most output expressions do not require parenthesis.
     2474\begin{lstlisting}
     2475int x = 0, y = 1, z = 2;
     2476sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
     2477
     2478cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
     2479\end{lstlisting}
     2480
     2481Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
     2482
     2483\begin{figure}
     2484\begin{lstlisting}[mathescape=off]
     2485#include <fstream>
     2486
     2487int main() {
     2488        char c;
     2489        short int si;
     2490        unsigned short int usi;
     2491        int i;
     2492        unsigned int ui;
     2493        long int li;
     2494        unsigned long int uli;
     2495        long long int lli;
     2496        unsigned long long int ulli;
     2497        float f;
     2498        double d;
     2499        long double ld;
     2500        float _Complex fc;
     2501        double _Complex dc;
     2502        long double _Complex ldc;
     2503        char s1[10], s2[10];
     2504
     2505        ifstream in;
     2506        open( &in, "read.data", "r" );
     2507
     2508        &in | &c
     2509                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli
     2510                | &f | &d | &ld
     2511                | &fc | &dc | &ldc
     2512                | str( s1 ) | str( s2, 10 );
     2513
     2514        sout | c | ' ' | endl
     2515                 | si | usi | i | ui | li | uli | lli | ulli | endl
     2516                 | f | d | ld | endl
     2517                 | f | "" | d | "" | ld | endl;
     2518
     2519        sepSet( sout, ", $" );
     2520        sout | fc | dc | ldc | endl
     2521                 | sepOn | s1 | sepOff | s2 | endl
     2522                 | s1 | "" | s2 | endl;
     2523}
     2524
     2525$ cat read.data
     2526A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
     2527$ a.out
     2528A
     25291 2 3 4 5 6 7 8
     25301.1 1.2 1.3
     25311.11.21.3
     25321.1+2.3i, $1.1-2.3i, $1.1-2.3i
     2533, $abcxyz
     2534abcxyz
     2535\end{lstlisting}
     2536\end{figure}
     2537
     2538
     2539\section{Standard Library}
     2540\label{s:StandardLibrary}
     2541
     2542The goal of the \CFA standard-library is to wrap many of the existing C library-routines that are explicitly polymorphic into implicitly polymorphic versions.
     2543
     2544
     2545\subsection{malloc}
     2546
     2547\begin{lstlisting}
     2548forall( otype T ) T * malloc( void );
     2549forall( otype T ) T * malloc( char fill );
     2550forall( otype T ) T * malloc( T * ptr, size_t size );
     2551forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
     2552forall( otype T ) T * calloc( size_t size );
     2553forall( otype T ) T * realloc( T * ptr, size_t size );
     2554forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
     2555
     2556forall( otype T ) T * aligned_alloc( size_t alignment );
     2557forall( otype T ) T * memalign( size_t alignment );             // deprecated
     2558forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
     2559
     2560forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
     2561forall( otype T ) T * memset( T * ptr );                                // remove when default value available
     2562\end{lstlisting}
     2563
     2564
     2565\subsection{ato/strto}
     2566
     2567\begin{lstlisting}
     2568int ato( const char * ptr );
     2569unsigned int ato( const char * ptr );
     2570long int ato( const char * ptr );
     2571unsigned long int ato( const char * ptr );
     2572long long int ato( const char * ptr );
     2573unsigned long long int ato( const char * ptr );
     2574float ato( const char * ptr );
     2575double ato( const char * ptr );
     2576long double ato( const char * ptr );
     2577float _Complex ato( const char * ptr );
     2578double _Complex ato( const char * ptr );
     2579long double _Complex ato( const char * ptr );
     2580
     2581int strto( const char * sptr, char ** eptr, int base );
     2582unsigned int strto( const char * sptr, char ** eptr, int base );
     2583long int strto( const char * sptr, char ** eptr, int base );
     2584unsigned long int strto( const char * sptr, char ** eptr, int base );
     2585long long int strto( const char * sptr, char ** eptr, int base );
     2586unsigned long long int strto( const char * sptr, char ** eptr, int base );
     2587float strto( const char * sptr, char ** eptr );
     2588double strto( const char * sptr, char ** eptr );
     2589long double strto( const char * sptr, char ** eptr );
     2590float _Complex strto( const char * sptr, char ** eptr );
     2591double _Complex strto( const char * sptr, char ** eptr );
     2592long double _Complex strto( const char * sptr, char ** eptr );
     2593\end{lstlisting}
     2594
     2595
     2596\subsection{bsearch/qsort}
     2597
     2598\begin{lstlisting}
     2599forall( otype T | { int ?<?( T, T ); } )
     2600T * bsearch( const T key, const T * arr, size_t dimension );
     2601
     2602forall( otype T | { int ?<?( T, T ); } )
     2603void qsort( const T * arr, size_t dimension );
     2604\end{lstlisting}
     2605
     2606
     2607\subsection{abs}
     2608
     2609\begin{lstlisting}
     2610char abs( char );
     2611extern "C" {
     2612int abs( int );         // use default C routine for int
     2613} // extern
     2614long int abs( long int );
     2615long long int abs( long long int );
     2616float abs( float );
     2617double abs( double );
     2618long double abs( long double );
     2619float _Complex abs( float _Complex );
     2620double _Complex abs( double _Complex );
     2621long double _Complex abs( long double _Complex );
     2622\end{lstlisting}
     2623
     2624
     2625\subsection{random}
     2626
     2627\begin{lstlisting}
     2628void randseed( long int s );
     2629char random();
     2630int random();
     2631unsigned int random();
     2632long int random();
     2633unsigned long int random();
     2634float random();
     2635double random();
     2636float _Complex random();
     2637double _Complex random();
     2638long double _Complex random();
     2639\end{lstlisting}
     2640
     2641
     2642\subsection{min/max/swap}
     2643
     2644\begin{lstlisting}
     2645forall( otype T | { int ?<?( T, T ); } )
     2646T min( const T t1, const T t2 );
     2647
     2648forall( otype T | { int ?>?( T, T ); } )
     2649T max( const T t1, const T t2 );
     2650
     2651forall( otype T )
     2652void swap( T * t1, T * t2 );
     2653\end{lstlisting}
    26232654
    26242655
    … …  
    26452676
    26462677task creates a type with implicit locking, separate stack, and a thread
    2647 
    26482678
    26492679\subsection{Monitors}
    … …  
    37453775\multicolumn{1}{c|}{\textbf{\CFA/\CC}} & \multicolumn{1}{c|}{\textbf{Go}} & \multicolumn{1}{c}{\textbf{Rust}}   \\
    37463776\hline
    3747 \begin{lstlisting}[boxpos=t]
     3777\begin{lstlisting}
    37483778extern "C" {
    37493779#include <sys/types.h>
    … …  
    37523782}
    37533783size_t fileSize( const char *path ) {
    3754         struct stat s;
     3784        stat s;
    37553785        stat(path, &s);
    37563786        return s.st_size;
    … …  
    37583788\end{lstlisting}
    37593789&
    3760 \begin{lstlisting}[boxpos=t]
     3790\begin{lstlisting}
    37613791/*
    37623792#cgo
    … …  
    37773807\end{lstlisting}
    37783808&
    3779 \begin{lstlisting}[boxpos=t]
     3809\begin{lstlisting}
    37803810use libc::{c_int, size_t};
     3811
     3812// The following declarations are
    37813813// translated from sys/stat.h
    37823814#[repr(C)]
    … …  
    37863818        ...
    37873819}
     3820
    37883821#[link(name = "libc")]
    37893822extern {
    … …  
    37913824        buf: *mut stat_t) -> c_int;
    37923825}
     3826
    37933827fn fileSize(path: *const u8) -> size_t
    37943828{
    37953829        unsafe {
    3796                 let mut buf: stat_t = uninit();
    3797                 stat(path, &mut buf);
    3798                 buf.st_size
     3830        let mut buf: stat_t = uninit();
     3831        stat(path, &mut buf);
     3832        buf.st_size
    37993833        }
    38003834}
    … …  
    39193953
    39203954
    3921 \begin{comment}
    39223955\subsubsection{Modules/Packages}
    39233956
    … …  
    39994032}
    40004033\end{lstlisting}
    4001 \end{comment}
    4002 
    40034034
    40044035\subsubsection{Parallel Tasks}
    … …  
    41564187\end{flushleft}
    41574188
    4158 \lstset{basicstyle=\sf\relsize{-1}}
    4159 
    4160 
    41614189\subsection{Summary of Language Comparison}
    41624190
    … …  
    42254253D does not have any built-in concurrency constructs in the
    42264254language, though it does have a standard library for concurrency which includes the low-level primitives for concurrency.
    4227 
    4228 
    4229 \appendix
    4230 
    4231 
    4232 \section{I/O Library}
    4233 \label{s:IOLibrary}
    4234 \index{input/output library}
    4235 
    4236 The goal for \CFA I/O is to make I/O as simple as possible for the general case, while fully supporting polmorphism and user defined types in a consistent way.
    4237 The general case is printing out a sequence of variables separated by whitespace.
    4238 \begin{quote2}
    4239 \begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
    4240 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{\CC}}      \\
    4241 \begin{lstlisting}
    4242 int x = 0, y = 1, z = 2;
    4243 `sout` `|` x `|` y `|` z `| endl`;
    4244 \end{lstlisting}
    4245 &
    4246 \begin{lstlisting}
    4247 
    4248 cout << x << " " << y << " " << z << endl;
    4249 \end{lstlisting}
    4250 \end{tabular}
    4251 \end{quote2}
    4252 The \CFA form is half as many characters, and is similar to Python I/O with respect to implicit separators.
    4253 
    4254 The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment.
    4255 Therefore, fewer output expressions require parenthesis.
    4256 \begin{quote2}
    4257 \begin{tabular}{@{}ll@{}}
    4258 \textbf{\CFA:}
    4259 &
    4260 \begin{lstlisting}
    4261 sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
    4262 \end{lstlisting}
    4263 \\
    4264 \textbf{\CC:}
    4265 &
    4266 \begin{lstlisting}
    4267 cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
    4268 \end{lstlisting}
    4269 \end{tabular}
    4270 \end{quote2}
    4271 Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
    4272 
    4273 The implicit seperator\index{I/O separator} character (space/blank) is a separator not a terminator.
    4274 The rules for implicitly adding the separator are:
    4275 \begin{enumerate}
    4276 \item
    4277 A seperator does not appear at the start or end of a line.
    4278 \begin{lstlisting}[belowskip=0pt]
    4279 sout 1 | 2 | 3 | endl;
    4280 \end{lstlisting}
    4281 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4282 1 2 3
    4283 \end{lstlisting}
    4284 \item
    4285 A seperator does not appear before or after a character literal or variable.
    4286 \begin{lstlisting}
    4287 sout | '1' | '2' | '3' | endl;
    4288 123
    4289 \end{lstlisting}
    4290 \item
    4291 A seperator does not appear before or after a null (empty) C string
    4292 \begin{lstlisting}
    4293 sout | 1 | "" | 2 | "" | 3 | endl;
    4294 123
    4295 \end{lstlisting}
    4296 which is a local mechanism to disable insertion of the separator character.
    4297 \item
    4298 A seperator does not appear before a C string starting with the \Index{extended ASCII}\index{ASCII} characters: \lstinline[mathescape=off]@([{$£¥¿«@
    4299 %$
    4300 \begin{lstlisting}[mathescape=off]
    4301 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¿" | 7 | "x «" | 8 | endl;
    4302 \end{lstlisting}
    4303 %$
    4304 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4305 x (1 x [2 x {3 x $4 x £5 x ¥6 x ¿7 x «8
    4306 \end{lstlisting}
    4307 %$
    4308 \item
    4309 A seperator does not appear after a C string ending with the extended ASCII characters: \lstinline@,.:;!?)]}%¢»@
    4310 \begin{lstlisting}[belowskip=0pt]
    4311 sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
    4312          | 10 | "% x" | 11 | L"¢ x" | 12 | L"» x" | endl;
    4313 \end{lstlisting}
    4314 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4315 1, x 2. x 3: x 4; x 5! x 6? x 7) x 8] x 9} x 10% x 11¢ 12»
    4316 \end{lstlisting}
    4317 \item
    4318 A seperator does not appear before or after a C string begining/ending with the characters: \lstinline@\f\n\r\t\v\`'"@
    4319 \begin{lstlisting}[belowskip=0pt]
    4320 sout | "x '" | 1 | "' x \`" | 2 | "\` x \"" | 3 | "\" x" | endl;
    4321 \end{lstlisting}
    4322 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4323 x '1' x \`2\` x "3" x
    4324 \end{lstlisting}
    4325 \begin{lstlisting}[showtabs=true,aboveskip=0pt]
    4326 sout | "x\t" | 1 | "\tx" | endl;
    4327 x       1       x
    4328 \end{lstlisting}
    4329 \end{enumerate}
    4330 The following \CC-style \Index{manipulator}s allow further control over implicit seperation.
    4331 \begin{lstlisting}[mathescape=off,belowskip=0pt]
    4332 sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
    4333 \end{lstlisting}
    4334 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4335  1 2 3
    4336 \end{lstlisting}
    4337 \begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    4338 sout | 1 | sepOff | 2 | 3 | endl;                       // turn off implicit separator temporarily
    4339 \end{lstlisting}
    4340 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4341 12 3
    4342 \end{lstlisting}
    4343 \begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    4344 sout | sepDisable | 1 | 2 | 3 | endl;           // turn off implicit separation, affects all subsequent prints
    4345 \end{lstlisting}
    4346 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4347 123
    4348 \end{lstlisting}
    4349 \begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    4350 sout | 1 | sepOn | 2 | 3 | endl;                        // turn on implicit separator temporarily
    4351 \end{lstlisting}
    4352 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4353 1 23
    4354 \end{lstlisting}
    4355 \begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    4356 sout | sepEnable | 1 | 2 | 3 | endl;            // turn on implicit separation, affects all subsequent prints
    4357 \end{lstlisting}
    4358 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    4359 1 2 3
    4360 \end{lstlisting}
    4361 \begin{lstlisting}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
    4362 sepSet( sout, ", $" );                                          // change separator from " " to ", $"
    4363 sout | 1 | 2 | 3 | endl;
    4364 \end{lstlisting}
    4365 %$
    4366 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt]
    4367 1, $2, $3
    4368 \end{lstlisting}
    4369 %$
    4370 \VRef[Figure]{f:ExampleIO} shows an example of input and output I/O in \CFA.
    4371 
    4372 \begin{figure}
    4373 \begin{lstlisting}[mathescape=off]
    4374 #include <fstream>
    4375 
    4376 int main() {
    4377         char c;                                                                                                         // basic types
    4378         short int si;
    4379         unsigned short int usi;
    4380         int i;
    4381         unsigned int ui;
    4382         long int li;
    4383         unsigned long int uli;
    4384         long long int lli;
    4385         unsigned long long int ulli;
    4386         float f;
    4387         double d;
    4388         long double ld;
    4389         float _Complex fc;
    4390         double _Complex dc;
    4391         long double _Complex ldc;
    4392         char s1[10], s2[10];
    4393 
    4394         ifstream in;                                                                                            // create / open file
    4395         open( &in, "input.data", "r" );
    4396 
    4397         &in | &c                                                                                                        // character
    4398                 | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
    4399                 | &f | &d | &ld                                                                                 // floating point
    4400                 | &fc | &dc | &ldc                                                                              // floating-point complex
    4401                 | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
    4402 
    4403         sout | c | ' ' | endl                                                                           // character
    4404                  | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
    4405                  | f | d | ld | endl                                                                    // floating point
    4406                  | fc | dc | ldc | endl;                                                                // complex
    4407         sout | endl;
    4408         sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
    4409                  | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
    4410                  | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
    4411                  | s1 | "" | s2 | endl;                                                                 // C string withou separator
    4412         sout | endl;
    4413         sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
    4414         sout | f | d | ld | endl                                                                        // floating point without separator
    4415                  | fc | dc | ldc | endl                                                                 // complex without separator
    4416                  | s1 | s2 | endl;
    4417 }
    4418 
    4419 $ cat input.data
    4420 A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
    4421 $ a.out
    4422 A
    4423 1 2 3 4 5 6 7 8
    4424 1.1 1.2 1.3
    4425 1.1+2.3i 1.1-2.3i 1.1-2.3i
    4426 
    4427 1.11.21.3
    4428 1.1+2.3i1.1-2.3i1.1-2.3i
    4429  abcxyz
    4430 abcxyz
    4431 
    4432 1.1, $1.2, $1.3
    4433 1.1+2.3i, $1.1-2.3i, $1.1-2.3i
    4434 abc, $xyz
    4435 \end{lstlisting}
    4436 \caption{Example I/O}
    4437 \label{f:ExampleIO}
    4438 \end{figure}
    4439 
    4440 
    4441 \section{Standard Library}
    4442 \label{s:StandardLibrary}
    4443 
    4444 The goal of the \CFA standard-library is to wrap many of the existing C library-routines that are explicitly polymorphic into implicitly polymorphic versions.
    4445 
    4446 
    4447 \subsection{malloc}
    4448 
    4449 \begin{lstlisting}
    4450 forall( otype T ) T * malloc( void );
    4451 forall( otype T ) T * malloc( char fill );
    4452 forall( otype T ) T * malloc( T * ptr, size_t size );
    4453 forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
    4454 forall( otype T ) T * calloc( size_t size );
    4455 forall( otype T ) T * realloc( T * ptr, size_t size );
    4456 forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
    4457 
    4458 forall( otype T ) T * aligned_alloc( size_t alignment );
    4459 forall( otype T ) T * memalign( size_t alignment );             // deprecated
    4460 forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
    4461 
    4462 forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
    4463 forall( otype T ) T * memset( T * ptr );                                // remove when default value available
    4464 \end{lstlisting}
    4465 
    4466 
    4467 \subsection{ato/strto}
    4468 
    4469 \begin{lstlisting}
    4470 int ato( const char * ptr );
    4471 unsigned int ato( const char * ptr );
    4472 long int ato( const char * ptr );
    4473 unsigned long int ato( const char * ptr );
    4474 long long int ato( const char * ptr );
    4475 unsigned long long int ato( const char * ptr );
    4476 float ato( const char * ptr );
    4477 double ato( const char * ptr );
    4478 long double ato( const char * ptr );
    4479 float _Complex ato( const char * ptr );
    4480 double _Complex ato( const char * ptr );
    4481 long double _Complex ato( const char * ptr );
    4482 
    4483 int strto( const char * sptr, char ** eptr, int base );
    4484 unsigned int strto( const char * sptr, char ** eptr, int base );
    4485 long int strto( const char * sptr, char ** eptr, int base );
    4486 unsigned long int strto( const char * sptr, char ** eptr, int base );
    4487 long long int strto( const char * sptr, char ** eptr, int base );
    4488 unsigned long long int strto( const char * sptr, char ** eptr, int base );
    4489 float strto( const char * sptr, char ** eptr );
    4490 double strto( const char * sptr, char ** eptr );
    4491 long double strto( const char * sptr, char ** eptr );
    4492 float _Complex strto( const char * sptr, char ** eptr );
    4493 double _Complex strto( const char * sptr, char ** eptr );
    4494 long double _Complex strto( const char * sptr, char ** eptr );
    4495 \end{lstlisting}
    4496 
    4497 
    4498 \subsection{bsearch/qsort}
    4499 
    4500 \begin{lstlisting}
    4501 forall( otype T | { int ?<?( T, T ); } )
    4502 T * bsearch( const T key, const T * arr, size_t dimension );
    4503 
    4504 forall( otype T | { int ?<?( T, T ); } )
    4505 void qsort( const T * arr, size_t dimension );
    4506 \end{lstlisting}
    4507 
    4508 
    4509 \subsection{abs}
    4510 
    4511 \begin{lstlisting}
    4512 char abs( char );
    4513 extern "C" {
    4514 int abs( int );                         // use default C routine for int
    4515 } // extern "C"
    4516 long int abs( long int );
    4517 long long int abs( long long int );
    4518 float abs( float );
    4519 double abs( double );
    4520 long double abs( long double );
    4521 float _Complex abs( float _Complex );
    4522 double _Complex abs( double _Complex );
    4523 long double _Complex abs( long double _Complex );
    4524 \end{lstlisting}
    4525 
    4526 
    4527 \subsection{floor/ceil}
    4528 
    4529 \begin{lstlisting}
    4530 float floor( float );
    4531 extern "C" {
    4532 double floor( double );         // use C routine for double
    4533 } // extern "C"
    4534 long double floor( long double );
    4535 
    4536 float ceil( float );
    4537 extern "C" {
    4538 double ceil( double );          // use C routine for double
    4539 } // extern "C"
    4540 long double ceil( long double );
    4541 \end{lstlisting}
    4542 
    4543 
    4544 \subsection{random}
    4545 
    4546 \begin{lstlisting}
    4547 void rand48seed( long int s );
    4548 char rand48();
    4549 int rand48();
    4550 unsigned int rand48();
    4551 long int rand48();
    4552 unsigned long int rand48();
    4553 float rand48();
    4554 double rand48();
    4555 float _Complex rand48();
    4556 double _Complex rand48();
    4557 long double _Complex rand48();
    4558 \end{lstlisting}
    4559 
    4560 
    4561 \subsection{min/max/swap}
    4562 
    4563 \begin{lstlisting}
    4564 forall( otype T | { int ?<?( T, T ); } )
    4565 T min( const T t1, const T t2 );
    4566 
    4567 forall( otype T | { int ?>?( T, T ); } )
    4568 T max( const T t1, const T t2 );
    4569 
    4570 forall( otype T )
    4571 void swap( T * t1, T * t2 );
    4572 \end{lstlisting}
    45734255
    45744256
Note: See TracChangeset for help on using the changeset viewer.