Changes in / [3ecfa13:0f5da65]

Files:

• libcfa/src/assert.cfa (modified) (3 diffs)
• libcfa/src/bits/debug.cfa (modified) (2 diffs)
• libcfa/src/bits/debug.hfa (modified) (3 diffs)
• libcfa/src/bits/locks.hfa (modified) (2 diffs)
• libcfa/src/concurrency/CtxSwitch-x86_64.S (modified) (1 diff)
• libcfa/src/concurrency/coroutine.cfa (modified) (4 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (5 diffs)
• libcfa/src/concurrency/invoke.c (modified) (6 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (8 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (1 diff)
• libcfa/src/concurrency/monitor.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (3 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (1 diff)
• libcfa/src/fstream.cfa (modified) (12 diffs)
• libcfa/src/fstream.hfa (modified) (6 diffs)
• libcfa/src/gmp.hfa (modified) (5 diffs)
• libcfa/src/heap.cfa (modified) (3 diffs)
• libcfa/src/interpose.cfa (modified) (8 diffs)
• libcfa/src/iostream.cfa (modified) (39 diffs)
• libcfa/src/iostream.hfa (modified) (8 diffs)
• libcfa/src/math.hfa (modified) (2 diffs)
• libcfa/src/startup.cfa (modified) (2 diffs)
• libcfa/src/stdhdr/assert.h (modified) (2 diffs)
• libcfa/src/stdhdr/bfdlink.h (modified) (1 diff)
• libcfa/src/stdhdr/hwloc.h (modified) (1 diff)
• libcfa/src/stdhdr/krb5.h (modified) (1 diff)
• libcfa/src/stdhdr/math.h (modified) (1 diff)
• libcfa/src/stdhdr/sys/ucontext.h (modified) (1 diff)
• libcfa/src/stdlib.cfa (modified) (4 diffs)
• libcfa/src/stdlib.hfa (modified) (2 diffs)
• libcfa/src/time.cfa (modified) (2 diffs)
• libcfa/src/time.hfa (modified) (2 diffs)
• src/Common/PassVisitor.impl.h (modified) (3 diffs)
• src/Concurrency/Keywords.cc (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (2 diffs)
• src/Parser/lex.ll (modified) (2 diffs)
• src/main.cc (modified) (5 diffs)
• tests/expression.cfa (modified) (3 diffs)
• tests/labelledExit.cfa (modified) (2 diffs)
• tests/quotedKeyword.cfa (modified) (2 diffs)

libcfa/src/assert.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 13:00:18 2020
-// Update Count     : 6
+// Last Modified On : Thu Nov 21 17:09:26 2019
+// Update Count     : 5
 //
 
@@ -26 +26 @@
 
         // 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();
@@ -32 +32 @@
 
         // 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/debug.cfa

@@ -10 +10 @@
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 13:03:16 2020
-// Update Count     : 11
+// Last Modified On : Thu Nov 21 17:16:30 2019
+// Update Count     : 10
 //
 
@@ -27 +27 @@
 
 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

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 12:29:21 2020
-// Update Count     : 9
+// Last Modified On : Thu Nov 21 17:06:58 2019
+// Update Count     : 8
 //
 
@@ -21 +21 @@
         #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(...)
@@ -38 +38 @@
         #include <stdio.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/locks.hfa

@@ -10 +10 @@
 // Created On       : Tue Oct 31 15:14:38 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 13:03:19 2020
-// Update Count     : 11
+// Last Modified On : Sat Aug 11 15:42:24 2018
+// Update Count     : 10
 //
 
@@ -54 +54 @@
 
                 #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/concurrency/CtxSwitch-x86_64.S

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

libcfa/src/concurrency/coroutine.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 12:29:25 2020
-// Update Count     : 16
+// Last Modified On : Thu Dec  5 14:37:29 2019
+// Update Count     : 15
 //
 
@@ -89 +89 @@
 }
 
-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};
@@ -187 +187 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __leave_coroutine( struct coroutine_desc * src ) {
+        void __suspend_internal(void) {
+                suspend();
+        }
+
+        void __leave_coroutine( coroutine_desc * src ) {
                 coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
 
@@ -203 +207 @@
                 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

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 12:29:26 2020
-// Update Count     : 11
+// Last Modified On : Tue Dec  3 22:47:58 2019
+// Update Count     : 10
 //
 
@@ -35 +35 @@
 // 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 );
 
@@ -41 +41 @@
 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 }; }
 
 //-----------------------------------------------------------------------------
@@ -61 +61 @@
 // Start coroutine routines
 extern "C" {
-        void CtxInvokeCoroutine(void (*main)(void *), void * this);
+      forall(dtype T | is_coroutine(T))
+      void CtxInvokeCoroutine(T * this);
 
-        forall(dtype T)
-        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+      forall(dtype T | is_coroutine(T))
+      void CtxStart(T * this, void ( *invoke)(T *));
 
         extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
@@ -128 +129 @@
 
         if( unlikely(dst->context.SP == 0p) ) {
-                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(main, dst, cor, CtxInvokeCoroutine);
-                TL_GET( this_thread )->curr_cor = src;
+                CtxStart(&cor, CtxInvokeCoroutine);
         }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern void __leave_coroutine ( struct coroutine_desc * );
-extern struct coroutine_desc * __finish_coroutine(void);
-extern void __leave_thread_monitor();
+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 disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
@@ -37 +38 @@
 void CtxInvokeCoroutine(
         void (*main)(void *),
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
-        // Finish setting up the coroutine by setting its state
-        struct coroutine_desc * cor = __finish_coroutine();
+        struct coroutine_desc* cor = get_coroutine( this );
 
-        // Call the main of the coroutine
+        if(cor->state == Primed) {
+                __suspend_internal();
+        }
+
+        cor->state = Active;
+
         main( this );
 
@@ -77 +83 @@
 
 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 );
@@ -93 +108 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor();
+        __leave_thread_monitor( thrd );
         __cabi_abort( "Resumed dead thread" );
 }
 
+
 void CtxStart(
         void (*main)(void *),
-        struct coroutine_desc * cor,
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this,
         void (*invoke)(void *)
 ) {
+        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 
@@ -121 +138 @@
 
         fs->dummyReturn = NULL;
-        fs->argument[0] = main;     // argument to invoke
-        fs->argument[1] = this;     // argument to invoke
+        fs->argument[0] = this;     // argument to invoke
         fs->rturn = invoke;
 
@@ -140 +156 @@
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
-        fs->fixedRegisters[0] = main;
-        fs->fixedRegisters[1] = this;
-        fs->fixedRegisters[2] = invoke;
+        fs->fixedRegisters[0] = this;
+        fs->fixedRegisters[1] = 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

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 13:03:15 2020
-// Update Count     : 58
+// Last Modified On : Thu Jan 30 22:55:50 2020
+// Update Count     : 56
 //
 
@@ -209 +209 @@
 
 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;
@@ -238 +238 @@
 }
 
-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;
@@ -441 +441 @@
 }
 
-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 ) );
@@ -469 +469 @@
         );
 
-        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); 
 
         Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
@@ -490 +490 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
-        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
+        CtxStart(&this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -506 +505 @@
         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
@@ -981 +978 @@
 __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

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

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

libcfa/src/concurrency/monitor.cfa

@@ -243 +243 @@
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor() {
-                thread_desc * thrd = TL_GET( this_thread );
+        void __leave_thread_monitor( thread_desc * thrd ) {
                 monitor_desc * this = &thrd->self_mon;
 

libcfa/src/concurrency/thread.cfa

@@ -58 +58 @@
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
-        __thrd_start(handle, main);
+        __thrd_start(handle);
 }
 
@@ -64 +64 @@
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
-        __thrd_start(handle, main);
+        __thrd_start(handle);
 }
 
@@ -75 +75 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
+void __thrd_start( T& this ) {
         thread_desc * this_thrd = get_thread(this);
         thread_desc * curr_thrd = TL_GET( this_thread );
 
         disable_interrupts();
-        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
-
+        CtxStart(&this, CtxInvokeThread);
         this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
         verify( this_thrd->context.SP );
-        // CtxSwitch( &curr_thrd->context, &this_thrd->context );
+        CtxSwitch( &curr_thrd->context, &this_thrd->context );
 
         ScheduleThread(this_thrd);
         enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+extern "C" {
+        // KERNEL ONLY
+        void __finish_creation(thread_desc * this) {
+                // set new coroutine that the processor is executing
+                // and context switch to it
+                verify( kernelTLS.this_thread != this );
+                verify( kernelTLS.this_thread->context.SP );
+                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
+        }
 }
 

libcfa/src/concurrency/thread.hfa

@@ -54 +54 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*)(T &) );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------

libcfa/src/fstream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:01:01 2020
-// Update Count     : 363
+// Last Modified On : Fri Nov 29 06:56:46 2019
+// Update Count     : 355
 //
 
@@ -32 +32 @@
 
 void ?{}( ofstream & os, void * file ) {
-        os.$file = file;
-        os.$sepDefault = true;
-        os.$sepOnOff = false;
-        os.$nlOnOff = true;
-        os.$prt = false;
-        os.$sawNL = false;
-        $sepSetCur( os, sepGet( os ) );
+        os.file = file;
+        os.sepDefault = true;
+        os.sepOnOff = false;
+        os.nlOnOff = true;
+        os.prt = false;
+        os.sawNL = false;
         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 = 0p; }
-
-void ?{}( ofstream & os, const char name[], const char mode[] ) {
+void ?{}( ofstream & os ) { os.file = 0; }
+
+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" );
 } // ?{}
@@ -70 +70 @@
 } // ^?{}
 
-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();
@@ -112 +112 @@
 
 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 == 0p ) {
+        if ( file == 0 ) {
                 abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
         } // if
@@ -129 +129 @@
 } // 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
@@ -155 +155 @@
         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
@@ -163 +163 @@
         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
@@ -184 +184 @@
 // private
 void ?{}( ifstream & is, void * file ) {
-        is.$file = file;
-        is.$nlOnOff = false;
+        is.file = file;
+        is.nlOnOff = false;
 } // ?{}
 
 // public
-void ?{}( ifstream & is ) { is.$file = 0p; }
-
-void ?{}( ifstream & is, const char name[], const char mode[] ) {
+void ?{}( ifstream & is ) {     is.file = 0; }
+
+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" );
 } // ?{}
@@ -203 +203 @@
 } // ^?{}
 
-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 == 0p || ferror( (FILE *)(is.$file) );
+        return is.file == 0 || 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 == 0p ) {
+        if ( file == 0 ) {
                 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
@@ -242 +242 @@
         } // 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
@@ -253 +253 @@
         } // if
 
-        if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is.file) ) == EOF ) {
                 abort | IO_MSG "ungetc" | nl | strerror( errno );
         } // if
@@ -263 +263 @@
 
         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

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:00:51 2020
-// Update Count     : 174
+// Last Modified On : Fri Nov 29 06:56:02 2019
+// Update Count     : 168
 //
 
@@ -24 +24 @@
 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
@@ -56 +56 @@
 
 const char * sepGet( ofstream & );
-void sepSet( ofstream &, const char [] );
+void sepSet( ofstream &, const char * );
 const char * sepGetTuple( ofstream & );
-void sepSetTuple( ofstream &, const char [] );
+void sepSetTuple( ofstream &, const char * );
 
 void ends( ofstream & os );
 int fail( ofstream & );
 int flush( ofstream & );
-void open( ofstream &, const char name[], const char mode[] );
-void open( ofstream &, const char name[] );
+void open( ofstream &, const char * name, const char * mode );
+void open( ofstream &, const char * name );
 void close( ofstream & );
-ofstream & write( ofstream &, const char data[], size_t size );
+ofstream & write( ofstream &, const char * data, size_t size );
 int fmt( ofstream &, const char format[], ... );
 
 void ?{}( ofstream & os );
-void ?{}( ofstream & os, const char name[], const char mode[] );
-void ?{}( ofstream & os, const char name[] );
+void ?{}( ofstream & os, const char * name, const char * mode );
+void ?{}( ofstream & os, const char * name );
 void ^?{}( ofstream & os );
 
@@ -82 +82 @@
 
 struct ifstream {
-        void * $file;
-        bool $nlOnOff;
+        void * file;
+        bool nlOnOff;
 }; // ifstream
 
@@ -92 +92 @@
 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 );
@@ -100 +100 @@
 
 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

@@ -10 +10 @@
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 22:10:30 2020
-// Update Count     : 29
+// Last Modified On : Sat Jul 13 15:25:05 2019
+// Update Count     : 27
 //
 
@@ -31 +31 @@
         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 ); }
 
@@ -37 +37 @@
         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
@@ -43 +43 @@
         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; }
@@ -265 +265 @@
         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

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 10:04:51 2020
-// Update Count     : 648
+// Last Modified On : Sun Dec  8 21:01:31 2019
+// Update Count     : 647
 //
 
@@ -380 +380 @@
 
 
-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"
@@ -418 +418 @@
 
 
-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

@@ -10 +10 @@
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:40:34 2020
-// Update Count     : 163
+// Last Modified On : Thu Jan 30 17:47:32 2020
+// Update Count     : 156
 //
 
@@ -29 +29 @@
 #include "bits/signal.hfa"                                                              // sigHandler_?
 #include "startup.hfa"                                                                  // STARTUP_PRIORITY_CORE
-#include <assert.h>
 
 //=============================================================================================
@@ -41 +40 @@
 
 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;
 
@@ -146 +145 @@
 extern "C" {
         void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
-                abort( false, "%s", "" );
+                abort( false, NULL ); // FIX ME: 0p does not work
         }
 
@@ -162 +161 @@
 
 void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
-void kernel_abort_msg( void * data, char buffer[], int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
+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; }
@@ -170 +169 @@
 
 static void __cfaabi_backtrace( int start ) {
-        enum { Frames = 50, };                                                          // maximum number of stack frames
+        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 ); // does not demangle names
+        char ** messages = backtrace_symbols( array, size );
 
         *index( messages[0], '(' ) = '\0';                                      // find executable name
@@ -183 +184 @@
                 char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
 
-                for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
+                for ( char * p = messages[i]; *p; ++p ) {               // find parantheses and +offset
                         //__cfaabi_bits_print_nolock( "X %s\n", p);
                         if ( *p == '(' ) {
@@ -227 +228 @@
         __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 ( 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 );
+                }
         }
 

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 18:48:38 2020
-// Update Count     : 825
+// Last Modified On : Sat Jul 13 08:07:59 2019
+// Update Count     : 821
 //
 
@@ -35 +35 @@
 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;
@@ -44 +44 @@
 
         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;
@@ -53 +53 @@
 
         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;
@@ -63 +63 @@
         ostype & ?|?( ostype & os, char c ) {
                 fmt( os, "%c", c );
-                if ( c == '\n' ) $setNL( os, true );
+                if ( c == '\n' ) setNL( os, true );
                 return sepOff( os );
         } // ?|?
@@ -71 +71 @@
 
         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;
@@ -80 +80 @@
 
         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;
@@ -89 +89 @@
 
         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;
@@ -98 +98 @@
 
         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;
@@ -107 +107 @@
 
         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;
@@ -116 +116 @@
 
         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;
@@ -125 +125 @@
 
         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;
@@ -134 +134 @@
 
         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;
@@ -143 +143 @@
 
         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;
@@ -152 +152 @@
 
         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;
@@ -175 +175 @@
 
         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;
@@ -184 +184 @@
 
         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;
@@ -193 +193 @@
 
         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;
@@ -202 +202 @@
 
         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 ) );
@@ -214 +214 @@
 
         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 );
@@ -226 +226 @@
 
         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 );
@@ -237 +237 @@
         } // ?|?
 
-        ostype & ?|?( ostype & os, const char str[] ) {
+        ostype & ?|?( ostype & os, const char * str ) {
                 enum { Open = 1, Close, OpenClose };
                 static const unsigned char mask[256] @= {
@@ -257 +257 @@
                 // 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;
@@ -288 +287 @@
 // #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;
@@ -295 +294 @@
 
 //      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;
@@ -301 +300 @@
 
         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;
@@ -316 +315 @@
         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
         } // ?|?
 
@@ -330 +329 @@
         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
@@ -337 +336 @@
 
         ostype & nonl( ostype & os ) {
-                $setPrt( os, false );                                                   // turn off
+                setPrt( os, false );                                                    // turn off
                 return os;
         } // nonl
@@ -376 +375 @@
         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;
         } // ?|?
@@ -384 +383 @@
                 // (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 );
         } // ?|?
@@ -415 +414 @@
 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 */ \
@@ -514 +513 @@
 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) ); \
@@ -537 +536 @@
                 return os; \
         } /* ?|? */ \
-\
         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
 } // distribution
@@ -557 +555 @@
                 } // if
 
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
 
                 #define CFMTNP "% * "
@@ -573 +571 @@
                 return os;
         } // ?|?
-
         void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
@@ -595 +592 @@
                 } // if
 
-                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
 
                 #define SFMTNP "% * "
@@ -619 +616 @@
                 return os;
         } // ?|?
-
         void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
@@ -739 +735 @@
         } // ?|?
 
-        // istype & ?|?( istype & is, const char fmt[] ) {
+        // istype & ?|?( istype & is, const char * fmt ) {
         //      fmt( is, fmt, "" );
         //      return is;

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 17:53:52 2020
-// Update Count     : 336
+// Last Modified On : Fri Jul 12 12:08:38 2019
+// Update Count     : 334
 //
 
@@ -24 +24 @@
 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
@@ -43 +43 @@
 
         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
@@ -113 +113 @@
         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
@@ -256 +256 @@
 
 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; }
@@ -281 +281 @@
         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 );
@@ -316 +316 @@
         istype & ?|?( istype &, long double _Complex & );
 
-//      istype & ?|?( istype &, const char [] );
+//      istype & ?|?( istype &, const char * );
         istype & ?|?( istype &, char * );
 
@@ -343 +343 @@
 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

@@ -10 +10 @@
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 10:27:11 2020
-// Update Count     : 117
+// Last Modified On : Fri Jul 13 11:02:15 2018
+// Update Count     : 116
 //
 
@@ -51 +51 @@
 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/startup.cfa

@@ -10 +10 @@
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 13:03:18 2020
-// Update Count     : 30
+// Last Modified On : Fri Dec 13 13:16:45 2019
+// Update Count     : 29
 //
 
@@ -41 +41 @@
 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

@@ -10 +10 @@
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 12:58:49 2020
-// Update Count     : 15
+// Last Modified On : Mon Jul 31 23:09:32 2017
+// Update Count     : 13
 //
 
@@ -27 +27 @@
         #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

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:26:04 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:05:08 2020
-// Update Count     : 6
+// Last Modified On : Sat Feb  1 07:15:29 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:45:00 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:05:18 2020
-// Update Count     : 6
+// Last Modified On : Sat Feb  1 07:15:39 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Tue Jul 18 07:55:44 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:05:35 2020
-// Update Count     : 6
+// Last Modified On : Sat Feb  1 07:15:47 2020
+// Update Count     : 5
 // 
 
 // 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

@@ -10 +10 @@
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:05:27 2020
-// Update Count     : 15
+// Last Modified On : Sat Feb  1 07:15:58 2020
+// Update Count     : 14
 // 
 
 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

@@ -10 +10 @@
 // Created On       : Thu Feb  8 23:48:16 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:05:41 2020
-// Update Count     : 6
+// Last Modified On : Sat Feb  1 07:16:05 2020
+// Update Count     : 5
 // 
 
 #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

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 08:27:08 2020
-// Update Count     : 486
+// Last Modified On : Wed Nov 20 17:22:47 2019
+// Update Count     : 485
 //
 
@@ -107 +107 @@
 //---------------------------------------
 
-float _Complex strto( const char sptr[], char ** eptr ) {
+float _Complex strto( const char * sptr, char ** eptr ) {
         float re, im;
         char * eeptr;
@@ -118 +118 @@
 } // strto
 
-double _Complex strto( const char sptr[], char ** eptr ) {
+double _Complex strto( const char * sptr, char ** eptr ) {
         double re, im;
         char * eeptr;
@@ -129 +129 @@
 } // 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

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

@@ -10 +10 @@
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 08:24:18 2020
-// Update Count     : 70
+// Last Modified On : Sun Jan  5 17:27:40 2020
+// Update Count     : 69
 //
 
@@ -129 +129 @@
 } // dd_mm_yy
 
-size_t strftime( char buf[], size_t size, const char fmt[], Time time ) with( time ) {
+size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
         time_t s = tn / TIMEGRAN;
         tm tm;

libcfa/src/time.hfa

@@ -10 +10 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  4 08:24:32 2020
-// Update Count     : 654
+// Last Modified On : Mon Jan  6 12:50:16 2020
+// Update Count     : 653
 //
 
@@ -191 +191 @@
 } // 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) -------------------------

src/Common/PassVisitor.impl.h

@@ -3302 +3302 @@
         VISIT_START( node );
 
-        indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
 
         {
@@ -3317 +3317 @@
         VISIT_START( node );
 
-        indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
 
         {
@@ -3332 +3332 @@
         MUTATE_START( node );
 
-        indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
 
         {

src/Concurrency/Keywords.cc

@@ -716 +716 @@
                                 new UntypedExpr(
                                         new NameExpr( "__thrd_start" ),
-                                        { new VariableExpr( param ), new NameExpr("main") }
+                                        { new VariableExpr( param ) }
                                 )
                         )

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 17:56:02 2020
-// Update Count     : 891
+// Last Modified On : Mon Dec 16 07:46:01 2019
+// Update Count     : 888
 //
 
@@ -449 +449 @@
                                 * out++ = result;
                         } else {
-                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
+                                assertf(false, "buildList unknown type");
                         } // if
                 } catch( SemanticErrorException & e ) {

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Fri Feb  7 19:02:43 2020
- * Update Count     : 725
+ * Last Modified On : Sat Feb  1 07:16:44 2020
+ * Update Count     : 724
  */
 
@@ -330 +330 @@
                                 /* identifier */
 {identifier}    { IDENTIFIER_RETURN(); }
-"``"{identifier} {                                                                              // CFA
-        yytext[yyleng] = '\0'; yytext += 2;                                     // SKULLDUGGERY: remove backquotes (ok to shorten?)
+"``"{identifier}"``" {                                                                  // CFA
+        yytext[yyleng - 2] = '\0'; yytext += 2;                         // SKULLDUGGERY: remove backquotes (ok to shorten?)
         IDENTIFIER_RETURN();
 }

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:33:50 2020
-// Update Count     : 633
+// Last Modified On : Mon Dec 16 17:55:53 2019
+// Update Count     : 627
 //
 
@@ -105 +105 @@
 
 static void backtrace( int start ) {                                    // skip first N stack frames
-        enum { Frames = 50, };                                                          // maximum number of stack frames
+        enum { Frames = 50 };
         void * array[Frames];
-        size_t size = ::backtrace( array, Frames );
+        int size = ::backtrace( array, Frames );
         char ** messages = ::backtrace_symbols( array, size ); // does not demangle names
 
@@ -114 +114 @@
 
         // skip last 2 stack frames after main
-        for ( unsigned int i = start; i < size - 2 && messages != nullptr; i += 1 ) {
+        for ( int i = start; i < size - 2 && messages != nullptr; i += 1 ) {
                 char * mangled_name = nullptr, * offset_begin = nullptr, * offset_end = nullptr;
 
@@ -180 +180 @@
 } // sigSegvBusHandler
 
-static void sigFpeHandler( SIGPARMS ) {
-        const char * msg;
-
-        switch ( sfp->si_code ) {
-          case FPE_INTDIV: case FPE_FLTDIV: msg = "divide by zero"; break;
-          case FPE_FLTOVF: msg = "overflow"; break;
-          case FPE_FLTUND: msg = "underflow"; break;
-          case FPE_FLTRES: msg = "inexact result"; break;
-          case FPE_FLTINV: msg = "invalid operation"; break;
-          default: msg = "unknown";
-        } // choose
-        cerr << "Computation error " << msg << " at location " << sfp->si_addr << endl
-                 << "Possible cause is constant-expression evaluation invalid." << endl;
-        backtrace( 2 );                                                                         // skip first 2 stack frames
-        abort();                                                                                        // cause core dump for debugging
-} // sigFpeHandler
-
 static void sigAbortHandler( SIGPARMS ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
@@ -210 +193 @@
         Signal( SIGSEGV, sigSegvBusHandler, SA_SIGINFO );
         Signal( SIGBUS, sigSegvBusHandler, SA_SIGINFO );
-        Signal( SIGFPE, sigFpeHandler, SA_SIGINFO );
         Signal( SIGABRT, sigAbortHandler, SA_SIGINFO );
 

tests/expression.cfa

@@ -1 +1 @@
 struct S { int i; };
-void ?{}( S & s, int i ) { s.i = i; }
+void ?{}( S & s, int i ) {}
 int ?`mary( int );
 int ?`mary( S );
@@ -10 +10 @@
     int a[3] = { 0, 0, 0 };
     S s = { 3 }, * ps = &s;
-    [int] t = { 3 };
+    [int] t;
     * [int] pt = &t;
-    int i = 1, j = 2;
+    int i = 3, j = 4;
 
     // operators
 
-    !i;
+    ! i;
     ~i;
     +i;
@@ -26 +26 @@
     ps--;
 
-    i + j;
-    i - j;
-    i * j;
+    i+j;
+    i-j;
+    i*j;
 
-    i / j;
-    i % j;
-    i ^ j;
-    i & j;
-    i | j;
-    i < j;
-    i > j;
-    i = j;
+    i/j;
+    i%j;
+    i^j;
+    i&j;
+    i|j;
+    i<j;
+    i>j;
+    i=j;
 
-    i == j;
-    i != j;
-    i << j;
-    i >> j;
-    i <= j;
-    i >= j;
-    i && j;
-    i || j;
+    i==j;
+    i!=j;
+    i<<j;
+    i>>j;
+    i<=j;
+    i>=j;
+    i&&j;
+    i||j;
     ps->i;
 
-    i *= j;
-    i /= j;
-    i %= j;
-    i += j;
-    i -= j;
-    i &= j;
-    i |= j;
-    i ^= j;
-    i <<= j;
-    i >>= j;
+    i*=j;
+    i/=j;
+    i%=j;
+    i+=j;
+    i-=j;
+    i&=j;
+    i|=j;
+    i^=j;
+    i<<=j;
+    i>>=j;
 
-    i ? i : j;
+    i?i:j;
 
     // postfix function call

tests/labelledExit.cfa

@@ -10 +10 @@
 // Created On       : Wed Aug 10 07:29:39 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  5 16:49:48 2020
-// Update Count     : 9
+// Last Modified On : Fri Oct 25 17:41:51 2019
+// Update Count     : 7
 // 
 
@@ -162 +162 @@
 
         // computed goto
-        {
-                void *array[] = { &&foo, &&bar, &&hack };
-          foo: bar: hack:
-                &&foo;
-                &&bar;
-                goto *array[i];
-        }
+        // {
+        //      void *array[] = { &&foo, &&bar, &&hack };
+        //   foo: bar: hack:
+        //      &&foo;
+        //      &&bar;
+        //      goto *array[i];
+        // }
 
   Q: if ( i > 5 ) {

tests/quotedKeyword.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:07:07 2020
-// Update Count     : 25
+// Last Modified On : Sat Feb  1 00:02:22 2020
+// Update Count     : 24
 //
 
@@ -17 +17 @@
 
 struct {
-        int ``otype;
-        int ``struct;
+        int ``otype``;
+        int ``struct``;
 } st = { 10, 10 };
 
-typedef int ``forall;
-``forall xxx = 10;
+typedef int ``forall``;
+``forall`` xxx = 10;
 
-int ``_Alignas, ``_Alignof, ``__alignof, ``__alignof__, ``asm, ``__asm, ``__asm__, ``_At, ``_Atomic, ``__attribute,
-        ``__attribute__, ``auto, ``_Bool, ``break, ``case, ``catch, ``catchResume, ``char, ``choose, ``_Complex, ``__complex,
-        ``__complex__, ``const, ``__const, ``__const__, ``continue, ``default, ``disable, ``do, ``double, ``dtype, ``else,
-        ``enable, ``enum, ``__extension__, ``extern, ``fallthru, ``finally, ``float, ``__float128, ``for, ``forall, ``fortran,
-        ``ftype, ``_Generic, ``goto, ``if, ``_Imaginary, ``__imag, ``__imag__, ``inline, ``__inline, ``__inline__, ``int,
-        ``__int128, ``__label__, ``long, ``lvalue, ``_Noreturn, ``__builtin_offsetof, ``otype, ``register, ``restrict,
-        ``__restrict, ``__restrict__, ``return, ``short, ``signed, ``__signed, ``__signed__, ``sizeof, ``static,
-        ``_Static_assert, ``struct, ``switch, ``_Thread_local, ``throw, ``throwResume, ``trait, ``try, ``typedef,
-        ``typeof, ``__typeof, ``__typeof__, ``union, ``unsigned, ``__builtin_va_list, ``void, ``volatile, ``__volatile,
-        ``__volatile__, ``while;
+int ``_Alignas``, ``_Alignof``, ``__alignof``, ``__alignof__``, ``asm``, ``__asm``, ``__asm__``, ``_At``, ``_Atomic``, ``__attribute``,
+        ``__attribute__``, ``auto``, ``_Bool``, ``break``, ``case``, ``catch``, ``catchResume``, ``char``, ``choose``, ``_Complex``, ``__complex``,
+        ``__complex__``, ``const``, ``__const``, ``__const__``, ``continue``, ``default``, ``disable``, ``do``, ``double``, ``dtype``, ``else``,
+        ``enable``, ``enum``, ``__extension__``, ``extern``, ``fallthru``, ``finally``, ``float``, ``__float128``, ``for``, ``forall``, ``fortran``,
+        ``ftype``, ``_Generic``, ``goto``, ``if``, ``_Imaginary``, ``__imag``, ``__imag__``, ``inline``, ``__inline``, ``__inline__``, ``int``,
+        ``__int128``, ``__label__``, ``long``, ``lvalue``, ``_Noreturn``, ``__builtin_offsetof``, ``otype``, ``register``, ``restrict``,
+        ``__restrict``, ``__restrict__``, ``return``, ``short``, ``signed``, ``__signed``, ``__signed__``, ``sizeof``, ``static``,
+        ``_Static_assert``, ``struct``, ``switch``, ``_Thread_local``, ``throw``, ``throwResume``, ``trait``, ``try``, ``typedef``,
+        ``typeof``, ``__typeof``, ``__typeof__``, ``union``, ``unsigned``, ``__builtin_va_list``, ``void``, ``volatile``, ``__volatile``,
+        ``__volatile__``, ``while``;
 
 int main() {
-        int ``if = 0;
-        ``catch = 1;
-        st.``otype = 2;
-        st.``struct = 3;
-        ``throw = 4;
-        sout | ``catch + st.``otype + st.``struct + ``throw;
+        int ``if`` = 0;
+        ``catch`` = 1;
+        st.``otype`` = 2;
+        st.``struct`` = 3;
+        ``throw`` = 4;
+        sout | ``catch`` + st.``otype`` + st.``struct`` + ``throw``;
 }