Changes in / [78885b5:bc1ab61]

Files:

• doc/refrat/refrat.tex (modified) (8 diffs)
• doc/user/user.tex (modified) (36 diffs)
• src/driver/cfa.cc (modified) (3 diffs)
• src/examples/io.c (deleted)
• src/examples/io.data (deleted)
• src/examples/rational.c (deleted)
• src/examples/rational.cc (deleted)
• src/examples/read.c (added)
• src/examples/read.data (added)
• src/libcfa/Makefile.am (modified) (2 diffs)
• src/libcfa/Makefile.in (modified) (3 diffs)
• src/libcfa/fstream (modified) (3 diffs)
• src/libcfa/fstream.c (modified) (7 diffs)
• src/libcfa/iostream (modified) (4 diffs)
• src/libcfa/iostream.c (modified) (21 diffs)
• src/libcfa/limits (modified) (1 diff)
• src/libcfa/limits.c (deleted)
• src/libcfa/rational (deleted)
• src/libcfa/rational.c (deleted)
• src/libcfa/stdlib (modified) (4 diffs)
• src/libcfa/stdlib.c (modified) (2 diffs)

doc/refrat/refrat.tex

@@ -1 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% 
-%% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-%%
-%% The contents of this file are covered under the licence agreement in the
-%% file "LICENCE" distributed with Cforall.
-%% 
-%% refrat.tex -- 
-%% 
-%% Author           : Peter A. Buhr
-%% Created On       : Wed Apr  6 14:52:25 2016
-%% Last Modified By : Peter A. Buhr
-%% Last Modified On : Wed Apr  6 21:57:27 2016
-%% Update Count     : 2
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 
@@ -21 +5 @@
 
 % Latex packages used in the document.
+
 \usepackage{fullpage,times}
 \usepackage{xspace}
@@ -38 +23 @@
 % Names used in the document.
 
-\newcommand{\CFA}{C$\mathbf\forall$\xspace}     % set language symbolic name
+\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
 \newcommand{\CFL}{Cforall\xspace}               % set language text name
 \newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
@@ -166 +151 @@
 % CFA based on ANSI C
 \lstdefinelanguage{CFA}[ANSI]{C}%
-{morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
-    _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
-        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
-        _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
+{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
+        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
+        _Thread_local,throw,throwResume,try,},
 }%
 
@@ -179 +163 @@
 xleftmargin=\parindent,
 escapechar=@,
-mathescape=true,
 keepspaces=true,
 showstringspaces=false,
 showlines=true,
-aboveskip=6pt,
-belowskip=4pt,
 }%
 
@@ -190 +171 @@
 % replace/adjust listings characters that look bad in sanserif
 \lst@CCPutMacro
-\lst@ProcessOther{"22}{\lst@ttfamily{"}{\raisebox{0.3ex}{\ttfamily\upshape "}}} % replace double quote
-\lst@ProcessOther{"27}{\lst@ttfamily{'}{\raisebox{0.3ex}{\ttfamily\upshape '\hspace*{-2pt}}}} % replace single quote
-\lst@ProcessOther{"2D}{\lst@ttfamily{-}{\ttfamily\upshape -}} % replace minus
+\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
 \lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
 \lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
 \lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
-\lst@ProcessOther{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
-\lst@ProcessOther{"60}{\lst@ttfamily{`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}} % replace backquote
+\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
 \lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde
 %\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
@@ -3865 +3843 @@
 ``\lstinline$Safe_pointer$ acts like a pointer to \lstinline$int$''.
 \begin{lstlisting}
-trait ptr_to( otype P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
+trait ptr_to( type P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
         lvalue T *?( P );
         lvalue T ?[?]( P, long int );
 };
-trait ptr_to_const( otype P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
+trait ptr_to_const( type P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
         const lvalue T *?( P );
         const lvalue T ?[?]( P, long int );@\use{pointer}@
 };
-trait ptr_to_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
+trait ptr_to_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
         volatile lvalue T *?( P );
         volatile lvalue T ?[?]( P, long int );@\use{pointer}@
 };
-trait ptr_to_const_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
+trait ptr_to_const_volatile( type P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
         const volatile lvalue T *?( P );@\use{pointer}@
         const volatile lvalue T ?[?]( P, long int );
@@ -3887 +3865 @@
 ``\lstinline$ptr_to$'' specifications.
 \begin{lstlisting}
-trait m_l_ptr_to( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
+trait m_l_ptr_to( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
         P ?=?( P *, T * );
         T * ?=?( T **, P );
 };
-trait m_l_ptr_to_const( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
+trait m_l_ptr_to_const( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
         P ?=?( P *, const T * );
         const T * ?=?( const T **, P );
 };
-trait m_l_ptr_to_volatile( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
+trait m_l_ptr_to_volatile( type P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
         P ?=?( P *, volatile T * );
         volatile T * ?=?( volatile T **, P );
 };
-trait m_l_ptr_to_const_volatile( otype P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
-                otype T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
+trait m_l_ptr_to_const_volatile( type P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
+                type T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
         P ?=?( P *, const volatile T * );
         const volatile T * ?=?( const volatile T **, P );

doc/user/user.tex

@@ -1 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% 
-%% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-%%
-%% The contents of this file are covered under the licence agreement in the
-%% file "LICENCE" distributed with Cforall.
-%% 
-%% user.tex -- 
-%% 
-%% Author           : Peter A. Buhr
-%% Created On       : Wed Apr  6 14:53:29 2016
-%% Last Modified By : Peter A. Buhr
-%% Last Modified On : Wed Apr  6 17:37:39 2016
-%% Update Count     : 34
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 
@@ -21 +5 @@
 
 % Latex packages used in the document.
-\usepackage[T1]{fontenc}
-\usepackage{textcomp}
-\usepackage[latin1]{inputenc}
-\usepackage{upquote}
+
 \usepackage{fullpage,times}
 \usepackage{xspace}
@@ -43 +24 @@
 % Names used in the document.
 
-\newcommand{\CFA}{C$\mathbf\forall$\xspace}     % set language symbolic name
+\newcommand{\CFA}{C$\forall$\xspace}    % set language symbolic name
 \newcommand{\CFL}{Cforall\xspace}               % set language text name
 \newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
@@ -179 +160 @@
 % CFA based on ANSI C
 \lstdefinelanguage{CFA}[ANSI]{C}%
-{morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
-    _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
-        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
-        _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
-  moredelim=**[is][\color{red}]{`}{`},
+{morekeywords={asm,_Alignas,_Alignof,_At,_Atomic,_Bool,catch,catchResume,choose,_Complex,trait,disable,dtype,enable,
+        fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,lvalue,_Noreturn,otype,restrict,_Static_assert,
+        _Thread_local,throw,throwResume,try,},
 }%
 
@@ -197 +176 @@
 showstringspaces=false,
 showlines=true,
-aboveskip=6pt,
-belowskip=4pt,
-literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used to highlight in red
-%extendedchars=true,
 }%
 
@@ -206 +181 @@
 % replace/adjust listings characters that look bad in sanserif
 \lst@CCPutMacro
-\lst@ProcessOther{"22}{\lst@ttfamily{"}{\raisebox{0.3ex}{\ttfamily\upshape "}}} % replace double quote
-\lst@ProcessOther{"27}{\lst@ttfamily{'}{\raisebox{0.3ex}{\ttfamily\upshape '\hspace*{-2pt}}}} % replace single quote
-\lst@ProcessOther{"2D}{\lst@ttfamily{-}{\ttfamily\upshape -}} % replace minus
+\lst@ProcessOther{"2D}{\lst@ttfamily{-{}}{{\ttfamily\upshape -}}} % replace minus
 \lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
 \lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
 \lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
-\lst@ProcessOther{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
-\lst@ProcessOther{"60}{\lst@ttfamily{`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}} % replace backquote
+\lst@ProcessLetter{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore
 \lst@ProcessOther{"7E}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}} % replace tilde
 %\lst@ProcessOther{"7E}{\raisebox{-.4ex}[1ex][0pt]{\textasciitilde}} % lower tilde
@@ -394 +366 @@
 
 The command \lstinline@cfa@ is used to compile \CFA program(s).
-This command works like the GNU \lstinline@gcc@\index{gcc} command, e.g.:
+This command works like the GNU \lstinline@gcc@ command, e.g.:
 \begin{lstlisting}
 cfa [ gcc-options ] C/@{\CFA}@-files [ assembler/loader-files ]
 \end{lstlisting}
-By default, \CFA programs having the following \lstinline@gcc@ flags turned on:
-\begin{description}
-\item
-\hspace*{-4pt}\lstinline@-std=gnu99@
-The 1999 C standard plus GNU extensions.
-\end{description}
-The following new \CFA option is available:
+The following additional option is available:
 \begin{description}
 \item
@@ -416 +382 @@
 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
 \begin{lstlisting}
-2`_`147`_`483`_`648;                            // decimal constant
+2_147_483_648;                          // decimal constant
 56_ul;                                          // decimal unsigned long constant
 0_377;                                          // octal constant
@@ -485 +451 @@
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
-`* int x, y;`
+* int x, y;
 \end{lstlisting}
 &
@@ -605 +571 @@
 The point of the new syntax is to allow returning multiple values from a routine~\cite{CLU,Galletly96}, e.g.:
 \begin{lstlisting}
-`[ int o1, int o2, char o3 ]` f( int i1, char i2, char i3 ) {
+[ int o1, int o2, char o3 ] f( int i1, char i2, char i3 ) {
         @\emph{routine body}@
 }
@@ -673 +639 @@
 Because 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:
 \begin{lstlisting}
-`[ int x ]` f() {
+[ int x ] f() {
         ... x = 0; ... x = y; ...
-        `return;` // implicitly return x
+        return; // implicitly return x
 }
 \end{lstlisting}
@@ -731 +697 @@
 for example, the following is incorrect:
 \begin{lstlisting}
-* [ int x ] f () fp;            // routine name "f" is not allowed
+* [ int x ] f () fp;            // routine name ``f'' is not allowed
 \end{lstlisting}
 
@@ -898 +864 @@
 \subsection{Type Nesting}
 
-\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.
+C allows \Index{type nesting}, but the nested types are hoisted\index{type!hoisting} (refactored) into the enclosing scope.
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l|l@{}}
@@ -953 +919 @@
 
 int fred() {
-        s.t.c = `S.`R;  // type qualification
-        struct `S.`T t = { `S.`R, 1, 2 };
-        enum `S.`C c;
-        union `S.T.`U u;
+        s.t.c = S.R;
+        struct S.T t = { S.R, 1, 2 };
+        enum S.C c;
+        union S.T.U u;
 }
 \end{lstlisting}
 \end{tabular}
 \end{quote2}
-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.
-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@::@''.
+
+\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
+Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
+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.
 
 
@@ -976 +944 @@
 \begin{lstlisting}
 const unsigned int size = 10;
-int ia[size];
-...                                             // assign values to array ia
-qsort( ia, size );              // sort ascending order using builtin ?<?
-{
-        `int ?<?( int x, int y ) { return x > y; }` // nested routine
-        qsort( ia, size );      // sort descending order by local redefinition
-}
-\end{lstlisting}
-
-Nested routines are not first-class, meaning a nested routine cannot be returned if it has references to variables in its enclosing blocks;
-the only exception is references to the external block of the translation unit, as these variables persist for the duration of the program.
-The following program in undefined in \CFA (and \lstinline@gcc@\index{gcc})
-\begin{lstlisting}
-[* [int]( int )] foo() {                // int (*foo())( int )
-        int `i` = 7;
-        int bar( int p ) {
-                `i` += 1;                                       // dependent on local variable
-                sout | `i` | endl;
-        }
-        return bar;                                     // undefined because of local dependence
-}
-int main() {
-        * [int](int) fp = foo();        // int (*fp)(int)
-    sout | fp( 3 ) | endl;
-}
-\end{lstlisting}
-because 
-
-Currently, there are no \Index{lambda} expressions, i.e., unnamed routines because routine names are very important to properly select the correct routine.
+int a[size];
+
+qsort( a, size );               // ascending order using built in ?<?
+{                                               // descending order by local redefinition
+        int ?<?( int a, int b ) { return a > b; } // nested routine
+        qsort( a, size );
+}
+\end{lstlisting}
 
 
@@ -1066 +1013 @@
 
 \item
-Change: A struct is a scope in C++, not in C \\
-Rationale: Class scope is crucial to C++, and a struct is a class. \\
-Effect on original feature: Change to semantics of well-defined feature. \\
-Difficulty of converting: Semantic transformation. \\
-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.
-The latter is probably rare.
-
-\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
-Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
-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.
-
+Change: A struct is a scope in C++, not in C
+Rationale: Class scope is crucial to C++, and a struct is a class.
+Effect on original feature: Change to semantics of well-defined feature.
+Difficulty of converting: Semantic transformation.
+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. The latter is probably
+rare.
 
 \item
@@ -1242 +1185 @@
 First the right-hand tuple is flattened and then the values are assigned individually.
 Flattening is also performed on tuple types.
-For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type \lstinline@[ int, int, int, int ]@.
+For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type lstinline@[ int, int, int, int ]@.
 
 A \newterm{structuring coercion} is the opposite of flattening;
@@ -1409 +1352 @@
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
-`L1:` for ( ... ) {
-        `L2:` for ( ... ) {
-                `L3:` for ( ... ) {
-                        ... break `L1`; ...
-                        ... break `L2`; ...
-                        ... break `L3`; // or break
+L1: for ( ... ) {
+        L2: for ( ... ) {
+                L3: for ( ... ) {
+                        ... break L1; ...
+                        ... break L2; ...
+                        ... break L3; // or break
                 }
         }
@@ -1439 +1382 @@
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
-`L1`: for ( ... ) {
-        `L2`: for ( ... ) {
-                `L3`: for ( ... ) {
-                        ... continue `L1`; ...
-                        ... continue `L2`; ...
-                        ... continue `L3`; ...
+L1: for ( ... ) {
+        L2: for ( ... ) {
+                L3: for ( ... ) {
+                        ... continue L1; ...
+                        ... continue L2; ...
+                        ... continue L3; ...
 
                 }
@@ -1680 +1623 @@
 \begin{lstlisting}
 switch ( i ) {
-  `case 1, 3, 5`:
+  case 1, 3, 5:
         ...
-  `case 2, 4, 6`:
+  case 2, 4, 6:
         ...
 }
@@ -1691 +1634 @@
   case 1: case 3 : case 5:
         ...
-  case 2: case 4 : case 6:
+  case 2: case 4 : case 6: /* even values */
         ...
 }
@@ -1712 +1655 @@
 \begin{lstlisting}
 switch ( i ) {
-  `case 1~5:`
+  case 1~5
         ...
-  `case 10~15:`
+  case 10~15
         ...
 }
@@ -1729 +1672 @@
 &
 \begin{lstlisting}
-
 // 1, 2, 3, 4, 5
 
@@ -2226 +2168 @@
 
 
-\section{Auto Type-Inferencing}
-
-Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type.
-\begin{quote2}
-\begin{tabular}{@{}l@{\hspace{30pt}}ll@{}}
-\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{\lstinline@gcc@}\index{gcc} \\
-\begin{lstlisting}
-
-auto j = 3.0 * 4;
-int i;
-auto k = i;
-\end{lstlisting}
-&
-\begin{lstlisting}
-#define expr 3.0 * i
-typeof(expr) j = expr;
-int i;
-typeof(i) k = i;
-\end{lstlisting}
-&
-\begin{lstlisting}
-
-// use type of initialization expression
-
-// use type of primary variable
-\end{lstlisting}
-\end{tabular}
-\end{quote2}
-The two important capabilities are:
-\begin{itemize}
-\item
-preventing having to determine or write out long generic types,
-\item
-ensure secondary variables, related to a primary variable, always have the same type.
-\end{itemize}
-
-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.
-\lstinline@gcc@ provides \lstinline@typeof@ to declare a secondary variable from a primary variable.
-\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.
-Only for overloaded routines with the same return type is variable type-inferencing possible.
-Finally, \lstinline@auto@ presents the programming problem of tracking down a type when the type is actually needed.
-For example, given
-\begin{lstlisting}
-auto j = `...`
-\end{lstlisting}
-and the need to write a routine to compute using \lstinline@j@
-\begin{lstlisting}
-void rtn( `...` parm );
-rtn( j );
-\end{lstlisting}
-A programmer must work backwards to determine the type of \lstinline@j@'s initialization expression, reconstructing the possibly long generic type-name.
-In this situation, having the type name or a short alias is very useful.
-
-There is also the conundrum in type inferencing of when to \emph{\Index{brand}} a type.
-That is, when is the type of the variable more important than the type of its initialization expression.
-For example, if a change is made in an initialization expression, it can cause hundreds or thousands of cascading type changes and/or errors.
-At some point, a programmer wants the type of the variable to remain constant and the expression to be in error when it changes.
-
-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.
-Should a significant need arise, this feature can be revisited.
-
-
-\section{Generics}
+\section{Generics }
 
 \CFA supports parametric polymorphism to allow users to define generic functions and types.
@@ -2577 +2457 @@
 
 
-\section{Syntactic Anomalies}
-
-The number 0 and 1 are treated specially in \CFA, and can be redefined as variables.
-One syntactic anomaly is when a field in an structure is names 0 or 1:
-\begin{lstlisting}
-struct S {
-        int 0, 1;
-} s;
-\end{lstlisting}
-The problem occurs in accesing these fields using the selection operation ``\lstinline@.@'':
-\begin{lstlisting}
-s.0 = 0;        // ambiguity with floating constant .0
-s.1 = 1;        // ambiguity with floating constant .1
-\end{lstlisting}
-To make this work, a space is required after the field selection:
-\begin{lstlisting}
-`s.@\textvisiblespace@0` = 0;
-`s.@\textvisiblespace@1` = 1;
-\end{lstlisting}
-While this sytact is awkward, it is unlikely many programers will name fields of a structure 0 or 1.
-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.
-
-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@*?@.
-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.
-Even with this special hack, there are 5 general cases that cannot be handled.
-The first case is for the function-call identifier \lstinline@?()@:
-\begin{lstlisting}
-int *@\textvisiblespace@?()();  // declaration: space required after '*'
-*@\textvisiblespace@?()();              // expression: space required after '*'
-\end{lstlisting}
-Without the space, the string \lstinline@*?()@ is ambiguous without N character look ahead;
-it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument/parameter list.
-
-The 4 remaining cases occur in expressions:
-\begin{lstlisting}
-i++@\textvisiblespace@?i:0;             // space required before '?'
-i--@\textvisiblespace@?i:0;             // space required before '?'
-i@\textvisiblespace@?++i:0;             // space required after '?'
-i@\textvisiblespace@?--i:0;             // space required after '?'
-\end{lstlisting}
-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@?@;
-it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
-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@;
-it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
+\section{I/O Library}
+\label{s:IOLibrary}
+
+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.
+The general case is printing out a sequence of variables separated by whitespace.
+\begin{lstlisting}
+int x = 0, y = 1, z = 2;
+sout | x | y | z | endl;
+
+cout << x << " " << y << " " << z << endl;
+\end{lstlisting}
+The \CC form takes almost twice as many characters.
+
+The logical-or operator is used because it is the lowest priority overloadable operator, other than assignment.
+Therefore, most output expressions do not require parenthesis.
+\begin{lstlisting}
+int x = 0, y = 1, z = 2;
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+
+cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{lstlisting}
+
+Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
+
+\begin{figure}
+\begin{lstlisting}[mathescape=off]
+#include <fstream>
+
+int main() {
+        char c;
+        short int si;
+        unsigned short int usi;
+        int i;
+        unsigned int ui;
+        long int li;
+        unsigned long int uli;
+        long long int lli;
+        unsigned long long int ulli;
+        float f;
+        double d;
+        long double ld;
+        float _Complex fc;
+        double _Complex dc;
+        long double _Complex ldc;
+        char s1[10], s2[10];
+
+        ifstream in;
+        open( &in, "read.data", "r" );
+
+        &in | &c
+                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli
+                | &f | &d | &ld
+                | &fc | &dc | &ldc
+                | str( s1 ) | str( s2, 10 );
+
+        sout | c | ' ' | endl
+                 | si | usi | i | ui | li | uli | lli | ulli | endl
+                 | f | d | ld | endl
+                 | f | "" | d | "" | ld | endl;
+
+        sepSet( sout, ", $" );
+        sout | fc | dc | ldc | endl
+                 | sepOn | s1 | sepOff | s2 | endl
+                 | s1 | "" | s2 | endl;
+}
+
+$ cat read.data 
+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
+$ a.out
+A 
+1 2 3 4 5 6 7 8
+1.1 1.2 1.3
+1.11.21.3
+1.1+2.3i, $1.1-2.3i, $1.1-2.3i
+, $abcxyz
+abcxyz
+\end{lstlisting}
+\end{figure}
+
+
+\section{Standard Library}
+\label{s:StandardLibrary}
+
+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.
+
+
+\subsection{malloc}
+
+\begin{lstlisting}
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * calloc( size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
+
+forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr );                                // remove when default value available
+\end{lstlisting}
+
+
+\subsection{ato/strto}
+
+\begin{lstlisting}
+int ato( const char * ptr );
+unsigned int ato( const char * ptr );
+long int ato( const char * ptr );
+unsigned long int ato( const char * ptr );
+long long int ato( const char * ptr );
+unsigned long long int ato( const char * ptr );
+float ato( const char * ptr );
+double ato( const char * ptr );
+long double ato( const char * ptr );
+float _Complex ato( const char * ptr );
+double _Complex ato( const char * ptr );
+long double _Complex ato( const char * ptr );
+
+int strto( const char * sptr, char ** eptr, int base );
+unsigned int strto( const char * sptr, char ** eptr, int base );
+long int strto( const char * sptr, char ** eptr, int base );
+unsigned long int strto( const char * sptr, char ** eptr, int base );
+long long int strto( const char * sptr, char ** eptr, int base );
+unsigned long long int strto( const char * sptr, char ** eptr, int base );
+float strto( const char * sptr, char ** eptr );
+double strto( const char * sptr, char ** eptr );
+long double strto( const char * sptr, char ** eptr );
+float _Complex strto( const char * sptr, char ** eptr );
+double _Complex strto( const char * sptr, char ** eptr );
+long double _Complex strto( const char * sptr, char ** eptr );
+\end{lstlisting}
+
+
+\subsection{bsearch/qsort}
+
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T * bsearch( const T key, const T * arr, size_t dimension );
+
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dimension );
+\end{lstlisting}
+
+
+\subsection{abs}
+
+\begin{lstlisting}
+char abs( char );
+extern "C" {
+int abs( int );         // use default C routine for int
+} // extern
+long int abs( long int );
+long long int abs( long long int );
+float abs( float );
+double abs( double );
+long double abs( long double );
+float _Complex abs( float _Complex );
+double _Complex abs( double _Complex );
+long double _Complex abs( long double _Complex );
+\end{lstlisting}
+
+
+\subsection{random}
+
+\begin{lstlisting}
+void randseed( long int s );
+char random();
+int random();
+unsigned int random();
+long int random();
+unsigned long int random();
+float random();
+double random();
+float _Complex random();
+double _Complex random();
+long double _Complex random();
+\end{lstlisting}
+
+
+\subsection{min/max/swap}
+
+\begin{lstlisting}
+forall( otype T | { int ?<?( T, T ); } )
+T min( const T t1, const T t2 );
+
+forall( otype T | { int ?>?( T, T ); } )
+T max( const T t1, const T t2 );
+
+forall( otype T )
+void swap( T * t1, T * t2 );
+\end{lstlisting}
 
 
@@ -2645 +2676 @@
 
 task creates a type with implicit locking, separate stack, and a thread
-
 
 \subsection{Monitors}
@@ -3745 +3775 @@
 \multicolumn{1}{c|}{\textbf{\CFA/\CC}} & \multicolumn{1}{c|}{\textbf{Go}} & \multicolumn{1}{c}{\textbf{Rust}}   \\
 \hline
-\begin{lstlisting}[boxpos=t]
+\begin{lstlisting}
 extern "C" {
 #include <sys/types.h>
@@ -3752 +3782 @@
 }
 size_t fileSize( const char *path ) {
-        struct stat s;
+        stat s;
         stat(path, &s);
         return s.st_size;
@@ -3758 +3788 @@
 \end{lstlisting}
 &
-\begin{lstlisting}[boxpos=t]
+\begin{lstlisting}
 /*
 #cgo
@@ -3777 +3807 @@
 \end{lstlisting}
 &
-\begin{lstlisting}[boxpos=t]
+\begin{lstlisting}
 use libc::{c_int, size_t};
+
+// The following declarations are
 // translated from sys/stat.h
 #[repr(C)]
@@ -3786 +3818 @@
         ...
 }
+
 #[link(name = "libc")]
 extern {
@@ -3791 +3824 @@
         buf: *mut stat_t) -> c_int;
 }
+
 fn fileSize(path: *const u8) -> size_t
 {
         unsafe {
-                let mut buf: stat_t = uninit();
-                stat(path, &mut buf);
-                buf.st_size
+        let mut buf: stat_t = uninit();
+        stat(path, &mut buf);
+        buf.st_size
         }
 }
@@ -3919 +3953 @@
 
 
-\begin{comment}
 \subsubsection{Modules/Packages}
 
@@ -3999 +4032 @@
 }
 \end{lstlisting}
-\end{comment}
-
 
 \subsubsection{Parallel Tasks}
@@ -4156 +4187 @@
 \end{flushleft}
 
-\lstset{basicstyle=\sf\relsize{-1}}
-
-
 \subsection{Summary of Language Comparison}
 
@@ -4225 +4253 @@
 D does not have any built-in concurrency constructs in the
 language, though it does have a standard library for concurrency which includes the low-level primitives for concurrency.
-
-
-\appendix
-
-
-\section{I/O Library}
-\label{s:IOLibrary}
-\index{input/output library}
-
-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.
-The general case is printing out a sequence of variables separated by whitespace.
-\begin{quote2}
-\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
-\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{\CC}}      \\
-\begin{lstlisting}
-int x = 0, y = 1, z = 2;
-`sout` `|` x `|` y `|` z `| endl`;
-\end{lstlisting}
-&
-\begin{lstlisting}
-
-cout << x << " " << y << " " << z << endl;
-\end{lstlisting}
-\end{tabular}
-\end{quote2}
-The \CFA form is half as many characters, and is similar to Python I/O with respect to implicit separators.
-
-The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment.
-Therefore, fewer output expressions require parenthesis.
-\begin{quote2}
-\begin{tabular}{@{}ll@{}}
-\textbf{\CFA:}
-&
-\begin{lstlisting}
-sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
-\end{lstlisting}
-\\
-\textbf{\CC:}
-&
-\begin{lstlisting}
-cout << x * 3 << y + 1 << (z << 2) << (x == y) << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
-\end{lstlisting}
-\end{tabular}
-\end{quote2}
-Finally, the logical-or operator has a link with the Shell pipe-operator for moving data, although data flows in the opposite direction.
-
-The implicit seperator\index{I/O separator} character (space/blank) is a separator not a terminator.
-The rules for implicitly adding the separator are:
-\begin{enumerate}
-\item
-A seperator does not appear at the start or end of a line.
-\begin{lstlisting}[belowskip=0pt]
-sout 1 | 2 | 3 | endl;
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1 2 3
-\end{lstlisting}
-\item
-A seperator does not appear before or after a character literal or variable.
-\begin{lstlisting}
-sout | '1' | '2' | '3' | endl;
-123
-\end{lstlisting}
-\item
-A seperator does not appear before or after a null (empty) C string
-\begin{lstlisting}
-sout | 1 | "" | 2 | "" | 3 | endl;
-123
-\end{lstlisting}
-which is a local mechanism to disable insertion of the separator character.
-\item
-A seperator does not appear before a C string starting with the \Index{extended ASCII}\index{ASCII} characters: \lstinline[mathescape=off]@([{$£¥¿«@
-%$
-\begin{lstlisting}[mathescape=off]
-sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¿" | 7 | "x «" | 8 | endl;
-\end{lstlisting}
-%$
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-x (1 x [2 x {3 x $4 x £5 x ¥6 x ¿7 x «8
-\end{lstlisting}
-%$
-\item
-A seperator does not appear after a C string ending with the extended ASCII characters: \lstinline@,.:;!?)]}%¢»@
-\begin{lstlisting}[belowskip=0pt]
-sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
-         | 10 | "% x" | 11 | L"¢ x" | 12 | L"» x" | endl;
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1, x 2. x 3: x 4; x 5! x 6? x 7) x 8] x 9} x 10% x 11¢ 12»
-\end{lstlisting}
-\item
-A seperator does not appear before or after a C string begining/ending with the characters: \lstinline@\f\n\r\t\v\`'"@
-\begin{lstlisting}[belowskip=0pt]
-sout | "x '" | 1 | "' x \`" | 2 | "\` x \"" | 3 | "\" x" | endl;
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-x '1' x \`2\` x "3" x
-\end{lstlisting}
-\begin{lstlisting}[showtabs=true,aboveskip=0pt]
-sout | "x\t" | 1 | "\tx" | endl;
-x       1       x
-\end{lstlisting}
-\end{enumerate}
-The following \CC-style \Index{manipulator}s allow further control over implicit seperation.
-\begin{lstlisting}[mathescape=off,belowskip=0pt]
-sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
- 1 2 3
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | 1 | sepOff | 2 | 3 | endl;                       // turn off implicit separator temporarily
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-12 3
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | sepDisable | 1 | 2 | 3 | endl;           // turn off implicit separation, affects all subsequent prints
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-123
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | 1 | sepOn | 2 | 3 | endl;                        // turn on implicit separator temporarily
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1 23
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,aboveskip=0pt,belowskip=0pt]
-sout | sepEnable | 1 | 2 | 3 | endl;            // turn on implicit separation, affects all subsequent prints
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1 2 3
-\end{lstlisting}
-\begin{lstlisting}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
-sepSet( sout, ", $" );                                          // change separator from " " to ", $"
-sout | 1 | 2 | 3 | endl;
-\end{lstlisting}
-%$
-\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt]
-1, $2, $3
-\end{lstlisting}
-%$
-\VRef[Figure]{f:ExampleIO} shows an example of input and output I/O in \CFA.
-
-\begin{figure}
-\begin{lstlisting}[mathescape=off]
-#include <fstream>
-
-int main() {
-        char c;                                                                                                         // basic types
-        short int si;
-        unsigned short int usi;
-        int i;
-        unsigned int ui;
-        long int li;
-        unsigned long int uli;
-        long long int lli;
-        unsigned long long int ulli;
-        float f;
-        double d;
-        long double ld;
-        float _Complex fc;
-        double _Complex dc;
-        long double _Complex ldc;
-        char s1[10], s2[10];
-
-        ifstream in;                                                                                            // create / open file
-        open( &in, "input.data", "r" );
-
-        &in | &c                                                                                                        // character
-                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
-                | &f | &d | &ld                                                                                 // floating point
-                | &fc | &dc | &ldc                                                                              // floating-point complex
-                | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
-
-        sout | c | ' ' | endl                                                                           // character
-                 | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
-                 | f | d | ld | endl                                                                    // floating point
-                 | fc | dc | ldc | endl;                                                                // complex
-        sout | endl;
-        sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
-                 | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
-                 | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
-                 | s1 | "" | s2 | endl;                                                                 // C string withou separator
-        sout | endl;
-        sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
-        sout | f | d | ld | endl                                                                        // floating point without separator
-                 | fc | dc | ldc | endl                                                                 // complex without separator
-                 | s1 | s2 | endl;
-}
-
-$ cat input.data 
-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
-$ a.out
-A 
-1 2 3 4 5 6 7 8
-1.1 1.2 1.3
-1.1+2.3i 1.1-2.3i 1.1-2.3i
-
-1.11.21.3
-1.1+2.3i1.1-2.3i1.1-2.3i
- abcxyz
-abcxyz
-
-1.1, $1.2, $1.3
-1.1+2.3i, $1.1-2.3i, $1.1-2.3i
-abc, $xyz
-\end{lstlisting}
-\caption{Example I/O}
-\label{f:ExampleIO}
-\end{figure}
-
-
-\section{Standard Library}
-\label{s:StandardLibrary}
-
-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.
-
-
-\subsection{malloc}
-
-\begin{lstlisting}
-forall( otype T ) T * malloc( void );
-forall( otype T ) T * malloc( char fill );
-forall( otype T ) T * malloc( T * ptr, size_t size );
-forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
-forall( otype T ) T * calloc( size_t size );
-forall( otype T ) T * realloc( T * ptr, size_t size );
-forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
-
-forall( otype T ) T * aligned_alloc( size_t alignment );
-forall( otype T ) T * memalign( size_t alignment );             // deprecated
-forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
-
-forall( otype T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
-forall( otype T ) T * memset( T * ptr );                                // remove when default value available
-\end{lstlisting}
-
-
-\subsection{ato/strto}
-
-\begin{lstlisting}
-int ato( const char * ptr );
-unsigned int ato( const char * ptr );
-long int ato( const char * ptr );
-unsigned long int ato( const char * ptr );
-long long int ato( const char * ptr );
-unsigned long long int ato( const char * ptr );
-float ato( const char * ptr );
-double ato( const char * ptr );
-long double ato( const char * ptr );
-float _Complex ato( const char * ptr );
-double _Complex ato( const char * ptr );
-long double _Complex ato( const char * ptr );
-
-int strto( const char * sptr, char ** eptr, int base );
-unsigned int strto( const char * sptr, char ** eptr, int base );
-long int strto( const char * sptr, char ** eptr, int base );
-unsigned long int strto( const char * sptr, char ** eptr, int base );
-long long int strto( const char * sptr, char ** eptr, int base );
-unsigned long long int strto( const char * sptr, char ** eptr, int base );
-float strto( const char * sptr, char ** eptr );
-double strto( const char * sptr, char ** eptr );
-long double strto( const char * sptr, char ** eptr );
-float _Complex strto( const char * sptr, char ** eptr );
-double _Complex strto( const char * sptr, char ** eptr );
-long double _Complex strto( const char * sptr, char ** eptr );
-\end{lstlisting}
-
-
-\subsection{bsearch/qsort}
-
-\begin{lstlisting}
-forall( otype T | { int ?<?( T, T ); } )
-T * bsearch( const T key, const T * arr, size_t dimension );
-
-forall( otype T | { int ?<?( T, T ); } )
-void qsort( const T * arr, size_t dimension );
-\end{lstlisting}
-
-
-\subsection{abs}
-
-\begin{lstlisting}
-char abs( char );
-extern "C" {
-int abs( int );                         // use default C routine for int
-} // extern "C"
-long int abs( long int );
-long long int abs( long long int );
-float abs( float );
-double abs( double );
-long double abs( long double );
-float _Complex abs( float _Complex );
-double _Complex abs( double _Complex );
-long double _Complex abs( long double _Complex );
-\end{lstlisting}
-
-
-\subsection{floor/ceil}
-
-\begin{lstlisting}
-float floor( float );
-extern "C" {
-double floor( double );         // use C routine for double
-} // extern "C"
-long double floor( long double );
-
-float ceil( float );
-extern "C" {
-double ceil( double );          // use C routine for double
-} // extern "C"
-long double ceil( long double );
-\end{lstlisting}
-
-
-\subsection{random}
-
-\begin{lstlisting}
-void rand48seed( long int s );
-char rand48();
-int rand48();
-unsigned int rand48();
-long int rand48();
-unsigned long int rand48();
-float rand48();
-double rand48();
-float _Complex rand48();
-double _Complex rand48();
-long double _Complex rand48();
-\end{lstlisting}
-
-
-\subsection{min/max/swap}
-
-\begin{lstlisting}
-forall( otype T | { int ?<?( T, T ); } )
-T min( const T t1, const T t2 );
-
-forall( otype T | { int ?>?( T, T ); } )
-T max( const T t1, const T t2 );
-
-forall( otype T )
-void swap( T * t1, T * t2 );
-\end{lstlisting}
 
 

src/driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr  6 14:04:22 2016
-// Update Count     : 132
+// Last Modified On : Thu Jan 28 18:24:06 2016
+// Update Count     : 127
 //
 
@@ -165 +165 @@
                                 nargs += 1;
                         } else if ( prefix( arg, "-std=" ) ) {
-                                std_flag = true;                                                // -std=XX provided
+                                std_flag = true;                                                // std=XX provided
                                 args[nargs] = argv[i];                                  // pass the argument along
                                 nargs += 1;
@@ -307 +307 @@
                 nargs += 1;
                 if ( ! std_flag ) {                                                             // default c99, if none specified
-                        args[nargs] = "-std=gnu99";
+                        args[nargs] = "-std=c99";
                         nargs += 1;
                 } // if

src/libcfa/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Wed Apr  6 21:10:44 2016
-## Update Count     : 123
+## Last Modified On : Wed Mar  2 22:59:23 2016
+## Update Count     : 119
 ###############################################################################
 
@@ -60 +60 @@
         ${CC} ${CFLAGS} -c -o $@ $<
 
-libs = limits stdlib iostream fstream iterator rational
+libs = stdlib iostream fstream iterator
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 
-cheaders = # expat
-cfaheaders = # limits
+cheaders = #  expat
+cfaheaders = limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 

src/libcfa/Makefile.in

@@ -83 +83 @@
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
-am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) iostream.$(OBJEXT) \
-        fstream.$(OBJEXT) iterator.$(OBJEXT) rational.$(OBJEXT)
+am__objects_1 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
+        iterator.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -213 +213 @@
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
-libs = limits stdlib iostream fstream iterator rational
+libs = stdlib iostream fstream iterator
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
-cheaders = # expat
-cfaheaders = # limits
+cheaders = #  expat
+cfaheaders = limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
@@ -297 +297 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iterator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa-prelude.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/limits.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdlib.Po@am__quote@
 

src/libcfa/fstream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr  5 22:37:12 2016
-// Update Count     : 82
+// Last Modified On : Wed Mar  2 15:08:14 2016
+// Update Count     : 78
 //
 
@@ -20 +20 @@
 
 enum { separateSize = 16 };
-struct ofstream {
-        void *file;
-        _Bool sepDefault;
-        _Bool sepOnOff;
-        char separator[separateSize];
-}; // ofstream
+struct ofstream { void *file; int separate; char separator[separateSize]; };
 
 _Bool sepPrt( ofstream * );
 void sepOn( ofstream * );
 void sepOff( ofstream * );
-void sepReset( ofstream * );
-void sepReset( ofstream *, _Bool );
 void sepSet( ofstream *, const char * );
 const char * sepGet( ofstream * );
-_Bool sepDisable( ofstream * );
-_Bool sepEnable( ofstream * );
+void sepDisable( ofstream * );
+void sepEnable( ofstream * );
 int fail( ofstream * );
 int flush( ofstream * );
@@ -46 +39 @@
 
 // implement context istream
-struct ifstream {
-        void *file;
-}; // ifstream
+struct ifstream { void *file; };
 
 int fail( ifstream * is );

src/libcfa/fstream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr  6 17:55:27 2016
-// Update Count     : 176
+// Last Modified On : Mon Feb 29 18:41:10 2016
+// Update Count     : 162
 //
 
@@ -25 +25 @@
 }
 
-#define IO_MSG "I/O error: "
+#define IO_MSG "I/O error "
 
-_Bool sepPrt( ofstream * os ) { return os->sepOnOff; }
-void sepOn( ofstream * os ) { os->sepOnOff = 1; }
-void sepOff( ofstream * os ) { os->sepOnOff = 0; }
-void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; }
-void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; }
+_Bool sepPrt( ofstream * os ) { return os->separate == 1; }
+void sepOn( ofstream * os ) { if ( os->separate != 2 ) os->separate = 1; }
+void sepOff( ofstream * os ) { if ( os->separate != 2 ) os->separate = 0; }
 void sepSet( ofstream * os, const char * s ) {
         strncpy( &(os->separator[0]), s, separateSize - 1 );
@@ -37 +35 @@
 } // sepSet
 const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
-_Bool sepDisable( ofstream *os ) {
-        _Bool temp = os->sepDefault;
-        os->sepDefault = 0;
-        sepReset( os );
-        return temp;
-} // sepDisable
-_Bool sepEnable( ofstream *os ) {
-        _Bool temp = os->sepDefault;
-        os->sepDefault = 1;
-        sepReset( os );
-        return temp;
-} // sepEnable
+void sepDisable( ofstream *os ) { os->separate = 2; }
+void sepEnable( ofstream *os ) { os->separate = 0; }
 
 int fail( ofstream * os ) {
@@ -61 +49 @@
         FILE *file = fopen( name, mode );
         if ( file == 0 ) {                                                                      // do not change unless successful
-                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
-                perror( 0 );
+                perror( IO_MSG "open output" );
                 exit( EXIT_FAILURE );
         } // if
@@ -107 +94 @@
 
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
 
@@ -127 +114 @@
         FILE *t = fopen( name, mode );
         if ( t == 0 ) {                                                                         // do not change unless successful
-                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
-                perror( 0 );
+                perror( IO_MSG "open input" );
                 exit( EXIT_FAILURE );
         } // if
@@ -189 +175 @@
 // Local Variables: //
 // tab-width: 4 //
+// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr  5 22:32:37 2016
-// Update Count     : 90
+// Last Modified On : Wed Mar  2 18:05:27 2016
+// Update Count     : 85
 //
 
@@ -23 +23 @@
         void sepOn( ostype * );
         void sepOff( ostype * );
-        void sepReset( ostype * );
-        void sepReset( ostype *, _Bool );
         void sepSet( ostype *, const char * );
         const char * sepGet( ostype * );
-        _Bool sepDisable( ostype * );
-        _Bool sepEnable( ostype * );
+        void sepDisable( ostype * );
+        void sepEnable( ostype * );
         int fail( ostype * );
         int flush( ostype * );
@@ -69 +67 @@
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOn( ostype * );
 forall( dtype ostype | ostream( ostype ) ) ostype * sepOff( ostype * );
-forall( dtype ostype | ostream( ostype ) ) ostype * sepDisable( ostype * );
-forall( dtype ostype | ostream( ostype ) ) ostype * sepEnable( ostype * );
 
 // writes the range [begin, end) to the given stream
@@ -114 +110 @@
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
 
-struct _Istream_cstrUC { char * s; };
-_Istream_cstrUC cstr( char * );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrUC );
+struct _Istream_str1 { char * s; };
+_Istream_str1 str( char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str1 );
 
-struct _Istream_cstrC { char * s; int size; };
-_Istream_cstrC cstr( char *, int size );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrC );
+struct _Istream_str2 { char * s; int size; };
+_Istream_str2 str( char *, int size );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str2 );
 
 #endif // __IOSTREAM_H__

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr  6 16:13:29 2016
-// Update Count     : 278
+// Last Modified On : Mon Mar  7 13:51:23 2016
+// Update Count     : 227
 //
 
@@ -27 +27 @@
 ostype * ?|?( ostype *os, char c ) {
         prtfmt( os, "%c", c );
-        sepOff( os );
         return os;
 } // ?|?
@@ -33 +32 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, short int si ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%hd", si );
         return os;
@@ -41 +39 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned short int usi ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%hu", usi );
         return os;
@@ -49 +46 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%d", i );
         return os;
@@ -57 +53 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned int ui ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%u", ui );
         return os;
@@ -65 +60 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long int li ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%ld", li );
         return os;
@@ -73 +67 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long int uli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%lu", uli );
         return os;
@@ -81 +74 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long long int lli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%lld", lli );
         return os;
@@ -89 +81 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long long int ulli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%llu", ulli );
         return os;
@@ -97 +88 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%g", f );
         return os;
@@ -105 +95 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%.*lg", DBL_DIG, d );
         return os;
@@ -113 +102 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long double ld ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%.*Lg", LDBL_DIG, ld );
         return os;
@@ -122 +110 @@
 ostype * ?|?( ostype *os, float _Complex fc ) {
         os | crealf( fc );
-        _Bool temp = sepDisable( os );                                          // disable separators within complex value
-        if ( cimagf( fc ) >= 0 ) os | '+';                                      // negative value prints '-'
-        os | cimagf( fc ) | 'i';
-        sepReset( os, temp );                                                           // reset separator
+        if ( cimagf( fc ) >= 0 ) os | '+';
+        os | "" | cimagf( fc ) | 'i';
         return os;
 } // ?|?
@@ -132 +118 @@
 ostype * ?|?( ostype *os, double _Complex dc ) {
         os | creal( dc );
-        _Bool temp = sepDisable( os );                                          // disable separators within complex value
-        if ( cimag( dc ) >= 0 ) os | '+';                                       // negative value prints '-'
-        os | cimag( dc ) | 'i';
-        sepReset( os, temp );                                                           // reset separator
+        if ( cimag( dc ) >= 0 ) os | '+';
+        os | "" | cimag( dc ) | 'i';
         return os;
 } // ?|?
@@ -142 +126 @@
 ostype * ?|?( ostype *os, long double _Complex ldc ) {
         os | creall( ldc );
-        _Bool temp = sepDisable( os );                                          // disable separators within complex value
-        if ( cimagl( ldc ) >= 0 ) os | '+';                                     // negative value prints '-'
-        os | cimagl( ldc ) | 'i';
-        sepReset( os, temp );                                                           // reset separator
+        if ( cimagl( ldc ) >= 0 ) os | '+';
+        os | "" | cimagl( ldc ) | 'i';
         return os;
 } // ?|?
@@ -152 +134 @@
 ostype * ?|?( ostype *os, const char *cp ) {
         enum { Open = 1, Close, OpenClose };
-        static const unsigned char mask[256] = {
+        static const char mask[256] = {
                 // opening delimiters
                 ['('] : Open, ['['] : Open, ['{'] : Open,
-                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
+                ['$'] : Open, [L'£'] : Open, [L'¥'] : Open, [L'¢'] : Open, [L'¿'] : Open, [L'«'] : Open,
                 // closing delimiters
                 [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
                 [')'] : Close, [']'] : Close, ['}'] : Close,
-                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
+                ['%'] : Close, [L'»'] : Close,
                 // opening-closing delimiters
                 ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
-                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
         }; // mask
 
@@ -168 +149 @@
         // null string => no separator
   if ( len == 0 ) { sepOff( os ); return os; }
-        // first character IS NOT spacing or closing punctuation => add left separator
-        unsigned char ch = cp[0];                                                       // must make unsigned
-        if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+        // first character NOT spacing or closing punctuation => add left separator
+        if ( sepPrt( os ) && isspace( cp[0] ) == 0 && mask[ cp[0] ] != Close && mask[ cp[0] ] != OpenClose ) {
                 prtfmt( os, "%s", sepGet( os ) );
         } // if
         // last character IS spacing or opening punctuation => turn off separator for next item
         unsigned int posn = len - 1;
-        ch = cp[posn];                                                                          // must make unsigned
-        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
+        if ( isspace( cp[posn] ) || mask[ cp[posn] ] == Open || mask[ cp[posn] ] == OpenClose ) {
                 sepOff( os );
         } else {
@@ -186 +165 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
         prtfmt( os, "%p", p );
         return os;
@@ -218 +196 @@
 } // sepOff
 
-forall( dtype ostype | ostream( ostype ) ) 
-ostype * sepEnable( ostype * os ) {
-        sepEnable( os );
-        return os;
-} // sepEnable
-
-forall( dtype ostype | ostream( ostype ) ) 
-ostype * sepDisable( ostype * os ) {
-        sepDisable( os );
-        return os;
-} // sepDisable
-
 //---------------------------------------
 
@@ -344 +310 @@
 } // ?|?
 
-_Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
-        scanfmt( is, "%s", cstr.s );
-        return is;
-} // cstr
-
-_Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_cstrC cstr ) {
+_Istream_str1 str( char * s ) { _Istream_str1 s = { s }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_str1 str ) {
+        scanfmt( is, "%s", str.s );
+        return is;
+} // str
+
+_Istream_str2 str( char * s, int size ) { _Istream_str2 s = { s, size }; return s; }
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, _Istream_str2 str ) {
         char buf[16];
-        sprintf( buf, "%%%ds", cstr.size );
-        scanfmt( is, buf, cstr.s );
-        return is;
-} // cstr
+        sprintf( buf, "%%%ds", str.size );
+        scanfmt( is, buf, str.s );
+        return is;
+} // str
 
 // Local Variables: //

src/libcfa/limits

@@ -1 @@
-// 
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-// 
-// limits -- 
-// 
-// Author           : Peter A. Buhr
-// Created On       : Wed Apr  6 18:06:52 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr  6 21:08:16 2016
-// Update Count     : 6
-// 
-
 // Integral Constants
 
-extern const short int MIN;
-extern const int MIN;
-extern const long int MIN;
-extern const long long int MIN;
+const short int MIN = -32768;
+const int MIN = -2147483648;
+const long int MIN = -9223372036854775807L - 1L;
+const long long int MIN = -9223372036854775807LL - 1LL;
 
-extern const short int MAX;
-extern const unsigned short int MAX;
-extern const int MAX;
-extern const unsigned int MAX;
-extern const long int MAX;
-extern const unsigned long int MAX;
-extern const long long int MAX;
-extern const unsigned long long int MAX;
+const short int MAX = 32767;
+const unsigned short int MAX = 65535;
+const int MAX = 2147483647;
+const unsigned int MAX = 4294967295_U;
+const long int MAX = 9223372036854775807_L;
+const unsigned long int MAX = 4294967295_U;
+const long long int MAX = 9223372036854775807_LL;
+const unsigned long long int MAX = 18446744073709551615_ULL;
 
 // Floating-Point Constants
 
-extern const float PI;                                                                  // pi
-extern const float PI_2;                                                                // pi / 2
-extern const float PI_4;                                                                // pi / 4
-extern const float _1_PI;                                                               // 1 / pi
-extern const float _2_PI;                                                               // 2 / pi
-extern const float _2_SQRT_PI;                                                  // 2 / sqrt(pi)
+const float PI = 3.141592_F;                            // pi
+const float PI_2 = 1.570796_F;                          // pi / 2
+const float PI_4 = 0.7853981_F;                         // pi / 4
+const float _1_PI = 0.3183098_F;                        // 1 / pi
+const float _2_PI = 0.6366197_F;                        // 2 / pi
+const float _2_SQRT_PI = 1.128379_F;                    // 2 / sqrt(pi)
 
-extern const double PI;                                                                 // pi
-extern const double PI_2;                                                               // pi / 2
-extern const double PI_4;                                                               // pi / 4
-extern const double _1_PI;                                                              // 1 / pi
-extern const double _2_PI;                                                              // 2 / pi
-extern const double _2_SQRT_PI;                                                 // 2 / sqrt(pi)
+const double PI = 3.14159265358979323846_D;             // pi
+const double PI_2 = 1.57079632679489661923_D;           // pi / 2
+const double PI_4 = 0.78539816339744830962_D;           // pi / 4
+const double _1_PI = 0.31830988618379067154_D;          // 1 / pi
+const double _2_PI = 0.63661977236758134308_D;          // 2 / pi
+const double _2_SQRT_PI = 1.12837916709551257390_D;     // 2 / sqrt(pi)
 
-extern const long double PI;                                                    // pi
-extern const long double PI_2;                                                  // pi / 2
-extern const long double PI_4;                                                  // pi / 4
-extern const long double _1_PI;                                                 // 1 / pi
-extern const long double _2_PI;                                                 // 2 / pi
-extern const long double _2_SQRT_PI;                                    // 2 / sqrt(pi)
+const long double PI = 3.1415926535897932384626433832795029_DL; // pi
+const long double PI_2 = 1.5707963267948966192313216916397514_DL; // pi / 2
+const long double PI_4 = 0.7853981633974483096156608458198757_DL; // pi / 4
+const long double _1_PI = 0.3183098861837906715377675267450287_DL; // 1 / pi
+const long double _2_PI = 0.6366197723675813430755350534900574_DL; // 2 / pi
+const long double _2_SQRT_PI = 1.1283791670955125738961589031215452_DL; // 2 / sqrt(pi)
 
-extern const _Complex PI;                                                               // pi
-extern const _Complex PI_2;                                                             // pi / 2
-extern const _Complex PI_4;                                                             // pi / 4
-extern const _Complex _1_PI;                                                    // 1 / pi
-extern const _Complex _2_PI;                                                    // 2 / pi
-extern const _Complex _2_SQRT_PI;                                               // 2 / sqrt(pi)
+const _Complex PI = 3.14159265358979323846_D+0.0_iD;    // pi
+const _Complex PI_2 = 1.57079632679489661923_D+0.0_iD;  // pi / 2
+const _Complex PI_4 = 0.78539816339744830962_D+0.0_iD;  // pi / 4
+const _Complex _1_PI = 0.31830988618379067154_D+0.0_iD; // 1 / pi
+const _Complex _2_PI = 0.63661977236758134308_D+0.0_iD; // 2 / pi
+const _Complex _2_SQRT_PI = 1.12837916709551257390_D+0.0_iD; // 2 / sqrt(pi)
 
-extern const long _Complex PI;                                                  // pi
-extern const long _Complex PI_2;                                                // pi / 2
-extern const long _Complex PI_4;                                                // pi / 4
-extern const long _Complex _1_PI;                                               // 1 / pi
-extern const long _Complex _2_PI;                                               // 2 / pi
-extern const long _Complex _2_SQRT_PI;                                  // 2 / sqrt(pi)
+const long _Complex PI = 3.1415926535897932384626433832795029_L+0.0iL; // pi
+const long _Complex PI_2 = 1.5707963267948966192313216916397514_L+0.0iL; // pi / 2
+const long _Complex PI_4 = 0.7853981633974483096156608458198757_L+0.0iL; // pi / 4
+const long _Complex _1_PI = 0.3183098861837906715377675267450287_L+0.0iL; // 1 / pi
+const long _Complex _2_PI = 0.6366197723675813430755350534900574_L+0.0iL; // 2 / pi
+const long _Complex _2_SQRT_PI = 1.1283791670955125738961589031215452_L+0.0iL; // 2 / sqrt(pi)
 
-extern const float E;                                                                   // e
-extern const float LOG2_E;                                                              // log_2(e)
-extern const float LOG10_E;                                                             // log_10(e)
-extern const float LN_2;                                                                // log_e(2)
-extern const float LN_10;                                                               // log_e(10)
-extern const float SQRT_2;                                                              // sqrt(2)
-extern const float _1_SQRT_2;                                                   // 1 / sqrt(2)
+const float E = 2.718281;                               // e
+const float LOG2_E = 1.442695;                          // log_2(e)
+const float LOG10_E = 0.4342944;                        // log_10(e)
+const float LN_2 = 0.6931471;                           // log_e(2)
+const float LN_10 = 2.302585;                           // log_e(10)
+const float SQRT_2 = 1.414213;                          // sqrt(2)
+const float _1_SQRT_2 = 0.7071067;                      // 1 / sqrt(2)
 
-extern const double E;                                                                  // e
-extern const double LOG2_E;                                                             // log_2(e)
-extern const double LOG10_E;                                                    // log_10(e)
-extern const double LN_2;                                                               // log_e(2)
-extern const double LN_10;                                                              // log_e(10)
-extern const double SQRT_2;                                                             // sqrt(2)
-extern const double _1_SQRT_2;                                                  // 1 / sqrt(2)
+const double E = 2.7182818284590452354_D;               // e
+const double LOG2_E = 1.4426950408889634074_D;          // log_2(e)
+const double LOG10_E = 0.43429448190325182765_D;        // log_10(e)
+const double LN_2 = 0.69314718055994530942_D;           // log_e(2)
+const double LN_10 = 2.30258509299404568402_D;          // log_e(10)
+const double SQRT_2 = 1.41421356237309504880_D;         // sqrt(2)
+const double _1_SQRT_2 = 0.70710678118654752440_D;      // 1 / sqrt(2)
 
-extern const long double E;                                                             // e
-extern const long double LOG2_E;                                                // log_2(e)
-extern const long double LOG10_E;                                               // log_10(e)
-extern const long double LN_2;                                                  // log_e(2)
-extern const long double LN_10;                                                 // log_e(10)
-extern const long double SQRT_2;                                                // sqrt(2)
-extern const long double _1_SQRT_2;                                             // 1/sqrt(2)
+const long double E = 2.7182818284590452353602874713526625_DL; // e
+const long double LOG2_E = 1.4426950408889634073599246810018921_DL; // log_2(e)
+const long double LOG10_E = 0.4342944819032518276511289189166051_DL; // log_10(e)
+const long double LN_2 = 0.6931471805599453094172321214581766_DL; // log_e(2)
+const long double LN_10 = 2.3025850929940456840179914546843642_DL; // log_e(10)
+const long double SQRT_2 = 1.4142135623730950488016887242096981_DL; // sqrt(2)
+const long double _1_SQRT_2 = 0.7071067811865475244008443621048490_DL; // 1/sqrt(2)
 
-extern const _Complex E;                                                                // e
-extern const _Complex LOG2_E;                                                   // log_2(e)
-extern const _Complex LOG10_E;                                                  // log_10(e)
-extern const _Complex LN_2;                                                             // log_e(2)
-extern const _Complex LN_10;                                                    // log_e(10)
-extern const _Complex SQRT_2;                                                   // sqrt(2)
-extern const _Complex _1_SQRT_2;                                                // 1 / sqrt(2)
+const _Complex E = 2.7182818284590452354_D+0.0_iD;      // e
+const _Complex LOG2_E = 1.4426950408889634074_D+0.0_iD; // log_2(e)
+const _Complex LOG10_E = 0.43429448190325182765_D+0.0_iD; // log_10(e)
+const _Complex LN_2 = 0.69314718055994530942_D+0.0_iD;  // log_e(2)
+const _Complex LN_10 = 2.30258509299404568402_D+0.0_iD; // log_e(10)
+const _Complex SQRT_2 = 1.41421356237309504880_D+0.0_iD;        // sqrt(2)
+const _Complex _1_SQRT_2 = 0.70710678118654752440_D+0.0_iD; // 1 / sqrt(2)
 
-extern const long _Complex E;                                                   // e
-extern const long _Complex LOG2_E;                                              // log_2(e)
-extern const long _Complex LOG10_E;                                             // log_10(e)
-extern const long _Complex LN_2;                                                // log_e(2)
-extern const long _Complex LN_10;                                               // log_e(10)
-extern const long _Complex SQRT_2;                                              // sqrt(2)
-extern const long _Complex _1_SQRT_2;                                   // 1 / sqrt(2)
-
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //
+const long _Complex E = 2.7182818284590452353602874713526625_L+0.0_iL; // e
+const long _Complex LOG2_E = 1.4426950408889634073599246810018921_L+0.0_iL; // log_2(e)
+const long _Complex LOG10_E = 0.4342944819032518276511289189166051_L+0.0_iL; // log_10(e)
+const long _Complex LN_2 = 0.6931471805599453094172321214581766_L+0.0_iL; // log_e(2)
+const long _Complex LN_10 = 2.3025850929940456840179914546843642_L+0.0_iL; // log_e(10)
+const long _Complex SQRT_2 = 1.4142135623730950488016887242096981_L+0.0_iL; // sqrt(2)
+const long _Complex _1_SQRT_2 = 0.7071067811865475244008443621048490_L+0.0_iL; // 1 / sqrt(2)

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr  1 22:26:14 2016
-// Update Count     : 73
+// Last Modified On : Tue Mar 22 22:34:24 2016
+// Update Count     : 69
 //
 
@@ -18 +18 @@
 extern "C" {
 #include <stddef.h>                                                                             // size_t
-#include <math.h>                                                                               // floor
 } // extern "C"
 
@@ -81 +80 @@
 char abs( char );
 extern "C" {
-int abs( int );                         // use default C routine for int
-} // extern "C"
+int abs( int );         // use default C routine for int
+} // extern
 long int abs( long int );
 long long int abs( long long int );
@@ -91 +90 @@
 double _Complex abs( double _Complex );
 long double _Complex abs( long double _Complex );
-
-//---------------------------------------
-
-float floor( float );
-extern "C" {
-double floor( double );         // use C routine for double
-} // extern "C"
-long double floor( long double );
-
-float ceil( float );
-extern "C" {
-double ceil( double );          // use C routine for double
-} // extern "C"
-long double ceil( long double );
 
 //---------------------------------------

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 30 10:48:41 2016
-// Update Count     : 149
+// Last Modified On : Wed Mar 23 13:26:42 2016
+// Update Count     : 146
 //
 
@@ -243 +243 @@
 //---------------------------------------
 
-float floor( float v ) { return floorf( v ); }
-long double floor( long double v ) { return floorl( v ); }
-
-float ceil( float v ) { return ceilf( v ); }
-long double ceil( long double v ) { return ceill( v ); }
-
-//---------------------------------------
-
 void rand48seed( long int s ) { srand48( s ); }
 char rand48() { return mrand48(); }