Changeset 0f9e4403 for src/libcfa

Timestamp:

Apr 15, 2016, 12:03:11 PM (10 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

29ad0ac

Parents:

c5833e8 (diff), 37f0da8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into gc_noraii

Location:

src/libcfa

Files:

• Makefile.am (modified) (2 diffs)
• Makefile.in (modified) (4 diffs)
• bfd.h (deleted)
• bfdlink.h (deleted)
• builtins.cf (modified) (4 diffs)
• demangle.h (deleted)
• dialog.h (deleted)
• evdns.h (deleted)
• evhttp.h (deleted)
• evrpc.h (deleted)
• fcntl.h (deleted)
• form.h (deleted)
• fstream (modified) (3 diffs)
• fstream.c (modified) (8 diffs)
• gcrypt.h (deleted)
• iostream (modified) (3 diffs)
• iostream.c (modified) (3 diffs)
• iterator (modified) (4 diffs)
• iterator.c (modified) (2 diffs)
• limits (modified) (1 diff)
• limits.c (added)
• math.h (deleted)
• prelude.cf (modified) (6 diffs)
• rational (added)
• rational.c (added)
• stdlib (modified) (5 diffs)
• stdlib.c (modified) (11 diffs)

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 Feb  3 11:19:35 2016
-## Update Count     : 117
+## Last Modified On : Wed Apr  6 21:10:44 2016
+## Update Count     : 123
 ###############################################################################
 
@@ -60 +60 @@
         ${CC} ${CFLAGS} -c -o $@ $<
 
-libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 
-cheaders = bfd bfdlink demangle dialog evdns evhttp evrpc expat fcntl form gcrypt math
-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 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
-        iterator.$(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)
@@ -213 +213 @@
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
-libs = stdlib iostream fstream iterator
+libs = limits stdlib iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
-cheaders = bfd bfdlink demangle dialog evdns evhttp evrpc expat fcntl form gcrypt math
-cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
@@ -231 +231 @@
           esac; \
         done; \
-        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/libcfa/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/libcfa/Makefile'; \
         $(am__cd) $(top_srcdir) && \
-          $(AUTOMAKE) --gnu src/libcfa/Makefile
+          $(AUTOMAKE) --foreign src/libcfa/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@@ -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/builtins.cf

@@ -390 +390 @@
 int __builtin_sprintf(char *, const char *, ...);
 int __builtin_sscanf(const char *, const char *, ...);
-int __builtin_vfprintf(struct _IO_FILE *, const char *, void **);
-int __builtin_vfscanf(struct _IO_FILE *, const char *, void **);
-int __builtin_vprintf(const char *, void **);
-int __builtin_vscanf(const char *, void **);
-int __builtin_vsnprintf(char *, unsigned long, const char *, void **);
-int __builtin_vsprintf(char *, const char *, void **);
-int __builtin_vsscanf(const char *, const char *, void **);
+int __builtin_vfprintf(struct _IO_FILE *, const char *, __builtin_va_list);
+int __builtin_vfscanf(struct _IO_FILE *, const char *, __builtin_va_list);
+int __builtin_vprintf(const char *, __builtin_va_list);
+int __builtin_vscanf(const char *, __builtin_va_list);
+int __builtin_vsnprintf(char *, unsigned long, const char *, __builtin_va_list);
+int __builtin_vsprintf(char *, const char *, __builtin_va_list);
+int __builtin_vsscanf(const char *, const char *, __builtin_va_list);
 int __builtin_isalnum(int);
 int __builtin_isalpha(int);
@@ -534 +534 @@
 void __builtin_unwind_init();
 void __builtin_update_setjmp_buf(void *, int);
-void __builtin_va_copy(void **, void **);
-void __builtin_va_end(void **);
-void __builtin_va_start(void **, ...);
+void __builtin_va_copy(__builtin_va_list, __builtin_va_list);
+void __builtin_va_end(__builtin_va_list);
+void __builtin_va_start(__builtin_va_list, ...);
 int __builtin_va_arg_pack();
 int __builtin_va_arg_pack_len();
@@ -563 +563 @@
 int __builtin___snprintf_chk(char *, unsigned long, int, unsigned long, const char *, ...);
 int __builtin___sprintf_chk(char *, int, unsigned long, const char *, ...);
-int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, void **);
-int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, void **);
+int __builtin___vsnprintf_chk(char *, unsigned long, int, unsigned long, const char *, __builtin_va_list);
+int __builtin___vsprintf_chk(char *, int, unsigned long, const char *, __builtin_va_list);
 int __builtin___fprintf_chk(struct _IO_FILE *, int, const char *, ...);
 int __builtin___printf_chk(int, const char *, ...);
-int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, void **);
-int __builtin___vprintf_chk(int, const char *, void **);
+int __builtin___vfprintf_chk(struct _IO_FILE *, int, const char *, __builtin_va_list);
+int __builtin___vprintf_chk(int, const char *, __builtin_va_list);
 void __cyg_profile_func_enter(void *, void *);
 void __cyg_profile_func_exit(void *, void *);
@@ -583 +583 @@
 const char * __builtin_FUNCTION();
 int __builtin_LINE();
-typedef void ** __builtin_va_list;
 extern const char *__PRETTY_FUNCTION__;
-typedef int wchar_t;

src/libcfa/fstream

@@ -7 +7 @@
 // fstream -- 
 //
-// Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:02:01 2016
-// Update Count     : 22
+// Last Modified On : Tue Apr  5 22:37:12 2016
+// Update Count     : 82
 //
 
@@ -19 +19 @@
 #include "iostream"
 
-// implement context ostream
-struct ofstream;
+enum { separateSize = 16 };
+struct ofstream {
+        void *file;
+        _Bool sepDefault;
+        _Bool sepOnOff;
+        char separator[separateSize];
+}; // ofstream
 
-int fail( ofstream * os );
-int flush( ofstream * os );
-void open( ofstream ** os, const char * name, const char * mode );
-void close( ofstream * os );
-ofstream * write( ofstream * os, const char * data, streamsize_type size );
+_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 * );
+int fail( ofstream * );
+int flush( ofstream * );
+void open( ofstream *, const char * name, const char * mode );
+void close( ofstream * );
+ofstream * write( ofstream *, const char * data, unsigned long int size );
+int prtfmt( ofstream *, const char fmt[], ... );
 
 extern ofstream * sout, * serr;
 
 // implement context istream
-struct ifstream;
+struct ifstream {
+        void *file;
+}; // ifstream
 
 int fail( ifstream * is );
 int eof( ifstream * is );
-void open( ifstream ** is, const char * name, const char * mode );
+void open( ifstream * is, const char * name, const char * mode );
 void close( ifstream * is );
-ifstream * get( ifstream * is, int * data );
-ifstream * read( ifstream * is, char * data, streamsize_type size );
+ifstream * read( ifstream * is, char * data, unsigned long int size );
 ifstream * ungetc( ifstream * is, char c );
+int scanfmt( ifstream *, const char fmt[], ... );
 
 extern ifstream *sin;
@@ -49 +66 @@
 // tab-width: 4 //
 // End: //
+

src/libcfa/fstream.c

@@ -7 +7 @@
 // fstream.c -- 
 //
-// Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:03:05 2016
-// Update Count     : 76
+// Last Modified On : Wed Apr  6 17:55:27 2016
+// Update Count     : 176
 //
 
@@ -17 +17 @@
 
 extern "C" {
-#include <stdio.h>
-#include <stdlib.h>
+#include <stdio.h>                                                                              // vfprintf, vfscanf
+#include <stdlib.h>                                                                             // exit
+#include <stdarg.h>                                                                             // varargs
+#include <string.h>                                                                             // strlen
+#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
+#include <complex.h>                                                                    // creal, cimag
 }
 
-struct ofstream {
-        FILE *file;
-};
+#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; }
+void sepSet( ofstream * os, const char * s ) {
+        strncpy( &(os->separator[0]), s, separateSize - 1 );
+        os->separator[separateSize - 1] = '\0';
+} // 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
 
 int fail( ofstream * os ) {
-        return ferror( os->file );
+        return ferror( (FILE *)(os->file) );
 } // fail
 
 int flush( ofstream * os ) {
-        return fflush( os->file );
+        return fflush( (FILE *)(os->file) );
 } // flush
 
-void open( ofstream ** os, const char * name, const char * mode ) {
-        FILE *t = fopen( name, mode );
-        if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open output" );
+void open( ofstream * os, const char * name, const char * mode ) {
+        FILE *file = fopen( name, mode );
+        if ( file == 0 ) {                                                                      // do not change unless successful
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
-        (*os)->file = t;
+        os->file = file;
+        sepOff( os );
+        sepSet( os, " " );
 } // open
 
 void close( ofstream * os ) {
-        if ( os->file == stdout || os->file == stderr ) return;
+        if ( (FILE *)(os->file) == stdout || (FILE *)(os->file) == stderr ) return;
 
-        if ( fclose( os->file ) == EOF ) {
+        if ( fclose( (FILE *)(os->file) ) == EOF ) {
                 perror( IO_MSG "close output" );
         } // if 
 } // close
 
-ofstream * write( ofstream * os, const char * data, streamsize_type size ) {
+ofstream * write( ofstream * os, const char * data, unsigned long int size ) {
         if ( fail( os ) ) {
                 fprintf( stderr, "attempt write I/O on failed stream\n" );
@@ -58 +84 @@
         } // if
 
-        if ( fwrite( data, 1, size, os->file ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os->file) ) != size ) {
                 perror( IO_MSG "write" );
                 exit( EXIT_FAILURE );
@@ -65 +91 @@
 } // write
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
+int prtfmt( ofstream * os, const char fmt[], ... ) {
+    va_list args;
+
+    va_start( args, fmt );
+    int len = vfprintf( (FILE *)(os->file), fmt, args );
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(os->file) ) ) {
+                        fprintf( stderr, "invalid write\n" );
+                        exit( EXIT_FAILURE );
+                } // if
+        } // if
+    va_end( args );
+        return len;
+} // prtfmt
+
+
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
+
 
 //---------------------------------------
 
-struct ifstream {
-        FILE *file;
-};
 
 int fail( ifstream * is ) {
-        return ferror( is->file );
+        return ferror( (FILE *)(is->file) );
 } // fail
 
 int eof( ifstream * is ) {
-        return feof( is->file );
+        return feof( (FILE *)(is->file) );
 } // eof
 
-ifstream * get( ifstream * is, int * data ) {
-        if ( fscanf( is->file, "%d", data ) == EOF ) {
-                if ( ferror( is->file ) ) {
-                        fprintf( stderr, "invalid int read\n" );
-                        exit( EXIT_FAILURE );
-                } // if
+void open( ifstream * is, const char * name, const char * mode ) {
+        FILE *t = fopen( name, mode );
+        if ( t == 0 ) {                                                                         // do not change unless successful
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
+                exit( EXIT_FAILURE );
         } // if
-        return is;
-} // read
+        is->file = t;
+} // open
 
-ifstream * read( ifstream * is, char * data, streamsize_type size ) {
+void close( ifstream * is ) {
+        if ( (FILE *)(is->file) == stdin ) return;
+
+        if ( fclose( (FILE *)(is->file) ) == EOF ) {
+                perror( IO_MSG "close input" );
+        } // if 
+} // close
+
+ifstream * read( ifstream * is, char * data, unsigned long int size ) {
         if ( fail( is ) ) {
                 fprintf( stderr, "attempt read I/O on failed stream\n" );
@@ -100 +148 @@
         } // if
 
-        if ( fread( data, size, 1, is->file ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is->file) ) == 0 ) {
                 perror( IO_MSG "read" );
                 exit( EXIT_FAILURE );
@@ -113 +161 @@
         } // if
 
-        if ( ungetc( c, is->file ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is->file) ) == EOF ) {
                 perror( IO_MSG "ungetc" );
                 exit( EXIT_FAILURE );
@@ -120 +168 @@
 } // ungetc
 
-void open( ifstream ** is, const char * name, const char * mode ) {
-        FILE *t = fopen( name, mode );
-        if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open input" );
-                exit( EXIT_FAILURE );
+int scanfmt( ifstream * is, const char fmt[], ... ) {
+    va_list args;
+
+    va_start( args, fmt );
+    int len = vfscanf( (FILE *)(is->file), fmt, args );
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(is->file) ) ) {
+                        fprintf( stderr, "invalid read\n" );
+                        exit( EXIT_FAILURE );
+                } // if
         } // if
-        (*is)->file = t;
-} // open
+    va_end( args );
+        return len;
+} // prtfmt
 
-void close( ifstream * is ) {
-        if ( is->file == stdin ) return;
-
-        if ( fclose( is->file ) == EOF ) {
-                perror( IO_MSG "close input" );
-        } // if 
-} // close
 
 static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };
@@ -142 +189 @@
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

@@ -7 +7 @@
 // iostream -- 
 //
-// Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:04:24 2016
-// Update Count     : 32
+// Last Modified On : Sun Apr 10 23:00:12 2016
+// Update Count     : 92
 //
 
-#ifndef IOSTREAM_H
-#define IOSTREAM_H
+#ifndef __IOSTREAM_H__
+#define __IOSTREAM_H__
 
 #include "iterator"
 
-typedef unsigned long streamsize_type;
+trait ostream( dtype ostype ) {
+        _Bool sepPrt( ostype * );                                                       // return separator state (on/off)
+        void sepOn( ostype * );                                                         // turn separator state on
+        void sepOff( ostype * );                                                        // turn separator state off
+        void sepReset( ostype * );                                                      // set separator state to default state
+        void sepReset( ostype *, _Bool );                                       // set separator and default state
+        void sepSet( ostype *, const char * );                          // set separator to string (15 character maximum)
+        const char * sepGet( ostype * );                                        // get separator string 
+        _Bool sepDisable( ostype * );                                           // set default state to off, and return previous state
+        _Bool sepEnable( ostype * );                                            // set default state to on, and return previous state
 
-context ostream( dtype ostype ) {
         int fail( ostype * );
         int flush( ostype * );
-        ostype * write( ostype *, const char *, streamsize_type );
+        void open( ostype * os, const char * name, const char * mode );
+        void close( ostype * os );
+        ostype * write( ostype *, const char *, unsigned long int );
+        int prtfmt( ostype *, const char fmt[], ... );
 };
-context writeable( type T ) {
+
+trait writeable( otype T ) {
         forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
 };
@@ -33 +45 @@
 
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, char );
+
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, short int );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned short int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned int );
@@ -39 +54 @@
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long int );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, unsigned long long int );
+
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float ); // FIX ME: should not be required
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double );
+
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, float _Complex );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double _Complex );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, long double _Complex );
+
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
 
-forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) retostype * ?|?( ostype *os, retostype * (* manip)(ostype*) );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, ostype * (*)( ostype * ) );
 forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * );
+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
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write( iterator_type begin, iterator_type end, os_type *os );
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
+forall( otype elt_type | writeable( elt_type ), otype iterator_type | iterator( iterator_type, elt_type ), dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 
 //---------------------------------------
 
-context istream( dtype istype ) {
+trait istream( dtype istype ) {
         int fail( istype * );
         int eof( istype * );
-        istype * get( istype *, int * );
-        istype * read( istype *, char *, streamsize_type );
+        void open( istype * is, const char * name, const char * mode );
+        void close( istype * is );
+        istype * read( istype *, char *, unsigned long int );
         istype * ungetc( istype *, char );
+        int scanfmt( istype *, const char fmt[], ... );
 };
 
-context readable( type T ) {
+trait readable( otype T ) {
         forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
 };
 
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype *, char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * );
 
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype *, int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned short int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long long int * );
 
-#endif // IOSTREAM_H
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double * );
+
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float _Complex * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double _Complex * );
+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_cstrC { char * s; int size; };
+_Istream_cstrC cstr( char *, int size );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrC );
+
+#endif // __IOSTREAM_H__
 
 // Local Variables: //

src/libcfa/iostream.c

@@ -7 +7 @@
 // iostream.c -- 
 //
-// Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 17 14:19:56 2016
-// Update Count     : 76
+// Last Modified On : Wed Apr  6 16:13:29 2016
+// Update Count     : 278
 //
 
@@ -21 +21 @@
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <ctype.h>                                                                              // isspace, ispunct
 }
 
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, char c ) {
-        return write( os, &c, 1 );
+        prtfmt( os, "%c", c );
+        sepOff( os );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, short int si ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%hd", si );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned short int usi ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%hu", usi );
+        return os;
 } // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%d", i ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, unsigned int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%u", i ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, long int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%ld", i ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, long long int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%lld", i ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, unsigned long int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%lu", i ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, unsigned long long int i ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%llu", i ) );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%d", i );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned int ui ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%u", ui );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long int li ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%ld", li );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long int uli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%lu", uli );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long long int lli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%lld", lli );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, unsigned long long int ulli ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%llu", ulli );
+        return os;
 } // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%g", f ) );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%g", f );
+        return os;
 } // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%.*lg", DBL_DIG, d ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, long double d ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%.*Lg", LDBL_DIG, d ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, float _Complex c ) {
-        return os | crealf( c ) | (cimagf( c ) < 0 ? "" : "+") | cimagf( c ) | 'i';
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, double _Complex c ) {
-        return os | creal( c ) | (cimag( c ) < 0 ? "" : "+") | cimag( c ) | 'i';
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, long double _Complex c ) {
-        return os | creall( c ) | (cimagl( c ) < 0 ? "" : "+") | cimagl( c ) | 'i';
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%.*lg", DBL_DIG, d );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, long double ld ) {
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%.*Lg", LDBL_DIG, ld );
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+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
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+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
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+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
+        return os;
+} // ?|?
+
+forall( dtype ostype | ostream( ostype ) )
+ostype * ?|?( ostype *os, const char *cp ) {
+        enum { Open = 1, Close, OpenClose };
+        static const unsigned char mask[256] = {
+                // opening delimiters
+                ['('] : Open, ['['] : Open, ['{'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
+                // closing delimiters
+                [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
+                [')'] : Close, [']'] : Close, ['}'] : Close,
+                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
+                // opening-closing delimiters
+                ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
+                ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
+        }; // mask
+
+        int len = strlen( cp );
+        // 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 ) {
+                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 ) {
+                sepOff( os );
+        } else {
+                sepOn( os );
+        } // if
+        return write( os, cp, len );
 } // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
-        char buffer[32];
-        return write( os, buffer, sprintf( buffer, "%p", p ) );
-} // ?|?
-
-forall( dtype ostype | ostream( ostype ) )
-ostype * ?|?( ostype *os, const char *cp ) {
-        return write( os, cp, strlen( cp ) );
-} // ?|?
-
-
-forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) 
-retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
-  return manip( os );
-}
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
+        sepReset( os );
+        prtfmt( os, "%p", p );
+        return os;
+} // ?|?
+
+
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * ?|?( ostype *os, ostype * (* manip)( ostype * ) ) {
+        return manip( os );
+} // ?|?
 
 forall( dtype ostype | ostream( ostype ) ) 
 ostype * endl( ostype * os ) {
-        os | "\n";
+        os | '\n';
         flush( os );
+        sepOff( os );
         return os;
 } // endl
 
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * sepOn( ostype * os ) {
+        sepOn( os );
+        return os;
+} // sepOn
+
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * sepOff( ostype * os ) {
+        sepOff( os );
+        return os;
+} // 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
+
 //---------------------------------------
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
-                dtype os_type | ostream( os_type ) )
-void write( iterator_type begin, iterator_type end, os_type *os ) {
-        void print( elt_type i ) { os | i | ' '; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write( iteratortype begin, iteratortype end, ostype *os ) {
+        void print( elttype i ) { os | i; }
         for_each( begin, end, print );
 } // ?|?
 
-forall( type elt_type | writeable( elt_type ), type iterator_type | iterator( iterator_type, elt_type ),
-                dtype os_type | ostream( os_type ) )
-void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
-        void print( elt_type i ) { os | i | ' '; }
+forall( otype elttype | writeable( elttype ), otype iteratortype | iterator( iteratortype, elttype ), dtype ostype | ostream( ostype ) )
+void write_reverse( iteratortype begin, iteratortype end, ostype *os ) {
+        void print( elttype i ) { os | i; }
         for_each_reverse( begin, end, print );
 } // ?|?
@@ -140 +247 @@
 
 forall( dtype istype | istream( istype ) )
-istype * ?|?( istype *is, char *cp ) {
-        return read( is, cp, 1 );
-} // ?|?
-
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype *is, int *ip ) {
-        return get( is, ip );
-} // ?|?
+istype * ?|?( istype * is, char * c ) {
+        scanfmt( is, "%c", c );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, short int * si ) {
+        scanfmt( is, "%hd", si );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned short int * usi ) {
+        scanfmt( is, "%hu", usi );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, int * i ) {
+        scanfmt( is, "%d", i );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned int * ui ) {
+        scanfmt( is, "%u", ui );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long int * li ) {
+        scanfmt( is, "%ld", li );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long int * ulli ) {
+        scanfmt( is, "%lu", ulli );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long long int * lli ) {
+        scanfmt( is, "%lld", lli );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long long int * ulli ) {
+        scanfmt( is, "%llu", ulli );
+        return is;
+} // ?|?
+
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float * f ) {
+        scanfmt( is, "%f", f );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double * d ) {
+        scanfmt( is, "%lf", d );
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double * ld ) {
+        scanfmt( is, "%Lf", ld );
+        return is;
+} // ?|?
+
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float _Complex * fc ) {
+        float re, im;
+        scanfmt( is, "%g%gi", &re, &im );
+        *fc = re + im * _Complex_I;
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double _Complex * dc ) {
+        double re, im;
+        scanfmt( is, "%lf%lfi", &re, &im );
+        *dc = re + im * _Complex_I;
+        return is;
+} // ?|?
+
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double _Complex * ldc ) {
+        long double re, im;
+        scanfmt( is, "%Lf%Lfi", &re, &im );
+        *ldc = re + im * _Complex_I;
+        return is;
+} // ?|?
+
+_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 ) {
+        char buf[16];
+        sprintf( buf, "%%%ds", cstr.size );
+        scanfmt( is, buf, cstr.s );
+        return is;
+} // cstr
 
 // Local Variables: //

src/libcfa/iterator

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan 27 23:49:13 2016
-// Update Count     : 7
+// Last Modified On : Wed Mar  2 18:06:05 2016
+// Update Count     : 9
 //
 
@@ -18 +18 @@
 
 // An iterator can be used to traverse a data structure.
-context iterator( type iterator_type, type elt_type ) {
+trait iterator( otype iterator_type, otype elt_type ) {
         // point to the next element
 //      iterator_type ?++( iterator_type * );
@@ -32 +32 @@
 };
 
-context iterator_for( type iterator_type, type collection_type, type elt_type | iterator( iterator_type, elt_type ) ) {
+trait iterator_for( otype iterator_type, otype collection_type, otype elt_type | iterator( iterator_type, elt_type ) ) {
 //      [ iterator_type begin, iterator_type end ] get_iterators( collection_type );
         iterator_type begin( collection_type );
@@ -38 +38 @@
 };
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) );
 

src/libcfa/iterator.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 26 17:16:07 2016
-// Update Count     : 26
+// Last Modified On : Wed Mar  2 18:08:11 2016
+// Update Count     : 27
 //
 
 #include "iterator"
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
         for ( iterator_type i = begin; i != end; ++i ) {
@@ -23 +23 @@
 }
 
-forall( type iterator_type, type elt_type | iterator( iterator_type, elt_type ) )
+forall( otype iterator_type, otype elt_type | iterator( iterator_type, elt_type ) )
 void for_each_reverse( iterator_type begin, iterator_type end, void (*func)( elt_type ) ) {
         for ( iterator_type i = end; i != begin; ) {

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
 
-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 MIN;
+extern const int MIN;
+extern const long int MIN;
+extern const long long int MIN;
 
-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;
+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;
 
 // Floating-Point Constants
 
-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 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 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 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 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 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 _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 _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 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 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 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 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 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 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 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 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 _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 _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 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)
+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: //

src/libcfa/prelude.cf

@@ +1 @@
+# 2 "prelude.cf"  // needed for error messages from this file
 //                               -*- Mode: C -*- 
 // 
@@ -8 +9 @@
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan  4 11:13:26 2016
-// Update Count     : 81
+// Last Modified On : Wed Mar  2 18:03:41 2016
+// Update Count     : 89
 //
 
@@ -63 +64 @@
 long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
 
-forall( type T ) T *                     ?++(                T ** );
-forall( type T ) const T *               ?++( const          T ** );
-forall( type T ) volatile T *            ?++(       volatile T ** );
-forall( type T ) const volatile T *      ?++( const volatile T ** );
-forall( type T ) T *                     ?--(                T ** );
-forall( type T ) const T *               ?--( const          T ** );
-forall( type T ) volatile T *            ?--(       volatile T ** );
-forall( type T ) const volatile T *      ?--( const volatile T ** );
-
-forall( type T ) lvalue T                ?[?](                T *,          ptrdiff_t );
-forall( type T ) const lvalue T          ?[?]( const          T *,          ptrdiff_t );
-forall( type T ) volatile lvalue T       ?[?](       volatile T *,          ptrdiff_t );
-forall( type T ) const volatile lvalue T ?[?]( const volatile T *,          ptrdiff_t );
-forall( type T ) lvalue T                ?[?](          ptrdiff_t,                T * );
-forall( type T ) const lvalue T          ?[?](          ptrdiff_t, const          T * );
-forall( type T ) volatile lvalue T       ?[?](          ptrdiff_t,       volatile T * );
-forall( type T ) const volatile lvalue T ?[?](          ptrdiff_t, const volatile T * );
+forall( otype T ) T *                    ?++(                T ** );
+forall( otype T ) const T *              ?++( const          T ** );
+forall( otype T ) volatile T *           ?++(       volatile T ** );
+forall( otype T ) const volatile T *     ?++( const volatile T ** );
+forall( otype T ) T *                    ?--(                T ** );
+forall( otype T ) const T *              ?--( const          T ** );
+forall( otype T ) volatile T *           ?--(       volatile T ** );
+forall( otype T ) const volatile T *     ?--( const volatile T ** );
+
+forall( otype T ) lvalue T               ?[?](                T *,          ptrdiff_t );
+forall( otype T ) const lvalue T         ?[?]( const          T *,          ptrdiff_t );
+forall( otype T ) volatile lvalue T      ?[?](       volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile lvalue T ?[?]( const volatile T *,         ptrdiff_t );
+forall( otype T ) lvalue T               ?[?](          ptrdiff_t,                T * );
+forall( otype T ) const lvalue T         ?[?](          ptrdiff_t, const          T * );
+forall( otype T ) volatile lvalue T      ?[?](          ptrdiff_t,       volatile T * );
+forall( otype T ) const volatile lvalue T ?[?](         ptrdiff_t, const volatile T * );
 
 // ------------------------------------------------------------
@@ -101 +102 @@
 long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
 
-forall( type T ) T *                     ++?(                T ** );
-forall( type T ) const T *               ++?( const          T ** );
-forall( type T ) volatile T *            ++?(       volatile T ** );
-forall( type T ) const volatile T *      ++?( const volatile T ** );
-forall( type T ) T *                     --?(                T ** );
-forall( type T ) const T *               --?( const          T ** );
-forall( type T ) volatile T *            --?(       volatile T ** );
-forall( type T ) const volatile T *      --?( const volatile T ** );
-
-forall( type T ) lvalue T                *?(                 T * );
-forall( type T ) const lvalue T          *?( const           T * );
-forall( type T ) volatile lvalue T       *?(       volatile  T * );
-forall( type T ) const volatile lvalue T *?( const volatile  T * );
+forall( otype T ) T *                    ++?(                T ** );
+forall( otype T ) const T *              ++?( const          T ** );
+forall( otype T ) volatile T *           ++?(       volatile T ** );
+forall( otype T ) const volatile T *     ++?( const volatile T ** );
+forall( otype T ) T *                    --?(                T ** );
+forall( otype T ) const T *              --?( const          T ** );
+forall( otype T ) volatile T *           --?(       volatile T ** );
+forall( otype T ) const volatile T *     --?( const volatile T ** );
+
+forall( otype T ) lvalue T               *?(                 T * );
+forall( otype T ) const lvalue T                 *?( const           T * );
+forall( otype T ) volatile lvalue T      *?(       volatile  T * );
+forall( otype T ) const volatile lvalue T *?( const volatile  T * );
 forall( ftype FT ) lvalue FT             *?( FT * );
 
@@ -183 +184 @@
 long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
 
-forall( type T ) T *                    ?+?(                T *,          ptrdiff_t );
-forall( type T ) T *                    ?+?(          ptrdiff_t,                T * );
-forall( type T ) const T *              ?+?( const          T *,          ptrdiff_t );
-forall( type T ) const T *              ?+?(          ptrdiff_t, const          T * );
-forall( type T ) volatile T *           ?+?(       volatile T *,          ptrdiff_t );
-forall( type T ) volatile T *           ?+?(          ptrdiff_t,       volatile T * );
-forall( type T ) const volatile T *     ?+?( const volatile T *,          ptrdiff_t );
-forall( type T ) const volatile T *     ?+?(          ptrdiff_t, const volatile T * );
-forall( type T ) T *                    ?-?(                T *,          ptrdiff_t );
-forall( type T ) const T *              ?-?( const          T *,          ptrdiff_t );
-forall( type T ) volatile T *           ?-?(       volatile T *,          ptrdiff_t );
-forall( type T ) const volatile T *     ?-?( const volatile T *,          ptrdiff_t );
-forall( type T ) ptrdiff_t              ?-?( const volatile T *, const volatile T * );
+forall( otype T ) T *                   ?+?(                T *,          ptrdiff_t );
+forall( otype T ) T *                   ?+?(          ptrdiff_t,                T * );
+forall( otype T ) const T *             ?+?( const          T *,          ptrdiff_t );
+forall( otype T ) const T *             ?+?(          ptrdiff_t, const          T * );
+forall( otype T ) volatile T *          ?+?(       volatile T *,          ptrdiff_t );
+forall( otype T ) volatile T *          ?+?(          ptrdiff_t,       volatile T * );
+forall( otype T ) const volatile T *    ?+?( const volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile T *    ?+?(          ptrdiff_t, const volatile T * );
+forall( otype T ) T *                   ?-?(                T *,          ptrdiff_t );
+forall( otype T ) const T *             ?-?( const          T *,          ptrdiff_t );
+forall( otype T ) volatile T *          ?-?(       volatile T *,          ptrdiff_t );
+forall( otype T ) const volatile T *    ?-?( const volatile T *,          ptrdiff_t );
+forall( otype T ) ptrdiff_t             ?-?( const volatile T *, const volatile T * );
 
 // ------------------------------------------------------------
@@ -431 +432 @@
 forall( ftype FT ) FT *                 ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
 
-forall( type T ) T *                    ?+=?(                T *          *, ptrdiff_t );
-forall( type T ) T *                    ?+=?(                T * volatile *, ptrdiff_t );
-forall( type T ) const T *              ?+=?( const          T *          *, ptrdiff_t );
-forall( type T ) const T *              ?+=?( const          T * volatile *, ptrdiff_t );
-forall( type T ) volatile T *           ?+=?(       volatile T *          *, ptrdiff_t );
-forall( type T ) volatile T *           ?+=?(       volatile T * volatile *, ptrdiff_t );
-forall( type T ) const volatile T *     ?+=?( const volatile T *          *, ptrdiff_t );
-forall( type T ) const volatile T *     ?+=?( const volatile T * volatile *, ptrdiff_t );
-forall( type T ) T *                    ?-=?(                T *          *, ptrdiff_t );
-forall( type T ) T *                    ?-=?(                T * volatile *, ptrdiff_t );
-forall( type T ) const T *              ?-=?( const          T *          *, ptrdiff_t );
-forall( type T ) const T *              ?-=?( const          T * volatile *, ptrdiff_t );
-forall( type T ) volatile T *           ?-=?(       volatile T *          *, ptrdiff_t );
-forall( type T ) volatile T *           ?-=?(       volatile T * volatile *, ptrdiff_t );
-forall( type T ) const volatile T *     ?-=?( const volatile T *          *, ptrdiff_t );
-forall( type T ) const volatile T *     ?-=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *                   ?+=?(                T *          *, ptrdiff_t );
+forall( otype T ) T *                   ?+=?(                T * volatile *, ptrdiff_t );
+forall( otype T ) const T *             ?+=?( const          T *          *, ptrdiff_t );
+forall( otype T ) const T *             ?+=?( const          T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *          ?+=?(       volatile T *          *, ptrdiff_t );
+forall( otype T ) volatile T *          ?+=?(       volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?+=?( const volatile T *          *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?+=?( const volatile T * volatile *, ptrdiff_t );
+forall( otype T ) T *                   ?-=?(                T *          *, ptrdiff_t );
+forall( otype T ) T *                   ?-=?(                T * volatile *, ptrdiff_t );
+forall( otype T ) const T *             ?-=?( const          T *          *, ptrdiff_t );
+forall( otype T ) const T *             ?-=?( const          T * volatile *, ptrdiff_t );
+forall( otype T ) volatile T *          ?-=?(       volatile T *          *, ptrdiff_t );
+forall( otype T ) volatile T *          ?-=?(       volatile T * volatile *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?-=?( const volatile T *          *, ptrdiff_t );
+forall( otype T ) const volatile T *    ?-=?( const volatile T * volatile *, ptrdiff_t );
 
 _Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );

src/libcfa/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  5 15:21:18 2016
-// Update Count     : 61
+// Last Modified On : Wed Apr 13 14:45:53 2016
+// Update Count     : 85
 //
 
@@ -20 +20 @@
 } // extern "C"
 
-forall( type T ) T * memset( T * ptr, unsigned char fill ); // use default value '\0' for fill
-forall( type T ) T * memset( T * ptr );                                 // remove when default value available
+//---------------------------------------
 
-forall( type T ) T * malloc( void );
-forall( type T ) T * malloc( char fill );
-forall( type T ) T * malloc( size_t size );
-forall( type T ) T * malloc( T * ptr, size_t size );
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill );
-forall( type T ) T * calloc( size_t size );
-forall( type T ) T * realloc( T * ptr, size_t size );
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill );
+extern "C" {
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE    1                                                               // failing exit status
+#define EXIT_SUCCESS    0                                                               // successful exit status
+#endif // ! EXIT_FAILURE
+void exit( int rc );
+} // extern "C"
 
-forall( type T ) T * aligned_alloc( size_t alignment );
-forall( type T ) T * memalign( size_t alignment );              // deprecated
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment );
+//---------------------------------------
+
+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"
+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"
+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
 
 //---------------------------------------
@@ -66 +86 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension );
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
 
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 );
 
@@ -81 +101 @@
 char abs( char );
 extern "C" {
-int abs( int );         // use default C routine for int
-} // extern
+int abs( int );                                                                                 // use default C routine for int
+} // extern "C"
 long int abs( long int );
 long long int abs( long long int );
@@ -94 +114 @@
 //---------------------------------------
 
-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();
+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 );
 
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+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();
+
+//---------------------------------------
+
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 );
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 );
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 );
 

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 Feb 10 15:45:56 2016
-// Update Count     : 140
+// Last Modified On : Wed Apr 13 14:49:58 2016
+// Update Count     : 155
 //
 
@@ -27 +27 @@
 } // extern "C"
 
-forall( type 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( type T ) T * memset( T * ptr ) {                                // remove when default value available
-        printf( "memset2\n" );
-    return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
-} // memset
-
-forall( type T ) T * malloc( void ) {
-        printf( "malloc1\n" );
+forall( otype T ) T * malloc( void ) {
+        //printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( type T ) T * malloc( size_t size ) {
-        printf( "malloc2\n" );
-    return (T *)(void *)malloc( size );
-} // malloc
-forall( type T ) T * malloc( char fill ) {
-        printf( "malloc3\n" );
+forall( otype T ) T * malloc( char fill ) {
+        //printf( "malloc3\n" );
         T * ptr = (T *)malloc( sizeof(T) );
     return memset( ptr );
 } // malloc
 
-forall( type T ) T * calloc( size_t size ) {
-        printf( "calloc\n" );
-    return (T *)calloc( size, sizeof(T) );
+forall( otype T ) T * calloc( size_t nmemb ) {
+        //printf( "calloc\n" );
+    return (T *)calloc( nmemb, sizeof(T) );
 } // calloc
 
-forall( type T ) T * realloc( T * ptr, size_t size ) {
-        printf( "realloc1\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
+        //printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "realloc2\n" );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
     size_t unused = malloc_usable_size( nptr );
@@ -67 +54 @@
 } // realloc
 
-forall( type T ) T * malloc( T * ptr, size_t size ) {
-        printf( "malloc4\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
+        //printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "malloc5\n" );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+        //printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
-forall( type T ) T * aligned_alloc( size_t alignment ) {
-        printf( "aligned_alloc\n" );
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
+        //printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
-forall( type T ) T * memalign( size_t alignment ) {
-        printf( "memalign\n" );
+forall( otype T ) T * memalign( size_t alignment ) {
+        //printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
-        printf( "posix_memalign\n" );
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
+        //printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
 } // 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
 
 //---------------------------------------
@@ -123 +119 @@
         return ulli;
 }
+
 float ato( const char * ptr ) {
         float f;
@@ -138 +135 @@
         return ld;
 }
+
 float _Complex ato( const char * ptr ) {
         float re, im;
@@ -172 +170 @@
         return strtoull( sptr, eptr, base );
 }
+
 float strto( const char * sptr, char ** eptr ) {
         return strtof( sptr, eptr );
@@ -181 +180 @@
         return strtold( sptr, eptr );
 }
+
 float _Complex strto( const char * sptr, char ** eptr ) {
         float re, im;
@@ -208 +208 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -214 +214 @@
 } // bsearch
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -222 +222 @@
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
 
@@ -239 +239 @@
 //---------------------------------------
 
-void randseed( long int s ) { srand48( s ); }
-char random() { return lrand48(); }
-int random() { return mrand48(); }
-unsigned int random() { return lrand48(); }
-long int random() { return mrand48(); }
-unsigned long int random() { return lrand48(); }
-float random() { return (float)drand48(); }                             // otherwise float uses lrand48
-double random() { return drand48(); }
-float _Complex random() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
-double _Complex random() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
-long double _Complex random() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
-
-//---------------------------------------
-
-forall( type T | { int ?<?( T, T ); } )
+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(); }
+int rand48() { return mrand48(); }
+unsigned int rand48() { return lrand48(); }
+long int rand48() { return mrand48(); }
+unsigned long int rand48() { return lrand48(); }
+float rand48() { return (float)drand48(); }                             // otherwise float uses lrand48
+double rand48() { return drand48(); }
+float _Complex rand48() { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex rand48() { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex rand48() { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+
+//---------------------------------------
+
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 ) {
         return t1 < t2 ? t1 : t2;
 } // min
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 ) {
         return t1 > t2 ? t1 : t2;
 } // max
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 ) {
         T temp = *t1;