Changeset 3b56166 for libcfa/src

libcfa/src/Makefile.am

r807a632	r3b56166
33	33	# The built sources must not depend on the installed headers
34	34	AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
35		AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
	35	AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
36	36	AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
37	37	CFACC = @CFACC@

libcfa/src/Makefile.in

-              r807a632
+              r3b56166
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
+AM_V_RUST = $(am__v_RUST_@AM_V@)
+am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
+am__v_RUST_0 = @echo "  RUST     " $@;
+am__v_RUST_1 =
+AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
+am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
+am__v_NODEJS_0 = @echo "  NODEJS     " $@;
+am__v_NODEJS_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
 lib_LTLIBRARIES = libcfa.la libcfathread.la
 gdbwaittarget = ""
 …
 # The built sources must not depend on the installed headers
 AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
+AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
 @BUILDLIB_FALSE@headers_nosrc =

libcfa/src/assert.cfa

-              r807a632
+              r3b56166
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 20 15:10:26 2017
 // Update Count     : 2
+// Last Modified On : Tue Feb  4 13:00:18 2020
+// Update Count     : 6
 //
 …
 #include <stdarg.h>                                                             // varargs
 #include <stdio.h>                                                              // fprintf
+#include <unistd.h>                                                             // STDERR_FILENO
 #include "bits/debug.hfa"
 …
         // called by macro assert in assert.h
         void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
                 __cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
+        void __assert_fail( const char assertion[], const char file[], unsigned int line, const char function[] ) {
+                __cfaabi_bits_print_safe( STDERR_FILENO, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
                 abort();
+        }
         // called by macro assertf
         void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
                 __cfaabi_dbg_bits_acquire();
                 __cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
+        void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) {
+                __cfaabi_bits_acquire();
+                __cfaabi_bits_print_nolock( STDERR_FILENO, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
                 va_list args;
                 va_start( args, fmt );
                 __cfaabi_dbg_bits_print_vararg( fmt, args );
+                __cfaabi_bits_print_vararg( STDERR_FILENO, fmt, args );
                 va_end( args );
                 __cfaabi_dbg_bits_print_nolock( "\n" );
                 __cfaabi_dbg_bits_release();
+                __cfaabi_bits_print_nolock( STDERR_FILENO, "\n" );
+                __cfaabi_bits_release();
                 abort();
+        }

libcfa/src/bits/align.hfa

-              r807a632
+              r3b56166
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 23:05:35 2017
 // Update Count     : 2
+// Last Modified On : Sat Nov 16 18:58:22 2019
+// Update Count     : 3
 //
 // This  library is free  software; you  can redistribute  it and/or  modify it
 …
 // Minimum size used to align memory boundaries for memory allocations.
+#define libAlign() (sizeof(double))
+//#define libAlign() (sizeof(double))
+// gcc-7 uses xmms instructions, which require 16 byte alignment.
+#define libAlign() (16)
 // Check for power of 2

libcfa/src/bits/containers.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Oct 31 16:38:50 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun 26 08:52:20 2019
 // Update Count     : 4
+// Last Modified On : Wed Jan 15 07:42:35 2020
+// Update Count     : 28
 #pragma once
 …
         forall(dtype T | sized(T))
         static inline T& ?[?]( __small_array(T) & this, __lock_size_t idx) {
+        static inline T & ?[?]( __small_array(T) & this, __lock_size_t idx ) {
                 return ((typeof(this.data))this.data)[idx];
+        }
         forall(dtype T | sized(T))
         static inline T& ?[?]( const __small_array(T) & this, __lock_size_t idx) {
+        static inline T & ?[?]( const __small_array(T) & this, __lock_size_t idx ) {
                 return ((typeof(this.data))this.data)[idx];
+        }
+        forall(dtype T)
+        static inline T * begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
         forall(dtype T | sized(T))
+        static inline T* begin( const __small_array(T) & this ) {
+                return ((typeof(this.data))this.data);
+        }
+        forall(dtype T | sized(T))
+        static inline T* end( const __small_array(T) & this ) {
+        static inline T * end( const __small_array(T) & this ) {
                 return ((typeof(this.data))this.data) + this.size;
+        }
 …
 #ifdef __cforall
         trait is_node(dtype T) {
                 T*& get_next( T& );
+                T *& get_next( T & );
         };
 #endif
 …
         forall(dtype T)
         static inline void ?{}( __stack(T) & this ) {
+                (this.top){ NULL };
+        }
+        forall(dtype T | is_node(T) | sized(T))
+        static inline void push( __stack(T) & this, T * val ) {
+                verify( !get_next( *val ) );
+                get_next( *val ) = this.top;
+                this.top = val;
+        }
+        forall(dtype T | is_node(T) | sized(T))
+        static inline T * pop( __stack(T) & this ) {
+                T * top = this.top;
+                if( top ) {
+                        this.top = get_next( *top );
+                        get_next( *top ) = NULL;
+                }
+                return top;
+        }
+        forall(dtype T | is_node(T))
+        static inline int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
+                return this.top != 0;
+                (this.top){ 0p };
+        }
+        static inline forall( dtype T | is_node(T) ) {
+                void push( __stack(T) & this, T * val ) {
+                        verify( !get_next( *val ) );
+                        get_next( *val ) = this.top;
+                        this.top = val;
+                }
+                T * pop( __stack(T) & this ) {
+                        T * top = this.top;
+                        if( top ) {
+                                this.top = get_next( *top );
+                                get_next( *top ) = 0p;
+                        }
+                        return top;
+                }
+                int ?!=?( const __stack(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.top != 0;
+                }
+        }
 #endif
 …
 #ifdef __cforall
+        forall(dtype T)
+        static inline void ?{}( __queue(T) & this ) with( this ) {
+                head{ NULL };
+                tail{ &head };
+        }
+        forall(dtype T | is_node(T) | sized(T))
+        static inline void append( __queue(T) & this, T * val ) with( this ) {
+                verify(tail != NULL);
+                *tail = val;
+                tail = &get_next( *val );
+        }
+        forall(dtype T | is_node(T) | sized(T))
+        static inline T * pop_head( __queue(T) & this ) {
+                T * head = this.head;
+                if( head ) {
+                        this.head = get_next( *head );
+                        if( !get_next( *head ) ) {
+                                this.tail = &this.head;
+                        }
+                        get_next( *head ) = NULL;
+                }
+                return head;
+        }
+        forall(dtype T | is_node(T) | sized(T))
+        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
+                T * val = *it;
+                verify( val );
+                (*it) = get_next( *val );
+                if( tail == &get_next( *val ) ) {
+                        tail = it;
+                }
+                get_next( *val ) = NULL;
+                verify( (head == NULL) == (&head == tail) );
+                verify( *tail == NULL );
+                return val;
+        }
+        forall(dtype T | is_node(T))
+        static inline int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
+                return this.head != 0;
+        static inline forall( dtype T | is_node(T) ) {
+                void ?{}( __queue(T) & this ) with( this ) {
+                        head{ 0p };
+                        tail{ &head };
+                }
+                void append( __queue(T) & this, T * val ) with( this ) {
+                        verify(tail != 0p);
+                        *tail = val;
+                        tail = &get_next( *val );
+                }
+                T * pop_head( __queue(T) & this ) {
+                        T * head = this.head;
+                        if( head ) {
+                                this.head = get_next( *head );
+                                if( !get_next( *head ) ) {
+                                        this.tail = &this.head;
+                                }
+                                get_next( *head ) = 0p;
+                        }
+                        return head;
+                }
+                T * remove( __queue(T) & this, T ** it ) with( this ) {
+                        T * val = *it;
+                        verify( val );
+                        (*it) = get_next( *val );
+                        if( tail == &get_next( *val ) ) {
+                                tail = it;
+                        }
+                        get_next( *val ) = 0p;
+                        verify( (head == 0p) == (&head == tail) );
+                        verify( *tail == 0p );
+                        return val;
+                }
+                int ?!=?( const __queue(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.head != 0;
+                }
+        }
 #endif
 …
 #ifdef __cforall
+        forall(dtype T | sized(T))
+        forall(dtype T )
         static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
                 this.head{ NULL };
+                this.head{ 0p };
                 this.__get = __get;
+        }
 …
         #define next 0
         #define prev 1
+        forall(dtype T | sized(T))
+        static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
+                if ( head ) {
+                        __get( node ).next = head;
+                        __get( node ).prev = __get( *head ).prev;
+                        // inserted node must be consistent before it is seen
+        static inline forall(dtype T) {
+                void push_front( __dllist(T) & this, T & node ) with( this ) {
+                        verify(__get);
+                        if ( head ) {
+                                __get( node ).next = head;
+                                __get( node ).prev = __get( *head ).prev;
+                                // inserted node must be consistent before it is seen
+                                // prevent code movement across barrier
+                                asm( "" : : : "memory" );
+                                __get( *head ).prev = &node;
+                                T & _prev = *__get( node ).prev;
+                                __get( _prev ).next = &node;
+                        } else {
+                                __get( node ).next = &node;
+                                __get( node ).prev = &node;
+                        }
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
+                        __get( *head ).prev = &node;
+                        T & _prev = *__get( node ).prev;
+                        __get( _prev ).next = &node;
+                }
+                else {
+                        __get( node ).next = &node;
+                        __get( node ).prev = &node;
+                }
+                // prevent code movement across barrier
+                asm( "" : : : "memory" );
+                head = &node;
+        }
+        forall(dtype T | sized(T))
+        static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
+                if ( &node == head ) {
+                        if ( __get( *head ).next == head ) {
+                                head = NULL;
+                        }
+                        else {
+                                head = __get( *head ).next;
+                        }
+                }
+                __get( *__get( node ).next ).prev = __get( node ).prev;
+                __get( *__get( node ).prev ).next = __get( node ).next;
+                __get( node ).next = NULL;
+                __get( node ).prev = NULL;
+        }
+        forall(dtype T | sized(T))
+        static inline int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
+                return this.head != 0;
+                        head = &node;
+                }
+                void remove( __dllist(T) & this, T & node ) with( this ) {
+                        verify(__get);
+                        if ( &node == head ) {
+                                if ( __get( *head ).next == head ) {
+                                        head = 0p;
+                                } else {
+                                        head = __get( *head ).next;
+                                }
+                        }
+                        __get( *__get( node ).next ).prev = __get( node ).prev;
+                        __get( *__get( node ).prev ).next = __get( node ).next;
+                        __get( node ).next = 0p;
+                        __get( node ).prev = 0p;
+                }
+                int ?!=?( const __dllist(T) & this, __attribute__((unused)) zero_t zero ) {
+                        return this.head != 0;
+                }
+        }
         #undef next
 …
 #endif
+// Local Variables: //
+// tab-width: 4 //
+// End: //

libcfa/src/bits/debug.cfa

-              r807a632
+              r3b56166
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 14 22:17:35 2019
 // Update Count     : 4
+// Last Modified On : Tue Feb  4 13:03:16 2020
+// Update Count     : 11
 //
 …
 extern "C" {
+        void __cfaabi_dbg_bits_write( const char *in_buffer, int len ) {
+        void __cfaabi_bits_write( int fd, const char in_buffer[], int len ) {
                 // ensure all data is written
                 for ( int count = 0, retcode; count < len; count += retcode ) {
 …
                         for ( ;; ) {
                                 retcode = write( STDERR_FILENO, in_buffer, len - count );
+                                retcode = write( fd, in_buffer, len - count );
                                 // not a timer interrupt ?
 …
+        }
         void __cfaabi_dbg_bits_acquire() __attribute__((__weak__)) {}
         void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {}
+        void __cfaabi_bits_acquire() __attribute__((__weak__)) {}
+        void __cfaabi_bits_release() __attribute__((__weak__)) {}
         void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
+        void __cfaabi_bits_print_safe  ( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) )) {
                 va_list args;
                 va_start( args, fmt );
                 __cfaabi_dbg_bits_acquire();
+                __cfaabi_bits_acquire();
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_dbg_bits_write( buffer, len );
+                __cfaabi_bits_write( fd, buffer, len );
                 __cfaabi_dbg_bits_release();
+                __cfaabi_bits_release();
                 va_end( args );
+        }
         void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
+        void __cfaabi_bits_print_nolock( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) )) {
                 va_list args;
 …
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_dbg_bits_write( buffer, len );
+                __cfaabi_bits_write( fd, buffer, len );
                 va_end( args );
+        }
         void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list args ) {
+        void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list args ) {
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_dbg_bits_write( buffer, len );
+                __cfaabi_bits_write( fd, buffer, len );
+        }
         void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) )) {
+        void __cfaabi_bits_print_buffer( int fd, char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) )) {
                 va_list args;
 …
                 int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
                 __cfaabi_dbg_bits_write( in_buffer, len );
+                __cfaabi_bits_write( fd, in_buffer, len );
                 va_end( args );

libcfa/src/bits/debug.hfa

-              r807a632
+              r3b56166
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  8 12:35:19 2018
 // Update Count     : 2
+// Last Modified On : Tue Feb  4 12:29:21 2020
+// Update Count     : 9
 //
 …
         #define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx_param const char * caller
         #define __cfaabi_dbg_ctx_param2 , const char * caller
+        #define __cfaabi_dbg_ctx_param const char caller[]
+        #define __cfaabi_dbg_ctx_param2 , const char caller[]
 #else
         #define __cfaabi_dbg_debug_do(...)
 …
         #include <stdio.h>
       extern void __cfaabi_dbg_bits_write( const char *buffer, int len );
       extern void __cfaabi_dbg_bits_acquire();
       extern void __cfaabi_dbg_bits_release();
       extern void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
       extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
       extern void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list arg );
       extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) ));
+        extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
+        extern void __cfaabi_bits_acquire();
+        extern void __cfaabi_bits_release();
+        extern void __cfaabi_bits_print_safe  ( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) ));
+        extern void __cfaabi_bits_print_nolock( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) ));
+        extern void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list arg );
+        extern void __cfaabi_bits_print_buffer( int fd, char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) ));
 #ifdef __cforall
+}
 …
 #ifdef __CFA_DEBUG_PRINT__
         #define __cfaabi_dbg_write( buffer, len )         __cfaabi_dbg_bits_write( buffer, len )
         #define __cfaabi_dbg_acquire()                    __cfaabi_dbg_bits_acquire()
         #define __cfaabi_dbg_release()                    __cfaabi_dbg_bits_release()
         #define __cfaabi_dbg_print_safe(...)              __cfaabi_dbg_bits_print_safe   (__VA_ARGS__)
         #define __cfaabi_dbg_print_nolock(...)            __cfaabi_dbg_bits_print_nolock (__VA_ARGS__)
         #define __cfaabi_dbg_print_buffer(...)            __cfaabi_dbg_bits_print_buffer (__VA_ARGS__)
         #define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
         #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
+        #define __cfaabi_dbg_write( buffer, len )         __cfaabi_bits_write( STDERR_FILENO, buffer, len )
+        #define __cfaabi_dbg_acquire()                    __cfaabi_bits_acquire()
+        #define __cfaabi_dbg_release()                    __cfaabi_bits_release()
+        #define __cfaabi_dbg_print_safe(...)              __cfaabi_bits_print_safe   (__VA_ARGS__)
+        #define __cfaabi_dbg_print_nolock(...)            __cfaabi_bits_print_nolock (__VA_ARGS__)
+        #define __cfaabi_dbg_print_buffer(...)            __cfaabi_bits_print_buffer (__VA_ARGS__)
+        #define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len );
+        #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_write( __dbg_text, __dbg_len );
 #else
         #define __cfaabi_dbg_write(...)               ((void)0)

libcfa/src/bits/defs.hfa

-              r807a632
+              r3b56166
 // Created On       : Thu Nov  9 13:24:10 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  8 16:22:41 2018
 // Update Count     : 8
+// Last Modified On : Tue Jan 28 22:38:27 2020
+// Update Count     : 9
 //
 …
 #ifdef __cforall
+void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 extern "C" {
 #endif
 …
 #define OPTIONAL_THREAD __attribute__((weak))
 #endif
+static inline long long rdtscl(void) {
+    unsigned int lo, hi;
+    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+}

libcfa/src/bits/locks.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Oct 31 15:14:38 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 11 15:42:24 2018
 // Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:19 2020
+// Update Count     : 11
 //
 …
                 #ifdef __CFA_DEBUG__
                         void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name);
+                        void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
                 #else
                         #define __cfaabi_dbg_record(x, y)

libcfa/src/bits/signal.hfa

-              r807a632
+              r3b56166
         act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
+        sigemptyset( &act.sa_mask );
+        sigaddset( &act.sa_mask, SIGALRM );             // disabled during signal handler
+        sigaddset( &act.sa_mask, SIGUSR1 );
+        sigaddset( &act.sa_mask, SIGSEGV );
+        sigaddset( &act.sa_mask, SIGBUS );
+        sigaddset( &act.sa_mask, SIGILL );
+        sigaddset( &act.sa_mask, SIGFPE );
+        sigaddset( &act.sa_mask, SIGHUP );              // revert to default on second delivery
+        sigaddset( &act.sa_mask, SIGTERM );
+        sigaddset( &act.sa_mask, SIGINT );
         act.sa_flags = flags;
         if ( sigaction( sig, &act, NULL ) == -1 ) {
+        if ( sigaction( sig, &act, 0p ) == -1 ) {
                 __cfaabi_dbg_print_buffer_decl(
                         " __cfaabi_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
 …
                 );
                 _exit( EXIT_FAILURE );
+        }
+        } // if
+}
-// Sigaction wrapper : restore default handler
-static void __cfaabi_sigdefault( int sig ) {
-        struct sigaction act;
-        act.sa_handler = SIG_DFL;
-        act.sa_flags = 0;
-        sigemptyset( &act.sa_mask );
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
-                        " __cfaabi_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
-                        sig, errno, strerror( errno )
-                );
-                _exit( EXIT_FAILURE );
+        }
+}

libcfa/src/clock.hfa

-              r807a632
+              r3b56166
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 13 21:21:13 2019
 // Update Count     : 8
+// Last Modified On : Mon Jan  6 12:49:58 2020
+// Update Count     : 9
 //
 #include <time.hfa>
 //######################### C time #########################
 …
 static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }
 //######################### Clock #########################
 struct Clock {                                                                                  // private
         Duration offset;                                                                        // for virtual clock: contains offset from real-time
-        int clocktype;                                                                          // implementation only -1 (virtual), CLOCK_REALTIME
 };
 static inline {
-        void resetClock( Clock & clk ) with( clk ) {
-                clocktype = CLOCK_REALTIME_COARSE;
-        } // Clock::resetClock
         void resetClock( Clock & clk, Duration adj ) with( clk ) {
-                clocktype = -1;
                 offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
         } // resetClock
-        void ?{}( Clock & clk ) { resetClock( clk ); }
         void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
 …
                 return ret;
         } // getTime
+        Time getCPUTime() {
+                timespec ts;
+                clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
+                return (Time){ ts };
+    } // getCPUTime
 } // distribution

libcfa/src/concurrency/CtxSwitch-x86_64.S

-              r807a632
+              r3b56166
 CtxInvokeStub:
         movq %rbx, %rdi
+        jmp *%r12
+        movq %r12, %rsi
+        jmp *%r13
         .size  CtxInvokeStub, .-CtxInvokeStub

libcfa/src/concurrency/alarm.cfa

-              r807a632
+              r3b56166
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May 25 06:25:47 2018
 // Update Count     : 67
+// Last Modified On : Sun Jan  5 08:41:36 2020
+// Update Count     : 69
 //
 …
 void __kernel_set_timer( Duration alarm ) {
         verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv);
         setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns);
+        setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p );
+}
 …
                         this->tail = &this->head;
+                }
                 head->next = NULL;
+                head->next = 0p;
+        }
         verify( validate( this ) );
 …
                 this->tail = it;
+        }
         n->next = NULL;
+        n->next = 0p;
         verify( validate( this ) );

libcfa/src/concurrency/coroutine.cfa

-              r807a632
+              r3b56166
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 30 17:20:57 2018
 // Update Count     : 9
+// Last Modified On : Tue Feb  4 12:29:25 2020
+// Update Count     : 16
 //
 …
+}
 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) {
         (this.context){NULL, NULL};
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+        (this.context){0p, 0p};
         (this.stack){storage, storageSize};
         this.name = name;
         state = Start;
         starter = NULL;
         last = NULL;
         cancellation = NULL;
+        starter = 0p;
+        last = 0p;
+        cancellation = 0p;
+}
 …
 [void *, size_t] __stack_alloc( size_t storageSize ) {
         static const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
+        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
         assert(__page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
 …
 void __stack_prepare( __stack_info_t * this, size_t create_size ) {
         static const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
+        const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
         bool userStack;
         void * storage;
 …
 // is not inline (We can't inline Cforall in C)
 extern "C" {
+        void __suspend_internal(void) {
+                suspend();
+        }
+        void __leave_coroutine( coroutine_desc * src ) {
+        void __leave_coroutine( struct coroutine_desc * src ) {
                 coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
 …
                 CoroutineCtxSwitch( src, starter );
+        }
+        struct coroutine_desc * __finish_coroutine(void) {
+                struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+                if(cor->state == Primed) {
+                        suspend();
+                }
+                cor->state = Active;
+                return cor;
+        }
+}

libcfa/src/concurrency/coroutine.hfa

-              r807a632
+              r3b56166
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun 21 17:49:39 2019
 // Update Count     : 9
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 11
 //
 …
 // void ^?{}( coStack_t & this );
 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
 void ^?{}( coroutine_desc & this );
 static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", NULL, 0 }; }
 static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", NULL, stackSize }; }
+static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
+static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
 static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
 static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, NULL, 0 }; }
 static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, NULL, stackSize }; }
+static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 //-----------------------------------------------------------------------------
 …
 // Start coroutine routines
 extern "C" {
+      forall(dtype T | is_coroutine(T))
+      void CtxInvokeCoroutine(T * this);
+        void CtxInvokeCoroutine(void (*main)(void *), void * this);
       forall(dtype T | is_coroutine(T))
       void CtxStart(T * this, void ( *invoke)(T *));
+        forall(dtype T)
+        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
         extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
 …
         src->state = Active;
         if( unlikely(src->cancellation != NULL) ) {
+        if( unlikely(src->cancellation != 0p) ) {
                 _CtxCoroutine_Unwind(src->cancellation, src);
+        }
 …
         coroutine_desc * dst = get_coroutine(cor);
+        if( unlikely(dst->context.SP == NULL) ) {
+        if( unlikely(dst->context.SP == 0p) ) {
+                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
+                CtxStart(&cor, CtxInvokeCoroutine);
+                CtxStart(main, dst, cor, CtxInvokeCoroutine);
+                TL_GET( this_thread )->curr_cor = src;
+        }

libcfa/src/concurrency/invoke.c

-              r807a632
+              r3b56166
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
+extern void __suspend_internal(void);
+extern void __leave_coroutine( struct coroutine_desc * );
+extern void __finish_creation( struct thread_desc * );
+extern void __leave_thread_monitor( struct thread_desc * this );
+extern void __leave_coroutine ( struct coroutine_desc * );
+extern struct coroutine_desc * __finish_coroutine(void);
+extern void __leave_thread_monitor();
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
 …
 void CtxInvokeCoroutine(
         void (*main)(void *),
-        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
+        struct coroutine_desc* cor = get_coroutine( this );
+        // Finish setting up the coroutine by setting its state
+        struct coroutine_desc * cor = __finish_coroutine();
+        if(cor->state == Primed) {
+                __suspend_internal();
+        }
+        cor->state = Active;
+        // Call the main of the coroutine
         main( this );
 …
 void CtxInvokeThread(
-        void (*dtor)(void *),
         void (*main)(void *),
-        struct thread_desc *(*get_thread)(void *),
         void *this
 ) {
-        // Fetch the thread handle from the user defined thread structure
-        struct thread_desc* thrd = get_thread( this );
-        // First suspend, once the thread arrives here,
-        // the function pointer to main can be invalidated without risk
-        __finish_creation( thrd );
         // Officially start the thread by enabling preemption
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         // The order of these 4 operations is very important
         //Final suspend, should never return
         __leave_thread_monitor( thrd );
+        __leave_thread_monitor();
         __cabi_abort( "Resumed dead thread" );
+}
 void CtxStart(
         void (*main)(void *),
         struct coroutine_desc *(*get_coroutine)(void *),
+        struct coroutine_desc * cor,
         void *this,
         void (*invoke)(void *)
 ) {
-        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 …
         fs->dummyReturn = NULL;
+        fs->argument[0] = this;     // argument to invoke
+        fs->argument[0] = main;     // argument to invoke
+        fs->argument[1] = this;     // argument to invoke
         fs->rturn = invoke;
 …
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
+        fs->fixedRegisters[0] = this;
+        fs->fixedRegisters[1] = invoke;
+        fs->fixedRegisters[0] = main;
+        fs->fixedRegisters[1] = this;
+        fs->fixedRegisters[2] = invoke;
 #elif defined( __ARM_ARCH )
+#error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
         struct FakeStack {
                 float fpRegs[16];                       // floating point registers

libcfa/src/concurrency/invoke.h

-              r807a632
+              r3b56166
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 22 18:19:13 2019
 // Update Count     : 40
+// Last Modified On : Thu Dec  5 16:26:03 2019
+// Update Count     : 44
 //
 …
         #ifdef __cforall
         extern "Cforall" {
                 extern thread_local struct KernelThreadData {
+                extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
                         struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
 …
                                 volatile bool in_progress;
                         } preemption_state;
+                        uint32_t rand_seed;
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+        }
 …
                 static inline void ?{}(__monitor_group_t & this) {
                         (this.data){NULL};
+                        (this.data){0p};
                         (this.size){0};
                         (this.func){NULL};

libcfa/src/concurrency/kernel.cfa

-              r807a632
+              r3b56166
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 20 17:21:23 2019
 // Update Count     : 25
+// Last Modified On : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 …
 #include <signal.h>
 #include <unistd.h>
+#include <limits.h>                                                                             // PTHREAD_STACK_MIN
+#include <sys/mman.h>                                                                   // mprotect
+}
 …
 //-----------------------------------------------------------------------------
 // Some assembly required
 #if   defined( __i386 )
+#if defined( __i386 )
         #define CtxGet( ctx )        \
                 __asm__ volatile (     \
 …
 extern "C" {
 struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+        struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+}
 …
 // Global state
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
+        NULL,                                                                                           // cannot use 0p
         NULL,
         NULL,
         { 1, false, false }
+        { 1, false, false },
+u //this should be seeded better but due to a bug calling rdtsc doesn't work
 };
 …
 // Struct to steal stack
 struct current_stack_info_t {
         __stack_t * storage;            // pointer to stack object
         void *base;                             // base of stack
         void *limit;                    // stack grows towards stack limit
         void *context;                  // address of cfa_context_t
+        __stack_t * storage;                                                            // pointer to stack object
+        void * base;                                                                            // base of stack
+        void * limit;                                                                           // stack grows towards stack limit
+        void * context;                                                                         // address of cfa_context_t
 };
 …
         name = "Main Thread";
         state = Start;
         starter = NULL;
         last = NULL;
         cancellation = NULL;
+        starter = 0p;
+        last = 0p;
+        cancellation = 0p;
+}
 …
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
         next = NULL;
         node.next = NULL;
         node.prev = NULL;
+        next = 0p;
+        node.next = 0p;
+        node.prev = 0p;
         doregister(curr_cluster, this);
 …
 static void start(processor * this);
 void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
         this.name = name;
         this.cltr = &cltr;
         terminated{ 0 };
         do_terminate = false;
         preemption_alarm = NULL;
+        preemption_alarm = 0p;
         pending_preemption = false;
         runner.proc = &this;
 …
+        }
+        pthread_join( kernel_thread, NULL );
+}
+void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+        pthread_join( kernel_thread, 0p );
+        free( this.stack );
+}
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
 …
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
+        // Because of a bug, we couldn't initialized the seed on construction
+        // Do it here
+        kernelTLS.rand_seed ^= rdtscl();
         processor * this = runner.proc;
         verify(this);
 …
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
+                {
+                thread_desc * readyThread = 0p;
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
                         readyThread = nextThread( this->cltr );
+                        if(readyThread)
+                        {
+                        if(readyThread) {
                                 verify( ! kernelTLS.preemption_state.enabled );
 …
                                 spin_count = 0;
+                        }
+                        else
+                        {
+                        } else {
                                 // spin(this, &spin_count);
                                 halt(this);
 …
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
         kernelTLS.this_thread    = NULL;
+        kernelTLS.this_thread    = 0p;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
 …
         //Set global state
         kernelTLS.this_thread    = NULL;
+        kernelTLS.this_thread = 0p;
         //We now have a proper context from which to schedule threads
 …
         __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
+        return NULL;
+        return 0p;
+}
+static void Abort( int ret, const char func[] ) {
+        if ( ret ) {                                                                            // pthread routines return errno values
+                abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
+        } // if
+} // Abort
+void * create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+        pthread_attr_t attr;
+        Abort( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+        size_t stacksize;
+        // default stack size, normally defined by shell limit
+        Abort( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+        assert( stacksize >= PTHREAD_STACK_MIN );
+        void * stack;
+        __cfaabi_dbg_debug_do(
+                stack = memalign( __page_size, stacksize + __page_size );
+                // pthread has no mechanism to create the guard page in user supplied stack.
+                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                        abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
+                } // if
+        );
+        __cfaabi_dbg_no_debug_do(
+                stack = malloc( stacksize );
+        );
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        return stack;
+}
 …
         __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
+        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
         __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 …
         verify( ! kernelTLS.preemption_state.enabled );
+        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
         CtxStart(&this->runner, CtxInvokeCoroutine);
+        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
         verify( ! kernelTLS.preemption_state.enabled );
 …
         // when CtxSwitch returns we are back in the src coroutine
+        mainThread->curr_cor = &mainThread->self_cor;
         // set state of new coroutine to active
         src->state = Active;
 …
         verify( ! kernelTLS.preemption_state.enabled );
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
+        verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
         with( *thrd->curr_cluster ) {
 …
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
                 this.__cor.starter = NULL;
+                this.__cor.starter = 0p;
                 this.proc = proc;
+        }
 …
                 terminated{ 0 };
                 do_terminate = false;
                 preemption_alarm = NULL;
+                preemption_alarm = 0p;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
 …
                 sigemptyset( &mask );
                 sigaddset( &mask, SIGALRM );            // block SIGALRM signals
+                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+                sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
+                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
+        }
         else {
 …
         if(thrd) {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
                 __cfaabi_dbg_bits_write( abort_text, len );
+                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
                 if ( &thrd->self_cor != thrd->curr_cor ) {
                         len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
                         __cfaabi_dbg_bits_write( abort_text, len );
+                        __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                }
                 else {
                         __cfaabi_dbg_bits_write( ".\n", 2 );
+                        __cfaabi_bits_write( STDERR_FILENO, ".\n", 2 );
+                }
+        }
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
                 __cfaabi_dbg_bits_write( abort_text, len );
+                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+        }
+}
 …
 extern "C" {
         void __cfaabi_dbg_bits_acquire() {
+        void __cfaabi_bits_acquire() {
                 lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
+        }
         void __cfaabi_dbg_bits_release() {
+        void __cfaabi_bits_release() {
                 unlock( kernel_debug_lock );
+        }
 …
 void V(semaphore & this) with( this ) {
         thread_desc * thrd = NULL;
+        thread_desc * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
 …
 __cfaabi_dbg_debug_do(
         extern "C" {
                 void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+                void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
                         this.prev_name = prev_name;
                         this.prev_thrd = kernelTLS.this_thread;

libcfa/src/concurrency/kernel.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 22 11:39:17 2019
 // Update Count     : 16
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 22
 //
 …
 #include "invoke.h"
 #include "time_t.hfa"
+#include "coroutine.hfa"
 extern "C" {
 …
 static inline void ?{}(FinishAction & this) {
         this.action_code = No_Action;
         this.thrd = NULL;
         this.lock = NULL;
+        this.thrd = 0p;
+        this.lock = 0p;
+}
 static inline void ^?{}(FinishAction &) {}
 …
         semaphore terminated;
+        // pthread Stack
+        void * stack;
         // Link lists fields
         struct __dbg_node_proc {
 …
 };
 void  ?{}(processor & this, const char * name, struct cluster & cltr);
+void  ?{}(processor & this, const char name[], struct cluster & cltr);
 void ^?{}(processor & this);
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
 static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 static inline [processor *&, processor *& ] __get( processor & this ) {
 …
 extern Duration default_preemption();
 void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate);
 void ^?{}(cluster & this);
 static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
 static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
 static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 static inline [cluster *&, cluster *& ] __get( cluster & this ) {

libcfa/src/concurrency/kernel_private.hfa

-              r807a632
+              r3b56166
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 29 14:06:40 2018
 // Update Count     : 3
+// Last Modified On : Sat Nov 30 19:25:02 2019
+// Update Count     : 8
 //
 …
 void main(processorCtx_t *);
+void * create_pthread( pthread_t *, void * (*)(void *), void * );
 static inline void wake_fast(processor * this) {
         __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
 …
 // Threads
 extern "C" {
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
+      void CtxInvokeThread(void (*main)(void *), void * this);
+}
 …
 // Utils
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
+static inline uint32_t tls_rand() {
+        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
+        kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;
+        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 7;
+        return kernelTLS.rand_seed;
+}

libcfa/src/concurrency/monitor.cfa

-              r807a632
+              r3b56166
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 30 14:30:26 2018
 // Update Count     : 9
+// Last Modified On : Wed Dec  4 07:55:14 2019
+// Update Count     : 10
 //
 …
         // last routine called by a thread.
         // Should never return
+        void __leave_thread_monitor( thread_desc * thrd ) {
+        void __leave_thread_monitor() {
+                thread_desc * thrd = TL_GET( this_thread );
                 monitor_desc * this = &thrd->self_mon;
 …
         this.waiting_thread = waiting_thread;
         this.count = count;
         this.next = NULL;
+        this.next = 0p;
         this.user_info = user_info;
+}
 …
 void ?{}(__condition_criterion_t & this ) with( this ) {
         ready  = false;
         target = NULL;
         owner  = NULL;
         next   = NULL;
+        target = 0p;
+        owner  = 0p;
+        next   = 0p;
+}
 …
         this.target = target;
         this.owner  = &owner;
         this.next   = NULL;
+        this.next   = 0p;
+}
 …
         // Check that everything is as expected
         assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        assertf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
         verifyf( this.monitor_count < 32u, "Excessive monitor count (%"PRIiFAST16")", this.monitor_count );
 …
         // Lock all monitors
         lock_all( this.monitors, NULL, count );
+        lock_all( this.monitors, 0p, count );
         //Pop the head of the waiting queue
 …
         //Check that everything is as expected
         verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
 …
 static inline void reset_mask( monitor_desc * this ) {
         this->mask.accepted = NULL;
         this->mask.data = NULL;
+        this->mask.accepted = 0p;
+        this->mask.data = 0p;
         this->mask.size = 0;
+}
 …
+        }
         __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
         return ready2run ? node->waiting_thread : NULL;
+        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : 0p );
+        return ready2run ? node->waiting_thread : 0p;
+}
 …
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
                 assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
+                assertf( thrd->monitors.data != 0p, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;

libcfa/src/concurrency/monitor.hfa

-              r807a632
+              r3b56166
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Oct  7 18:06:45 2017
 // Update Count     : 10
+// Last Modified On : Wed Dec  4 07:55:32 2019
+// Update Count     : 11
 //
 …
         entry_queue{};
         signal_stack{};
         owner         = NULL;
+        owner         = 0p;
         recursion     = 0;
         mask.accepted = NULL;
         mask.data     = NULL;
+        mask.accepted = 0p;
+        mask.data     = 0p;
         mask.size     = 0;
         dtor_node     = NULL;
+        dtor_node     = 0p;
+}
+static inline void ^?{}(monitor_desc & ) {}
 struct monitor_guard_t {
 …
 static inline void ?{}( condition & this ) {
         this.monitors = NULL;
+        this.monitors = 0p;
         this.monitor_count = 0;
+}

libcfa/src/concurrency/mutex.cfa

-              r807a632
+              r3b56166
 // Author           : Thierry Delisle
 // Created On       : Fri May 25 01:37:11 2018
 // Last Modified By : Thierry Delisle
 // Last Modified On : Fri May 25 01:37:51 2018
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Dec  4 09:16:39 2019
+// Update Count     : 1
 //
 …
         this.lock{};
         this.blocked_threads{};
         this.owner = NULL;
+        this.owner = 0p;
         this.recursion_count = 0;
+}
 …
 void lock(recursive_mutex_lock & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         if( owner == NULL ) {
+        if( owner == 0p ) {
                 owner = kernelTLS.this_thread;
                 recursion_count = 1;
 …
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
         if( owner == NULL ) {
+        if( owner == 0p ) {
                 owner = kernelTLS.this_thread;
                 recursion_count = 1;

libcfa/src/concurrency/mutex.hfa

-              r807a632
+              r3b56166
 // Author           : Thierry Delisle
 // Created On       : Fri May 25 01:24:09 2018
 // Last Modified By : Thierry Delisle
 // Last Modified On : Fri May 25 01:24:12 2018
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Dec  4 09:16:53 2019
+// Update Count     : 1
 //
 …
         static inline void ?{}(lock_scope(L) & this) {
                 this.locks = NULL;
+                this.locks = 0p;
                 this.count = 0;
+        }

libcfa/src/concurrency/preemption.cfa

-              r807a632
+              r3b56166
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jun  5 17:35:49 2018
 // Update Count     : 37
+// Last Modified On : Thu Dec  5 16:34:05 2019
+// Update Count     : 43
 //
 …
 #include <string.h>
 #include <unistd.h>
+#include <limits.h>                                                                             // PTHREAD_STACK_MIN
+}
 …
 event_kernel_t * event_kernel;                        // kernel public handle to even kernel
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
+static void * alarm_stack;                                                        // pthread stack for alarm thread
 static void ?{}(event_kernel_t & this) with( this ) {
 …
 // Get next expired node
 static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
         if( !alarms->head ) return NULL;                          // If no alarms return null
         if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
         return pop(alarms);                                       // Otherwise just pop head
+        if( !alarms->head ) return 0p;                                          // If no alarms return null
+        if( alarms->head->alarm >= currtime ) return 0p;        // If alarms head not expired return null
+        return pop(alarms);                                                                     // Otherwise just pop head
+}
 // Tick one frame of the Discrete Event Simulation for alarms
 static void tick_preemption() {
         alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
         Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
+        alarm_node_t * node = 0p;                                                       // Used in the while loop but cannot be declared in the while condition
+        alarm_list_t * alarms = &event_kernel->alarms;          // Local copy for ease of reading
+        Time currtime = __kernel_get_time();                            // Check current time once so everything "happens at once"
         //Loop throught every thing expired
 …
         sigaddset( &mask, sig );
         if ( pthread_sigmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
+        if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
         sigaddset( &mask, sig );
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
+        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
         // Setup proper signal handlers
         __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART );         // CtxSwitch handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler
         signal_block( SIGALRM );
         pthread_create( &alarm_thread, NULL, alarm_loop, NULL );
+        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
+}
 …
         sigset_t mask;
         sigfillset( &mask );
         sigprocmask( SIG_BLOCK, &mask, NULL );
+        sigprocmask( SIG_BLOCK, &mask, 0p );
         // Notify the alarm thread of the shutdown
 …
         // Wait for the preemption thread to finish
+        pthread_join( alarm_thread, NULL );
+        pthread_join( alarm_thread, 0p );
+        free( alarm_stack );
         // Preemption is now fully stopped
 …
         static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
         #endif
         if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) {
+        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
                 abort( "internal error, sigprocmask" );
+        }
 …
         sigset_t mask;
         sigfillset(&mask);
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
+        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
                                         {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );}
                                         continue;
                         case EINVAL :
+                                case EINVAL :
                                         abort( "Timeout was invalid." );
                                 default:
 …
 EXIT:
         __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
         return NULL;
+        return 0p;
+}
 …
         sigset_t oldset;
         int ret;
         ret = pthread_sigmask(0, NULL, &oldset);
+        ret = pthread_sigmask(0, 0p, &oldset);
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }

libcfa/src/concurrency/thread.cfa

-              r807a632
+              r3b56166
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar 30 17:19:52 2018
 // Update Count     : 8
+// Last Modified On : Wed Dec  4 09:17:49 2019
+// Update Count     : 9
 //
 …
 // Thread ctors and dtors
 void ?{}(thread_desc & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
         context{ NULL, NULL };
+        context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
         state = Start;
 …
         self_mon_p = &self_mon;
         curr_cluster = &cl;
         next = NULL;
+        next = 0p;
         node.next = NULL;
         node.prev = NULL;
+        node.next = 0p;
+        node.prev = 0p;
         doregister(curr_cluster, this);
 …
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
         __thrd_start(handle);
+        __thrd_start(handle, main);
+}
 …
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
         __thrd_start(handle);
+        __thrd_start(handle, main);
+}
 …
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
 void __thrd_start( T& this ) {
+void __thrd_start( T & this, void (*main_p)(T &) ) {
         thread_desc * this_thrd = get_thread(this);
         thread_desc * curr_thrd = TL_GET( this_thread );
         disable_interrupts();
+        CtxStart(&this, CtxInvokeThread);
+        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
         this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
         verify( this_thrd->context.SP );
         CtxSwitch( &curr_thrd->context, &this_thrd->context );
+        // CtxSwitch( &curr_thrd->context, &this_thrd->context );
         ScheduleThread(this_thrd);
         enable_interrupts( __cfaabi_dbg_ctx );
+}
-extern "C" {
-        // KERNEL ONLY
-        void __finish_creation(thread_desc * this) {
-                // set new coroutine that the processor is executing
-                // and context switch to it
-                verify( kernelTLS.this_thread != this );
-                verify( kernelTLS.this_thread->context.SP );
-                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
+        }
+}

libcfa/src/concurrency/thread.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun 21 17:51:33 2019
 // Update Count     : 5
+// Last Modified On : Wed Dec  4 09:18:14 2019
+// Update Count     : 6
 //
 …
 forall( dtype T | is_thread(T) )
 void __thrd_start( T & this );
+void __thrd_start( T & this, void (*)(T &) );
 //-----------------------------------------------------------------------------
 …
 void ^?{}(thread_desc & this);
 static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, NULL, 65000 }; }
 static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, NULL, stackSize }; }
+static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
 static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
 static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, NULL, 65000 }; }
 static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, NULL, stackSize }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
 static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
 static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, NULL, 65000 }; }
 static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, NULL, 65000 }; }
 static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, NULL, stackSize }; }
+static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
+static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
+static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
 //-----------------------------------------------------------------------------

libcfa/src/exception.c

-              r807a632
+              r3b56166
 // This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
 // in termination.
+// This macro should be the only thing that needs to change across machines.
+// Used in the personality function, way down in termination.
 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
 #define MATCHER_FROM_CONTEXT(ptr_to_context) \
 …
+}
+// Do we control where exceptions get thrown even with concurency?  If not these are not quite thread safe, the cleanup
+// hook has to be added after the node is built but before it is made the top node.
+// Do we control where exceptions get thrown even with concurency?
+// If not these are not quite thread safe, the cleanup hook has to
+// be added after the node is built but before it is made the top node.
 void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
 …
         _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
+        // If we reach here it means something happened.  For resumption to work we need to find a way to return back to
+        // here.  Most of them will probably boil down to setting a global flag and making the phase 1 either stop or
+        // fail.  Causing an error on purpose may help avoiding unnecessary work but it might have some weird side
+        // effects.  If we just pretend no handler was found that would work but may be expensive for no reason since we
+        // will always search the whole stack.
+        // If we reach here it means something happened. For resumption to work we need to find a way
+        // to return back to here. Most of them will probably boil down to setting a global flag and
+        // making the phase 1 either stop or fail. Causing an error on purpose may help avoiding
+        // unnecessary work but it might have some weird side effects. If we just pretend no handler
+        // was found that would work but may be expensive for no reason since we will always search
+        // the whole stack.
         if( ret == _URC_END_OF_STACK ) {
                 // No proper handler was found.  This can be handled in several way.  C++ calls std::terminate Here we
                 // force unwind the stack, basically raising a cancellation.
+                // No proper handler was found. This can be handled in many ways, C++ calls std::terminate.
+                // Here we force unwind the stack, basically raising a cancellation.
                 printf("Uncaught exception %p\n", &this_exception_storage);
 …
+        }
         // We did not simply reach the end of the stack without finding a handler.  Something wen't wrong
+        // We did not simply reach the end of the stack without finding a handler. This is an error.
         printf("UNWIND ERROR %d after raise exception\n", ret);
         abort();
 …
         abort();
+}
+#else
+// This is our personality routine.  For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0".
+// This function will be called twice when unwinding.  Once in the search phased and once in the cleanup phase.
+#else // PIC
+// This is our personality routine. For every stack frame annotated with
+// ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
+//  Once in the search phase and once in the cleanup phase.
 _Unwind_Reason_Code __gcfa_personality_v0 (
                 int version, _Unwind_Action actions, unsigned long long exceptionClass,
 …
         //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context));
+        __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
+        __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):",
+                        version, actions, exceptionClass, unwind_exception, context);
         // If we've reached the end of the stack then there is nothing much we can do...
 …
         // Get the instuction pointer and a reading pointer into the exception table
         lsda_header_info lsd_info;
         const unsigned char * cur_ptr = parse_lsda_header( context, lsd, &lsd_info);
+        const unsigned char * cur_ptr = parse_lsda_header(context, lsd, &lsd_info);
         _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context );
 …
                 // Decode the common stuff we have in here
                 cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
                 cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
                 cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
                 cur_ptr = read_uleb128 (cur_ptr, &callsite_action);
+                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
+                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
+                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
+                cur_ptr = read_uleb128(cur_ptr, &callsite_action);
                 // Have we reach the correct frame info yet?
 …
                         void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
                         void * ip = (void*)instruction_ptr;
+                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
+                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n",
+                                        bp, ep, ls, cs, cl, ip);
 #endif // __CFA_DEBUG_PRINT__
                         continue;
+                }
                 // Have we gone too far
+                // Have we gone too far?
                 if( lsd_info.Start + callsite_start > instruction_ptr ) {
                         printf(" gone too far");
 …
                         // Which phase are we in
                         if (actions & _UA_SEARCH_PHASE) {
                                 // Search phase, this means we probably found a potential handler and must check if it is a match
                                 // If we have arbitrarily decided that 0 means nothing to do and 1 means there is a potential handler
                                 // This doesn't seem to conflict the gcc default behavior
+                                // In search phase, these means we found a potential handler we must check.
+                                // We have arbitrarily decided that 0 means nothing to do and 1 means there is
+                                // a potential handler. This doesn't seem to conflict the gcc default behavior.
                                 if (callsite_action != 0) {
                                         // Now we want to run some code to see if the handler matches
 …
                                         // The current apprach uses one exception table entry per try block
                                         _uleb128_t imatcher;
+                                        // Get the relative offset to the
+                                        cur_ptr = read_uleb128 (cur_ptr, &imatcher);
+                                        // Get a function pointer from the relative offset and call it
+                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
+                                        // Get the relative offset to the {...}?
+                                        cur_ptr = read_uleb128(cur_ptr, &imatcher);
                                         _Unwind_Reason_Code (*matcher)(exception_t *) =
 …
+}
 // Try statements are hoisted out see comments for details.  With this could probably be unique and simply linked from
 // libcfa but there is one problem left, see the exception table for details
+// Try statements are hoisted out see comments for details. While this could probably be unique
+// and simply linked from libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
 void __cfaabi_ehm__try_terminate(void (*try_block)(),
 …
         // assembly works.
         // Setup the personality routine
+        // Setup the personality routine and exception table.
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
-        // Setup the exception table
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
 …
         asm volatile goto ("" : : : : CATCH );
         // Normal return
+        // Normal return for when there is no throw.
         return;
 …
+}
+// Exception table data we need to generate.  While this is almost generic, the custom data refers to foo_try_match try
+// match, which is no way generic.  Some more works need to be done if we want to have a single call to the try routine.
+// Exception table data we need to generate. While this is almost generic, the custom data refers
+// to {*}try_terminate, which is no way generic. Some more works need to be done if we want to
+// have a single call to the try routine.
 #if defined( __i386 ) || defined( __x86_64 )
 asm (
         //HEADER
+        // HEADER
         ".LFECFA1:\n"
         "       .globl  __gcfa_personality_v0\n"
         "       .section        .gcc_except_table,\"a\",@progbits\n"
+        ".LLSDACFA2:\n"                                                 //TABLE header
+        // TABLE HEADER (important field is the BODY length at the end)
+        ".LLSDACFA2:\n"
         "       .byte   0xff\n"
         "       .byte   0xff\n"
         "       .byte   0x1\n"
+        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"         // BODY length
+        // Body uses language specific data and therefore could be modified arbitrarily
+        ".LLSDACSBCFA2:\n"                                              // BODY start
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"               // Handled area start  (relative to start of function)
+        "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"                          // Hanlder landing pad adress  (relative to start of function)
+        "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
+        ".LLSDACSECFA2:\n"                                              // BODY end
+        "       .text\n"                                                        // TABLE footer
+        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
+        // BODY (language specific data)
+        ".LLSDACSBCFA2:\n"
+        //      Handled area start (relative to start of function)
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        //      Handled area length
+        "       .uleb128 .TRYEND-.TRYSTART\n"
+        //      Handler landing pad address (relative to start of function)
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        //      Action code, gcc seems to always use 0.
+        "       .uleb128 1\n"
+        // TABLE FOOTER
+        ".LLSDACSECFA2:\n"
+        "       .text\n"
         "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 …
 );
 #endif // __i386 || __x86_64
 #endif //PIC
+#endif // PIC

libcfa/src/executor.cfa

-              r807a632
+              r3b56166
 #include <stdio.h>
 forall( otype T | is_node(T) | is_monitor(T) ) {
     monitor Buffer {                                    // unbounded buffer
         __queue_t( T ) queue;                           // unbounded list of work requests
         condition delay;
     }; // Buffer
+forall( dtype T )
+monitor Buffer {                                        // unbounded buffer
+    __queue_t( T ) queue;                               // unbounded list of work requests
+    condition delay;
+}; // Buffer
+forall( dtype T | is_node(T) ) {
     void insert( Buffer( T ) & mutex buf, T * elem ) with(buf) {
         append( queue, elem );                          // insert element into buffer
 …
     T * remove( Buffer( T ) & mutex buf ) with(buf) {
         if ( ! queue ) wait( delay );                   // no request to process ? => wait
         return pop_head( queue );
+        if ( queue.head != 0 ) wait( delay );                   // no request to process ? => wait
+//      return pop_head( queue );
     } // remove
 } // distribution

libcfa/src/fstream.cfa

-              r807a632
+              r3b56166
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 10 22:19:56 2019
 // Update Count     : 354
+// Last Modified On : Fri Feb  7 19:01:01 2020
+// Update Count     : 363
 //
 …
 void ?{}( ofstream & os, void * file ) {
+        os.file = file;
+        os.sepDefault = true;
+        os.sepOnOff = false;
+        os.nlOnOff = true;
+        os.prt = false;
+        os.sawNL = false;
+        os.$file = file;
+        os.$sepDefault = true;
+        os.$sepOnOff = false;
+        os.$nlOnOff = true;
+        os.$prt = false;
+        os.$sawNL = false;
+        $sepSetCur( os, sepGet( os ) );
         sepSet( os, " " );
-        sepSetCur( os, sepGet( os ) );
         sepSetTuple( os, ", " );
 } // ?{}
 // private
 bool sepPrt( ofstream & os ) { setNL( os, false ); return os.sepOnOff; }
 void sepReset( ofstream & os ) { os.sepOnOff = os.sepDefault; }
 void sepReset( ofstream & os, bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
 const char * sepGetCur( ofstream & os ) { return os.sepCur; }
 void sepSetCur( ofstream & os, const char * sepCur ) { os.sepCur = sepCur; }
 bool getNL( ofstream & os ) { return os.sawNL; }
 void setNL( ofstream & os, bool state ) { os.sawNL = state; }
 bool getANL( ofstream & os ) { return os.nlOnOff; }
 bool getPrt( ofstream & os ) { return os.prt; }
 void setPrt( ofstream & os, bool state ) { os.prt = state; }
+bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
+void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
+void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
+const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
+void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
+bool $getNL( ofstream & os ) { return os.$sawNL; }
+void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
+bool $getANL( ofstream & os ) { return os.$nlOnOff; }
+bool $getPrt( ofstream & os ) { return os.$prt; }
+void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
 // public
 void ?{}( ofstream & os ) { os.file = 0; }
 void ?{}( ofstream & os, const char * name, const char * mode ) {
+void ?{}( ofstream & os ) { os.$file = 0p; }
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
         open( os, name, mode );
 } // ?{}
 void ?{}( ofstream & os, const char * name ) {
+void ?{}( ofstream & os, const char name[] ) {
         open( os, name, "w" );
 } // ?{}
+void sepOn( ofstream & os ) { os.sepOnOff = ! getNL( os ); }
+void sepOff( ofstream & os ) { os.sepOnOff = false; }
+void ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
+void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
+void sepOff( ofstream & os ) { os.$sepOnOff = false; }
 bool sepDisable( ofstream & os ) {
         bool temp = os.sepDefault;
         os.sepDefault = false;
         sepReset( os );
+        bool temp = os.$sepDefault;
+        os.$sepDefault = false;
+        $sepReset( os );
         return temp;
 } // sepDisable
 bool sepEnable( ofstream & os ) {
         bool temp = os.sepDefault;
         os.sepDefault = true;
         if ( os.sepOnOff ) sepReset( os );                                      // start of line ?
+        bool temp = os.$sepDefault;
+        os.$sepDefault = true;
+        if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
         return temp;
 } // sepEnable
 void nlOn( ofstream & os ) { os.nlOnOff = true; }
 void nlOff( ofstream & os ) { os.nlOnOff = false; }
 const char * sepGet( ofstream & os ) { return os.separator; }
 void sepSet( ofstream & os, const char * s ) {
+void nlOn( ofstream & os ) { os.$nlOnOff = true; }
+void nlOff( ofstream & os ) { os.$nlOnOff = false; }
+const char * sepGet( ofstream & os ) { return os.$separator; }
+void sepSet( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.separator, s, sepSize - 1 );
         os.separator[sepSize - 1] = '\0';
+        strncpy( os.$separator, s, sepSize - 1 );
+        os.$separator[sepSize - 1] = '\0';
 } // sepSet
 const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator; }
 void sepSetTuple( ofstream & os, const char * s ) {
+const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
+void sepSetTuple( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.tupleSeparator, s, sepSize - 1 );
         os.tupleSeparator[sepSize - 1] = '\0';
+        strncpy( os.$tupleSeparator, s, sepSize - 1 );
+        os.$tupleSeparator[sepSize - 1] = '\0';
 } // sepSet
 void ends( ofstream & os ) {
         if ( getANL( os ) ) nl( os );
         else setPrt( os, false );                                                       // turn off
+        if ( $getANL( os ) ) nl( os );
+        else $setPrt( os, false );                                                      // turn off
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
 …
 int fail( ofstream & os ) {
         return os.file == 0 || ferror( (FILE *)(os.file) );
+        return os.$file == 0 || ferror( (FILE *)(os.$file) );
 } // fail
 int flush( ofstream & os ) {
         return fflush( (FILE *)(os.file) );
+        return fflush( (FILE *)(os.$file) );
 } // flush
 void open( ofstream & os, const char * name, const char * mode ) {
+void open( ofstream & os, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+        if ( file == 0p ) {
                 abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
         } // if
 …
 } // open
 void open( ofstream & os, const char * name ) {
+void open( ofstream & os, const char name[] ) {
         open( os, name, "w" );
 } // open
 void close( ofstream & os ) {
         if ( (FILE *)(os.file) == stdout || (FILE *)(os.file) == stderr ) return;
         if ( fclose( (FILE *)(os.file) ) == EOF ) {
+        if ( (FILE *)(os.$file) == stdout || (FILE *)(os.$file) == stderr ) return;
+        if ( fclose( (FILE *)(os.$file) ) == EOF ) {
                 abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
 } // close
 ofstream & write( ofstream & os, const char * data, size_t size ) {
+ofstream & write( ofstream & os, const char data[], size_t size ) {
         if ( fail( os ) ) {
                 abort | IO_MSG "attempt write I/O on failed stream";
         } // if
         if ( fwrite( data, 1, size, (FILE *)(os.file) ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
                 abort | IO_MSG "write" | nl | strerror( errno );
         } // if
 …
         va_list args;
         va_start( args, format );
         int len = vfprintf( (FILE *)(os.file), format, args );
+        int len = vfprintf( (FILE *)(os.$file), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file) ) ) {
+                if ( ferror( (FILE *)(os.$file) ) ) {
                         abort | IO_MSG "invalid write";
                 } // if
 …
         va_end( args );
         setPrt( os, true );                                                                     // called in output cascade
         sepReset( os );                                                                         // reset separator
+        $setPrt( os, true );                                                            // called in output cascade
+        $sepReset( os );                                                                        // reset separator
         return len;
 } // fmt
 …
 // private
 void ?{}( ifstream & is, void * file ) {
         is.file = file;
         is.nlOnOff = false;
+        is.$file = file;
+        is.$nlOnOff = false;
 } // ?{}
 // public
 void ?{}( ifstream & is ) {     is.file = 0; }
 void ?{}( ifstream & is, const char * name, const char * mode ) {
+void ?{}( ifstream & is ) { is.$file = 0p; }
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
         open( is, name, mode );
 } // ?{}
 void ?{}( ifstream & is, const char * name ) {
+void ?{}( ifstream & is, const char name[] ) {
         open( is, name, "r" );
 } // ?{}
+void nlOn( ifstream & os ) { os.nlOnOff = true; }
+void nlOff( ifstream & os ) { os.nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff; }
+void ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
+void nlOn( ifstream & os ) { os.$nlOnOff = true; }
+void nlOff( ifstream & os ) { os.$nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.$nlOnOff; }
 int fail( ifstream & is ) {
         return is.file == 0 || ferror( (FILE *)(is.file) );
+        return is.$file == 0p || ferror( (FILE *)(is.$file) );
 } // fail
 int eof( ifstream & is ) {
         return feof( (FILE *)(is.file) );
+        return feof( (FILE *)(is.$file) );
 } // eof
 void open( ifstream & is, const char * name, const char * mode ) {
+void open( ifstream & is, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
         #ifdef __CFA_DEBUG__
         if ( file == 0 ) {
+        if ( file == 0p ) {
                 abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
         } // if
         #endif // __CFA_DEBUG__
         is.file = file;
 } // open
 void open( ifstream & is, const char * name ) {
+        is.$file = file;
+} // open
+void open( ifstream & is, const char name[] ) {
         open( is, name, "r" );
 } // open
 void close( ifstream & is ) {
         if ( (FILE *)(is.file) == stdin ) return;
         if ( fclose( (FILE *)(is.file) ) == EOF ) {
+        if ( (FILE *)(is.$file) == stdin ) return;
+        if ( fclose( (FILE *)(is.$file) ) == EOF ) {
                 abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
 …
         } // if
         if ( fread( data, size, 1, (FILE *)(is.file) ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
                 abort | IO_MSG "read" | nl | strerror( errno );
         } // if
 …
         } // if
         if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
                 abort | IO_MSG "ungetc" | nl | strerror( errno );
         } // if
 …
         va_start( args, format );
         int len = vfscanf( (FILE *)(is.file), format, args );
+        int len = vfscanf( (FILE *)(is.$file), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file) ) ) {
+                if ( ferror( (FILE *)(is.$file) ) ) {
                         abort | IO_MSG "invalid read";
                 } // if

libcfa/src/fstream.hfa

-              r807a632
+              r3b56166
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 15 18:10:23 2019
 // Update Count     : 167
+// Last Modified On : Fri Feb  7 19:00:51 2020
+// Update Count     : 174
 //
 …
 enum { sepSize = 16 };
 struct ofstream {
         void * file;
         bool sepDefault;
         bool sepOnOff;
         bool nlOnOff;
         bool prt;                                                                                       // print text
         bool sawNL;
         const char * sepCur;
         char separator[sepSize];
         char tupleSeparator[sepSize];
+        void * $file;
+        bool $sepDefault;
+        bool $sepOnOff;
+        bool $nlOnOff;
+        bool $prt;                                                                                      // print text
+        bool $sawNL;
+        const char * $sepCur;
+        char $separator[sepSize];
+        char $tupleSeparator[sepSize];
 }; // ofstream
 // private
 bool sepPrt( ofstream & );
 void sepReset( ofstream & );
 void sepReset( ofstream &, bool );
 const char * sepGetCur( ofstream & );
 void sepSetCur( ofstream &, const char * );
 bool getNL( ofstream & );
 void setNL( ofstream &, bool );
 bool getANL( ofstream & );
 bool getPrt( ofstream & );
 void setPrt( ofstream &, bool );
+bool $sepPrt( ofstream & );
+void $sepReset( ofstream & );
+void $sepReset( ofstream &, bool );
+const char * $sepGetCur( ofstream & );
+void $sepSetCur( ofstream &, const char [] );
+bool $getNL( ofstream & );
+void $setNL( ofstream &, bool );
+bool $getANL( ofstream & );
+bool $getPrt( ofstream & );
+void $setPrt( ofstream &, bool );
 // public
 …
 const char * sepGet( ofstream & );
 void sepSet( ofstream &, const char * );
+void sepSet( ofstream &, const char [] );
 const char * sepGetTuple( ofstream & );
 void sepSetTuple( ofstream &, const char * );
+void sepSetTuple( ofstream &, const char [] );
 void ends( ofstream & os );
 int fail( ofstream & );
 int flush( ofstream & );
 void open( ofstream &, const char * name, const char * mode );
 void open( ofstream &, const char * name );
+void open( ofstream &, const char name[], const char mode[] );
+void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char * data, size_t size );
+ofstream & write( ofstream &, const char data[], size_t size );
 int fmt( ofstream &, const char format[], ... );
 void ?{}( ofstream & os );
+void ?{}( ofstream & os, const char * name, const char * mode );
+void ?{}( ofstream & os, const char * name );
+void ?{}( ofstream & os, const char name[], const char mode[] );
+void ?{}( ofstream & os, const char name[] );
+void ^?{}( ofstream & os );
 extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
 …
 struct ifstream {
         void * file;
         bool nlOnOff;
+        void * $file;
+        bool $nlOnOff;
 }; // 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 );
+void open( ifstream & is, const char name[], const char mode[] );
+void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
 …
 void ?{}( ifstream & is );
+void ?{}( ifstream & is, const char * name, const char * mode );
+void ?{}( ifstream & is, const char * name );
+void ?{}( ifstream & is, const char name[], const char mode[] );
+void ?{}( ifstream & is, const char name[] );
+void ^?{}( ifstream & is );
 extern ifstream & sin, & stdin;                                                 // aliases

libcfa/src/gmp.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 13 15:25:05 2019
 // Update Count     : 27
+// Last Modified On : Sun Feb  9 09:56:54 2020
+// Update Count     : 31
 //
 …
 static inline {
         // constructor
+        // constructor, zero_t/one_t are unnecessary because of relationship with signed/unsigned int
         void ?{}( Int & this ) { mpz_init( this.mpz ); }
         void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
-        void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
-        void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
         void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
         void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
         void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
+        void ?{}( Int & this, const char val[] ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
         void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
 …
         Int ?`mp( signed long int init ) { return (Int){ init }; }
         Int ?`mp( unsigned long int init ) { return (Int){ init }; }
         Int ?`mp( const char * init ) { return (Int){ init }; }
+        Int ?`mp( const char init[] ) { return (Int){ init }; }
         // assignment
 …
         Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
         Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
         Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
+        Int ?=?( Int & lhs, const char rhs[] ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
         char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
 …
         forall( dtype ostype | ostream( ostype ) ) {
                 ostype & ?|?( ostype & os, Int mp ) {
                         if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                        if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                         gmp_printf( "%Zd", mp.mpz );
                         sepOn( os );

libcfa/src/heap.cfa

-              r807a632
+              r3b56166
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Oct 18 07:42:09 2019
 // Update Count     : 556
+// Last Modified On : Tue Feb  4 10:04:51 2020
+// Update Count     : 648
 //
 …
 #include <stdio.h>                                                                              // snprintf, fileno
 #include <errno.h>                                                                              // errno
+#include <string.h>                                                                             // memset, memcpy
 extern "C" {
 #include <sys/mman.h>                                                                   // mmap, munmap
 …
 #include "bits/locks.hfa"                                                               // __spinlock_t
 #include "startup.hfa"                                                                  // STARTUP_PRIORITY_MEMORY
 #include "stdlib.hfa"                                                                   // bsearchl
+//#include "stdlib.hfa"                                                                 // bsearchl
 #include "malloc.h"
+#define MIN(x, y) (y > x ? x : y)
 static bool traceHeap = false;
+inline bool traceHeap() {
+        return traceHeap;
+} // traceHeap
+inline bool traceHeap() { return traceHeap; }
 bool traceHeapOn() {
 …
 } // traceHeapOff
+static bool checkFree = false;
+inline bool checkFree() {
+        return checkFree;
+} // checkFree
+bool checkFreeOn() {
+        bool temp = checkFree;
+        checkFree = true;
+bool traceHeapTerm() { return false; }
+static bool prtFree = false;
+inline bool prtFree() {
+        return prtFree;
+} // prtFree
+bool prtFreeOn() {
+        bool temp = prtFree;
+        prtFree = true;
         return temp;
 } // checkFreeOn
 bool checkFreeOff() {
         bool temp = checkFree;
         checkFree = false;
+} // prtFreeOn
+bool prtFreeOff() {
+        bool temp = prtFree;
+        prtFree = false;
         return temp;
+} // checkFreeOff
+// static bool traceHeapTerm = false;
+// inline bool traceHeapTerm() {
+//      return traceHeapTerm;
+// } // traceHeapTerm
+// bool traceHeapTermOn() {
+//      bool temp = traceHeapTerm;
+//      traceHeapTerm = true;
+//      return temp;
+// } // traceHeapTermOn
+// bool traceHeapTermOff() {
+//      bool temp = traceHeapTerm;
+//      traceHeapTerm = false;
+//      return temp;
+// } // traceHeapTermOff
+} // prtFreeOff
 enum {
+        // Define the default extension heap amount in units of bytes. When the uC++ supplied heap reaches the brk address,
+        // the brk address is extended by the extension amount.
+        __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
+        // Define the mmap crossover point during allocation. Allocations less than this amount are allocated from buckets;
+        // values greater than or equal to this value are mmap from the operating system.
         __CFA_DEFAULT_MMAP_START__ = (512 * 1024 + 1),
-        __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
 };
 …
 static unsigned int allocFree;                                                  // running total of allocations minus frees
 static void checkUnfreed() {
+static void prtUnfreed() {
         if ( allocFree != 0 ) {
                 // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
                 // char helpText[512];
                 // int len = snprintf( helpText, sizeof(helpText), "CFA warning (UNIX pid:%ld) : program terminating with %u(0x%x) bytes of storage allocated but not freed.\n"
                 //                                      "Possible cause is unfreed storage allocated by the program or system/library routines called from the program.\n",
                 //                                      (long int)getpid(), allocFree, allocFree ); // always print the UNIX pid
                 // __cfaabi_dbg_bits_write( helpText, len );
         } // if
 } // checkUnfreed
+                char helpText[512];
+                int len = snprintf( helpText, sizeof(helpText), "CFA warning (UNIX pid:%ld) : program terminating with %u(0x%x) bytes of storage allocated but not freed.\n"
+                                                        "Possible cause is unfreed storage allocated by the program or system/library routines called from the program.\n",
+                                                        (long int)getpid(), allocFree, allocFree ); // always print the UNIX pid
+                __cfaabi_bits_write( STDERR_FILENO, helpText, len ); // print debug/nodebug
+        } // if
+} // prtUnfreed
 extern "C" {
 …
         void heapAppStop() {                                                            // called by __cfaabi_appready_startdown
                 fclose( stdin ); fclose( stdout );
                 checkUnfreed();
+                prtUnfreed();
         } // heapAppStop
 } // extern "C"
 #endif // __CFA_DEBUG__
 // statically allocated variables => zero filled.
 …
 static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
-// #comment TD : This defined is significantly different from the __ALIGN__ define from locks.hfa
-#define ALIGN 16
 #define SPINLOCK 0
 …
 // Recursive definitions: HeapManager needs size of bucket array and bucket area needs sizeof HeapManager storage.
 // Break recusion by hardcoding number of buckets and statically checking number is correct after bucket array defined.
 enum { NoBucketSizes = 93 };                                                    // number of buckets sizes
+enum { NoBucketSizes = 91 };                                                    // number of buckets sizes
 struct HeapManager {
 …
                         } kind; // Kind
                 } header; // Header
                 char pad[ALIGN - sizeof( Header )];
+                char pad[libAlign() - sizeof( Header )];
                 char data[0];                                                                   // storage
         }; // Storage
         static_assert( ALIGN >= sizeof( Storage ), "ALIGN < sizeof( Storage )" );
+        static_assert( libAlign() >= sizeof( Storage ), "libAlign() < sizeof( Storage )" );
         struct FreeHeader {
 …
 #define __STATISTICS__
+// Bucket size must be multiple of 16.
 // Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size.
 static const unsigned int bucketSizes[] @= {                    // different bucket sizes
+, 32, 48, 64,
++ sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224,
++ sizeof(HeapManager.Storage), 320, 384, 448, 512 + sizeof(HeapManager.Storage), 640, 768, 896,
+_024 + sizeof(HeapManager.Storage), 1_536, 2_048 + sizeof(HeapManager.Storage), 2_560, 3_072, 3_584, 4_096 + sizeof(HeapManager.Storage), 6_144,
+_192 + sizeof(HeapManager.Storage), 9_216, 10_240, 11_264, 12_288, 13_312, 14_336, 15_360,
+_384 + sizeof(HeapManager.Storage), 18_432, 20_480, 22_528, 24_576, 26_624, 28_672, 30_720,
+_768 + sizeof(HeapManager.Storage), 36_864, 40_960, 45_056, 49_152, 53_248, 57_344, 61_440,
+_536 + sizeof(HeapManager.Storage), 73_728, 81_920, 90_112, 98_304, 106_496, 114_688, 122_880,
+_072 + sizeof(HeapManager.Storage), 147_456, 163_840, 180_224, 196_608, 212_992, 229_376, 245_760,
+_144 + sizeof(HeapManager.Storage), 294_912, 327_680, 360_448, 393_216, 425_984, 458_752, 491_520,
+_288 + sizeof(HeapManager.Storage), 655_360, 786_432, 917_504, 1_048_576 + sizeof(HeapManager.Storage), 1_179_648, 1_310_720, 1_441_792,
+_572_864, 1_703_936, 1_835_008, 1_966_080, 2_097_152 + sizeof(HeapManager.Storage), 2_621_440, 3_145_728, 3_670_016,
+_194_304 + sizeof(HeapManager.Storage)
+, 32, 48, 64 + sizeof(HeapManager.Storage), // 4
+, 112, 128 + sizeof(HeapManager.Storage), // 3
+, 192, 224, 256 + sizeof(HeapManager.Storage), // 4
+, 384, 448, 512 + sizeof(HeapManager.Storage), // 4
+, 768, 896, 1_024 + sizeof(HeapManager.Storage), // 4
+_536, 2_048 + sizeof(HeapManager.Storage), // 2
+_560, 3_072, 3_584, 4_096 + sizeof(HeapManager.Storage), // 4
+_144, 8_192 + sizeof(HeapManager.Storage), // 2
+_216, 10_240, 11_264, 12_288, 13_312, 14_336, 15_360, 16_384 + sizeof(HeapManager.Storage), // 8
+_432, 20_480, 22_528, 24_576, 26_624, 28_672, 30_720, 32_768 + sizeof(HeapManager.Storage), // 8
+_864, 40_960, 45_056, 49_152, 53_248, 57_344, 61_440, 65_536 + sizeof(HeapManager.Storage), // 8
+_728, 81_920, 90_112, 98_304, 106_496, 114_688, 122_880, 131_072 + sizeof(HeapManager.Storage), // 8
+_456, 163_840, 180_224, 196_608, 212_992, 229_376, 245_760, 262_144 + sizeof(HeapManager.Storage), // 8
+_912, 327_680, 360_448, 393_216, 425_984, 458_752, 491_520, 524_288 + sizeof(HeapManager.Storage), // 8
+_360, 786_432, 917_504, 1_048_576 + sizeof(HeapManager.Storage), // 4
+_179_648, 1_310_720, 1_441_792, 1_572_864, 1_703_936, 1_835_008, 1_966_080, 2_097_152 + sizeof(HeapManager.Storage), // 8
+_621_440, 3_145_728, 3_670_016, 4_194_304 + sizeof(HeapManager.Storage), // 4
 };
 …
 static unsigned char lookup[LookupSizes];                               // O(1) lookup for small sizes
 #endif // FASTLOOKUP
 static int mmapFd = -1;                                                                 // fake or actual fd for anonymous file
 #ifdef __CFA_DEBUG__
 static bool heapBoot = 0;                                                               // detect recursion during boot
 …
 static HeapManager heapManager __attribute__(( aligned (128) )) @= {}; // size of cache line to prevent false sharing
-// #comment TD : The return type of this function should be commented
-static inline bool setMmapStart( size_t value ) {
-  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
-        mmapStart = value;                                                                      // set global
-        // find the closest bucket size less than or equal to the mmapStart size
-        maxBucketsUsed = bsearchl( (unsigned int)mmapStart, bucketSizes, NoBucketSizes ); // binary search
-        assert( maxBucketsUsed < NoBucketSizes );                       // subscript failure ?
-        assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ?
-        return false;
-} // setMmapStart
-static void ?{}( HeapManager & manager ) with ( manager ) {
-        pageSize = sysconf( _SC_PAGESIZE );
-        for ( unsigned int i = 0; i < NoBucketSizes; i += 1 ) { // initialize the free lists
-                freeLists[i].blockSize = bucketSizes[i];
-        } // for
-        #ifdef FASTLOOKUP
-        unsigned int idx = 0;
-        for ( unsigned int i = 0; i < LookupSizes; i += 1 ) {
-                if ( i > bucketSizes[idx] ) idx += 1;
-                lookup[i] = idx;
-        } // for
-        #endif // FASTLOOKUP
-        if ( setMmapStart( default_mmap_start() ) ) {
-                abort( "HeapManager : internal error, mmap start initialization failure." );
-        } // if
-        heapExpand = default_heap_expansion();
-        char * End = (char *)sbrk( 0 );
-        sbrk( (char *)libCeiling( (long unsigned int)End, libAlign() ) - End ); // move start of heap to multiple of alignment
-        heapBegin = heapEnd = sbrk( 0 );                                        // get new start point
-} // HeapManager
-static void ^?{}( HeapManager & ) {
-        #ifdef __STATISTICS__
-        // if ( traceHeapTerm() ) {
-        //      printStats();
-        //      if ( checkfree() ) checkFree( heapManager, true );
-        // } // if
-        #endif // __STATISTICS__
-} // ~HeapManager
-static void memory_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_MEMORY ) ));
-void memory_startup( void ) {
-        #ifdef __CFA_DEBUG__
-        if ( unlikely( heapBoot ) ) {                                           // check for recursion during system boot
-                // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
-                abort( "boot() : internal error, recursively invoked during system boot." );
-        } // if
-        heapBoot = true;
-        #endif // __CFA_DEBUG__
-        //assert( heapManager.heapBegin != 0 );
-        //heapManager{};
-        if ( heapManager.heapBegin == 0 ) heapManager{};
-} // memory_startup
-static void memory_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_MEMORY ) ));
-void memory_shutdown( void ) {
-        ^heapManager{};
-} // memory_shutdown
 #ifdef __STATISTICS__
+static unsigned long long int mmap_storage;                             // heap statistics counters
+// Heap statistics counters.
+static unsigned long long int mmap_storage;
 static unsigned int mmap_calls;
 static unsigned long long int munmap_storage;
 …
 static unsigned long long int realloc_storage;
 static unsigned int realloc_calls;
+static int statfd;                                                                              // statistics file descriptor (changed by malloc_stats_fd)
+// Statistics file descriptor (changed by malloc_stats_fd).
+static int statfd = STDERR_FILENO;                                              // default stderr
 // Use "write" because streams may be shutdown when calls are made.
 static void printStats() {
         char helpText[512];
         __cfaabi_dbg_bits_print_buffer( helpText, sizeof(helpText),
+        __cfaabi_bits_print_buffer( STDERR_FILENO, helpText, sizeof(helpText),
                                                                         "\nHeap statistics:\n"
                                                                         "  malloc: calls %u / storage %llu\n"
 …
                                                 sbrk_calls, sbrk_storage
                 );
+        return write( fileno( stream ), helpText, len );        // -1 => error
+        __cfaabi_bits_write( fileno( stream ), helpText, len ); // ensures all bytes written or exit
+        return len;
 } // printStatsXML
 #endif // __STATISTICS__
+// #comment TD : Is this the samething as Out-of-Memory?
 static inline void noMemory() {
         abort( "Heap memory exhausted at %zu bytes.\n"
                    "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
                    ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
 } // noMemory
+// static inline void noMemory() {
+//      abort( "Heap memory exhausted at %zu bytes.\n"
+//                 "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
+//                 ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
+// } // noMemory
 static inline void checkAlign( size_t alignment ) {
         if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) {
                 abort( "Alignment %zu for memory allocation is less than sizeof(void *) and/or not a power of 2.", alignment );
+        if ( alignment < libAlign() || ! libPow2( alignment ) ) {
+                abort( "Alignment %zu for memory allocation is less than %d and/or not a power of 2.", alignment, libAlign() );
         } // if
 } // checkAlign
 …
+static inline void checkHeader( bool check, const char * name, void * addr ) {
+        if ( unlikely( check ) ) {                                                      // bad address ?
+                abort( "Attempt to %s storage %p with address outside the heap.\n"
+                           "Possible cause is duplicate free on same block or overwriting of memory.",
+                           name, addr );
+        } // if
+} // checkHeader
+// #comment TD : function should be commented and/or have a more evocative name
+//               this isn't either a check or a constructor which is what I would expect this function to be
+static inline void fakeHeader( HeapManager.Storage.Header *& header, size_t & size, size_t & alignment ) {
+        if ( unlikely( (header->kind.fake.alignment & 1) == 1 ) ) { // fake header ?
+                size_t offset = header->kind.fake.offset;
+                alignment = header->kind.fake.alignment & -2;   // remove flag from value
+                #ifdef __CFA_DEBUG__
+                checkAlign( alignment );                                                // check alignment
+                #endif // __CFA_DEBUG__
+                header = (HeapManager.Storage.Header *)((char *)header - offset);
+        } // if
+} // fakeHeader
+// #comment TD : Why is this a define
+#define headerAddr( addr ) ((HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ))
+static inline bool headers( const char * name, void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
+        header = headerAddr( addr );
+        if ( unlikely( heapEnd < addr ) ) {                                     // mmapped ?
+                fakeHeader( header, size, alignment );
+                size = header->kind.real.blockSize & -3;                // mmap size
+                return true;
+        } // if
+        #ifdef __CFA_DEBUG__
+        checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+        #endif // __CFA_DEBUG__
+        // #comment TD : This code looks weird...
+        //               It's called as the first statement of both branches of the last if, with the same parameters in all cases
+        // header may be safe to dereference
+        fakeHeader( header, size, alignment );
+        #ifdef __CFA_DEBUG__
+        checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
+        #endif // __CFA_DEBUG__
+        freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
+        #ifdef __CFA_DEBUG__
+        if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
+                abort( "Attempt to %s storage %p with corrupted header.\n"
+                           "Possible cause is duplicate free on same block or overwriting of header information.",
+                           name, addr );
+        } // if
+        #endif // __CFA_DEBUG__
+        size = freeElem->blockSize;
+        return false;
+} // headers
+static inline void * extend( size_t size ) with ( heapManager ) {
+        lock( extlock __cfaabi_dbg_ctx2 );
+        ptrdiff_t rem = heapRemaining - size;
+        if ( rem < 0 ) {
+                // If the size requested is bigger than the current remaining storage, increase the size of the heap.
+                size_t increase = libCeiling( size > heapExpand ? size : heapExpand, libAlign() );
+                if ( sbrk( increase ) == (void *)-1 ) {
+                        unlock( extlock );
+                        errno = ENOMEM;
+                        return 0;
+                } // if
+                #ifdef __STATISTICS__
+                sbrk_calls += 1;
+                sbrk_storage += increase;
+                #endif // __STATISTICS__
+                #ifdef __CFA_DEBUG__
+                // Set new memory to garbage so subsequent uninitialized usages might fail.
+                memset( (char *)heapEnd + heapRemaining, '\377', increase );
+                #endif // __CFA_DEBUG__
+                rem = heapRemaining + increase - size;
+        } // if
+        HeapManager.Storage * block = (HeapManager.Storage *)heapEnd;
+        heapRemaining = rem;
+        heapEnd = (char *)heapEnd + size;
+        unlock( extlock );
+        return block;
+} // extend
+// thunk problem
 size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
         size_t l = 0, m, h = dim;
 …
+static inline bool setMmapStart( size_t value ) {               // true => mmapped, false => sbrk
+  if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
+        mmapStart = value;                                                                      // set global
+        // find the closest bucket size less than or equal to the mmapStart size
+        maxBucketsUsed = Bsearchl( (unsigned int)mmapStart, bucketSizes, NoBucketSizes ); // binary search
+        assert( maxBucketsUsed < NoBucketSizes );                       // subscript failure ?
+        assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ?
+        return false;
+} // setMmapStart
+static inline void checkHeader( bool check, const char name[], void * addr ) {
+        if ( unlikely( check ) ) {                                                      // bad address ?
+                abort( "Attempt to %s storage %p with address outside the heap.\n"
+                           "Possible cause is duplicate free on same block or overwriting of memory.",
+                           name, addr );
+        } // if
+} // checkHeader
+static inline void fakeHeader( HeapManager.Storage.Header *& header, size_t & alignment ) {
+        if ( unlikely( (header->kind.fake.alignment & 1) == 1 ) ) { // fake header ?
+                size_t offset = header->kind.fake.offset;
+                alignment = header->kind.fake.alignment & -2;   // remove flag from value
+                #ifdef __CFA_DEBUG__
+                checkAlign( alignment );                                                // check alignment
+                #endif // __CFA_DEBUG__
+                header = (HeapManager.Storage.Header *)((char *)header - offset);
+        } // if
+} // fakeHeader
+// <-------+----------------------------------------------------> bsize (bucket size)
+// |header |addr
+//==================================================================================
+//                                | alignment
+// <-----------------<------------+-----------------------------> bsize (bucket size)
+//                   |fake-header | addr
+#define headerAddr( addr ) ((HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) ))
+// <-------<<--------------------- dsize ---------------------->> bsize (bucket size)
+// |header |addr
+//==================================================================================
+//                                | alignment
+// <------------------------------<<---------- dsize --------->>> bsize (bucket size)
+//                   |fake-header |addr
+#define dataStorage( bsize, addr, header ) (bsize - ( (char *)addr - (char *)header ))
+static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
+        header = headerAddr( addr );
+        if ( unlikely( heapEnd < addr ) ) {                                     // mmapped ?
+                fakeHeader( header, alignment );
+                size = header->kind.real.blockSize & -3;                // mmap size
+                return true;
+        } // if
+        #ifdef __CFA_DEBUG__
+        checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
+        #endif // __CFA_DEBUG__
+        // header may be safe to dereference
+        fakeHeader( header, alignment );
+        #ifdef __CFA_DEBUG__
+        checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
+        #endif // __CFA_DEBUG__
+        freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
+        #ifdef __CFA_DEBUG__
+        if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
+                abort( "Attempt to %s storage %p with corrupted header.\n"
+                           "Possible cause is duplicate free on same block or overwriting of header information.",
+                           name, addr );
+        } // if
+        #endif // __CFA_DEBUG__
+        size = freeElem->blockSize;
+        return false;
+} // headers
+static inline void * extend( size_t size ) with ( heapManager ) {
+        lock( extlock __cfaabi_dbg_ctx2 );
+        ptrdiff_t rem = heapRemaining - size;
+        if ( rem < 0 ) {
+                // If the size requested is bigger than the current remaining storage, increase the size of the heap.
+                size_t increase = libCeiling( size > heapExpand ? size : heapExpand, libAlign() );
+                if ( sbrk( increase ) == (void *)-1 ) {
+                        unlock( extlock );
+                        errno = ENOMEM;
+                        return 0p;
+                } // if
+                #ifdef __STATISTICS__
+                sbrk_calls += 1;
+                sbrk_storage += increase;
+                #endif // __STATISTICS__
+                #ifdef __CFA_DEBUG__
+                // Set new memory to garbage so subsequent uninitialized usages might fail.
+                memset( (char *)heapEnd + heapRemaining, '\377', increase );
+                #endif // __CFA_DEBUG__
+                rem = heapRemaining + increase - size;
+        } // if
+        HeapManager.Storage * block = (HeapManager.Storage *)heapEnd;
+        heapRemaining = rem;
+        heapEnd = (char *)heapEnd + size;
+        unlock( extlock );
+        return block;
+} // extend
 static inline void * doMalloc( size_t size ) with ( heapManager ) {
         HeapManager.Storage * block;                                            // pointer to new block of storage
 …
         // along with the block and is a multiple of the alignment size.
   if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0;
+  if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0p;
         size_t tsize = size + sizeof(HeapManager.Storage);
         if ( likely( tsize < mmapStart ) ) {                            // small size => sbrk
 …
                 block = freeElem->freeList.pop();
                 #endif // SPINLOCK
                 if ( unlikely( block == 0 ) ) {                                 // no free block ?
+                if ( unlikely( block == 0p ) ) {                                // no free block ?
                         #if defined( SPINLOCK )
                         unlock( freeElem->lock );
 …
                         block = (HeapManager.Storage *)extend( tsize ); // mutual exclusion on call
   if ( unlikely( block == 0 ) ) return 0;
                         #if defined( SPINLOCK )
+  if ( unlikely( block == 0p ) ) return 0p;
+                #if defined( SPINLOCK )
                 } else {
                         freeElem->freeList = block->header.kind.real.next;
                         unlock( freeElem->lock );
                         #endif // SPINLOCK
+                #endif // SPINLOCK
                 } // if
                 block->header.kind.real.home = freeElem;                // pointer back to free list of apropriate size
         } else {                                                                                        // large size => mmap
   if ( unlikely( size > ~0ul - pageSize ) ) return 0;
+  if ( unlikely( size > ~0ul - pageSize ) ) return 0p;
                 tsize = libCeiling( tsize, pageSize );                  // must be multiple of page size
                 #ifdef __STATISTICS__
 …
         } // if
         void * area = &(block->data);                                           // adjust off header to user bytes
+        void * addr = &(block->data);                                           // adjust off header to user bytes
         #ifdef __CFA_DEBUG__
         assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
+        assert( ((uintptr_t)addr & (libAlign() - 1)) == 0 ); // minimum alignment ?
         __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
         if ( traceHeap() ) {
                 enum { BufferSize = 64 };
                 char helpText[BufferSize];
                 int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize );
                 // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size );
                 __cfaabi_dbg_bits_write( helpText, len );
+                int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", addr, size, tsize );
+                // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", addr, size );
+                __cfaabi_bits_write( STDERR_FILENO, helpText, len ); // print debug/nodebug
         } // if
         #endif // __CFA_DEBUG__
         return area;
+        return addr;
 } // doMalloc
 …
 static inline void doFree( void * addr ) with ( heapManager ) {
         #ifdef __CFA_DEBUG__
         if ( unlikely( heapManager.heapBegin == 0 ) ) {
+        if ( unlikely( heapManager.heapBegin == 0p ) ) {
                 abort( "doFree( %p ) : internal error, called before heap is initialized.", addr );
         } // if
 …
                 char helpText[BufferSize];
                 int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
                 __cfaabi_dbg_bits_write( helpText, len );
+                __cfaabi_bits_write( STDERR_FILENO, helpText, len ); // print debug/nodebug
         } // if
         #endif // __CFA_DEBUG__
 …
 size_t checkFree( HeapManager & manager ) with ( manager ) {
+size_t prtFree( HeapManager & manager ) with ( manager ) {
         size_t total = 0;
         #ifdef __STATISTICS__
         __cfaabi_dbg_bits_acquire();
         __cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" );
+        __cfaabi_bits_acquire();
+        __cfaabi_bits_print_nolock( STDERR_FILENO, "\nBin lists (bin size : free blocks on list)\n" );
         #endif // __STATISTICS__
         for ( unsigned int i = 0; i < maxBucketsUsed; i += 1 ) {
 …
                 #if defined( SPINLOCK )
                 for ( HeapManager.Storage * p = freeLists[i].freeList; p != 0; p = p->header.kind.real.next ) {
+                for ( HeapManager.Storage * p = freeLists[i].freeList; p != 0p; p = p->header.kind.real.next ) {
                 #else
                 for ( HeapManager.Storage * p = freeLists[i].freeList.top(); p != 0; p = p->header.kind.real.next.top ) {
+                for ( HeapManager.Storage * p = freeLists[i].freeList.top(); p != 0p; p = p->header.kind.real.next.top ) {
                 #endif // SPINLOCK
                         total += size;
 …
                 #ifdef __STATISTICS__
                 __cfaabi_dbg_bits_print_nolock( "%7zu, %-7u  ", size, N );
                 if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" );
+                __cfaabi_bits_print_nolock( STDERR_FILENO, "%7zu, %-7u  ", size, N );
+                if ( (i + 1) % 8 == 0 ) __cfaabi_bits_print_nolock( STDERR_FILENO, "\n" );
                 #endif // __STATISTICS__
         } // for
         #ifdef __STATISTICS__
         __cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total );
         __cfaabi_dbg_bits_release();
+        __cfaabi_bits_print_nolock( STDERR_FILENO, "\ntotal free blocks:%zu\n", total );
+        __cfaabi_bits_release();
         #endif // __STATISTICS__
         return (char *)heapEnd - (char *)heapBegin - total;
+} // checkFree
+} // prtFree
+static void ?{}( HeapManager & manager ) with ( manager ) {
+        pageSize = sysconf( _SC_PAGESIZE );
+        for ( unsigned int i = 0; i < NoBucketSizes; i += 1 ) { // initialize the free lists
+                freeLists[i].blockSize = bucketSizes[i];
+        } // for
+        #ifdef FASTLOOKUP
+        unsigned int idx = 0;
+        for ( unsigned int i = 0; i < LookupSizes; i += 1 ) {
+                if ( i > bucketSizes[idx] ) idx += 1;
+                lookup[i] = idx;
+        } // for
+        #endif // FASTLOOKUP
+        if ( setMmapStart( default_mmap_start() ) ) {
+                abort( "HeapManager : internal error, mmap start initialization failure." );
+        } // if
+        heapExpand = default_heap_expansion();
+        char * end = (char *)sbrk( 0 );
+        sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment
+        heapBegin = heapEnd = sbrk( 0 );                                        // get new start point
+} // HeapManager
+static void ^?{}( HeapManager & ) {
+        #ifdef __STATISTICS__
+        if ( traceHeapTerm() ) {
+                printStats();
+                // if ( prtfree() ) prtFree( heapManager, true );
+        } // if
+        #endif // __STATISTICS__
+} // ~HeapManager
+static void memory_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_MEMORY ) ));
+void memory_startup( void ) {
+        #ifdef __CFA_DEBUG__
+        if ( unlikely( heapBoot ) ) {                                           // check for recursion during system boot
+                // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
+                abort( "boot() : internal error, recursively invoked during system boot." );
+        } // if
+        heapBoot = true;
+        #endif // __CFA_DEBUG__
+        //assert( heapManager.heapBegin != 0 );
+        //heapManager{};
+        if ( heapManager.heapBegin == 0p ) heapManager{};
+} // memory_startup
+static void memory_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_MEMORY ) ));
+void memory_shutdown( void ) {
+        ^heapManager{};
+} // memory_shutdown
 static inline void * mallocNoStats( size_t size ) {             // necessary for malloc statistics
         //assert( heapManager.heapBegin != 0 );
         if ( unlikely( heapManager.heapBegin == 0 ) ) heapManager{}; // called before memory_startup ?
         void * area = doMalloc( size );
         if ( unlikely( area == 0 ) ) errno = ENOMEM;            // POSIX
         return area;
+        if ( unlikely( heapManager.heapBegin == 0p ) ) heapManager{}; // called before memory_startup ?
+        void * addr = doMalloc( size );
+        if ( unlikely( addr == 0p ) ) errno = ENOMEM;           // POSIX
+        return addr;
 } // mallocNoStats
+static inline void * callocNoStats( size_t noOfElems, size_t elemSize ) {
+        size_t size = noOfElems * elemSize;
+        char * addr = (char *)mallocNoStats( size );
+  if ( unlikely( addr == 0p ) ) return 0p;
+        HeapManager.Storage.Header * header;
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize, alignment;
+        bool mapped __attribute__(( unused )) = headers( "calloc", addr, header, freeElem, bsize, alignment );
+        #ifndef __CFA_DEBUG__
+        // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
+        if ( ! mapped )
+        #endif // __CFA_DEBUG__
+                // Zero entire data space even when > than size => realloc without a new allocation and zero fill works.
+                // <-------00000000000000000000000000000000000000000000000000000> bsize (bucket size)
+                // `-header`-addr                      `-size
+                memset( addr, '\0', bsize - sizeof(HeapManager.Storage) ); // set to zeros
+        header->kind.real.blockSize |= 2;                                       // mark as zero filled
+        return addr;
+} // callocNoStats
 …
         // subtract libAlign() because it is already the minimum alignment
         // add sizeof(Storage) for fake header
+        // #comment TD : this is the only place that calls doMalloc without calling mallocNoStats, why ?
+        char * area = (char *)doMalloc( size + alignment - libAlign() + sizeof(HeapManager.Storage) );
+  if ( unlikely( area == 0 ) ) return area;
+        char * addr = (char *)mallocNoStats( size + alignment - libAlign() + sizeof(HeapManager.Storage) );
+  if ( unlikely( addr == 0p ) ) return addr;
         // address in the block of the "next" alignment address
         char * user = (char *)libCeiling( (uintptr_t)(area + sizeof(HeapManager.Storage)), alignment );
+        char * user = (char *)libCeiling( (uintptr_t)(addr + sizeof(HeapManager.Storage)), alignment );
         // address of header from malloc
         HeapManager.Storage.Header * realHeader = headerAddr( area );
+        HeapManager.Storage.Header * realHeader = headerAddr( addr );
         // address of fake header * before* the alignment location
         HeapManager.Storage.Header * fakeHeader = headerAddr( user );
 …
         return user;
 } // memalignNoStats
+static inline void * cmemalignNoStats( size_t alignment, size_t noOfElems, size_t elemSize ) {
+        size_t size = noOfElems * elemSize;
+        char * addr = (char *)memalignNoStats( alignment, size );
+  if ( unlikely( addr == 0p ) ) return 0p;
+        HeapManager.Storage.Header * header;
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize;
+        bool mapped __attribute__(( unused )) = headers( "cmemalign", addr, header, freeElem, bsize, alignment );
+        #ifndef __CFA_DEBUG__
+        // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
+        if ( ! mapped )
+        #endif // __CFA_DEBUG__
+                memset( addr, '\0', dataStorage( bsize, addr, header ) ); // set to zeros
+        header->kind.real.blockSize |= 2;                               // mark as zero filled
+        return addr;
+} // cmemalignNoStats
 …
 extern "C" {
         // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
         // initialized. If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be
+        // initialized. If size is 0, then malloc() returns either 0p, or a unique pointer value that can later be
         // successfully passed to free().
         void * malloc( size_t size ) {
 …
         // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to
         // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either NULL, or a
+        // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a
         // unique pointer value that can later be successfully passed to free().
         void * calloc( size_t noOfElems, size_t elemSize ) {
-                size_t size = noOfElems * elemSize;
                 #ifdef __STATISTICS__
                 __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                char * area = (char *)mallocNoStats( size );
+          if ( unlikely( area == 0 ) ) return 0;
+                __atomic_add_fetch( &calloc_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return callocNoStats( noOfElems, elemSize );
+        } // calloc
+        // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
+        // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
+        // is larger than the old size, the added memory will not be initialized.  If ptr is 0p, then the call is
+        // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not 0p, then the call
+        // is equivalent to free(ptr). Unless ptr is 0p, it must have been returned by an earlier call to malloc(),
+        // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
+        void * realloc( void * oaddr, size_t size ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+          if ( unlikely( size == 0 ) ) { free( oaddr ); return mallocNoStats( size ); } // special cases
+          if ( unlikely( oaddr == 0p ) ) return mallocNoStats( size );
                 HeapManager.Storage.Header * header;
                 HeapManager.FreeHeader * freeElem;
+                size_t asize, alignment;
+                bool mapped __attribute__(( unused )) = headers( "calloc", area, header, freeElem, asize, alignment );
+                #ifndef __CFA_DEBUG__
+                // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
+                if ( ! mapped )
+                #endif // __CFA_DEBUG__
+                        memset( area, '\0', asize - sizeof(HeapManager.Storage) ); // set to zeros
+                header->kind.real.blockSize |= 2;                               // mark as zero filled
+                return area;
+        } // calloc
+        // #comment TD : Document this function
+        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) {
+                size_t size = noOfElems * elemSize;
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                char * area = (char *)memalignNoStats( alignment, size );
+          if ( unlikely( area == 0 ) ) return 0;
+                HeapManager.Storage.Header * header;
+                HeapManager.FreeHeader * freeElem;
+                size_t asize;
+                bool mapped __attribute__(( unused )) = headers( "cmemalign", area, header, freeElem, asize, alignment );
+                #ifndef __CFA_DEBUG__
+                // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
+                if ( ! mapped )
+                        #endif // __CFA_DEBUG__
+                        memset( area, '\0', asize - ( (char *)area - (char *)header ) ); // set to zeros
+                header->kind.real.blockSize |= 2;                               // mark as zero filled
+                return area;
+        } // cmemalign
+        // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
+        // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
+        // is larger than the old size, the added memory will not be initialized.  If ptr is NULL, then the call is
+        // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call
+        // is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(),
+        // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
+        void * realloc( void * addr, size_t size ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+          if ( unlikely( addr == 0 ) ) return mallocNoStats( size ); // special cases
+          if ( unlikely( size == 0 ) ) { free( addr ); return 0; }
+                HeapManager.Storage.Header * header;
+                HeapManager.FreeHeader * freeElem;
+                size_t asize, alignment = 0;
+                headers( "realloc", addr, header, freeElem, asize, alignment );
+                size_t usize = asize - ( (char *)addr - (char *)header ); // compute the amount of user storage in the block
+                if ( usize >= size ) {                                                  // already sufficient storage
+                size_t bsize, oalign = 0;
+                headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+                size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+          if ( size <= odsize && odsize <= size * 2 ) { // allow up to 50% wasted storage in smaller size
+                        // Do not know size of original allocation => cannot do 0 fill for any additional space because do not know
+                        // where to start filling, i.e., do not overwrite existing values in space.
+                        //
                         // This case does not result in a new profiler entry because the previous one still exists and it must match with
                         // the free for this memory.  Hence, this realloc does not appear in the profiler output.
                         return addr;
+                        return oaddr;
                 } // if
 …
                 #endif // __STATISTICS__
+                void * area;
+                if ( unlikely( alignment != 0 ) ) {                             // previous request memalign?
+                        area = memalign( alignment, size );                     // create new aligned area
+                // change size and copy old content to new storage
+                void * naddr;
+                if ( unlikely( oalign != 0 ) ) {                                // previous request memalign?
+                        if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill
+                                naddr = cmemalignNoStats( oalign, 1, size ); // create new aligned area
+                        } else {
+                                naddr = memalignNoStats( oalign, size ); // create new aligned area
+                        } // if
                 } else {
+                        area = mallocNoStats( size );                           // create new area
+                        if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill
+                                naddr = callocNoStats( 1, size );               // create new area
+                        } else {
+                                naddr = mallocNoStats( size );                  // create new area
+                        } // if
                 } // if
+          if ( unlikely( area == 0 ) ) return 0;
+                if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill (calloc/cmemalign) ?
+                        assert( (header->kind.real.blockSize & 1) == 0 );
+                        bool mapped __attribute__(( unused )) = headers( "realloc", area, header, freeElem, asize, alignment );
+                        #ifndef __CFA_DEBUG__
+                        // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
+                        if ( ! mapped )
+                        #endif // __CFA_DEBUG__
+                                memset( (char *)area + usize, '\0', asize - ( (char *)area - (char *)header ) - usize ); // zero-fill back part
+                        header->kind.real.blockSize |= 2;                       // mark new request as zero fill
+                } // if
+                memcpy( area, addr, usize );                                    // copy bytes
+                free( addr );
+                return area;
+          if ( unlikely( naddr == 0p ) ) return 0p;
+                headers( "realloc", naddr, header, freeElem, bsize, oalign );
+                size_t ndsize = dataStorage( bsize, naddr, header ); // data storage avilable in bucket
+                // To preserve prior fill, the entire bucket must be copied versus the size.
+                memcpy( naddr, oaddr, MIN( odsize, ndsize ) );  // copy bytes
+                free( oaddr );
+                return naddr;
         } // realloc
 …
                 #endif // __STATISTICS__
+                void * area = memalignNoStats( alignment, size );
+                return area;
+                return memalignNoStats( alignment, size );
         } // memalign
+        // The cmemalign() function is the same as calloc() with memory alignment.
+        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) {
+                #ifdef __STATISTICS__
+                __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
+                __atomic_add_fetch( &cmemalign_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST );
+                #endif // __STATISTICS__
+                return cmemalignNoStats( alignment, noOfElems, elemSize );
+        } // cmemalign
         // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a
 …
         // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The
         // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of
         // sizeof(void *). If size is 0, then posix_memalign() returns either NULL, or a unique pointer value that can later
+        // sizeof(void *). If size is 0, then posix_memalign() returns either 0p, or a unique pointer value that can later
         // be successfully passed to free(3).
         int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
           if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
                 * memptr = memalign( alignment, size );
           if ( unlikely( * memptr == 0 ) ) return ENOMEM;
+          if ( unlikely( * memptr == 0p ) ) return ENOMEM;
                 return 0;
         } // posix_memalign
 …
         // The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to
         // malloc(), calloc() or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior
         // occurs. If ptr is NULL, no operation is performed.
+        // occurs. If ptr is 0p, no operation is performed.
         void free( void * addr ) {
                 #ifdef __STATISTICS__
 …
                 #endif // __STATISTICS__
+                // #comment TD : To decrease nesting I would but the special case in the
+                //               else instead, plus it reads more naturally to have the
+                //               short / normal case instead
+                if ( unlikely( addr == 0 ) ) {                                  // special case
+                        #ifdef __CFA_DEBUG__
+                        if ( traceHeap() ) {
+                                #define nullmsg "Free( 0x0 ) size:0\n"
+                                // Do not debug print free( 0 ), as it can cause recursive entry from sprintf.
+                                __cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 );
+                        } // if
+                        #endif // __CFA_DEBUG__
+          if ( unlikely( addr == 0p ) ) {                                       // special case
+                        // #ifdef __CFA_DEBUG__
+                        // if ( traceHeap() ) {
+                        //      #define nullmsg "Free( 0x0 ) size:0\n"
+                        //      // Do not debug print free( 0p ), as it can cause recursive entry from sprintf.
+                        //      __cfaabi_dbg_write( nullmsg, sizeof(nullmsg) - 1 );
+                        // } // if
+                        // #endif // __CFA_DEBUG__
                         return;
                 } // exit
 …
         } // free
+        // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
+        // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
+        // parameter.
+        int mallopt( int option, int value ) {
+                choose( option ) {
+                  case M_TOP_PAD:
+                        if ( setHeapExpand( value ) ) fallthru default;
+                  case M_MMAP_THRESHOLD:
+                        if ( setMmapStart( value ) ) fallthru default;
+                  default:
+                        // #comment TD : 1 for unsopported feels wrong
+                        return 1;                                                                       // success, or unsupported
+                } // switch
+                return 0;                                                                               // error
+        } // mallopt
+        // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
+        // suitable argument).
+        int malloc_trim( size_t ) {
+                return 0;                                                                               // => impossible to release memory
+        } // malloc_trim
+        // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
+        // a block of memory allocated by malloc(3) or a related function.
+        size_t malloc_usable_size( void * addr ) {
+          if ( unlikely( addr == 0 ) ) return 0;                        // null allocation has 0 size
+                HeapManager.Storage.Header * header;
+                HeapManager.FreeHeader * freeElem;
+                size_t size, alignment;
+                headers( "malloc_usable_size", addr, header, freeElem, size, alignment );
+                size_t usize = size - ( (char *)addr - (char *)header ); // compute the amount of user storage in the block
+                return usize;
+        } // malloc_usable_size
+    // The malloc_alignment() function returns the alignment of the allocation.
+        // The malloc_alignment() function returns the alignment of the allocation.
         size_t malloc_alignment( void * addr ) {
           if ( unlikely( addr == 0 ) ) return libAlign();       // minimum alignment
+          if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
                 HeapManager.Storage.Header * header = headerAddr( addr );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
 …
     // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
+        // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
         bool malloc_zero_fill( void * addr ) {
           if ( unlikely( addr == 0 ) ) return false;            // null allocation is not zero fill
+          if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
                 HeapManager.Storage.Header * header = headerAddr( addr );
                 if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
 …
+    // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
+    // related functions.
+        // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
+        // a block of memory allocated by malloc(3) or a related function.
+        size_t malloc_usable_size( void * addr ) {
+          if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
+                HeapManager.Storage.Header * header;
+                HeapManager.FreeHeader * freeElem;
+                size_t bsize, alignment;
+                headers( "malloc_usable_size", addr, header, freeElem, bsize, alignment );
+                return dataStorage( bsize, addr, header );      // data storage in bucket
+        } // malloc_usable_size
+        // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
+        // related functions.
         void malloc_stats( void ) {
                 #ifdef __STATISTICS__
                 printStats();
                 if ( checkFree() ) checkFree( heapManager );
+                if ( prtFree() ) prtFree( heapManager );
                 #endif // __STATISTICS__
         } // malloc_stats
         // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics.
         int malloc_stats_fd( int fd ) {
+        int malloc_stats_fd( int fd __attribute__(( unused )) ) {
                 #ifdef __STATISTICS__
                 int temp = statfd;
 …
         } // malloc_stats_fd
+        // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
+        // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
+        // parameter.
+        int mallopt( int option, int value ) {
+                choose( option ) {
+                  case M_TOP_PAD:
+                        if ( setHeapExpand( value ) ) return 1;
+                  case M_MMAP_THRESHOLD:
+                        if ( setMmapStart( value ) ) return 1;
+                } // switch
+                return 0;                                                                               // error, unsupported
+        } // mallopt
+        // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
+        // suitable argument).
+        int malloc_trim( size_t ) {
+                return 0;                                                                               // => impossible to release memory
+        } // malloc_trim
         // The malloc_info() function exports an XML string that describes the current state of the memory-allocation
         // implementation in the caller.  The string is printed on the file stream stream.  The exported string includes
         // information about all arenas (see malloc(3)).
         int malloc_info( int options, FILE * stream ) {
+                if ( options != 0 ) { errno = EINVAL; return -1; }
                 return printStatsXML( stream );
         } // malloc_info
 …
         // structure is returned as the function result.  (It is the caller's responsibility to free(3) this memory.)
         void * malloc_get_state( void ) {
                 return 0;                                                                               // unsupported
+                return 0p;                                                                              // unsupported
         } // malloc_get_state
 …
+// Must have CFA linkage to overload with C linkage realloc.
+void * realloc( void * oaddr, size_t nalign, size_t size ) {
+        #ifdef __STATISTICS__
+        __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
+        #endif // __STATISTICS__
+        // If size is equal to 0, either NULL or a pointer suitable to be passed to free() is returned.
+  if ( unlikely( size == 0 ) ) { free( oaddr ); return mallocNoStats( size ); } // special cases
+  if ( unlikely( oaddr == 0p ) ) return mallocNoStats( size );
+        if ( unlikely( nalign == 0 ) ) nalign = libAlign();     // reset alignment to minimum
+        #ifdef __CFA_DEBUG__
+        else
+                checkAlign( nalign );                                                   // check alignment
+        #endif // __CFA_DEBUG__
+        HeapManager.Storage.Header * header;
+        HeapManager.FreeHeader * freeElem;
+        size_t bsize, oalign = 0;
+        headers( "realloc", oaddr, header, freeElem, bsize, oalign );
+        size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket
+  if ( oalign != 0 && (uintptr_t)oaddr % nalign == 0 ) { // has alignment and just happens to work out
+                headerAddr( oaddr )->kind.fake.alignment = nalign | 1; // update alignment (could be the same)
+                return realloc( oaddr, size );
+        } // if
+        #ifdef __STATISTICS__
+        __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
+        #endif // __STATISTICS__
+        // change size and copy old content to new storage
+        void * naddr;
+        if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill
+                naddr = cmemalignNoStats( nalign, 1, size );    // create new aligned area
+        } else {
+                naddr = memalignNoStats( nalign, size );                // create new aligned area
+        } // if
+        headers( "realloc", naddr, header, freeElem, bsize, oalign );
+        size_t ndsize = dataStorage( bsize, naddr, header ); // data storage avilable in bucket
+        // To preserve prior fill, the entire bucket must be copied versus the size.
+        memcpy( naddr, oaddr, MIN( odsize, ndsize ) );          // copy bytes
+        free( oaddr );
+        return naddr;
+} // realloc
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/interpose.cfa

-              r807a632
+              r3b56166
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 14 22:57:16 2019
 // Update Count     : 116
+// Last Modified On : Sat Feb  8 08:40:34 2020
+// Update Count     : 163
 //
 …
 #include "bits/signal.hfa"                                                              // sigHandler_?
 #include "startup.hfa"                                                                  // STARTUP_PRIORITY_CORE
+#include <assert.h>
 //=============================================================================================
 …
 typedef void (* generic_fptr_t)(void);
 generic_fptr_t interpose_symbol( const char * symbol, const char * version ) {
+generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
         const char * error;
 …
         void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
         void __cfaabi_interpose_startup( void ) {
                 const char *version = NULL;
+                const char *version = 0p;
                 preload_libgcc();
 …
 #pragma GCC diagnostic pop
+                // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
+                // task stacks might be very small (4K) and the signal delivery corrupts memory to the point that a clean
+                // shutdown is impossible. Also, when a stack overflow encounters the non-accessible sentinel page (debug only)
+                // and generates a segment fault, the signal cannot be delivered on the sentinel page. Finally, calls to abort
+                // print a stack trace that uses substantial stack space.
+                #define MINSTKSZ SIGSTKSZ * 8
+                static char stack[MINSTKSZ] __attribute__(( aligned (16) ));
+                static stack_t ss;
+                ss.ss_sp = stack;
+                ss.ss_size = MINSTKSZ;
+                ss.ss_flags = 0;
+                if ( sigaltstack( &ss, 0p ) == -1 ) {
+                        abort( "__cfaabi_interpose_startup : internal error, sigaltstack error(%d) %s.", errno, strerror( errno ) );
+                } // if
                 // Failure handler
+                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
+                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
+                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
+                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
+                __cfaabi_sigaction( SIGABRT, sigHandler_abrt, SA_SIGINFO | SA_RESETHAND);
+                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
+                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
+                __cfaabi_sigaction( SIGSEGV, sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGBUS , sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGILL , sigHandler_ill , SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGFPE , sigHandler_fpe , SA_SIGINFO | SA_ONSTACK );
+                __cfaabi_sigaction( SIGTERM, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // one shot handler, return to default
+                __cfaabi_sigaction( SIGINT , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
+                __cfaabi_sigaction( SIGABRT, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
+                __cfaabi_sigaction( SIGHUP , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // terminal hangup
+        }
+}
 …
 void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+void abort( bool signalAbort, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 extern "C" {
         void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 abort( NULL );
+                abort( false, "%s", "" );
+        }
 …
                 va_list argp;
                 va_start( argp, fmt );
                 abort( fmt, argp );
+                abort( false, fmt, argp );
                 va_end( argp );
+        }
 …
+}
+void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
+void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
+void kernel_abort_msg( void * data, char buffer[], int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+// See concurrency/kernel.cfa for strong definition used in multi-processor mode.
 int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
 enum { abort_text_size = 1024 };
 static char abort_text[ abort_text_size ];
+static int abort_lastframe;
+void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
+    va_list args;
+    va_start( args, fmt );
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+        __cabi_libc.exit( status );
+}
+void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
+        void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
+        int len;
+        abort_lastframe = kernel_abort_lastframe();
+        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
+        __cfaabi_dbg_bits_write( abort_text, len );
+        if ( fmt ) {
+                va_list args;
+                va_start( args, fmt );
+                len = vsnprintf( abort_text, abort_text_size, fmt, args );
+                va_end( args );
+                __cfaabi_dbg_bits_write( abort_text, len );
+                if ( fmt[strlen( fmt ) - 1] != '\n' ) {         // add optional newline if missing at the end of the format text
+                        __cfaabi_dbg_bits_write( "\n", 1 );
+                }
+        }
+        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cabi_libc.abort();
+}
+static void __cfaabi_backtrace() {
+        enum {
+                Frames = 50,                                                                    // maximum number of stack frames
+                Start = 8,                                                                              // skip first N stack frames
+        };
+static void __cfaabi_backtrace( int start ) {
+        enum { Frames = 50, };                                                          // maximum number of stack frames
+        int last = kernel_abort_lastframe();                            // skip last N stack frames
         void * array[Frames];
         size_t size = backtrace( array, Frames );
+        char ** messages = backtrace_symbols( array, size );
+        // find executable name
+        *index( messages[0], '(' ) = '\0';
+        __cfaabi_dbg_bits_print_nolock( "Stack back trace for: %s\n", messages[0]);
+        for ( int i = Start; i < size - abort_lastframe && messages != NULL; i += 1 ) {
+                char * name = NULL, * offset_begin = NULL, * offset_end = NULL;
+                for ( char * p = messages[i]; *p; ++p ) {
+                        //__cfaabi_dbg_bits_print_nolock( "X %s\n", p);
+                        // find parantheses and +offset
+        char ** messages = backtrace_symbols( array, size ); // does not demangle names
+        *index( messages[0], '(' ) = '\0';                                      // find executable name
+        __cfaabi_bits_print_nolock( STDERR_FILENO, "Stack back trace for: %s\n", messages[0]);
+        for ( unsigned int i = start; i < size - last && messages != 0p; i += 1 ) {
+                char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
+                for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
+                        //__cfaabi_bits_print_nolock( "X %s\n", p);
                         if ( *p == '(' ) {
                                 name = p;
 …
+                }
                 // if line contains symbol print it
                 int frameNo = i - Start;
+                // if line contains symbol, print it
+                int frameNo = i - start;
                 if ( name && offset_begin && offset_end && name < offset_begin ) {
+                        // delimit strings
+                        *name++ = '\0';
+                        *name++ = '\0';                                                         // delimit strings
                         *offset_begin++ = '\0';
                         *offset_end++ = '\0';
                         __cfaabi_dbg_bits_print_nolock( "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
+                        __cfaabi_bits_print_nolock( STDERR_FILENO, "(%i) %s : %s + %s %s\n", frameNo, messages[i], name, offset_begin, offset_end);
                 } else {                                                                                // otherwise, print the whole line
                         __cfaabi_dbg_bits_print_nolock( "(%i) %s\n", frameNo, messages[i] );
+                        __cfaabi_bits_print_nolock( STDERR_FILENO, "(%i) %s\n", frameNo, messages[i] );
+                }
+        }
 …
+}
+void exit( int status, const char fmt[], ... ) {
+        va_list args;
+        va_start( args, fmt );
+        vfprintf( stderr, fmt, args );
+        va_end( args );
+        __cabi_libc.exit( status );
+}
+void abort( bool signalAbort, const char fmt[], ... ) {
+        void * kernel_data = kernel_abort();                            // must be done here to lock down kernel
+        int len;
+        signal( SIGABRT, SIG_DFL );                                                     // prevent final "real" abort from recursing to handler
+        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
+        __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+        assert( fmt );
+        va_list args;
+        va_start( args, fmt );
+        len = vsnprintf( abort_text, abort_text_size, fmt, args );
+        va_end( args );
+        __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+        if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
+                __cfaabi_dbg_write( "\n", 1 );
+        }
+        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cfaabi_backtrace( signalAbort ? 4 : 3 );
+        __cabi_libc.abort();                                                            // print stack trace in handler
+}
+void abort( const char fmt[], ... ) {
+        va_list args;
+        va_start( args, fmt );
+        abort( false, fmt, args );
+        va_end( args );
+}
 void sigHandler_segv( __CFA_SIGPARMS__ ) {
+        abort( "Addressing invalid memory at location %p\n"
+                        "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
+                        sfp->si_addr );
+                if ( sfp->si_addr == 0p ) {
+                        abort( true, "Null pointer (0p) dereference.\n" );
+                } else {
+                        abort( true, "%s at memory location %p.\n"
+                                   "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
+                                   (sig == SIGSEGV ? "Segment fault" : "Bus error"), sfp->si_addr );
+                }
+}
 void sigHandler_ill( __CFA_SIGPARMS__ ) {
         abort( "Executing illegal instruction at location %p.\n"
+        abort( true, "Executing illegal instruction at location %p.\n"
                         "Possible cause is stack corruption.\n",
                         sfp->si_addr );
 …
           default: msg = "unknown";
         } // choose
+        abort( "Computation error %s at location %p.\n", msg, sfp->si_addr );
+}
+void sigHandler_abrt( __CFA_SIGPARMS__ ) {
+        __cfaabi_backtrace();
+        // reset default signal handler
+        __cfaabi_sigdefault( SIGABRT );
+        raise( SIGABRT );
+        abort( true, "Computation error %s at location %p.\n", msg, sfp->si_addr );
+}
 void sigHandler_term( __CFA_SIGPARMS__ ) {
         abort( "Application stopped by %s signal.", sig == SIGINT ? "an interrupt (SIGINT)" : "a terminate (SIGTERM)" );
+        abort( true, "Application interrupted by signal: %s.\n", strsignal( sig ) );
+}

libcfa/src/iostream.cfa

-              r807a632
+              r3b56166
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 13 08:07:59 2019
 // Update Count     : 821
+// Last Modified On : Fri Feb  7 18:48:38 2020
+// Update Count     : 825
 //
 …
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, zero_t ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", 0n );
                 return os;
 …
         ostype & ?|?( ostype & os, one_t ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", 1n );
                 return os;
 …
         ostype & ?|?( ostype & os, bool b ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%s", b ? "true" : "false" );
                 return os;
 …
         ostype & ?|?( ostype & os, char c ) {
                 fmt( os, "%c", c );
                 if ( c == '\n' ) setNL( os, true );
+                if ( c == '\n' ) $setNL( os, true );
                 return sepOff( os );
         } // ?|?
 …
         ostype & ?|?( ostype & os, signed char sc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hhd", sc );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned char usc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hhu", usc );
                 return os;
 …
         ostype & ?|?( ostype & os, short int si ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hd", si );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned short int usi ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%hu", usi );
                 return os;
 …
         ostype & ?|?( ostype & os, int i ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%d", i );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned int ui ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%u", ui );
                 return os;
 …
         ostype & ?|?( ostype & os, long int li ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%ld", li );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long int uli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%lu", uli );
                 return os;
 …
         ostype & ?|?( ostype & os, long long int lli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%lld", lli );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%llu", ulli );
                 return os;
 …
         ostype & ?|?( ostype & os, float f ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%g", f );
                 return os;
 …
         ostype & ?|?( ostype & os, double d ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%.*lg", d, DBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, long double ld ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, float _Complex fc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | crealf( fc ) | nonl;
                 PrintWithDP( os, "%g", crealf( fc ) );
 …
         ostype & ?|?( ostype & os, double _Complex dc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | creal( dc ) | nonl;
                 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
 …
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              os | creall( ldc ) || nonl;
                 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
 …
         } // ?|?
         ostype & ?|?( ostype & os, const char * str ) {
+        ostype & ?|?( ostype & os, const char str[] ) {
                 enum { Open = 1, Close, OpenClose };
                 static const unsigned char mask[256] @= {
 …
                 // first character IS NOT spacing or closing punctuation => add left separator
                 unsigned char ch = str[0];                                              // must make unsigned
                 if ( sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                         fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+                        fmt( os, "%s", $sepGetCur( os ) );
                 } // if
                 // if string starts line, must reset to determine open state because separator is off
                 sepReset( os );                                                                 // reset separator
+                $sepReset( os );                                                                // reset separator
                 // last character IS spacing or opening punctuation => turn off separator for next item
                 size_t len = strlen( str );
                 ch = str[len - 1];                                                              // must make unsigned
                 if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
                         sepOn( os );
                 } else {
                         sepOff( os );
                 } // if
                 if ( ch == '\n' ) setNL( os, true );                    // check *AFTER* sepPrt call above as it resets NL flag
+                if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
                 return write( os, str, len );
         } // ?|?
+        void ?|?( ostype & os, const char * str ) {
+        void ?|?( ostype & os, const char str[] ) {
                 (ostype &)(os | str); ends( os );
         } // ?|?
 //      ostype & ?|?( ostype & os, const char16_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 //      ostype & ?|?( ostype & os, const char32_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
 //      ostype & ?|?( ostype & os, const wchar_t * str ) {
 //              if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+//              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
 //              return os;
 …
         ostype & ?|?( ostype & os, const void * p ) {
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 fmt( os, "%p", p );
                 return os;
 …
         void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
                 (ostype &)(manip( os ));
                 if ( getPrt( os ) ) ends( os );                                 // something printed ?
                 setPrt( os, false );                                                    // turn off
+                if ( $getPrt( os ) ) ends( os );                                // something printed ?
+                $setPrt( os, false );                                                   // turn off
         } // ?|?
 …
         ostype & nl( ostype & os ) {
                 (ostype &)(os | '\n');
                 setPrt( os, false );                                                    // turn off
                 setNL( os, true );
+                $setPrt( os, false );                                                   // turn off
+                $setNL( os, true );
                 flush( os );
                 return sepOff( os );                                                    // prepare for next line
 …
         ostype & nonl( ostype & os ) {
                 setPrt( os, false );                                                    // turn off
+                $setPrt( os, false );                                                   // turn off
                 return os;
         } // nonl
 …
         ostype & ?|?( ostype & os, T arg, Params rest ) {
                 (ostype &)(os | arg);                                                   // print first argument
                 sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
                 return os;
         } // ?|?
 …
                 // (ostype &)(?|?( os, arg, rest )); ends( os );
                 (ostype &)(os | arg);                                                   // print first argument
                 sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
+                $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
+                $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
                 ends( os );
         } // ?|?
 …
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
                 if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
 …
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) ); \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
                 char fmtstr[sizeof(DFMTP)];                                             /* sizeof includes '\0' */ \
                 if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
 …
                 return os; \
         } /* ?|? */ \
+\
         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
 } // distribution
 …
                 } // if
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 #define CFMTNP "% * "
 …
                 return os;
         } // ?|?
         void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
 …
                 } // if
                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
                 #define SFMTNP "% * "
 …
                 return os;
         } // ?|?
         void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
 …
         } // ?|?
         // istype & ?|?( istype & is, const char * fmt ) {
+        // istype & ?|?( istype & is, const char fmt[] ) {
         //      fmt( is, fmt, "" );
         //      return is;

libcfa/src/iostream.hfa

-              r807a632
+              r3b56166
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 12 12:08:38 2019
 // Update Count     : 334
+// Last Modified On : Fri Feb  7 17:53:52 2020
+// Update Count     : 336
 //
 …
 trait ostream( dtype ostype ) {
         // private
         bool sepPrt( ostype & );                                                        // get separator state (on/off)
         void sepReset( ostype & );                                                      // set separator state to default state
         void sepReset( ostype &, bool );                                        // set separator and default state
         const char * sepGetCur( ostype & );                                     // get current separator string
         void sepSetCur( ostype &, const char * );                       // set current separator string
         bool getNL( ostype & );                                                         // check newline
         void setNL( ostype &, bool );                                           // saw newline
         bool getANL( ostype & );                                                        // get auto newline (on/off)
         bool getPrt( ostype & );                                                        // get fmt called in output cascade
         void setPrt( ostype &, bool );                                          // set fmt called in output cascade
+        bool $sepPrt( ostype & );                                                       // get separator state (on/off)
+        void $sepReset( ostype & );                                                     // set separator state to default state
+        void $sepReset( ostype &, bool );                                       // set separator and default state
+        const char * $sepGetCur( ostype & );                            // get current separator string
+        void $sepSetCur( ostype &, const char [] );                     // set current separator string
+        bool $getNL( ostype & );                                                        // check newline
+        void $setNL( ostype &, bool );                                          // saw newline
+        bool $getANL( ostype & );                                                       // get auto newline (on/off)
+        bool $getPrt( ostype & );                                                       // get fmt called in output cascade
+        void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
         // public
         void sepOn( ostype & );                                                         // turn separator state on
 …
         const char * sepGet( ostype & );                                        // get separator string
         void sepSet( ostype &, const char * );                          // set separator to string (15 character maximum)
+        void sepSet( ostype &, const char [] );                         // set separator to string (15 character maximum)
         const char * sepGetTuple( ostype & );                           // get tuple separator string
         void sepSetTuple( ostype &, const char * );                     // set tuple separator to string (15 character maximum)
+        void sepSetTuple( ostype &, const char [] );            // set tuple separator to string (15 character maximum)
         void ends( ostype & os );                                                       // end of output statement
         int fail( ostype & );
         int flush( ostype & );
         void open( ostype & os, const char * name, const char * mode );
+        void open( ostype & os, const char name[], const char mode[] );
         void close( ostype & os );
         ostype & write( ostype &, const char *, size_t );
+        ostype & write( ostype &, const char [], size_t );
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 }; // ostream
 …
         void ?|?( ostype &, long double _Complex );
         ostype & ?|?( ostype &, const char * );
         void ?|?( ostype &, const char * );
+        ostype & ?|?( ostype &, const char [] );
+        void ?|?( ostype &, const char [] );
         // ostype & ?|?( ostype &, const char16_t * );
 #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 …
 static inline {
         _Ostream_Manip(const char *) bin( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
         _Ostream_Manip(const char *) oct( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
         _Ostream_Manip(const char *) hex( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
+        _Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
+        _Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
+        _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
         _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
         _Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
 …
         int fail( istype & );
         int eof( istype & );
         void open( istype & is, const char * name );
+        void open( istype & is, const char name[] );
         void close( istype & is );
         istype & read( istype &, char *, size_t );
 …
         istype & ?|?( istype &, long double _Complex & );
 //      istype & ?|?( istype &, const char * );
+//      istype & ?|?( istype &, const char [] );
         istype & ?|?( istype &, char * );
 …
 static inline {
         _Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
         _Istream_Cstr skip( const char * scanset ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr incl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
         _Istream_Cstr & incl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
         _Istream_Cstr excl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
         _Istream_Cstr & excl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
         _Istream_Cstr ignore( const char * s ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
+        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
+        _Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
+        _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
+        _Istream_Cstr excl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
+        _Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
+        _Istream_Cstr ignore( const char s[] ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
         _Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
         _Istream_Cstr wdi( unsigned int w, char * s ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
+        _Istream_Cstr wdi( unsigned int w, char s[] ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
         _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
 } // distribution

libcfa/src/math.hfa

-              r807a632
+              r3b56166
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 13 11:02:15 2018
 // Update Count     : 116
+// Last Modified On : Tue Feb  4 10:27:11 2020
+// Update Count     : 117
 //
 …
 static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
 static inline float nan( const char * tag ) { return nanf( tag ); }
 // extern "C" { double nan( const char * ); }
 static inline long double nan( const char * tag ) { return nanl( tag ); }
+static inline float nan( const char tag[] ) { return nanf( tag ); }
+// extern "C" { double nan( const char [] ); }
+static inline long double nan( const char tag[] ) { return nanl( tag ); }
 //---------------------- Exponential ----------------------

libcfa/src/rational.cfa

-              r807a632
+              r3b56166
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 12 18:12:08 2019
 // Update Count     : 184
+// Last Modified On : Sat Feb  8 17:56:36 2020
+// Update Count     : 187
 //
 …
         } // rational
+        void ?{}( Rational(RationalImpl) & r, zero_t ) {
+                r{ (RationalImpl){0}, (RationalImpl){1} };
+        } // rational
+        void ?{}( Rational(RationalImpl) & r, one_t ) {
+                r{ (RationalImpl){1}, (RationalImpl){1} };
+        } // rational
         // getter for numerator/denominator

libcfa/src/startup.cfa

-              r807a632
+              r3b56166
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul 25 16:42:01 2018
 // Update Count     : 11
+// Last Modified On : Tue Feb  4 13:03:18 2020
+// Update Count     : 30
 //
+#include <time.h>                                                                               // tzset
 #include "startup.hfa"
-#include <unistd.h>
 extern "C" {
     static void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
+    void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_startup( void ) {
+                tzset();                                                                                // initialize time global variables
                 #ifdef __CFA_DEBUG__
                 extern void heapAppStart();
 …
     } // __cfaabi_appready_startup
     static void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
+    void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_shutdown( void ) {
                 #ifdef __CFA_DEBUG__
 …
 struct __spinlock_t;
 extern "C" {
         void __cfaabi_dbg_record(struct __spinlock_t & this, const char * prev_name) __attribute__(( weak )) {}
+        void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
+}

libcfa/src/stdhdr/assert.h

-              r807a632
+              r3b56166
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 31 23:09:32 2017
 // Update Count     : 13
+// Last Modified On : Tue Feb  4 12:58:49 2020
+// Update Count     : 15
 //
 …
         #define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
         void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
+        void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) __attribute__((noreturn, format( printf, 5, 6) ));
 #endif

libcfa/src/stdhdr/bfdlink.h

-              r807a632
+              r3b56166
 // Created On       : Tue Jul 18 07:26:04 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 22 13:49:30 2018
 // Update Count     : 4
+// Last Modified On : Fri Feb  7 19:05:08 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "with".
 #if ! defined( with )                                                                   // nesting ?
 #define with `with`                                                                             // make keyword an identifier
+#define with ``with                                                                             // make keyword an identifier
 #define __CFA_BFDLINK_H__
 #endif

libcfa/src/stdhdr/hwloc.h

-              r807a632
+              r3b56166
 // Created On       : Tue Jul 18 07:45:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 22 13:49:58 2018
 // Update Count     : 4
+// Last Modified On : Fri Feb  7 19:05:18 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "thread".
 #if ! defined( thread )                                                                 // nesting ?
 #define thread `thread`                                                                 // make keyword an identifier
+#define thread ``thread                                                                 // make keyword an identifier
 #define __CFA_HWLOC_H__
 #endif

libcfa/src/stdhdr/krb5.h

-              r807a632
+              r3b56166
 // Created On       : Tue Jul 18 07:55:44 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jul 22 13:50:24 2018
 // Update Count     : 4
+// Last Modified On : Fri Feb  7 19:05:35 2020
+// Update Count     : 6
 //
 // include file uses the CFA keyword "enable".
 #if ! defined( enable )                                                                 // nesting ?
 #define enable `enable`                                                                 // make keyword an identifier
+#define enable ``enable                                                                 // make keyword an identifier
 #define __CFA_KRB5_H__
 #endif

libcfa/src/stdhdr/math.h

-              r807a632
+              r3b56166
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 22 18:16:07 2018
 // Update Count     : 13
+// Last Modified On : Fri Feb  7 19:05:27 2020
+// Update Count     : 15
 //
 extern "C" {
 #if ! defined( exception )                                                              // nesting ?
 #define exception `exception`                                                   // make keyword an identifier
+#define exception ``exception                                                   // make keyword an identifier
 #define __CFA_MATH_H__
 #endif

libcfa/src/stdhdr/sys/ucontext.h

-              r807a632
+              r3b56166
 // Created On       : Thu Feb  8 23:48:16 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  8 23:50:44 2018
 // Update Count     : 4
+// Last Modified On : Fri Feb  7 19:05:41 2020
+// Update Count     : 6
 //
 #if ! defined( ftype )                                                                  // nesting ?
 #define ftype `ftype`                                                                   // make keyword an identifier
+#define ftype ``ftype                                                                   // make keyword an identifier
 #define __CFA_UCONTEXT_H__
 #endif

libcfa/src/stdlib.cfa

-              r807a632
+              r3b56166
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Oct 22 08:57:52 2019
 // Update Count     : 478
+// Last Modified On : Tue Feb  4 08:27:08 2020
+// Update Count     : 486
 //
 …
         T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
                 size_t olen = malloc_usable_size( ptr );                // current allocation
                 char * nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
                 size_t nlen = malloc_usable_size( nptr );               // new allocation
                 if ( nlen > olen ) {                                                    // larger ?
                         memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
                 } // if
                 return (T *)nptr;
         } // alloc_set
-        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
-                char * nptr;
-                size_t alignment = malloc_alignment( ptr );
-                if ( align != alignment && (uintptr_t)ptr % align != 0 ) {
-                        size_t olen = malloc_usable_size( ptr );        // current allocation
-                        nptr = (char *)memalign( align, olen );
-                        size_t nlen = malloc_usable_size( nptr );       // new allocation
-                        size_t lnth = olen < nlen ? olen : nlen;        // min
-                        memcpy( nptr, ptr, lnth );                                      // initialize storage
-                        free( ptr );
-                } else {
-                        nptr = (char *)ptr;
-                } // if
-                return (T *)nptr;
-        } // alloc_align
-        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
-                char * nptr;
-                size_t alignment = malloc_alignment( ptr );
-                if ( align != alignment ) {
-                        size_t olen = malloc_usable_size( ptr );        // current allocation
-                        nptr = (char *)memalign( align, dim * sizeof(T) );
-                        size_t nlen = malloc_usable_size( nptr );       // new allocation
-                        size_t lnth = olen < nlen ? olen : nlen;        // min
-                        memcpy( nptr, ptr, lnth );                                      // initialize storage
-                        free( ptr );
-                } else {
-                        nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
-                } // if
-                return (T *)nptr;
-        } // alloc_align
         T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
                 size_t olen = malloc_usable_size( ptr );                // current allocation
+                char * nptr = alloc_align( ptr, align );
+                void * nptr = (void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+                // char * nptr = alloc_align( ptr, align );
                 size_t nlen = malloc_usable_size( nptr );               // new allocation
                 if ( nlen > olen ) {                                                    // larger ?
                         memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
                 } // if
                 return (T *)nptr;
 …
 //---------------------------------------
 float _Complex strto( const char * sptr, char ** eptr ) {
+float _Complex strto( const char sptr[], char ** eptr ) {
         float re, im;
         char * eeptr;
 …
 } // strto
 double _Complex strto( const char * sptr, char ** eptr ) {
+double _Complex strto( const char sptr[], char ** eptr ) {
         double re, im;
         char * eeptr;
 …
 } // strto
 long double _Complex strto( const char * sptr, char ** eptr ) {
+long double _Complex strto( const char sptr[], char ** eptr ) {
         long double re, im;
         char * eeptr;

libcfa/src/stdlib.hfa

-              r807a632
+              r3b56166
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 20 22:57:33 2019
 // Update Count     : 390
+// Last Modified On : Tue Feb  4 08:27:01 2020
+// Update Count     : 401
 //
 …
 } // extern "C"
+void * realloc( void * oaddr, size_t nalign, size_t size ); // CFA heap
 //---------------------------------------
 …
         } // calloc
+        T * realloc( T * ptr, size_t size ) {
+                if ( unlikely( ptr == 0 ) ) return malloc();
+        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
         } // realloc
 …
         } // memalign
+        T * cmemalign( size_t align, size_t dim  ) {
+                return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
+        } // cmemalign
         T * aligned_alloc( size_t align ) {
                 return (T *)aligned_alloc( align, sizeof(T) );  // C aligned_alloc
 …
         T * alloc( T ptr[], size_t dim ) {                                      // realloc
                 return realloc( ptr, dim * sizeof(T) );
+                return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
         } // alloc
 …
         } // alloc_align
+        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+        } // alloc_align
+        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, dim * sizeof(T) ); // CFA realloc
+        } // alloc_align
         T * alloc_align_set( size_t align, char fill ) {
                 return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
 …
 forall( dtype T | sized(T) ) {
-        T * alloc_align( T ptr[], size_t align );                       // realign
-        T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
 } // distribution
 …
 static inline {
         int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
         unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
         long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
         unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
         long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
         unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
         float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
         double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
         long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
 } // distribution
 float _Complex strto( const char * sptr, char ** eptr );
 double _Complex strto( const char * sptr, char ** eptr );
 long double _Complex strto( const char * sptr, char ** eptr );
+        int strto( const char sptr[], char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
+        unsigned int strto( const char sptr[], char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
+        long int strto( const char sptr[], char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
+        unsigned long int strto( const char sptr[], char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
+        long long int strto( const char sptr[], char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
+        unsigned long long int strto( const char sptr[], char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
+        float strto( const char sptr[], char ** eptr ) { return strtof( sptr, eptr ); }
+        double strto( const char sptr[], char ** eptr ) { return strtod( sptr, eptr ); }
+        long double strto( const char sptr[], char ** eptr ) { return strtold( sptr, eptr ); }
+} // distribution
+float _Complex strto( const char sptr[], char ** eptr );
+double _Complex strto( const char sptr[], char ** eptr );
+long double _Complex strto( const char sptr[], char ** eptr );
 static inline {
         int ato( const char * sptr ) { return (int)strtol( sptr, 0, 10 ); }
         unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
         long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
         unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
         long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
         unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
         float ato( const char * sptr ) { return strtof( sptr, 0 ); }
         double ato( const char * sptr ) { return strtod( sptr, 0 ); }
         long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
         float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
         double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
         long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+        int ato( const char sptr[] ) { return (int)strtol( sptr, 0p, 10 ); }
+        unsigned int ato( const char sptr[] ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
+        long int ato( const char sptr[] ) { return strtol( sptr, 0p, 10 ); }
+        unsigned long int ato( const char sptr[] ) { return strtoul( sptr, 0p, 10 ); }
+        long long int ato( const char sptr[] ) { return strtoll( sptr, 0p, 10 ); }
+        unsigned long long int ato( const char sptr[] ) { return strtoull( sptr, 0p, 10 ); }
+        float ato( const char sptr[] ) { return strtof( sptr, 0p ); }
+        double ato( const char sptr[] ) { return strtod( sptr, 0p ); }
+        long double ato( const char sptr[] ) { return strtold( sptr, 0p ); }
+        float _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+        double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+        long double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
 } // distribution

libcfa/src/time.cfa

-              r807a632
+              r3b56166
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 13 08:41:55 2019
 // Update Count     : 65
+// Last Modified On : Tue Feb  4 08:24:18 2020
+// Update Count     : 70
 //
 …
 forall( dtype ostype | ostream( ostype ) ) {
         ostype & ?|?( ostype & os, Duration dur ) with( dur ) {
                 (ostype &)(os | tv / TIMEGRAN);                                 // print seconds
                 long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                (ostype &)(os | tn / TIMEGRAN);                                 // print seconds
+                long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
                 if ( ns != 0 ) {                                                                // some ?
                         char buf[16];
 …
 #ifdef __CFA_DEBUG__
 static void tabort( int year, int month, int day, int hour, int min, int sec, int nsec ) {
+static void tabort( int year, int month, int day, int hour, int min, int sec, int64_t nsec ) {
         abort | "Attempt to create Time( year=" | year | "(>=1970), month=" | month | "(1-12), day=" | day | "(1-31), hour=" | hour | "(0-23), min=" | min | "(0-59), sec=" | sec
                   | "(0-60), nsec=" | nsec | "(0-999_999_999), which exceeds range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038.";
+                  | "(0-60), nsec=" | nsec | "(0-999_999_999), which is not in the range 00:00:00 UTC, January 1, 1970 to 03:14:07 UTC, January 19, 2038, where month and day have 1 origin.";
 } // tabort
 #endif // __CFA_DEBUG__
 void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int nsec ) with( time ) {
+void ?{}( Time & time, int year, int month, int day, int hour, int min, int sec, int64_t nsec ) with( time ) {
         tm tm;
         tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
+        // Values can be in any range (+/-) but result must be in the epoch.
         tm.tm_year = year - 1900;                                                       // mktime uses 1900 as its starting point
+#ifdef __CFA_DEBUG__
+        if ( month < 1 || 12 < month ) {
+                tabort( year, month, day, hour, min, sec, nsec );
+        } // if
+#endif // __CFA_DEBUG__
+        // Make month in range 1-12 to match with day.
         tm.tm_mon = month - 1;                                                          // mktime uses range 0-11
-#ifdef __CFA_DEBUG__
-        if ( day < 1 || 31 < day ) {
-                tabort( year, month, day, hour, min, sec, nsec );
-        } // if
-#endif // __CFA_DEBUG__
         tm.tm_mday = day;                                                                       // mktime uses range 1-31
         tm.tm_hour = hour;
         tm.tm_min = min;
         tm.tm_sec = sec;
+        tm.tm_isdst = -1;                                                                       // let mktime determine if alternate timezone is in effect
         time_t epochsec = mktime( &tm );
 #ifdef __CFA_DEBUG__
         if ( epochsec == (time_t)-1 ) {
+        if ( epochsec <= (time_t)-1 ) {                                         // MUST BE LESS THAN OR EQUAL!
                 tabort( year, month, day, hour, min, sec, nsec );
         } // if
 #endif // __CFA_DEBUG__
         tv = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
+        tn = (int64_t)(epochsec) * TIMEGRAN + nsec;                     // convert to nanoseconds
 #ifdef __CFA_DEBUG__
         if ( tv > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
+        if ( tn > 2147483647LL * TIMEGRAN ) {                           // between 00:00:00 UTC, January 1, 1970 and 03:14:07 UTC, January 19, 2038.
                 tabort( year, month, day, hour, min, sec, nsec );
         } // if
 …
 char * yy_mm_dd( Time time, char * buf ) with( time ) {
         time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
 …
 char * mm_dd_yy( Time time, char * buf ) with( time ) {
         time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
 …
 char * dd_mm_yy( Time time, char * buf ) with( time ) {
         time_t s = tv / TIMEGRAN;
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );                                                            // tm_mon <= 11, tm_mday <= 31
 …
 } // dd_mm_yy
 size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
         time_t s = tv / TIMEGRAN;
+size_t strftime( char buf[], size_t size, const char fmt[], Time time ) with( time ) {
+        time_t s = tn / TIMEGRAN;
         tm tm;
         gmtime_r( &s, &tm );
 …
         ostype & ?|?( ostype & os, Time time ) with( time ) {
                 char buf[32];                                                                   // at least 26
                 time_t s = tv / TIMEGRAN;
+                time_t s = tn / TIMEGRAN;
                 ctime_r( &s, (char *)&buf );                                    // 26 characters: "Wed Jun 30 21:49:08 1993\n"
                 buf[24] = '\0';                                                                 // remove trailing '\n'
                 long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
+                long int ns = (tn < 0 ? -tn : tn) % TIMEGRAN;   // compute nanoseconds
                 if ( ns == 0 ) {                                                                // none ?
                         (ostype &)(os | buf);                                           // print date/time/year

libcfa/src/time.hfa

-              r807a632
+              r3b56166
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Sep 22 12:25:34 2018
 // Update Count     : 643
+// Last Modified On : Tue Feb  4 08:24:32 2020
+// Update Count     : 654
 //
 …
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
         Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +tv }; }
         Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
+        Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
+        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn + rhs.tn }; }
         Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
         Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
         Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tn }; }
+        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
         Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
         Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
         Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
+        Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn * rhs }; }
+        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tn }; }
         Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
         int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
         Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
+        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tn / rhs.tn; }
+        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn / rhs }; }
         Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
         double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
         Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
+        double div( Duration lhs, Duration rhs ) { return (double)lhs.tn / (double)rhs.tn; }
+        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
         bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
         bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
         bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
         bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
         bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
         bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
         bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv == 0; }
         bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv != 0; }
         bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <  0; }
         bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <= 0; }
         bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >  0; }
         bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >= 0; }
         Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
+        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
+        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tn != rhs.tn; }
+        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tn <  rhs.tn; }
+        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tn <= rhs.tn; }
+        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
+        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
+        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
+        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
+        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
+        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
+        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
+        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
+        Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
         Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
 …
         Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
         int64_t ?`ns( Duration dur ) { return dur.tv; }
         int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
         int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
         int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
         int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
         int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
         int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
         int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
         Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
         Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
+        int64_t ?`ns( Duration dur ) { return dur.tn; }
+        int64_t ?`us( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000_000LL); }
+        int64_t ?`ms( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000LL); }
+        int64_t ?`s( Duration dur ) { return dur.tn / TIMEGRAN; }
+        int64_t ?`m( Duration dur ) { return dur.tn / (60LL * TIMEGRAN); }
+        int64_t ?`h( Duration dur ) { return dur.tn / (60LL * 60LL * TIMEGRAN); }
+        int64_t ?`d( Duration dur ) { return dur.tn / (24LL * 60LL * 60LL * TIMEGRAN); }
+        int64_t ?`w( Duration dur ) { return dur.tn / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+        Duration max( Duration lhs, Duration rhs ) { return  (lhs.tn < rhs.tn) ? rhs : lhs;}
+        Duration min( Duration lhs, Duration rhs ) { return !(rhs.tn < lhs.tn) ? lhs : rhs;}
 } // distribution
 …
 //######################### Time #########################
 void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
+void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
 static inline {
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
         void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
                 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
         void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
                 tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
                 return time;
         } // ?=?
         Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
+        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tn + rhs.tn }; }
         Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
         Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
         Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
         Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
+        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
+        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tn - rhs.tn }; }
         Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+        bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
+        bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
+        bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
+        bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
+        bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
+        bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
+        bool ?==?( Time lhs, Time rhs ) { return lhs.tn == rhs.tn; }
+        bool ?!=?( Time lhs, Time rhs ) { return lhs.tn != rhs.tn; }
+        bool ?<?( Time lhs, Time rhs ) { return lhs.tn < rhs.tn; }
+        bool ?<=?( Time lhs, Time rhs ) { return lhs.tn <= rhs.tn; }
+        bool ?>?( Time lhs, Time rhs ) { return lhs.tn > rhs.tn; }
+        bool ?>=?( Time lhs, Time rhs ) { return lhs.tn >= rhs.tn; }
+        int64_t ?`ns( Time t ) { return t.tn; }
 } // distribution
 …
 } // dmy
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+size_t strftime( char buf[], size_t size, const char fmt[], Time time );
 //------------------------- timeval (cont) -------------------------
 static inline void ?{}( timeval & t, Time time ) with( t, time ) {
         tv_sec = tv / TIMEGRAN;                                                         // seconds
         tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
+        tv_sec = tn / TIMEGRAN;                                                         // seconds
+        tv_usec = tn % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
 } // ?{}
 …
 static inline void ?{}( timespec & t, Time time ) with( t, time ) {
         tv_sec = tv / TIMEGRAN;                                                         // seconds
         tv_nsec = tv % TIMEGRAN;                                                        // nanoseconds
+        tv_sec = tn / TIMEGRAN;                                                         // seconds
+        tv_nsec = tn % TIMEGRAN;                                                        // nanoseconds
 } // ?{}

libcfa/src/time_t.hfa

-              r807a632
+              r3b56166
 // Created On       : Tue Apr 10 14:42:03 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr 13 07:51:47 2018
 // Update Count     : 6
+// Last Modified On : Sun Jan  5 08:22:46 2020
+// Update Count     : 7
 //
 …
 struct Duration {                                                                               // private
         int64_t tv;                                                                                     // nanoseconds
+        int64_t tn;                                                                                     // nanoseconds
 }; // Duration
 static inline void ?{}( Duration & dur ) with( dur ) { tv = 0; }
 static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tv = 0; }
+static inline void ?{}( Duration & dur ) with( dur ) { tn = 0; }
+static inline void ?{}( Duration & dur, __attribute__((unused)) zero_t ) with( dur ) { tn = 0; }
 …
 struct Time {                                                                                   // private
         uint64_t tv;                                                                            // nanoseconds since UNIX epoch
+        uint64_t tn;                                                                            // nanoseconds since UNIX epoch
 }; // Time
 static inline void ?{}( Time & time ) with( time ) { tv = 0; }
 static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tv = 0; }
+static inline void ?{}( Time & time ) with( time ) { tn = 0; }
+static inline void ?{}( Time & time, __attribute__((unused)) zero_t ) with( time ) { tn = 0; }
 // Local Variables: //

Context Navigation

Legend:

Download in other formats: