Changes in / [fbfb38e:dc2e7e0]

Files:

• doc/user/Cdecl.fig (deleted)
• doc/user/Makefile (modified) (1 diff)
• doc/user/user.tex (modified) (17 diffs)
• src/ResolvExpr/CastCost.cc (modified) (2 diffs)
• src/SymTab/Indexer.cc (modified) (4 diffs)
• src/SymTab/Indexer.h (modified) (1 diff)
• src/SymTab/Validate.cc (modified) (1 diff)
• src/driver/cfa.cc (modified) (2 diffs)
• src/examples/io.c (modified) (3 diffs)
• src/examples/swap.c (modified) (2 diffs)
• src/libcfa/Makefile.am (modified) (2 diffs)
• src/libcfa/Makefile.in (modified) (3 diffs)
• src/libcfa/fstream (modified) (2 diffs)
• src/libcfa/math (deleted)
• src/libcfa/math.c (deleted)
• src/libcfa/rational.c (modified) (2 diffs)
• src/libcfa/stdlib (modified) (4 diffs)
• src/libcfa/stdlib.c (modified) (7 diffs)

doc/user/Makefile

@@ -12 +12 @@
 
 FIGURES = ${addsuffix .tex, \
-Cdecl \
 }
 

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Thu Apr 21 08:15:37 2016
-%% Update Count     : 131
+%% Last Modified On : Sun Apr 10 22:50:15 2016
+%% Update Count     : 72
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -26 +26 @@
 \usepackage{upquote}
 \usepackage{fullpage,times}
-\usepackage{epic,eepic}
 \usepackage{xspace}
 \usepackage{varioref}
@@ -49 +48 @@
 % Names used in the document.
 
-\newcommand{\Version}{1.0.0}
 \newcommand{\CS}{C\raisebox{-0.9ex}{\large$^\sharp$}\xspace}
 
@@ -107 +105 @@
 The syntax of the \CFA language builds from C, and should look immediately familiar to C programmers.
 % Any language feature that is not described here can be assumed to be using the standard C11 syntax.
-\CFA adds many modern programming-language features, which directly leads to increased safety and productivity, while maintaining interoperability with existing C programs and achieving C performance.
+\CFA adds many modern programming-language features, which directly leads to increased safety and productivity, while maintaining interoperability with existing C programs and maintaining C-like performance.
 Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global garbage-collection.
 The primary new features include parametric-polymorphism routines and types, exceptions, concurrency, and modules.
@@ -226 +224 @@
 
 
-\section{Compiling \CFA Program}
+\section{Compiling \CFA}
 
 The command \lstinline@cfa@ is used to compile \CFA program(s).
@@ -233 +231 @@
 cfa [ gcc-options ] C/@{\CFA}@-files [ assembler/loader-files ]
 \end{lstlisting}
-\index{cfa@\lstinline$cfa$}\index{compilation!cfa@\lstinline$cfa$}
 By default, \CFA programs having the following \lstinline@gcc@ flags turned on:
 \begin{description}
 \item
 \hspace*{-4pt}\lstinline@-std=gnu99@
-\index{-std=gnu99@{\lstinline$-std=gnu99$}}\index{compilation option!-std=gnu99@{\lstinline$-std=gnu99$}}
 The 1999 C standard plus GNU extensions.
-\item
-\hspace*{-4pt}\lstinline@-fgnu89-inline@
-\index{-fgnu89-inline@{\lstinline$-fgnu89-inline$}}\index{compilation option!-fgnu89-inline@{\lstinline$-fgnu89-inline$}}
-Use the traditional GNU semantics for inline routines in C99 mode.
 \end{description}
 The following new \CFA option is available:
@@ -249 +241 @@
 \item
 \hspace*{-4pt}\lstinline@-CFA@
-\index{-CFA@{\lstinline$-CFA$}}\index{compilation option!-CFA@{\lstinline$-CFA$}}
 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
 \end{description}
-
-The following preprocessor variables are available:
-\begin{description}
-\item
-\hspace*{-4pt}\lstinline$__CFA__$
-\index{__CFA__@{\lstinline$__CFA__$}}\index{preprocessor variables!__CFA__@{\lstinline$__CFA__$}}
-is always available during preprocessing and its value is the current major \Index{version number} of \CFA.\footnote{
-The C preprocessor allows only integer values in a preprocessor variable so a value like ``\Version'' is not allowed.
-Hence, the need to have three variables for the major, minor and patch version number.}
-
-\item
-\hspace*{-4pt}\lstinline$__CFA_MINOR__$
-\index{__CFA_MINOR__@{\lstinline$__CFA_MINOR__$}}\index{preprocessor variables!__CFA_MINOR__@{\lstinline$__CFA_MINOR__$}}
-is always available during preprocessing and its value is the current minor \Index{version number} of \CFA.
-
-\item
-\hspace*{-4pt}\lstinline$__CFA_PATCH__$
-\index{__CFA_PATCH__@%(__CFA_PATCH__%)}\index{preprocessor variables!__CFA_PATCH__@%(__CFA_PATCH__%)}
-is always available during preprocessing and its value is the current patch \Index{version number} of \CFA.
-
-\item
-\hspace*{-4pt}\lstinline$__CFORALL__$
-\index{__CFORALL__@%(__CFORALL__%)}\index{preprocessor variables!__CFORALL__@%(__CFORALL__%)}
-is always available during preprocessing and it has no value.
-\end{description}
-
-These preprocessor variables allow conditional compilation of programs that must work differently in these situations.
-For example, to toggle between C and \CFA extensions, using the following:
-\begin{lstlisting}
-#ifndef __CFORALL__
-#include <stdio.h>              // C header file
-#else
-#include <fstream>              // @\CFA{}@ header file
-#endif
-\end{lstlisting}
-which conditionally includes the correct header file, if the program is compiled using \lstinline@gcc@ or \lstinline@cfa@. 
 
 
@@ -329 +284 @@
 C declaration syntax is notoriously confusing and error prone.
 For example, many C programmers are confused by a declaration as simple as:
-\begin{quote2}
-\begin{tabular}{@{}ll@{}}
-\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
-int *x[ 5 ]
-\end{lstlisting}
-&
-\raisebox{-0.75\totalheight}{\input{Cdecl}}
-\end{tabular}
-\end{quote2}
-Is this an array of 5 pointers to integers or a pointer to an array of 5 integers?
+\begin{lstlisting}
+int *x[ 10 ]
+\end{lstlisting}
+Is this a pointer to an array of 10 integers or an array of 10 pointers to integers?
 Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
 For example, a routine returning a pointer to an array of integers is defined and used in the following way:
 \begin{lstlisting}
-int (*f())[ 5 ] {...};  // definition mimics usage
-... (*f())[ 3 ] += 1;
+int (*f())[ 10 ] {...};
+... (*f())[  3 ] += 1;  // definition mimics usage
 \end{lstlisting}
 Essentially, the return type is wrapped around the routine name in successive layers (like an onion).
@@ -373 +322 @@
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
-[ 5 ] int z;
-[ 5 ] * char w;
-* [ 5 ] double v;
+[ 10 ] int z;
+[ 10 ] * char w;
+* [ 10 ] double v;
 struct s {
         int f0:3;
         * int f1;
-        [ 5 ] * int f2;
+        [ 10 ] * int f2;
 };
 \end{lstlisting}
 &
 \begin{lstlisting}
-int z[ 5 ];
-char *w[ 5 ];
-double (*v)[ 5 ];
+int z[ 10 ];
+char *w[ 10 ];
+double (*v)[ 10 ];
 struct s {
         int f0:3;
         int *f1;
-        int *f2[ 5 ]
+        int *f2[ 10 ]
 };
 \end{lstlisting}
 &
 \begin{lstlisting}
-// array of 5 integers
-// array of 5 pointers to char
-// pointer to array of 5 doubles
+// array of 10 integers
+// array of 10 pointers to char
+// pointer to array of 10 doubles
 
 // common bit field syntax
@@ -413 +362 @@
 \begin{lstlisting}
 const * const int x;
-const * [ 5 ] const int y;
+const * [ 10 ] const int y;
 \end{lstlisting}
 &
 \begin{lstlisting}
 int const * const x;
-const int (* const y)[ 5 ]
+const int (* const y)[ 10 ]
 \end{lstlisting}
 &
 \begin{lstlisting}
 // const pointer to const integer
-// const pointer to array of 5 const integers
+// const pointer to array of 10 const integers
 \end{lstlisting}
 \end{tabular}
@@ -433 +382 @@
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
-extern [ 5 ] int x;
+extern [ 10 ] int x;
 static * const int y;
 \end{lstlisting}
 &
 \begin{lstlisting}
-int extern x[ 5 ];
+int extern x[ 10 ];
 const int static *y;
 \end{lstlisting}
 &
 \begin{lstlisting}
-// externally visible array of 5 integers
+// externally visible array of 10 integers
 // internally visible pointer to constant int
 \end{lstlisting}
@@ -472 +421 @@
 \begin{lstlisting}
 y = (* int)x;
-i = sizeof([ 5 ] * int);
+i = sizeof([ 10 ] * int);
 \end{lstlisting}
 &
 \begin{lstlisting}
 y = (int *)x;
-i = sizeof(int *[ 5 ]);
+i = sizeof(int *[ 10 ]);
 \end{lstlisting}
 \end{tabular}
@@ -517 +466 @@
 \CFA style declarations cannot be used to declare parameters for K\&R style routine definitions because of the following ambiguity:
 \begin{lstlisting}
-int (*f(x))[ 5 ] int x; {}
-\end{lstlisting}
-The string ``\lstinline@int (*f(x))[ 5 ]@'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``\lstinline@[ 5 ] int x@'' declares a \CFA style parameter x of type array of 5 integers.
+int (*f(x))[ 10 ] int x; {}
+\end{lstlisting}
+The string ``\lstinline@int (*f(x))[ 10 ]@'' declares a K\&R style routine of type returning a pointer to an array of 10 integers, while the string ``\lstinline@[ 10 ] int x@'' declares a \CFA style parameter x of type array of 10 integers.
 Since the strings overlap starting with the open bracket, \lstinline@[@, there is an ambiguous interpretation for the string.
 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
@@ -538 +487 @@
 \begin{lstlisting}
 #define ptoa( n, d ) int (*n)[ d ]
-int f( ptoa(p,5) ) ...          // expands to int f( int (*p)[ 5 ] )
-[ int ] f( ptoa(p,5) ) ...      // expands to [ int ] f( int (*p)[ 5 ] )
+int f( ptoa(p,10) ) ...         // expands to int f( int (*p)[ 10 ] )
+[ int ] f( ptoa(p,10) ) ...     // expands to [ int ] f( int (*p)[ 10 ] )
 \end{lstlisting}
 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
@@ -858 +807 @@
 which can be used to sort in ascending and descending order by locally redefining the less-than operator into greater-than.
 \begin{lstlisting}
-const unsigned int size = 5;
+const unsigned int size = 10;
 int ia[size];
 ...                                             // assign values to array ia
@@ -925 +874 @@
 [ double, double, double ]
 [ * int, int * ]                // mix of CFA and ANSI
-[ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
+[ * [ 10 ] int, * * char, * [ [ int, int ] ] (int, int) ]
 \end{lstlisting}
 Like tuples, tuple types may be nested, such as \lstinline@[ [ int, int ], int ]@, which is a 2-element tuple type whose first element is itself a tuple type.
@@ -2267 +2216 @@
 
         try {
-                throw 13;
+        throw 13;
         }
         catch(int e) {
-                printf(.caught an exception: %d\n., e);
+        printf(.caught an exception: %d\n., e);
         }
 \end{lstlisting}

src/ResolvExpr/CastCost.cc

@@ -69 +69 @@
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
-                        // necessary for, e.g. unsigned long => void*
-                        cost = Cost( 1, 0, 0 );
+                        //cost = Cost( 1, 0, 0 );
+                        cost = Cost::infinity;
                 } else {
                         ConversionCost::visit( basicType );
@@ -89 +89 @@
                                 } else if ( castResult < 0 ) {
                                         cost = Cost::infinity;
+                                        //cost = Cost( 1, 0, 0 );
                                 } // if
                         } // if
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         if ( destAsBasic->isInteger() ) {
-                                // necessary for, e.g. void* => unsigned long
-                                cost = Cost( 1, 0, 0 );
+                                //cost = Cost( 1, 0, 0 );
+                                cost = Cost::infinity;
                         } // if
                 }

src/SymTab/Indexer.cc

@@ -511 +511 @@
         }
 
-        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
+        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
                 if ( ! tables ) return false;
-                if ( tables->scope < scope ) return false;
 
                 IdTable::const_iterator decls = tables->idTable.find( id );
@@ -525 +524 @@
                 }
 
-                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
+                return tables->base.hasIncompatibleCDecl( id, mangleName );
         }
         
@@ -618 +617 @@
                 DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
                 if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
-                        // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                        // this ensures that no two declarations with the same unmangled name both have C linkage
+                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName ) ) {
                                 throw SemanticError( "invalid overload of C function ", decl );
                         } // NOTE this is broken in Richard's original code in such a way that it never triggers (it 
@@ -784 +783 @@
             using std::cerr;
 
-                if ( tables ) {
-                        os << "--- scope " << tables->scope << " ---" << std::endl;
-
-                        os << "===idTable===" << std::endl;
-                        dump( tables->idTable, os );
-                        os << "===typeTable===" << std::endl;
-                        dump( tables->typeTable, os );
-                        os << "===structTable===" << std::endl;
-                        dump( tables->structTable, os );
-                        os << "===enumTable===" << std::endl;
-                        dump( tables->enumTable, os );
-                        os << "===unionTable===" << std::endl;
-                        dump( tables->unionTable, os );
-                        os << "===contextTable===" << std::endl;
-                        dump( tables->traitTable, os );
-
-                        tables->base.print( os, indent );
-                } else {
-                        os << "--- end ---" << std::endl;
-                }
-                
+            cerr << "===idTable===" << std::endl;
+            if ( tables ) dump( tables->idTable, os );
+            cerr << "===typeTable===" << std::endl;
+            if ( tables ) dump( tables->typeTable, os );
+            cerr << "===structTable===" << std::endl;
+            if ( tables ) dump( tables->structTable, os );
+            cerr << "===enumTable===" << std::endl;
+            if ( tables ) dump( tables->enumTable, os );
+            cerr << "===unionTable===" << std::endl;
+            if ( tables ) dump( tables->unionTable, os );
+            cerr << "===contextTable===" << std::endl;
+            if ( tables ) dump( tables->traitTable, os );
         }
 } // namespace SymTab

src/SymTab/Indexer.h

@@ -99 +99 @@
                 DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
                 /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
-                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
+                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
                 // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
                 NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;

src/SymTab/Validate.cc

@@ -515 +515 @@
                                 }
                                 rtt->get_parameters().clear();
-                                cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
-                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
+                                cloneAll(typeInst->get_parameters(), rtt->get_parameters());
                         } // if
                         delete typeInst;

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 20 18:31:28 2016
-// Update Count     : 133
+// Last Modified On : Wed Apr  6 14:04:22 2016
+// Update Count     : 132
 //
 
@@ -310 +310 @@
                         nargs += 1;
                 } // if
-                args[nargs] = "-fgnu89-inline"; 
-                nargs += 1;
                 args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
                 nargs += 1;

src/examples/io.c

@@ -11 +11 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 13 23:03:14 2016
-// Update Count     : 22
+// Last Modified On : Wed Apr  6 14:58:27 2016
+// Update Count     : 15
 // 
 
@@ -36 +36 @@
 
         ifstream in;                                                                                            // create / open file
-        open( &in, "io.data", "r" );
+        open( &in, "input.data", "r" );
 
         &in | &c                                                                                                        // character
@@ -59 +59 @@
                  | fc | dc | ldc | endl                                                                 // complex without separator
                  | s1 | s2 | endl;
-        sout | endl;
-        sepSet( sout, " " );
-
-        sout
-                // opening delimiters
-                | "v(" | 27
-                | "v[" | 27
-                | "v{" | 27
-                | "$" | 27
-                | "£" | 27
-                | "¥" | 27
-                | "¿" | 27
-                | "«" | 27
-                | endl
-                // closing delimiters
-                | 25 | ","
-                | 25 | "."
-                | 25 | ":"
-                | 25 | ";"
-                | 25 | "!"
-                | 25 | "?"
-                | 25 | ")"
-                | 25 | "]"
-                | 25 | "}"
-                | 25 | "%"
-                | 25 | "¢"
-                | 25 | "»"
-                | endl
-                // opening-closing delimiters
-                | 25 | "'" | 27
-                | 25 | "`" | 27
-                | 25 | "\"" | 27
-                | 25 | "\f" | 27
-                | 25 | "\n" | 27
-                | 25 | "\r" | 27
-                | 25 | "\t" | 27
-                | 25 | "\v" | 27
-                | endl;
 }
 

src/examples/swap.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 21 08:10:41 2016
-// Update Count     : 69
+// Last Modified On : Wed Mar  2 16:15:11 2016
+// Update Count     : 65
 //
 
@@ -24 +24 @@
 
         signed int i1 = -1, i2 = -2;
-        sout | "signed int\t\t" | i1 | i2 | "\t\t\tswap ";
+        sout | "signed int\t\t" | i1 | ' ' | i2 | "\t\t\tswap ";
         swap( &i1, &i2 );
-        sout | '\t' | i1 | i2 | endl;
+        sout | '\t' | i1 | ' ' | i2 | endl;
 
         unsigned int ui1 = 1, ui2 = 2;
-        sout | "unsigned int\t\t" | ui1 | ui2 | "\t\t\tswap ";
+        sout | "unsigned int\t\t" | ui1 | ' ' | ui2 | "\t\t\tswap ";
         swap( &ui1, &ui2 );
-        sout | '\t' | ui1 | ui2 | endl;
+        sout | '\t' | ui1 | ' ' | ui2 | endl;
 
         signed long int li1 = -1, li2 = -2;
-        sout | "signed long int\t\t" | li1 | li2 | "\t\t\tswap ";
+        sout | "signed long int\t\t" | li1 | ' ' | li2 | "\t\t\tswap ";
         swap( &li1, &li2 );
-        sout | '\t' | li1 | li2 | endl;
+        sout | '\t' | li1 | ' ' | li2 | endl;
 
         unsigned long int uli1 = 1, uli2 = 2;
-        sout | "unsigned long int\t" | uli1 | uli2 | "\t\t\tswap ";
+        sout | "unsigned long int\t" | uli1 | ' ' | uli2 | "\t\t\tswap ";
         swap( &uli1, &uli2 );
-        sout | '\t' | uli1 | uli2 | endl;
+        sout | '\t' | uli1 | ' ' | uli2 | endl;
 
         signed long long int lli1 = -1, lli2 = -2;
-        sout | "signed long long int\t" | lli1 | lli2 | "\t\t\tswap ";
+        sout | "signed long long int\t" | lli1 | ' ' | lli2 | "\t\t\tswap ";
         swap( &lli1, &lli2 );
-        sout | '\t' | lli1 | lli2 | endl;
+        sout | '\t' | lli1 | ' ' | lli2 | endl;
 
         unsigned long long int ulli1 = 1, ulli2 = 2;
-        sout | "unsigned long long int\t" | ulli1 | ulli2 | "\t\t\tswap ";
+        sout | "unsigned long long int\t" | ulli1 | ' ' | ulli2 | "\t\t\tswap ";
         swap( &ulli1, &ulli2 );
-        sout | '\t' | ulli1 | ulli2 | endl;
+        sout | '\t' | ulli1 | ' ' | ulli2 | endl;
 
         float f1 = 1.5, f2 = 2.5;
-        sout | "float\t\t\t" | f1 | f2 | "\t\t\tswap ";
+        sout | "float\t\t\t" | f1 | ' ' | f2 | "\t\tswap ";
         swap( &f1, &f2 );
-        sout | '\t' | f1 | f2 | endl;
+        sout | '\t' | f1 | ' ' | f2 | endl;
 
         double d1 = 1.5, d2 = 2.5;
-        sout | "double\t\t\t" | d1 | d2 | "\t\t\tswap ";
+        sout | "double\t\t\t" | d1 | ' ' | d2 | "\t\tswap ";
         swap( &d1, &d2 );
-        sout | '\t' | d1 | d2 | endl;
+        sout | '\t' | d1 | ' ' | d2 | endl;
 
         long double ld1 = 1.5, ld2 = 2.5;
-        sout | "long double\t\t" | ld1 | ld2 | "\t\t\tswap ";
+        sout | "long double\t\t" | ld1 | ' ' | ld2 | "\t\tswap ";
         swap( &ld1, &ld2 );
-        sout | '\t' | ld1 | ld2 | endl;
+        sout | '\t' | ld1 | ' ' | ld2 | endl;
 
         float _Complex fc1 = 1.5f+1.5if, fc2 = 2.5f+2.5if;
-        sout | "float _Complex\t\t" | fc1 | fc2 | "\tswap ";
+        sout | "float _Complex\t\t" | fc1 | ' ' | fc2 | "\tswap ";
         swap( &fc1, &fc2 );
-        sout | '\t' | fc1 | fc2 | endl;
+        sout | '\t' | fc1 | ' ' | fc2 | endl;
 
         double _Complex dc1 = 1.5d+1.5id, dc2 = 2.5d+2.5id;
-        sout | "double _Complex\t\t" | dc1 | dc2 | "\tswap ";
+        sout | "double _Complex\t\t" | dc1 | ' ' | dc2 | "\tswap ";
         swap( &dc1, &dc2 );
-        sout | '\t' | dc1 | dc2 | endl;
+        sout | '\t' | dc1 | ' ' | dc2 | endl;
 
         long double _Complex ldc1 = 1.5d+1.5il, ldc2 = 2.5d+2.5il;
-        sout | "long double _Complex\t" | ldc1 | ldc2 | "\tswap ";
+        sout | "long double _Complex\t" | ldc1 | ' ' | ldc2 | "\tswap ";
         swap( &ldc1, &ldc2 );
-        sout | '\t' | ldc1 | ldc2 | endl;
+        sout | '\t' | ldc1 | ' ' | ldc2 | endl;
 
         struct S { int i, j; } s1 = { 1, 2 }, s2 = { 2, 1 };
-        ofstream * ?|?( ofstream * os, S s ) { return os | s.i | s.j; }
-        sout | "struct S\t\t" | s1 | "," | s2 | "\t\tswap ";
+        ofstream * ?|?( ofstream * os, S s ) { return os | s.i | ' ' | s.j; }
+        sout | "struct S\t\t" | s1 | "  " | s2 | "\t\tswap ";
         swap( &s1, &s2 );
-        sout | '\t' | s1 | "," | s2 | endl;
+        sout | '\t' | s1 | "  " | s2 | endl;
 } // main
 

src/libcfa/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Tue Apr 19 22:30:17 2016
-## Update Count     : 124
+## Last Modified On : Wed Apr  6 21:10:44 2016
+## Update Count     : 123
 ###############################################################################
 
@@ -60 +60 @@
         ${CC} ${CFLAGS} -c -o $@ $<
 
-libs = limits stdlib math iostream fstream iterator rational
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 

src/libcfa/Makefile.in

@@ -83 +83 @@
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
-am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) math.$(OBJEXT) \
-        iostream.$(OBJEXT) fstream.$(OBJEXT) iterator.$(OBJEXT) \
-        rational.$(OBJEXT)
+am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) iostream.$(OBJEXT) \
+        fstream.$(OBJEXT) iterator.$(OBJEXT) rational.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -214 +213 @@
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
-libs = limits stdlib math iostream fstream iterator rational
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 cheaders = # expat
@@ -300 +299 @@
 @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)/math.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 19 20:44:10 2016
-// Update Count     : 84
+// Last Modified On : Tue Apr  5 22:37:12 2016
+// Update Count     : 82
 //
 
@@ -22 +22 @@
 struct ofstream {
         void *file;
-        int sepDefault;
-        int sepOnOff;
+        _Bool sepDefault;
+        _Bool sepOnOff;
         char separator[separateSize];
 }; // ofstream

src/libcfa/rational.c

@@ -11 +11 @@
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 21 07:33:03 2016
-// Update Count     : 22
+// Last Modified On : Tue Apr 12 21:26:42 2016
+// Update Count     : 21
 // 
 
@@ -18 +18 @@
 #include "fstream"
 #include "stdlib"
-#include "math"                                                                                 // floor
 
 

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 21 07:55:21 2016
-// Update Count     : 95
+// Last Modified On : Wed Apr 13 14:45:53 2016
+// Update Count     : 85
 //
 
@@ -28 +28 @@
 #endif // ! EXIT_FAILURE
 void exit( int rc );
-void abort( void );
 } // extern "C"
 
 //---------------------------------------
 
-extern "C" { void * malloc( size_t ); }                                 // use default C routine for void *
+extern "C" {
+void * malloc( size_t );                                                                // use default C routine for void *
+} // extern "C"
 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 );
-extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
+extern "C" {
+void * calloc( size_t nmemb, size_t size );                             // use default C routine for void *
+} // extern "C"
 forall( otype T ) T * calloc( size_t nmemb );
-extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
+extern "C" {
+void * realloc( void * ptr, size_t size );                              // use default C routine for void *
+} // extern "C"
 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 );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
 forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
 
-extern "C" {
-void * memset( void * ptr, int fill, size_t size );
-void free( void * ptr );
-} // extern "C"
+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
 
 //---------------------------------------
@@ -97 +100 @@
 
 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 "C"
 long int abs( long int );
 long long int abs( long long int );
@@ -103 +108 @@
 double abs( double );
 long double abs( long double );
-float abs( float _Complex );
-double abs( double _Complex );
-long double abs( long double _Complex );
+float _Complex abs( float _Complex );
+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 : Thu Apr 21 07:58:29 2016
-// Update Count     : 165
+// Last Modified On : Wed Apr 13 14:49:58 2016
+// Update Count     : 155
 //
 
@@ -24 +24 @@
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <math.h>                                                                               // fabsf, fabs, fabsl
-#include <complex.h>                                                                    // _Complex_I
+#include <complex.h>                                                                    // _Complex_I, cabsf, cabs, cabsl
 } // extern "C"
 
@@ -34 +34 @@
         //printf( "malloc3\n" );
         T * ptr = (T *)malloc( sizeof(T) );
-    return memset( ptr, (int)fill, sizeof(T) );
+    return memset( ptr );
 } // malloc
 
@@ -78 +78 @@
 } // posix_memalign
 
+forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+        //printf( "memset1\n" );
+    return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
+} // memset
+forall( otype T ) T * memset( T * ptr ) {                               // remove when default value available
+        //printf( "memset2\n" );
+    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
+} // memset
+
 //---------------------------------------
 
 int ato( const char * ptr ) {
         int i;
-        if ( sscanf( ptr, "%d", &i ) == EOF ) {}
+        if ( sscanf( ptr, "%d", &i ) == EOF ) {}                        // check return code
         return i;
 }
 unsigned int ato( const char * ptr ) {
         unsigned int ui;
-        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
+        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}                       // check return code
         return ui;
 }
 long int ato( const char * ptr ) {
         long int li;
-        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
+        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}                      // check return code
         return li;
 }
 unsigned long int ato( const char * ptr ) {
         unsigned long int uli;
-        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
+        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}                     // check return code
         return uli;
 }
 long long int ato( const char * ptr ) {
         long long int lli;
-        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
+        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}            // check return code
         return lli;
 }
 unsigned long long int ato( const char * ptr ) {
         unsigned long long int ulli;
-        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
+        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}           // check return code
         return ulli;
 }
@@ -113 +122 @@
 float ato( const char * ptr ) {
         float f;
-        if ( sscanf( ptr, "%f", &f ) == EOF ) {}
+        if ( sscanf( ptr, "%f", &f ) == EOF ) {}                        // check return code
         return f;
 }
 double ato( const char * ptr ) {
         double d;
-        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
+        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}                       // check return code
         return d;
 }
 long double ato( const char * ptr ) {
         long double ld;
-        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
+        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}                      // check return code
         return ld;
 }
@@ -129 +138 @@
 float _Complex ato( const char * ptr ) {
         float re, im;
-        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
+        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}       // check return code
         return re + im * _Complex_I;
 }
 double _Complex ato( const char * ptr ) {
         double re, im;
-        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
+        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code
         return re + im * _Complex_I;
 }
 long double _Complex ato( const char * ptr ) {
         long double re, im;
-        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
+        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}     // check return code
         return re + im * _Complex_I;
 }       
@@ -221 +230 @@
 long int abs( long int v ) { return labs( v ); }
 long long int abs( long long int v ) { return llabs( v ); }
-float abs( float x ) { return fabsf( x ); }
-double abs( double x ) { return fabs( x ); }
-long double abs( long double x ) { return fabsl( x ); }
-float abs( float _Complex x ) { return cabsf( x ); }
-double abs( double _Complex x ) { return cabs( x ); }
-long double abs( long double _Complex x ) { return cabsl( x ); }
+float abs( float v ) { return fabsf( v ); }
+double abs( double v ) { return fabs( v ); }
+long double abs( long double v ) { return fabsl( v ); }
+float _Complex abs( float _Complex v ) { return cabsf( v ); }
+double _Complex abs( double _Complex v ) { return cabs( v ); }
+long double _Complex abs( long double _Complex v ) { return cabsl( v ); }
+
+//---------------------------------------
+
+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 ); }
 
 //---------------------------------------