Changeset b7d6a36 for libcfa/src

libcfa/src/Makefile.in

-              rdca5802
+              rb7d6a36
 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 = ""

libcfa/src/assert.cfa

-              rdca5802
+              rb7d6a36
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:09:26 2019
 // Update Count     : 5
+// Last Modified On : Tue Feb  4 13:00:18 2020
+// Update Count     : 6
 //
 …
         // called by macro assert in assert.h
         void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
+        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, ... ) {
+        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 );

libcfa/src/bits/containers.hfa

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:16:30 2019
 // Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:16 2020
+// Update Count     : 11
 //
 …
 extern "C" {
+        void __cfaabi_bits_write( int fd, 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 ) {

libcfa/src/bits/debug.hfa

-              rdca5802
+              rb7d6a36
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 17:06:58 2019
 // Update Count     : 8
+// 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 <unistd.h>
         extern void __cfaabi_bits_write( int fd, const char *buffer, int len );
+        extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
         extern void __cfaabi_bits_acquire();
         extern void __cfaabi_bits_release();

libcfa/src/bits/defs.hfa

-              rdca5802
+              rb7d6a36
 // 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

libcfa/src/bits/locks.hfa

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
         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

-              rdca5802
+              rb7d6a36
 // 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

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

libcfa/src/concurrency/alarm.cfa

-              rdca5802
+              rb7d6a36
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  3 22:47:24 2019
 // Update Count     : 68
+// 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);
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns);
         setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p );
+}

libcfa/src/concurrency/coroutine.cfa

-              rdca5802
+              rb7d6a36
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  5 14:37:29 2019
 // Update Count     : 15
+// 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 ) {
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
         (this.stack){storage, storageSize};
 …
 // 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

-              rdca5802
+              rb7d6a36
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  3 22:47:58 2019
 // Update Count     : 10
+// 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, 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, 0p, 0 }; }
 static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, 0p, 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__));
 …
         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

-              rdca5802
+              rb7d6a36
 // 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/kernel.cfa

-              rdca5802
+              rb7d6a36
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  5 16:25:52 2019
 // Update Count     : 52
+// Last Modified On : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 …
 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;
 …
+}
 void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
 …
+}
 static void Abort( int ret, const char * func ) {
+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 ) );
 …
         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 );
 …
         CtxSwitch( &src->context, &dst->context );
         // when CtxSwitch returns we are back in the src coroutine
+        mainThread->curr_cor = &mainThread->self_cor;
         // set state of new coroutine to active
 …
                 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 {
 …
 __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

-              rdca5802
+              rb7d6a36
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:54:51 2019
 // Update Count     : 18
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 22
 //
 …
 };
 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

-              rdca5802
+              rb7d6a36
 // Threads
 extern "C" {
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
+      void CtxInvokeThread(void (*main)(void *), void * this);
+}

libcfa/src/concurrency/monitor.cfa

-              rdca5802
+              rb7d6a36
         // 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;

libcfa/src/concurrency/thread.cfa

-              rdca5802
+              rb7d6a36
 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 );
         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

rdca5802	rb7d6a36
54	54
55	55	forall( dtype T \| is_thread(T) )
56		void __thrd_start( T & this );
	56	void __thrd_start( T & this, void (*)(T &) );
57	57
58	58	//-----------------------------------------------------------------------------

libcfa/src/exception.c

-              rdca5802
+              rb7d6a36
 // 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();
 …
+}
+#if defined(PIC)
+#warning Exceptions not yet supported when using Position-Independent Code
+__attribute__((noinline))
+void __cfaabi_ehm__try_terminate(void (*try_block)(),
+                void (*catch_block)(int index, exception_t * except),
+                __attribute__((unused)) int (*match_block)(exception_t * except)) {
+        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.
+#pragma GCC push_options
+#pragma GCC optimize("O0")
+// 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.
+#ifdef __PIC__
+        asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
+        asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
+#else
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
-        // Setup the exception table
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
+#endif
         // Label which defines the start of the area for which the handler is setup.
 …
         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.
+#ifdef __PIC__
 #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)
+        // This uses language specific data and can be modified arbitrarily
+        // We use handled area offset, handled area length,
+        // handler landing pad offset and 1 (action code, gcc seems to use 0).
+        ".LLSDACSBCFA2:\n"
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYEND-.TRYSTART\n"
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 1\n"
+        ".LLSDACSECFA2:\n"
+        // TABLE FOOTER
+        "       .text\n"
+        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+);
+// Somehow this piece of helps with the resolution of debug symbols.
+__attribute__((unused)) static const int dummy = 0;
+asm (
+        // Add a hidden symbol which points at the function.
+        "       .hidden CFA.ref.__gcfa_personality_v0\n"
+        "       .weak   CFA.ref.__gcfa_personality_v0\n"
+        // No clue what this does specifically
+        "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
+        "       .align 8\n"
+        "       .type CFA.ref.__gcfa_personality_v0, @object\n"
+        "       .size CFA.ref.__gcfa_personality_v0, 8\n"
+        "CFA.ref.__gcfa_personality_v0:\n"
+#if defined( __x86_64 )
+        "       .quad __gcfa_personality_v0\n"
+#else // then __i386
+        "   .long __gcfa_personality_v0\n"
+#endif
+);
+#else
+#error Exception Handling: unknown architecture for position independent code.
+#endif // __i386 || __x86_64
+#else // __PIC__
+#if defined( __i386 ) || defined( __x86_64 )
+asm (
+        // HEADER
+        ".LFECFA1:\n"
+        "       .globl  __gcfa_personality_v0\n"
+        "       .section        .gcc_except_table,\"a\",@progbits\n"
+        // 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 (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"
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"
+        "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
+#else
+#error Exception Handling: unknown architecture for position dependent code.
 #endif // __i386 || __x86_64
+#endif //PIC
+#endif // __PIC__
+#pragma GCC pop_options

libcfa/src/executor.cfa

-              rdca5802
+              rb7d6a36
 #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

-              rdca5802
+              rb7d6a36
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 06:56:46 2019
 // Update Count     : 355
+// 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 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 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

-              rdca5802
+              rb7d6a36
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 06:56:02 2019
 // Update Count     : 168
+// Last Modified On : Mon Feb 17 08:29:23 2020
+// Update Count     : 175
 //
 …
 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 );
 int fmt( ofstream &, const char format[], ... );
+ofstream & write( ofstream &, const char data[], size_t size );
+int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 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 );
 …
 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 );
 ifstream & ungetc( ifstream & is, char c );
 int fmt( ifstream &, const char format[], ... );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 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 );

libcfa/src/gmp.hfa

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec  8 21:01:31 2019
 // Update Count     : 647
+// Last Modified On : Tue Feb  4 10:04:51 2020
+// Update Count     : 648
 //
 …
 static inline void checkHeader( bool check, const char * name, void * addr ) {
+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"
 …
 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 ) {
+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 );

libcfa/src/interpose.cfa

-              rdca5802
+              rb7d6a36
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Nov 30 07:09:42 2019
 // Update Count     : 119
+// Last Modified On : Mon Feb 17 10:18:53 2020
+// Update Count     : 166
 //
 …
 #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_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_write( 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 );
+        __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';
+        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 ( int i = Start; i < size - abort_lastframe && messages != 0p; i += 1 ) {
+        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 ) {
+                for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
                         //__cfaabi_bits_print_nolock( "X %s\n", p);
-                        // find parantheses and +offset
                         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';
 …
+}
+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 );
+        } // if
+        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cfaabi_backtrace( signalAbort ? 4 : 2 );
+        __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

-              rdca5802
+              rb7d6a36
 // 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 : Thu Feb 20 15:53:23 2020
+// Update Count     : 829
 //
 …
 #include <stdio.h>
 #include <stdbool.h>                                                                    // true/false
+#include <stdint.h>                                                                             // UINT64_MAX
 //#include <string.h>                                                                   // strlen, strcmp
 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
 …
 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 &)(os | ulli); ends( os );
         } // ?|?
+#if defined( __SIZEOF_INT128__ )
+        //      UINT64_MAX 18_446_744_073_709_551_615_ULL
+        #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
+        static void base10_128( ostype & os, unsigned int128 val ) {
+                if ( val > UINT64_MAX ) {
+                        base10_128( os, val / P10_UINT64 );                     // recursive
+                        fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
+                } else {
+                        fmt( os, "%lu", (uint64_t)val );
+                } // if
+        } // base10_128
+        static void base10_128( ostype & os, int128 val ) {
+                if ( val < 0 ) {
+                        fmt( os, "-" );                                                         // leading negative sign
+                        val = -val;
+                } // if
+                base10_128( os, (unsigned int128)val );                 // print zero/positive value
+        } // base10_128
+        ostype & ?|?( ostype & os, int128 llli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, llli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, int128 llli ) {
+                (ostype &)(os | llli); ends( os );
+        } // ?|?
+        ostype & ?|?( ostype & os, unsigned int128 ullli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, ullli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, unsigned int128 ullli ) {
+                (ostype &)(os | ullli); ends( os );
+        } // ?|?
+#endif // __SIZEOF_INT128__
         #define PrintWithDP( os, format, val, ... ) \
 …
         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 */ \
 …
+\
                 if ( ! f.flags.pc ) {                                                   /* no precision */ \
-                        /* printf( "%s\n", &fmtstr[star] ); */ \
                         fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.val ); \
                 } else {                                                                                /* precision */ \
                         fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
                         /* printf( "%s\n", &fmtstr[star] ); */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
                 } /* if */ \
 …
 IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
 IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
+#if defined( __SIZEOF_INT128__ )
+// Default prefix for non-decimal prints is 0b, 0, 0x.
+#define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
+forall( dtype ostype | ostream( ostype ) ) \
+static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
+        if ( fmt.val > UINT64_MAX ) { \
+                fmt.val /= P10_UINT64; \
+                base10_128( os, fmt ); /* recursive */ \
+                _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
+                fmt2.flags.nobsdp = true; \
+                printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
+                sepOff( os ); \
+                (ostype &)(os | fmt2); \
+        } else { \
+                printf( "fmt %c %lld %d\n", fmt.base, fmt.val, fmt.all ); \
+                (ostype &)(os | fmt); \
+        } /* if */ \
+} /* base10_128 */                                                 \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
+                if ( f.base == 'b' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
+                        unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
+                        unsigned long long int lsig = (unsigned long long int)(f.val); \
+                        _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \
+                        _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \
+                        if ( msig == 0 ) { \
+                                fmt.val = lsig; \
+                                (ostype &)(os | fmt); \
+                        } else { \
+                                fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
+                                if ( f.base == 'b' ) { \
+                                        if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
+                                        fmt2.wd = 64; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } else if ( f.base == 'o' ) { \
+                                        fmt.val = (unsigned long long int)fmt.val >> 2; \
+                                        if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
+                                        fmt2.wd = 1; \
+                                        fmt2.val = ((msig & 0x3) << 1) + 1; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                        sepOff( os ); \
+                                        fmt2.wd = 21; \
+                                        fmt2.val = lsig & 0x7fffffffffffffff; \
+                                        (ostype &)(os | fmt2); \
+                                } else { \
+                                        if ( f.flags.left ) { \
+                                                if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
+                                                fmt.wd = 16;                                                    \
+                                        } else { \
+                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
+                                                fmt2.wd = 16;                                                   \
+                                        } /* if */ \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } /* if */ \
+                        } /* if */ \
+                } else { \
+                        base10_128( os, f ); \
+                } /* if */ \
+                return os; \
+        } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+IntegralFMTImpl128( int128, signed, 'd', "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
+#endif // __SIZEOF_INT128__
 //*********************************** floating point ***********************************
 …
 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

-              rdca5802
+              rb7d6a36
 // 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 : Thu Feb 20 15:30:56 2020
+// Update Count     : 337
 //
 …
 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
 …
         ostype & ?|?( ostype &, unsigned long long int );
         void ?|?( ostype &, unsigned long long int );
+#if defined( __SIZEOF_INT128__ )
+        ostype & ?|?( ostype &, int128 );
+        void ?|?( ostype &, int128 );
+        ostype & ?|?( ostype &, unsigned int128 );
+        void ?|?( ostype &, unsigned int128 );
+#endif // __SIZEOF_INT128__
         ostype & ?|?( ostype &, float );
 …
         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
 …
 IntegralFMTDecl( signed long long int, 'd' )
 IntegralFMTDecl( unsigned long long int, 'u' )
+#if defined( __SIZEOF_INT128__ )
+IntegralFMTDecl( int128, 'd' )
+IntegralFMTDecl( unsigned int128, 'u' )
+#endif
 //*********************************** floating point ***********************************
 …
 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Nov 30 07:07:56 2019
 // Update Count     : 13
+// Last Modified On : Tue Feb  4 13:03:18 2020
+// Update Count     : 30
 //
+#include <time.h>                                                                               // tzset
 #include "startup.hfa"
-#include <time.h>                                                                               // tzset
 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
 …
     } // __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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov 20 17:22:47 2019
 // Update Count     : 485
+// Last Modified On : Tue Feb  4 08:27:08 2020
+// Update Count     : 486
 //
 …
 //---------------------------------------
 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

-              rdca5802
+              rb7d6a36
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Nov 29 23:08:02 2019
 // Update Count     : 400
+// Last Modified On : Tue Feb  4 08:27:01 2020
+// Update Count     : 401
 //
 …
 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, 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 ); }
+        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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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

-              rdca5802
+              rb7d6a36
 // 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: