Changeset 1048b31 for src/libcfa

Timestamp:

May 2, 2016, 3:28:16 PM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

1b7ea43

Parents:

1f6e009 (diff), e945826 (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 global-init

Location:

src/libcfa

Files:

• Makefile.am (modified) (2 diffs)
• Makefile.in (modified) (3 diffs)
• fstream (modified) (3 diffs)
• fstream.c (modified) (8 diffs)
• iostream (modified) (4 diffs)
• iostream.c (modified) (20 diffs)
• limits (modified) (1 diff)
• limits.c (added)
• math (added)
• math.c (added)
• rational (added)
• rational.c (added)
• stdlib (modified) (5 diffs)
• stdlib.c (modified) (7 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 Mar  2 22:59:23 2016
-## Update Count     : 119
+## Last Modified On : Tue Apr 19 22:30:17 2016
+## Update Count     : 124
 ###############################################################################
 
@@ -60 +60 @@
         ${CC} ${CFLAGS} -c -o $@ $<
 
-libs = stdlib iostream fstream iterator
+libs = limits stdlib math iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
 
-cheaders = #  expat
-cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 

src/libcfa/Makefile.in

@@ -83 +83 @@
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
-am__objects_1 = stdlib.$(OBJEXT) iostream.$(OBJEXT) fstream.$(OBJEXT) \
-        iterator.$(OBJEXT)
+am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) math.$(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 +214 @@
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} \
         ${addprefix ${libdir}/,${lib_LIBRARIES}} ${includedir}/*
-libs = stdlib iostream fstream iterator
+libs = limits stdlib math iostream fstream iterator rational
 libcfa_a_SOURCES = libcfa-prelude.c ${libs:=.c}
-cheaders = #  expat
-cfaheaders = limits
+cheaders = # expat
+cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
 all: all-am
@@ -297 +298 @@
 @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)/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 : Wed Mar  2 15:08:14 2016
-// Update Count     : 78
+// Last Modified On : Thu Apr 28 08:08:04 2016
+// Update Count     : 88
 //
 
@@ -20 +20 @@
 
 enum { separateSize = 16 };
-struct ofstream { void *file; int separate; char separator[separateSize]; };
+struct ofstream {
+        void *file;
+        _Bool sepDefault;
+        int sepOnOff;                                                                           // FIX ME: type should be _Bool
+        char separator[separateSize];
+}; // ofstream
 
 _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 * );
-void sepDisable( ofstream * );
-void sepEnable( ofstream * );
+_Bool sepDisable( ofstream * );
+_Bool sepEnable( ofstream * );
 int fail( ofstream * );
 int flush( ofstream * );
@@ -39 +46 @@
 
 // implement context istream
-struct ifstream { void *file; };
+struct ifstream {
+        void *file;
+}; // ifstream
 
 int fail( ifstream * is );

src/libcfa/fstream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb 29 18:41:10 2016
-// Update Count     : 162
+// Last Modified On : Wed Apr 27 18:20:30 2016
+// Update Count     : 187
 //
 
@@ -25 +25 @@
 }
 
-#define IO_MSG "I/O error "
+#define IO_MSG "I/O error: "
 
-_Bool sepPrt( ofstream * os ) { return os->separate == 1; }
-void sepOn( ofstream * os ) { if ( os->separate != 2 ) os->separate = 1; }
-void sepOff( ofstream * os ) { if ( os->separate != 2 ) os->separate = 0; }
+_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 );
@@ -35 +37 @@
 } // sepSet
 const char * sepGet( ofstream * os ) { return &(os->separator[0]); }
-void sepDisable( ofstream *os ) { os->separate = 2; }
-void sepEnable( ofstream *os ) { os->separate = 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 ) {
@@ -49 +61 @@
         FILE *file = fopen( name, mode );
         if ( file == 0 ) {                                                                      // do not change unless successful
-                perror( IO_MSG "open output" );
+                fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
@@ -80 +93 @@
 int prtfmt( ofstream * os, const char fmt[], ... ) {
     va_list args;
-
     va_start( args, fmt );
     int len = vfprintf( (FILE *)(os->file), fmt, args );
@@ -90 +102 @@
         } // if
     va_end( args );
+
+        sepReset( os );                                                                         // reset separator
         return len;
 } // prtfmt
 
 
-static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 0, { ' ', '\0' } };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, { ' ', '\0' } };
 ofstream *sout = &soutFile;
-static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 0, { ' ', '\0' } };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, { ' ', '\0' } };
 ofstream *serr = &serrFile;
 
@@ -114 +128 @@
         FILE *t = fopen( name, mode );
         if ( t == 0 ) {                                                                         // do not change unless successful
-                perror( IO_MSG "open input" );
+                fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
+                perror( 0 );
                 exit( EXIT_FAILURE );
         } // if
@@ -175 +190 @@
 // Local Variables: //
 // tab-width: 4 //
-// compile-command: "cfa fstream.c" //
 // End: //

src/libcfa/iostream

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 18:05:27 2016
-// Update Count     : 85
+// Last Modified On : Sun Apr 10 23:00:12 2016
+// Update Count     : 92
 //
 
@@ -20 +20 @@
 
 trait ostream( dtype ostype ) {
-        _Bool sepPrt( ostype * );
-        void sepOn( ostype * );
-        void sepOff( ostype * );
-        void sepSet( ostype *, const char * );
-        const char * sepGet( ostype * );
-        void sepDisable( ostype * );
-        void sepEnable( 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
+
         int fail( ostype * );
         int flush( ostype * );
@@ -67 +70 @@
 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
@@ -110 +115 @@
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
 
-struct _Istream_str1 { char * s; };
-_Istream_str1 str( char * );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str1 );
+struct _Istream_cstrUC { char * s; };
+_Istream_cstrUC cstr( char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_cstrUC );
 
-struct _Istream_str2 { char * s; int size; };
-_Istream_str2 str( char *, int size );
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, _Istream_str2 );
+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__

src/libcfa/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  7 13:51:23 2016
-// Update Count     : 227
+// Last Modified On : Sat Apr 30 14:00:53 2016
+// Update Count     : 302
 //
 
@@ -27 +27 @@
 ostype * ?|?( ostype *os, char c ) {
         prtfmt( os, "%c", c );
+        sepOff( os );
         return os;
 } // ?|?
@@ -32 +33 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, short int si ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%hd", si );
         return os;
@@ -39 +40 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned short int usi ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%hu", usi );
         return os;
@@ -46 +47 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, int i ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%d", i );
         return os;
@@ -53 +54 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned int ui ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%u", ui );
         return os;
@@ -60 +61 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long int li ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%ld", li );
         return os;
@@ -67 +68 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long int uli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%lu", uli );
         return os;
@@ -74 +75 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long long int lli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%lld", lli );
         return os;
@@ -81 +82 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, unsigned long long int ulli ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%llu", ulli );
         return os;
@@ -88 +89 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, float f ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%g", f );
         return os;
@@ -95 +96 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, double d ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%.*lg", DBL_DIG, d );
         return os;
@@ -102 +103 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, long double ld ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%.*Lg", LDBL_DIG, ld );
         return os;
@@ -110 +111 @@
 ostype * ?|?( ostype *os, float _Complex fc ) {
         os | crealf( fc );
-        if ( cimagf( fc ) >= 0 ) os | '+';
-        os | "" | cimagf( fc ) | 'i';
+        _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;
 } // ?|?
@@ -118 +121 @@
 ostype * ?|?( ostype *os, double _Complex dc ) {
         os | creal( dc );
-        if ( cimag( dc ) >= 0 ) os | '+';
-        os | "" | cimag( dc ) | 'i';
+        _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;
 } // ?|?
@@ -126 +131 @@
 ostype * ?|?( ostype *os, long double _Complex ldc ) {
         os | creall( ldc );
-        if ( cimagl( ldc ) >= 0 ) os | '+';
-        os | "" | cimagl( ldc ) | 'i';
+        _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;
 } // ?|?
@@ -134 +141 @@
 ostype * ?|?( ostype *os, const char *cp ) {
         enum { Open = 1, Close, OpenClose };
-        static const char mask[256] = {
+        static const unsigned char mask[256] = {
                 // opening delimiters
                 ['('] : Open, ['['] : Open, ['{'] : Open,
-                ['$'] : Open, [L'£'] : Open, [L'¥'] : Open, [L'¢'] : Open, [L'¿'] : Open, [L'«'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : 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, [L'»'] : Close,
+                ['%'] : Close, [(unsigned char)'¢'] : Close, [(unsigned char)'»'] : Close,
                 // opening-closing delimiters
                 ['\''] : OpenClose, ['`'] : 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 NOT spacing or closing punctuation => add left separator
-        if ( sepPrt( os ) && isspace( cp[0] ) == 0 && mask[ cp[0] ] != Close && mask[ cp[0] ] != OpenClose ) {
+  if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
+
+        // 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
+
+        // if string starts line, must reset to determine open state because separator is off
+        sepReset( os );                                                                         // reset separator
+
         // last character IS spacing or opening punctuation => turn off separator for next item
-        unsigned int posn = len - 1;
-        if ( isspace( cp[posn] ) || mask[ cp[posn] ] == Open || mask[ cp[posn] ] == OpenClose ) {
+        unsigned int len = strlen( cp ), posn = len - 1;
+        ch = cp[posn];                                                                          // must make unsigned
+        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                sepOn( os );
+        } else {
                 sepOff( os );
-        } else {
-                sepOn( os );
         } // if
         return write( os, cp, len );
@@ -165 +179 @@
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, const void *p ) {
-        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) ); else sepOn( os );
+        if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
         prtfmt( os, "%p", p );
         return os;
 } // ?|?
-
 
 forall( dtype ostype | ostream( ostype ) ) 
@@ -196 +209 @@
 } // 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
+
 //---------------------------------------
 
@@ -310 +335 @@
 } // ?|?
 
-_Istream_str1 str( char * s ) { _Istream_str1 s = { s }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_str1 str ) {
-        scanfmt( is, "%s", str.s );
-        return is;
-} // str
-
-_Istream_str2 str( char * s, int size ) { _Istream_str2 s = { s, size }; return s; }
-forall( dtype istype | istream( istype ) )
-istype * ?|?( istype * is, _Istream_str2 str ) {
+_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", str.size );
-        scanfmt( is, buf, str.s );
-        return is;
-} // str
+        sprintf( buf, "%%%ds", cstr.size );
+        scanfmt( is, buf, cstr.s );
+        return is;
+} // cstr
 
 // Local Variables: //

src/libcfa/limits

@@ +1 @@
+// 
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// 
+// limits -- 
+// 
+// Author           : Peter A. Buhr
+// Created On       : Wed Apr  6 18:06:52 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Apr  6 21:08:16 2016
+// Update Count     : 6
+// 
+
 // Integral Constants
 
-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/stdlib

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 22 22:34:24 2016
-// Update Count     : 69
+// Last Modified On : Wed Apr 27 22:03:29 2016
+// Update Count     : 96
 //
 
@@ -20 +20 @@
 } // extern "C"
 
+//---------------------------------------
+
+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 );
+void abort( void );
+} // extern "C"
+
+//---------------------------------------
+
+extern "C" { void * malloc( size_t ); }                                 // use default C routine for void *
 forall( otype T ) T * malloc( void );
 forall( otype T ) T * malloc( char fill );
 forall( otype T ) T * malloc( T * ptr, size_t size );
 forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
-forall( otype T ) T * calloc( size_t size );
+extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
+forall( otype T ) T * calloc( size_t nmemb );
+extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
 forall( otype T ) T * realloc( T * ptr, size_t size );
 forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
@@ -32 +48 @@
 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
+extern "C" {
+void * memset( void * ptr, int fill, size_t size );
+void free( void * ptr );
+} // extern "C"
 
 //---------------------------------------
@@ -79 +97 @@
 
 char abs( char );
-extern "C" {
-int abs( int );         // use default C routine for int
-} // extern
+extern "C" { int abs( int ); }                                                  // use default C routine for int
 long int abs( long int );
 long long int abs( long long int );
@@ -87 +103 @@
 double abs( double );
 long double abs( long double );
-float _Complex abs( float _Complex );
-double _Complex abs( double _Complex );
-long double _Complex abs( long double _Complex );
+float abs( float _Complex );
+double abs( double _Complex );
+long double abs( long double _Complex );
 
 //---------------------------------------

src/libcfa/stdlib.c

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 23 13:26:42 2016
-// Update Count     : 146
+// Last Modified On : Thu Apr 28 07:54:21 2016
+// Update Count     : 166
 //
 
@@ -24 +24 @@
 #include <malloc.h>                                                                             // malloc_usable_size
 #include <math.h>                                                                               // fabsf, fabs, fabsl
-#include <complex.h>                                                                    // _Complex_I, cabsf, cabs, cabsl
+#include <complex.h>                                                                    // _Complex_I
 } // extern "C"
 
 forall( otype T ) T * malloc( void ) {
-        printf( "malloc1\n" );
+        //printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( otype T ) T * malloc( size_t size ) {
-        printf( "malloc2\n" );
-    return (T *)(void *)malloc( size );
-} // malloc
 forall( otype T ) T * malloc( char fill ) {
-        printf( "malloc3\n" );
+        //printf( "malloc3\n" );
         T * ptr = (T *)malloc( sizeof(T) );
-    return memset( ptr );
-} // malloc
-
-forall( otype T ) T * calloc( size_t size ) {
-        printf( "calloc\n" );
-    return (T *)calloc( size, sizeof(T) );
+    return memset( ptr, (int)fill, sizeof(T) );
+} // malloc
+
+forall( otype T ) T * calloc( size_t nmemb ) {
+        //printf( "calloc\n" );
+    return (T *)calloc( nmemb, sizeof(T) );
 } // calloc
 
 forall( otype T ) T * realloc( T * ptr, size_t size ) {
-        printf( "realloc1\n" );
+        //printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
 forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "realloc2\n" );
+        //printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
     size_t unused = malloc_usable_size( nptr );
@@ -59 +55 @@
 
 forall( otype T ) T * malloc( T * ptr, size_t size ) {
-        printf( "malloc4\n" );
+        //printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
 forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
-        printf( "malloc5\n" );
+        //printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
 forall( otype T ) T * aligned_alloc( size_t alignment ) {
-        printf( "aligned_alloc\n" );
+        //printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
 forall( otype T ) T * memalign( size_t alignment ) {
-        printf( "memalign\n" );
+        //printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
 forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
-        printf( "posix_memalign\n" );
+        //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
-
 //---------------------------------------
 
 int ato( const char * ptr ) {
         int i;
-        if ( sscanf( ptr, "%d", &i ) == EOF ) {}                        // check return code
+        if ( sscanf( ptr, "%d", &i ) == EOF ) {}
         return i;
 }
 unsigned int ato( const char * ptr ) {
         unsigned int ui;
-        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}                       // check return code
+        if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
         return ui;
 }
 long int ato( const char * ptr ) {
         long int li;
-        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}                      // check return code
+        if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
         return li;
 }
 unsigned long int ato( const char * ptr ) {
         unsigned long int uli;
-        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}                     // check return code
+        if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
         return uli;
 }
 long long int ato( const char * ptr ) {
         long long int lli;
-        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}            // check return code
+        if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
         return lli;
 }
 unsigned long long int ato( const char * ptr ) {
         unsigned long long int ulli;
-        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}           // check return code
+        if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
         return ulli;
 }
@@ -126 +113 @@
 float ato( const char * ptr ) {
         float f;
-        if ( sscanf( ptr, "%f", &f ) == EOF ) {}                        // check return code
+        if ( sscanf( ptr, "%f", &f ) == EOF ) {}
         return f;
 }
 double ato( const char * ptr ) {
         double d;
-        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}                       // check return code
+        if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
         return d;
 }
 long double ato( const char * ptr ) {
         long double ld;
-        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}                      // check return code
+        if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
         return ld;
 }
@@ -142 +129 @@
 float _Complex ato( const char * ptr ) {
         float re, im;
-        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}       // check return code
+        if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
         return re + im * _Complex_I;
 }
 double _Complex ato( const char * ptr ) {
         double re, im;
-        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {} // check return code
+        if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
         return re + im * _Complex_I;
 }
 long double _Complex ato( const char * ptr ) {
         long double re, im;
-        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}     // check return code
+        if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
         return re + im * _Complex_I;
 }       
@@ -226 +213 @@
 //---------------------------------------
 
-forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
-[ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
+// forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
+// [ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
 
 //---------------------------------------
@@ -234 +221 @@
 long int abs( long int v ) { return labs( v ); }
 long long int abs( long long int v ) { return llabs( v ); }
-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 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 ); }
 
 //---------------------------------------