Diff [a50502128f8eabae54ded84a8ab9885411aad583:8c50aed95a361f33369903cfdf38ceaaefeffddf] for / – Cforall

Jenkinsfile

-              ra505021
+              r8c50aed
                 //Then publish the results
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'        , groupCompile    , false, 'Compilation')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'   , groupCompile    , true , 'Compilation (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'      , groupConcurrency, false, 'Context Switching')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff' , groupConcurrency, true , 'Context Switching (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'          , groupConcurrency, false, 'Mutual Exclusion')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'     , groupConcurrency, true , 'Mutual Exclusion (relative)')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling'     , groupConcurrency, false, 'Internal and External Scheduling')
                 do_plot(Settings.RunBenchmark && Settings.Publish, 'scheduling.diff', groupConcurrency, true , 'Internal and External Scheduling (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile'       , groupCompile    , false, 'Compilation')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'compile.diff'  , groupCompile    , true , 'Compilation (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch'     , groupConcurrency, false, 'Context Switching')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'ctxswitch.diff', groupConcurrency, true , 'Context Switching (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex'         , groupConcurrency, false, 'Mutual Exclusion')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'mutex.diff'    , groupConcurrency, true , 'Mutual Exclusion (relative)')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal'        , groupConcurrency, false, 'Internal and External Scheduling')
+                do_plot(Settings.RunBenchmark && Settings.Publish, 'signal.diff'   , groupConcurrency, true , 'Internal and External Scheduling (relative)')
+        }
+}

benchmark/Makefile.am

-              ra505021
+              r8c50aed
 BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
-BENCH_V_PY = $(__bench_v_PY_$(__quiet))
 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 …
 __bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_PY_verbose = $(AM_V_PY)
+__bench_v_RUSTC_verbose = $(AM_V_RUST)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 …
         echo "int main() { return 0; }" > ${@}
+.SILENT:                # do not print recipe
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
 .NOTPARALLEL:
 .PHONY: jenkins cleancsv
+.PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
 ## =========================================================================================================
 …
 FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
+cleancsv:
+        rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
+jenkins$(EXEEXT): cleancsv
+jenkins$(EXEEXT):
 @DOifskipcompile@
         +make compile.csv
         -+make compile.diff.csv
 @DOendif@
+        +make basic.csv
+        -+make basic.diff.csv
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make scheduling.csv
         -+make scheduling.diff.csv
+        +make schedint.csv
+        -+make schedint.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
+        cat basic.csv
+        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
         cat scheduling.csv
         -cat scheduling.diff.csv
+        cat schedint.csv
+        -cat schedint.diff.csv
 compile.csv:
-        echo "building $@"
         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
 …
         $(srcdir)/fixcsv.sh $@
+basic.csv:
+        echo "generator,coroutine,thread" > $@
+        +make basic-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make basic-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make basic-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
-        echo "building $@"
         echo "generator,coroutine,thread" > $@
         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
 …
 mutex.csv:
-        echo "building $@"
         echo "1-monitor,2-monitor" > $@
         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
         $(srcdir)/fixcsv.sh $@
+scheduling.csv:
+        echo "building $@"
+schedint.csv:
         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
 ctxswitch-python_coroutine$(EXEEXT):
         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_coroutine$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_await$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
         chmod a+x a.out
 …
 creation-python_coroutine$(EXEEXT):
         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
         chmod a+x a.out
 creation-nodejs_coroutine$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
         chmod a+x a.out

benchmark/Makefile.in

-              ra505021
+              r8c50aed
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
-AM_V_PY = $(am__v_PY_@AM_V@)
-am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
-am__v_PY_0 = @echo "  PYTHON  " $@;
-am__v_PY_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_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_0 = @echo "  NODEJS     " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
 …
 BENCH_V_UPP = $(__bench_v_UPP_$(__quiet))
 BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
-BENCH_V_PY = $(__bench_v_PY_$(__quiet))
 BENCH_V_RUSTC = $(__bench_v_RUSTC_$(__quiet))
 BENCH_V_NODEJS = $(__bench_v_NODEJS_$(__quiet))
 …
 __bench_v_UPP_verbose = $(AM_V_UPP)
 __bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_PY_verbose = $(AM_V_PY)
+__bench_v_RUSTC_verbose = $(AM_V_RUST)
+__bench_v_RUSTC_verbose = $(AM_V_RUSTC)
 __bench_v_NODEJS_verbose = $(AM_V_NODEJS)
 __bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 …
         echo "int main() { return 0; }" > ${@}
+.SILENT:                # do not print recipe
+#.SILENT:               # do not print recipe
+.ONESHELL:              # use one shell to execute recipe
 .NOTPARALLEL:
 .PHONY: jenkins cleancsv
+.PHONY: compile.csv basic.csv ctxswitch.csv mutex.csv schedint.csv
 all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
 …
         +make -C ${abs_top_builddir}/tools repeat
+cleancsv:
+        rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
+jenkins$(EXEEXT): cleancsv
+jenkins$(EXEEXT):
 @DOifskipcompile@
         +make compile.csv
         -+make compile.diff.csv
 @DOendif@
+        +make basic.csv
+        -+make basic.diff.csv
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make scheduling.csv
         -+make scheduling.diff.csv
+        +make schedint.csv
+        -+make schedint.diff.csv
 @DOifskipcompile@
         cat compile.csv
         -cat compile.diff.csv
 @DOendif@
+        cat basic.csv
+        -cat basic.diff.csv
         cat ctxswitch.csv
         -cat ctxswitch.diff.csv
         cat mutex.csv
         -cat mutex.diff.csv
         cat scheduling.csv
         -cat scheduling.diff.csv
+        cat schedint.csv
+        -cat schedint.diff.csv
 compile.csv:
-        echo "building $@"
         echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
         +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
 …
         $(srcdir)/fixcsv.sh $@
+basic.csv:
+        echo "generator,coroutine,thread" > $@
+        +make basic-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make basic-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make basic-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
-        echo "building $@"
         echo "generator,coroutine,thread" > $@
         +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
 …
 mutex.csv:
-        echo "building $@"
         echo "1-monitor,2-monitor" > $@
         +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
         $(srcdir)/fixcsv.sh $@
+scheduling.csv:
+        echo "building $@"
+schedint.csv:
         echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
         +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
 …
 ctxswitch-python_coroutine$(EXEEXT):
         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/ctxswitch/python_cor.py" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_coroutine$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_cor.js" >> a.out
         chmod a+x a.out
 ctxswitch-nodejs_await$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
         chmod a+x a.out
 …
 creation-python_coroutine$(EXEEXT):
         $(BENCH_V_PY)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "python3.7 $(srcdir)/creation/python_cor.py" >> a.out
         chmod a+x a.out
 creation-nodejs_coroutine$(EXEEXT):
         $(BENCH_V_NODEJS)echo "#!/bin/sh" > a.out
+        echo "#!/bin/sh" > a.out
         echo "nodejs $(srcdir)/creation/node_cor.js" >> a.out
         chmod a+x a.out

doc/theses/thierry_delisle_PhD/code/relaxed_list.cpp

-              ra505021
+              r8c50aed
 #include <vector>
-#include <getopt.h>
 #include <unistd.h>
 #include <sys/sysinfo.h>
 …
         int value;
+        int id;
+        Node() { creates++; }
+        Node(int value): value(value) { creates++; }
+        ~Node() { destroys++; }
+        Node(int value): value(value) {
+                creates++;
+        }
+        ~Node() {
+                destroys++;
+        }
 };
 …
 std::atomic_size_t Node::destroys = { 0 };
+static const constexpr int nodes_per_threads = 128;
+struct NodeArray {
+        __attribute__((aligned(64))) Node * array[nodes_per_threads];
+        __attribute__((aligned(64))) char pad;
+};
 bool enable_stats = false;
-template<>
-thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
-template<>
-relaxed_list<Node> * relaxed_list<Node>::head = nullptr;
-#ifndef NO_STATS
-template<>
-relaxed_list<Node>::GlobalStats relaxed_list<Node>::global_stats = {};
-#endif
-// ================================================================================================
-//                        UTILS
-// ================================================================================================
 struct local_stat_t {
 …
         size_t crc_in  = 0;
         size_t crc_out = 0;
-        size_t valmax = 0;
-        size_t valmin = 100000000ul;
 };
+struct global_stat_t {
+        std::atomic_size_t in  = { 0 };
+        std::atomic_size_t out = { 0 };
+        std::atomic_size_t empty = { 0 };
+        std::atomic_size_t crc_in  = { 0 };
+        std::atomic_size_t crc_out = { 0 };
+        std::atomic_size_t valmax = { 0 };
+        std::atomic_size_t valmin = { 100000000ul };
+};
+void atomic_max(std::atomic_size_t & target, size_t value) {
+        for(;;) {
+                size_t expect = target.load(std::memory_order_relaxed);
+                if(value <= expect) return;
+                bool success = target.compare_exchange_strong(expect, value);
+                if(success) return;
+        }
+}
+void atomic_min(std::atomic_size_t & target, size_t value) {
+        for(;;) {
+                size_t expect = target.load(std::memory_order_relaxed);
+                if(value >= expect) return;
+                bool success = target.compare_exchange_strong(expect, value);
+                if(success) return;
+        }
+}
+void tally_stats(global_stat_t & global, local_stat_t & local) {
+        global.in    += local.in;
+        global.out   += local.out;
+        global.empty += local.empty;
+        global.crc_in  += local.crc_in;
+        global.crc_out += local.crc_out;
+        atomic_max(global.valmax, local.valmax);
+        atomic_min(global.valmin, local.valmin);
+        relaxed_list<Node>::stats_tls_tally();
+}
+void waitfor(double & duration, barrier_t & barrier, std::atomic_bool & done) {
+__attribute__((noinline)) void run_body(
+        std::atomic<bool>& done,
+        Random & rand,
+        Node * (&my_nodes)[128],
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                int idx = rand.next() % nodes_per_threads;
+                if (auto node = my_nodes[idx]) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        my_nodes[idx] = nullptr;
+                        local.in++;
+                }
+                else if(auto node = list.pop()) {
+                        local.crc_out += node->value;
+                        my_nodes[idx] = node;
+                        local.out++;
+                }
+                else {
+                        local.empty++;
+                }
+        }
+}
+void run(unsigned nthread, unsigned nqueues, unsigned fill, double duration) {
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        struct {
+                std::atomic_size_t in  = { 0 };
+                std::atomic_size_t out = { 0 };
+                std::atomic_size_t empty = { 0 };
+                std::atomic_size_t crc_in  = { 0 };
+                std::atomic_size_t crc_out = { 0 };
+                struct {
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } pop;
+                } pick;
+        } global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        // Prep nodes
+        std::cout << "Initializing ";
+        size_t nnodes  = 0;
+        size_t npushed = 0;
+        NodeArray all_nodes[nthread];
+        for(auto & nodes : all_nodes) {
+                Random rand(rdtscl());
+                for(auto & node : nodes.array) {
+                        auto r = rand.next() % 100;
+                        if(r < fill) {
+                                node = new Node(rand.next() % 100);
+                                nnodes++;
+                        } else {
+                                node = nullptr;
+                        }
+                }
+                for(int i = 0; i < 10; i++) {
+                        int idx = rand.next() % nodes_per_threads;
+                        if (auto node = nodes.array[idx]) {
+                                global.crc_in += node->value;
+                                list.push(node);
+                                npushed++;
+                                nodes.array[idx] = nullptr;
+                        }
+                }
+        }
+        std::cout << nnodes << " nodes " << fill << "% (" << npushed << " pushed)" << std::endl;
+        enable_stats = true;
+        std::thread * threads[nthread];
+        unsigned i = 1;
+        for(auto & t : threads) {
+                auto & my_nodes = all_nodes[i - 1].array;
+                t = new std::thread([&done, &list, &barrier, &global, &my_nodes](unsigned tid) {
+                        Random rand(tid + rdtscl());
+                        local_stat_t local;
+                        // affinity(tid);
+                        barrier.wait(tid);
+                        // EXPERIMENT START
+                        run_body(done, rand, my_nodes, local, list);
+                        // EXPERIMENT END
+                        barrier.wait(tid);
+                        global.in    += local.in;
+                        global.out   += local.out;
+                        global.empty += local.empty;
+                        for(auto node : my_nodes) {
+                                delete node;
+                        }
+                        global.crc_in  += local.crc_in;
+                        global.crc_out += local.crc_out;
+                        global.pick.push.attempt += relaxed_list<Node>::tls.pick.push.attempt;
+                        global.pick.push.success += relaxed_list<Node>::tls.pick.push.success;
+                        global.pick.pop .attempt += relaxed_list<Node>::tls.pick.pop.attempt;
+                        global.pick.pop .success += relaxed_list<Node>::tls.pick.pop.success;
+                }, i++);
+        }
         std::cout << "Starting" << std::endl;
         auto before = Clock::now();
 …
         duration = durr.count();
         std::cout << "\rClosing down" << std::endl;
+}
+void waitfor(double & duration, barrier_t & barrier, const std::atomic_size_t & count) {
+        std::cout << "Starting" << std::endl;
+        auto before = Clock::now();
+        barrier.wait(0);
+        while(true) {
+                usleep(100000);
+                size_t c = count.load();
+                if( c == 0 ) {
+                        break;
+                }
+                std::cout << "\r" << c;
+                std::cout.flush();
+        }
+        barrier.wait(0);
+        auto after = Clock::now();
+        duration_t durr = after - before;
+        duration = durr.count();
+        std::cout << "\rClosing down" << std::endl;
+}
+void print_stats(double duration, unsigned nthread, global_stat_t & global) {
+        for(auto t : threads) {
+                t->join();
+                delete t;
+        }
+        enable_stats = false;
+        while(auto node = list.pop()) {
+                global.crc_out += node->value;
+                delete node;
+        }
         assert(Node::creates == Node::destroys);
         assert(global.crc_in == global.crc_out);
 …
         std::cout << "Ops/sec       : " << ops_sec << "\n";
         std::cout << "Total ops     : " << ops << "(" << global.in << "i, " << global.out << "o, " << global.empty << "e)\n";
-        if(global.valmax != 0) {
-                std::cout << "Max runs      : " << global.valmax << "\n";
-                std::cout << "Min runs      : " << global.valmin << "\n";
+        }
         #ifndef NO_STATS
+                relaxed_list<Node>::stats_print(std::cout);
+                double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
+                double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
+                std::cout << "Push Pick %   : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
+                std::cout << "Pop  Pick %   : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
         #endif
+}
+void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output);
+// ================================================================================================
+//                        EXPERIMENTS
+// ================================================================================================
+// ================================================================================================
+__attribute__((noinline)) void runChurn_body(
+        std::atomic<bool>& done,
+        Random & rand,
+        Node * my_nodes[],
+        unsigned nslots,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                int idx = rand.next() % nslots;
+                if (auto node = my_nodes[idx]) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        my_nodes[idx] = nullptr;
+                        local.in++;
+                }
+                else if(auto node = list.pop()) {
+                        local.crc_out += node->value;
+                        my_nodes[idx] = node;
+                        local.out++;
+                }
+                else {
+                        local.empty++;
+                }
+        }
+}
+void runChurn(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const unsigned nslots) {
+        std::cout << "Churn Benchmark" << std::endl;
+        assert(nnodes <= nslots);
+        // List being tested
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        // Prep nodes
+        std::cout << "Initializing ";
+        size_t npushed = 0;
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                Node** all_nodes[nthread];
+                for(auto & nodes : all_nodes) {
+                        nodes = new __attribute__((aligned(64))) Node*[nslots + 8];
+                        Random rand(rdtscl());
+                        for(unsigned i = 0; i < nnodes; i++) {
+                                nodes[i] = new Node(rand.next() % 100);
+                        }
+                        for(unsigned i = nnodes; i < nslots; i++) {
+                                nodes[i] = nullptr;
+                        }
+                        for(int i = 0; i < 10 && i < (int)nslots; i++) {
+                                int idx = rand.next() % nslots;
+                                if (auto node = nodes[idx]) {
+                                        global.crc_in += node->value;
+                                        list.push(node);
+                                        npushed++;
+                                        nodes[idx] = nullptr;
+                                }
+                        }
+                }
+                std::cout << nnodes << " nodes (" << nslots << " slots)" << std::endl;
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        auto & my_nodes = all_nodes[i - 1];
+                        t = new std::thread([&done, &list, &barrier, &global, &my_nodes, nslots](unsigned tid) {
+                                Random rand(tid + rdtscl());
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runChurn_body(done, rand, my_nodes, nslots, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                tally_stats(global, local);
+                                for(unsigned i = 0; i < nslots; i++) {
+                                        delete my_nodes[i];
+                                }
+                        }, i++);
+                }
+                waitfor(duration, barrier, done);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+                while(auto node = list.pop()) {
+                        global.crc_out += node->value;
+                        delete node;
+                }
+                for(auto nodes : all_nodes) {
+                        delete[] nodes;
+                }
+        }
+        print_stats(duration, nthread, global);
+}
+// ================================================================================================
+__attribute__((noinline)) void runPingPong_body(
+        std::atomic<bool>& done,
+        Node initial_nodes[],
+        unsigned nnodes,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        Node * nodes[nnodes];
+        {
+                unsigned i = 0;
+                for(auto & n : nodes) {
+                        n = &initial_nodes[i++];
+                }
+        }
+        while(__builtin_expect(!done.load(std::memory_order_relaxed), true)) {
+                for(Node * & node : nodes) {
+                        local.crc_in += node->value;
+                        list.push(node);
+                        local.in++;
+                }
+                // -----
+                for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        local.crc_out += node->value;
+                        local.out++;
+                }
+        }
+}
+void runPingPong(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes) {
+        std::cout << "PingPong Benchmark" << std::endl;
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        // Flag to signal termination
+        std::atomic_bool done  = { false };
+        std::cout << "Initializing ";
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        t = new std::thread([&done, &list, &barrier, &global, nnodes](unsigned tid) {
+                                Random rand(tid + rdtscl());
+                                Node nodes[nnodes];
+                                for(auto & n : nodes) {
+                                        n.value = (int)rand.next() % 100;
+                                }
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runPingPong_body(done, nodes, nnodes, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                tally_stats(global, local);
+                        }, i++);
+                }
+                waitfor(duration, barrier, done);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+        }
+        print_stats(duration, nthread, global);
+}
+// ================================================================================================
+__attribute__((noinline)) void runFairness_body(
+        unsigned tid,
+        size_t width,
+        size_t length,
+        int output[],
+        std::atomic_size_t & count,
+        Node initial_nodes[],
+        unsigned nnodes,
+        local_stat_t & local,
+        relaxed_list<Node> & list
+) {
+        Node * nodes[nnodes];
+        {
+                unsigned i = 0;
+                for(auto & n : nodes) {
+                        n = &initial_nodes[i++];
+                }
+        }
+        while(__builtin_expect(0 != count.load(std::memory_order_relaxed), true)) {
+                for(Node * & node : nodes) {
+                        local.crc_in += node->id;
+                        list.push(node);
+                        local.in++;
+                }
+                // -----
+                for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        if (unsigned(node->value) < length) {
+                                size_t idx = (node->value * width) + node->id;
+                                assert(idx < (width * length));
+                                output[idx] = tid;
+                        }
+                        node->value++;
+                        if(unsigned(node->value) == length) count--;
+                        local.crc_out += node->id;
+                        local.out++;
+                }
+        }
+}
+void runFairness(unsigned nthread, unsigned nqueues, double duration, unsigned nnodes, const std::string & output) {
+        std::cout << "Fairness Benchmark, outputing to : " << output << std::endl;
+        // Barrier for synchronization
+        barrier_t barrier(nthread + 1);
+        // Data to check everything is OK
+        global_stat_t global;
+        std::cout << "Initializing ";
+        // Check fairness by creating a png of where the threads ran
+        size_t width = nthread * nnodes;
+        size_t length = 100000;
+        std::unique_ptr<int[]> data_out { new int[width * length] };
+        // Flag to signal termination
+        std::atomic_size_t count = width;
+        // List being tested
+        relaxed_list<Node> list = { nthread * nqueues };
+        {
+                enable_stats = true;
+                std::thread * threads[nthread];
+                unsigned i = 1;
+                for(auto & t : threads) {
+                        t = new std::thread([&count, &list, &barrier, &global, nnodes, width, length, data_out = data_out.get()](unsigned tid) {
+                                unsigned int start = (tid - 1) * nnodes;
+                                Node nodes[nnodes];
+                                for(auto & n : nodes) {
+                                        n.id = start;
+                                        n.value = 0;
+                                        start++;
+                                }
+                                local_stat_t local;
+                                // affinity(tid);
+                                barrier.wait(tid);
+                                // EXPERIMENT START
+                                runFairness_body(tid, width, length, data_out, count, nodes, nnodes, local, list);
+                                // EXPERIMENT END
+                                barrier.wait(tid);
+                                for(const auto & n : nodes) {
+                                        local.valmax = max(local.valmax, size_t(n.value));
+                                        local.valmin = min(local.valmin, size_t(n.value));
+                                }
+                                tally_stats(global, local);
+                        }, i++);
+                }
+                waitfor(duration, barrier, count);
+                for(auto t : threads) {
+                        t->join();
+                        delete t;
+                }
+                enable_stats = false;
+        }
+        print_stats(duration, nthread, global);
+        save_fairness(data_out.get(), 100, nthread, width, length, output);
+}
+// ================================================================================================
+bool iequals(const std::string& a, const std::string& b)
+{
+    return std::equal(a.begin(), a.end(),
+                      b.begin(), b.end(),
+                      [](char a, char b) {
+                          return std::tolower(a) == std::tolower(b);
+                      });
+void usage(char * argv[]) {
+        std::cerr << argv[0] << ": [DURATION (FLOAT:SEC)] [NTHREADS] [NQUEUES] [FILL]" << std::endl;;
+        std::exit(1);
+}
 …
         double duration   = 5.0;
         unsigned nthreads = 2;
+        unsigned nqueues  = 4;
+        unsigned nnodes   = 100;
+        unsigned nslots   = 100;
+        std::string out   = "fairness.png";
+        enum {
+                Churn,
+                PingPong,
+                Fairness,
+                NONE
+        } benchmark = NONE;
+        unsigned nqueues  = 2;
+        unsigned fill     = 100;
         std::cout.imbue(std::locale(""));
+        for(;;) {
+                static struct option options[] = {
+                        {"duration",  required_argument, 0, 'd'},
+                        {"nthreads",  required_argument, 0, 't'},
+                        {"nqueues",   required_argument, 0, 'q'},
+                        {"benchmark", required_argument, 0, 'b'},
+                        {0, 0, 0, 0}
+                };
+                int idx = 0;
+                int opt = getopt_long(argc, argv, "d:t:q:b:", options, &idx);
+                std::string arg = optarg ? optarg : "";
+                size_t len = 0;
+                switch(opt) {
+                        // Exit Case
+                        case -1:
+                                /* paranoid */ assert(optind <= argc);
+                                switch(benchmark) {
+                                case NONE:
+                                        std::cerr << "Must specify a benchmark" << std::endl;
+                                        goto usage;
+                                case PingPong:
+                                        nnodes = 1;
+                                        nslots = 1;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        default:
+                                                std::cerr << "'PingPong' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                        break;
+                                case Churn:
+                                        nnodes = 100;
+                                        nslots = 100;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                        nslots = nnodes;
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        case 2:
+                                                try {
+                                                        arg = optarg = argv[optind];
+                                                        nnodes = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of nodes must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                try {
+                                                        arg = optarg = argv[optind + 1];
+                                                        nslots = stoul(optarg, &len);
+                                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                                } catch(std::invalid_argument &) {
+                                                        std::cerr << "Number of slots must be a positive integer, was " << arg << std::endl;
+                                                        goto usage;
+                                                }
+                                                break;
+                                        default:
+                                                std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                        break;
+                                case Fairness:
+                                        nnodes = 1;
+                                        switch(argc - optind) {
+                                        case 0: break;
+                                        case 1:
+                                                arg = optarg = argv[optind];
+                                                out = arg;
+                                                break;
+                                        default:
+                                                std::cerr << "'Churn' benchmark doesn't accept more than 2 extra arguments" << std::endl;
+                                                goto usage;
+                                        }
+                                }
+                                goto run;
+                        // Benchmarks
+                        case 'b':
+                                if(benchmark != NONE) {
+                                        std::cerr << "Only when benchmark can be run" << std::endl;
+                                        goto usage;
+                                }
+                                if(iequals(arg, "churn")) {
+                                        benchmark = Churn;
+                                        break;
+                                }
+                                if(iequals(arg, "pingpong")) {
+                                        benchmark = PingPong;
+                                        break;
+                                }
+                                if(iequals(arg, "fairness")) {
+                                        benchmark = Fairness;
+                                        break;
+                                }
+                                std::cerr << "Unkown benchmark " << arg << std::endl;
+                                goto usage;
+                        // Numeric Arguments
+                        case 'd':
+                                try {
+                                        duration = stod(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Duration must be a valid double, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        case 't':
+                                try {
+                                        nthreads = stoul(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Number of threads must be a positive integer, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        case 'q':
+                                try {
+                                        nqueues = stoul(optarg, &len);
+                                        if(len != arg.size()) { throw std::invalid_argument(""); }
+                                } catch(std::invalid_argument &) {
+                                        std::cerr << "Number of queues must be a positive integer, was " << arg << std::endl;
+                                        goto usage;
+                                }
+                                break;
+                        // Other cases
+                        default: /* ? */
+                                std::cerr << opt << std::endl;
+                        usage:
+                                std::cerr << "Usage: " << argv[0] << ": [options] -b churn [NNODES] [NSLOTS = NNODES]" << std::endl;
+                                std::cerr << "  or:  " << argv[0] << ": [options] -b pingpong [NNODES]" << std::endl;
+                                std::cerr << std::endl;
+                                std::cerr << "  -d, --duration=DURATION  Duration of the experiment, in seconds" << std::endl;
+                                std::cerr << "  -t, --nthreads=NTHREADS  Number of kernel threads" << std::endl;
+                                std::cerr << "  -q, --nqueues=NQUEUES    Number of queues per threads" << std::endl;
+                                std::exit(1);
+                }
+        }
+        run:
+        switch (argc)
+        {
+        case 5:
+                fill = std::stoul(argv[4]);
+                [[fallthrough]];
+        case 4:
+                nqueues = std::stoul(argv[3]);
+                [[fallthrough]];
+        case 3:
+                nthreads = std::stoul(argv[2]);
+                [[fallthrough]];
+        case 2:
+                duration = std::stod(argv[1]);
+                if( duration <= 0.0 ) {
+                        std::cerr << "Duration must be positive, was " << argv[1] << "(" << duration << ")" << std::endl;
+                        usage(argv);
+                }
+                [[fallthrough]];
+        case 1:
+                break;
+        default:
+                usage(argv);
+                break;
+        }
         check_cache_line_size();
         std::cout << "Running " << nthreads << " threads (" << (nthreads * nqueues) << " queues) for " << duration << " seconds" << std::endl;
+        switch(benchmark) {
+                case Churn:
+                        runChurn(nthreads, nqueues, duration, nnodes, nslots);
+                        break;
+                case PingPong:
+                        runPingPong(nthreads, nqueues, duration, nnodes);
+                        break;
+                case Fairness:
+                        runFairness(nthreads, nqueues, duration, nnodes, out);
+                        break;
+                default:
+                        abort();
+        }
+        run(nthreads, nqueues, fill, duration);
         return 0;
+}
+template<>
+thread_local relaxed_list<Node>::TLS relaxed_list<Node>::tls = {};
+template<>
+relaxed_list<Node>::intrusive_queue_t::stat::Dif relaxed_list<Node>::intrusive_queue_t::stat::dif = {};
 const char * __my_progname = "Relaxed List";
-struct rgb_t {
-    double r;       // a fraction between 0 and 1
-    double g;       // a fraction between 0 and 1
-    double b;       // a fraction between 0 and 1
-};
-struct hsv_t {
-    double h;       // angle in degrees
-    double s;       // a fraction between 0 and 1
-    double v;       // a fraction between 0 and 1
-};
-rgb_t hsv2rgb(hsv_t in) {
-        double hh, p, q, t, ff;
-        long   i;
-        rgb_t  out;
-        if(in.s <= 0.0) {       // < is bogus, just shuts up warnings
-                out.r = in.v;
-                out.g = in.v;
-                out.b = in.v;
-                return out;
+        }
-        hh = in.h;
-        if(hh >= 360.0) hh = 0.0;
-        hh /= 60.0;
-        i = (long)hh;
-        ff = hh - i;
-        p = in.v * (1.0 - in.s);
-        q = in.v * (1.0 - (in.s * ff));
-        t = in.v * (1.0 - (in.s * (1.0 - ff)));
-        switch(i) {
-        case 0:
-                out.r = in.v;
-                out.g = t;
-                out.b = p;
-                break;
-        case 1:
-                out.r = q;
-                out.g = in.v;
-                out.b = p;
-                break;
-        case 2:
-                out.r = p;
-                out.g = in.v;
-                out.b = t;
-                break;
-        case 3:
-                out.r = p;
-                out.g = q;
-                out.b = in.v;
-                break;
-        case 4:
-                out.r = t;
-                out.g = p;
-                out.b = in.v;
-                break;
-        case 5:
-        default:
-                out.r = in.v;
-                out.g = p;
-                out.b = q;
-                break;
+        }
-        return out;
+}
-void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
-        std::ofstream os(output);
-        os << "<html>\n";
-        os << "<head>\n";
-        os << "<style>\n";
-        os << "</style>\n";
-        os << "</head>\n";
-        os << "<body>\n";
-        os << "<table style=\"width=100%\">\n";
-        size_t idx = 0;
-        for(size_t r = 0ul; r < rows; r++) {
-                os << "<tr>\n";
-                for(size_t c = 0ul; c < columns; c++) {
-                        os << "<td class=\"custom custom" << data[idx] << "\"></td>\n";
-                        idx++;
+                }
-                os << "</tr>\n";
+        }
-        os << "</table>\n";
-        os << "</body>\n";
-        os << "</html>\n";
-        os << std::endl;
+}
-#include <png.h>
-#include <setjmp.h>
-/*
-void save_fairness(const int data[], int factor, unsigned nthreads, size_t columns, size_t rows, const std::string & output) {
-        int width  = columns * factor;
-        int height = rows / factor;
-        int code = 0;
-        int idx = 0;
-        FILE *fp = NULL;
-        png_structp png_ptr = NULL;
-        png_infop info_ptr = NULL;
-        png_bytep row = NULL;
-        // Open file for writing (binary mode)
-        fp = fopen(output.c_str(), "wb");
-        if (fp == NULL) {
-                fprintf(stderr, "Could not open file %s for writing\n", output.c_str());
-                code = 1;
-                goto finalise;
+        }
-           // Initialize write structure
-        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-        if (png_ptr == NULL) {
-                fprintf(stderr, "Could not allocate write struct\n");
-                code = 1;
-                goto finalise;
+        }
-        // Initialize info structure
-        info_ptr = png_create_info_struct(png_ptr);
-        if (info_ptr == NULL) {
-                fprintf(stderr, "Could not allocate info struct\n");
-                code = 1;
-                goto finalise;
+        }
-        // Setup Exception handling
-        if (setjmp(png_jmpbuf(png_ptr))) {
-                fprintf(stderr, "Error during png creation\n");
-                code = 1;
-                goto finalise;
+        }
-        png_init_io(png_ptr, fp);
-        // Write header (8 bit colour depth)
-        png_set_IHDR(png_ptr, info_ptr, width, height,
-, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
-                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-        png_write_info(png_ptr, info_ptr);
-        // Allocate memory for one row (3 bytes per pixel - RGB)
-        row = (png_bytep) malloc(3 * width * sizeof(png_byte));
-        // Write image data
-        int x, y;
-        for (y=0 ; y<height ; y++) {
-                for (x=0 ; x<width ; x++) {
-                        auto & r = row[(x * 3) + 0];
-                        auto & g = row[(x * 3) + 1];
-                        auto & b = row[(x * 3) + 2];
-                        assert(idx < (rows * columns));
-                        int color = data[idx] - 1;
-                        assert(color < nthreads);
-                        assert(color >= 0);
-                        idx++;
-                        double angle = double(color) / double(nthreads);
-                        auto c = hsv2rgb({ 360.0 * angle, 0.8, 0.8 });
-                        r = char(c.r * 255.0);
-                        g = char(c.g * 255.0);
-                        b = char(c.b * 255.0);
+                }
-                png_write_row(png_ptr, row);
+        }
-        assert(idx == (rows * columns));
-        // End write
-        png_write_end(png_ptr, NULL);
-        finalise:
-        if (fp != NULL) fclose(fp);
-        if (info_ptr != NULL) png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
-        if (png_ptr != NULL) png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
-        if (row != NULL) free(row);
+}
-*/

doc/theses/thierry_delisle_PhD/code/relaxed_list.hpp

-              ra505021
+              r8c50aed
 };
-static inline bool bts(std::atomic_size_t & target, size_t bit ) {
-        //*
-        int result = 0;
-        asm volatile(
-                "LOCK btsq %[bit], %[target]\n\t"
-                :"=@ccc" (result)
-                : [target] "m" (target), [bit] "r" (bit)
-        );
-        return result != 0;
-        /*/
-        size_t mask = 1ul << bit;
-        size_t ret = target.fetch_or(mask, std::memory_order_relaxed);
-        return (ret & mask) != 0;
-        //*/
+}
-static inline bool btr(std::atomic_size_t & target, size_t bit ) {
-        //*
-        int result = 0;
-        asm volatile(
-                "LOCK btrq %[bit], %[target]\n\t"
-                :"=@ccc" (result)
-                : [target] "m" (target), [bit] "r" (bit)
-        );
-        return result != 0;
-        /*/
-        size_t mask = 1ul << bit;
-        size_t ret = target.fetch_and(~mask, std::memory_order_relaxed);
-        return (ret & mask) != 0;
-        //*/
+}
 extern bool enable_stats;
 …
                 size_t attempt = 0;
                 size_t success = 0;
-                size_t mask_attempt = 0;
-        } pop;
-};
-struct empty_stat {
-        struct {
-                size_t value = 0;
-                size_t count = 0;
-        } push;
-        struct {
-                size_t value = 0;
-                size_t count = 0;
         } pop;
 };
 …
         static_assert(std::is_same<decltype(node_t::_links), _LinksFields_t<node_t>>::value, "Node must have a links field");
 public:
         relaxed_list(unsigned numLists)
+                : lists(new intrusive_queue_t[numLists])
+                : numNonEmpty{0}
+                , lists(new intrusive_queue_t[numLists])
                 , numLists(numLists)
+        {
+                assertf(7 * 8 * 8 >= numLists, "List currently only supports 448 sublists");
+                // assert(sizeof(*this) == 128);
+                std::cout << "Constructing Relaxed List with " << numLists << std::endl;
+        {}
+        ~relaxed_list() {
+                lists.reset();
                 #ifndef NO_STATS
+                        if(head) this->next = head;
+                        head = this;
+                        std::cout << "Difference   : "
+                                << ssize_t(double(intrusive_queue_t::stat::dif.value) / intrusive_queue_t::stat::dif.num  ) << " avg\t"
+                                << intrusive_queue_t::stat::dif.max << "max" << std::endl;
                 #endif
+        }
-        ~relaxed_list() {
-                std::cout << "Destroying Relaxed List" << std::endl;
-                lists.reset();
+        }
 …
                 while(true) {
                         // Pick a random list
                         unsigned i = tls.rng.next() % numLists;
+                        int i = tls.rng.next() % numLists;
                         #ifndef NO_STATS
 …
                         if( !lists[i].lock.try_lock() ) continue;
-                        __attribute__((unused)) int num = numNonEmpty;
                         // Actually push it
+                        if(lists[i].push(node)) {
+                                numNonEmpty++;
+                                size_t qword = i >> 6ull;
+                                size_t bit   = i & 63ull;
+                                assertf((list_mask[qword] & (1ul << bit)) == 0, "Before set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
+                                __attribute__((unused)) bool ret = bts(list_mask[qword], bit);
+                                assert(!ret);
+                                assertf((list_mask[qword] & (1ul << bit)) != 0, "After set %zu:%zu (%u), %zx & %zx", qword, bit, i, list_mask[qword].load(), (1ul << bit));
+                        }
+                        lists[i].push(node, numNonEmpty);
                         assert(numNonEmpty <= (int)numLists);
 …
                         #ifndef NO_STATS
                                 tls.pick.push.success++;
-                                tls.empty.push.value += num;
-                                tls.empty.push.count += 1;
                         #endif
                         return;
 …
         __attribute__((noinline, hot)) node_t * pop() {
+                #if !defined(NO_BITMASK)
+                        // for(int r = 0; r < 10 && numNonEmpty != 0; r++) {
+                        //      // Pick two lists at random
+                        //      unsigned i = tls.rng.next() % numLists;
+                        //      unsigned j = tls.rng.next() % numLists;
+                        //      if(auto node = try_pop(i, j)) return node;
+                        // }
+                        int nnempty;
+                        while(0 != (nnempty = numNonEmpty)) {
+                                tls.pick.pop.mask_attempt++;
+                                unsigned i, j;
+                                // if( numLists < 4 || (numLists / nnempty) < 4 ) {
+                                //      // Pick two lists at random
+                                //      i = tls.rng.next() % numLists;
+                                //      j = tls.rng.next() % numLists;
+                                // } else
+                                {
+                                        #ifndef NO_STATS
+                                                // tls.pick.push.mask_attempt++;
+                                        #endif
+                                        // Pick two lists at random
+                                        unsigned num = ((numLists - 1) >> 6) + 1;
+                                        unsigned ri = tls.rng.next();
+                                        unsigned rj = tls.rng.next();
+                                        unsigned wdxi = (ri >> 6u) % num;
+                                        unsigned wdxj = (rj >> 6u) % num;
+                                        size_t maski = list_mask[wdxi].load(std::memory_order_relaxed);
+                                        size_t maskj = list_mask[wdxj].load(std::memory_order_relaxed);
+                                        if(maski == 0 && maskj == 0) continue;
+                                        unsigned bi = rand_bit(ri, maski);
+                                        unsigned bj = rand_bit(rj, maskj);
+                                        assertf(bi < 64, "%zu %u", maski, bi);
+                                        assertf(bj < 64, "%zu %u", maskj, bj);
+                                        i = bi | (wdxi << 6);
+                                        j = bj | (wdxj << 6);
+                                        assertf(i < numLists, "%u", wdxi << 6);
+                                        assertf(j < numLists, "%u", wdxj << 6);
+                                }
+                                if(auto node = try_pop(i, j)) return node;
+                        }
+                #else
+                        while(numNonEmpty != 0) {
+                                // Pick two lists at random
+                                int i = tls.rng.next() % numLists;
+                                int j = tls.rng.next() % numLists;
+                                if(auto node = try_pop(i, j)) return node;
+                        }
+                #endif
+                while(numNonEmpty != 0) {
+                        // Pick two lists at random
+                        int i = tls.rng.next() % numLists;
+                        int j = tls.rng.next() % numLists;
+                        #ifndef NO_STATS
+                                tls.pick.pop.attempt++;
+                        #endif
+                        // Pick the bet list
+                        int w = i;
+                        if( __builtin_expect(lists[j].ts() != 0, true) ) {
+                                w = (lists[i].ts() < lists[j].ts()) ? i : j;
+                        }
+                        auto & list = lists[w];
+                        // If list looks empty retry
+                        if( list.ts() == 0 ) continue;
+                        // If we can't get the lock retry
+                        if( !list.lock.try_lock() ) continue;
+                        // If list is empty, unlock and retry
+                        if( list.ts() == 0 ) {
+                                list.lock.unlock();
+                                continue;
+                        }
+                        // Actually pop the list
+                        auto node = list.pop(numNonEmpty);
+                        assert(node);
+                        // Unlock and return
+                        list.lock.unlock();
+                        assert(numNonEmpty >= 0);
+                        #ifndef NO_STATS
+                                tls.pick.pop.success++;
+                        #endif
+                        return node;
+                }
                 return nullptr;
+        }
-private:
-        node_t * try_pop(unsigned i, unsigned j) {
-                #ifndef NO_STATS
-                        tls.pick.pop.attempt++;
-                #endif
-                // Pick the bet list
-                int w = i;
-                if( __builtin_expect(lists[j].ts() != 0, true) ) {
-                        w = (lists[i].ts() < lists[j].ts()) ? i : j;
+                }
-                auto & list = lists[w];
-                // If list looks empty retry
-                if( list.ts() == 0 ) return nullptr;
-                // If we can't get the lock retry
-                if( !list.lock.try_lock() ) return nullptr;
-                __attribute__((unused)) int num = numNonEmpty;
-                // If list is empty, unlock and retry
-                if( list.ts() == 0 ) {
-                        list.lock.unlock();
-                        return nullptr;
+                }
-                // Actually pop the list
-                node_t * node;
-                bool emptied;
-                std::tie(node, emptied) = list.pop();
-                assert(node);
-                if(emptied) {
-                        numNonEmpty--;
-                        size_t qword = w >> 6ull;
-                        size_t bit   = w & 63ull;
-                        assert((list_mask[qword] & (1ul << bit)) != 0);
-                        __attribute__((unused)) bool ret = btr(list_mask[qword], bit);
-                        assert(ret);
-                        assert((list_mask[qword] & (1ul << bit)) == 0);
+                }
-                // Unlock and return
-                list.lock.unlock();
-                assert(numNonEmpty >= 0);
-                #ifndef NO_STATS
-                        tls.pick.pop.success++;
-                        tls.empty.pop.value += num;
-                        tls.empty.pop.count += 1;
-                #endif
-                return node;
+        }
 private:
 …
                 struct stat {
                         ssize_t diff = 0;
+                        size_t  push = 0;
+                        size_t  pop  = 0;
+                        // size_t value = 0;
+                        // size_t count = 0;
+                        static struct Dif {
+                                ssize_t value = 0;
+                                size_t  num   = 0;
+                                ssize_t max   = 0;
+                        } dif;
                 };
 …
                 sentinel_t before;
                 sentinel_t after;
+                #ifndef NO_STATS
+                        stat s;
+                #endif
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+                stat s;
                 static constexpr auto fields_offset = offsetof( node_t, _links );
-#pragma GCC diagnostic pop
         public:
                 intrusive_queue_t()
 …
                         , after {{ head(), nullptr }}
+                {
+                        /* paranoid */ assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
+                        /* paranoid */ assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
+                        /* paranoid */ assert(head()->_links.prev == nullptr);
+                        /* paranoid */ assert(head()->_links.next == tail() );
+                        /* paranoid */ assert(tail()->_links.next == nullptr);
+                        /* paranoid */ assert(tail()->_links.prev == head() );
+                        /* paranoid */ assert(sizeof(*this) == 128);
+                        /* paranoid */ assert((intptr_t(this) % 128) == 0);
+                }
+                ~intrusive_queue_t() = default;
+                        assert((reinterpret_cast<uintptr_t>( head() ) + fields_offset) == reinterpret_cast<uintptr_t>(&before));
+                        assert((reinterpret_cast<uintptr_t>( tail() ) + fields_offset) == reinterpret_cast<uintptr_t>(&after ));
+                        assert(head()->_links.prev == nullptr);
+                        assert(head()->_links.next == tail() );
+                        assert(tail()->_links.next == nullptr);
+                        assert(tail()->_links.prev == head() );
+                        assert(sizeof(*this) == 128);
+                        assert((intptr_t(this) % 128) == 0);
+                }
+                ~intrusive_queue_t() {
+                        #ifndef NO_STATS
+                                stat::dif.value+= s.diff;
+                                stat::dif.num  ++;
+                                stat::dif.max  = std::abs(stat::dif.max) > std::abs(s.diff) ? stat::dif.max : s.diff;
+                        #endif
+                }
                 inline node_t * head() const {
 …
+                }
                 inline bool push(node_t * node) {
+                inline void push(node_t * node, std::atomic_int & nonEmpty) {
                         assert(lock);
                         assert(node->_links.ts != 0);
 …
                         prev->_links.next = node;
                         tail->_links.prev = node;
-                        #ifndef NO_STATS
-                                if(enable_stats) {
-                                        s.diff++;
-                                        s.push++;
+                                }
-                        #endif
                         if(before._links.ts == 0l) {
+                                nonEmpty += 1;
                                 before._links.ts = node->_links.ts;
                                 assert(node->_links.prev == this->head());
                                 return true;
+                        }
                         return false;
+                }
                 inline std::pair<node_t *, bool> pop() {
+                        }
+                        #ifndef NO_STATS
+                                if(enable_stats) s.diff++;
+                        #endif
+                }
+                inline node_t * pop(std::atomic_int & nonEmpty) {
                         assert(lock);
                         node_t * head = this->head();
 …
                         node_t * node = head->_links.next;
                         node_t * next = node->_links.next;
                         if(node == tail) return {nullptr, false};
+                        if(node == tail) return nullptr;
                         head->_links.next = next;
                         next->_links.prev = head;
-                        #ifndef NO_STATS
-                                if(enable_stats) {
-                                        s.diff--;
-                                        s.pop ++;
+                                }
-                        #endif
                         if(next == tail) {
                                 before._links.ts = 0l;
                                 return {node, true};
+                                nonEmpty -= 1;
+                        }
                         else {
 …
                                 before._links.ts = next->_links.ts;
                                 assert(before._links.ts != 0);
+                                return {node, false};
+                        }
+                        }
+                        #ifndef NO_STATS
+                                if(enable_stats) s.diff--;
+                        #endif
+                        return node;
+                }
 …
         static __attribute__((aligned(128))) thread_local struct TLS {
+                Random     rng = { int(rdtscl()) };
+                pick_stat  pick;
+                empty_stat empty;
+                Random    rng = { int(rdtscl()) };
+                pick_stat pick;
         } tls;
-public:
-        std::atomic_int numNonEmpty  = { 0 };  // number of non-empty lists
-        std::atomic_size_t list_mask[7] = { {0}, {0}, {0}, {0}, {0}, {0}, {0} }; // which queues are empty
 private:
+        std::atomic_int numNonEmpty; // number of non-empty lists
         __attribute__((aligned(64))) std::unique_ptr<intrusive_queue_t []> lists;
         const unsigned numLists;
 …
 public:
         static const constexpr size_t sizeof_queue = sizeof(intrusive_queue_t);
+#ifndef NO_STATS
+        static void stats_print(std::ostream & os) {
+                auto it = head;
+                while(it) {
+                        it->stats_print_local(os);
+                        it = it->next;
+                }
+        }
+        static void stats_tls_tally() {
+                global_stats.pick.push.attempt += tls.pick.push.attempt;
+                global_stats.pick.push.success += tls.pick.push.success;
+                global_stats.pick.pop .attempt += tls.pick.pop.attempt;
+                global_stats.pick.pop .success += tls.pick.pop.success;
+                global_stats.pick.pop .mask_attempt += tls.pick.pop.mask_attempt;
+                global_stats.qstat.push.value += tls.empty.push.value;
+                global_stats.qstat.push.count += tls.empty.push.count;
+                global_stats.qstat.pop .value += tls.empty.pop .value;
+                global_stats.qstat.pop .count += tls.empty.pop .count;
+        }
+private:
+        static struct GlobalStats {
+                struct {
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t success = { 0 };
+                                std::atomic_size_t mask_attempt = { 0 };
+                        } pop;
+                } pick;
+                struct {
+                        struct {
+                                std::atomic_size_t value = { 0 };
+                                std::atomic_size_t count = { 0 };
+                        } push;
+                        struct {
+                                std::atomic_size_t value = { 0 };
+                                std::atomic_size_t count = { 0 };
+                        } pop;
+                } qstat;
+        } global_stats;
+        // Link list of all lists for stats
+        __attribute__((aligned(64))) relaxed_list<node_t> * next = nullptr;
+        static relaxed_list<node_t> * head;
+        void stats_print_local(std::ostream & os ) {
+                std::cout << "----- Relaxed List Stats -----" << std::endl;
+                {
+                        ssize_t diff = 0;
+                        size_t  num  = 0;
+                        ssize_t max  = 0;
+                        for(size_t i = 0; i < numLists; i++) {
+                                const auto & list = lists[i];
+                                diff+= list.s.diff;
+                                num ++;
+                                max  = std::abs(max) > std::abs(list.s.diff) ? max : list.s.diff;
+                                os << "Local Q ops   : " << (list.s.push + list.s.pop) << "(" << list.s.push << "i, " << list.s.pop << "o)\n";
+                        }
+                        os << "Difference   : " << ssize_t(double(diff) / num  ) << " avg\t" << max << "max" << std::endl;
+                }
+                const auto & global = global_stats;
+                double push_sur = (100.0 * double(global.pick.push.success) / global.pick.push.attempt);
+                double pop_sur  = (100.0 * double(global.pick.pop .success) / global.pick.pop .attempt);
+                double mpop_sur = (100.0 * double(global.pick.pop .success) / global.pick.pop .mask_attempt);
+                os << "Push   Pick % : " << push_sur << "(" << global.pick.push.success << " / " << global.pick.push.attempt << ")\n";
+                os << "Pop    Pick % : " << pop_sur  << "(" << global.pick.pop .success << " / " << global.pick.pop .attempt << ")\n";
+                os << "TryPop Pick % : " << mpop_sur << "(" << global.pick.pop .success << " / " << global.pick.pop .mask_attempt << ")\n";
+                double avgQ_push = double(global.qstat.push.value) / global.qstat.push.count;
+                double avgQ_pop  = double(global.qstat.pop .value) / global.qstat.pop .count;
+                double avgQ      = double(global.qstat.push.value + global.qstat.pop .value) / (global.qstat.push.count + global.qstat.pop .count);
+                os << "Push   Avg Qs : " << avgQ_push << " (" << global.qstat.push.count << "ops)\n";
+                os << "Pop    Avg Qs : " << avgQ_pop  << " (" << global.qstat.pop .count << "ops)\n";
+                os << "Global Avg Qs : " << avgQ      << " (" << (global.qstat.push.count + global.qstat.pop .count) << "ops)\n";
+        }
+#endif
+};
+};

doc/theses/thierry_delisle_PhD/code/utils.hpp

-              ra505021
+              r8c50aed
 #include <unistd.h>
 #include <sys/sysinfo.h>
-#include <x86intrin.h>
 // Barrier from
 …
+}
 static inline void affinity(int tid) {
+void affinity(int tid) {
         static int cpus = get_nprocs();
 …
 static const constexpr std::size_t cache_line_size = 64;
 static inline void check_cache_line_size() {
+void check_cache_line_size() {
         std::cout << "Checking cache line size" << std::endl;
         const std::string cache_file = "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size";
 …
         return std::chrono::duration_cast<std::chrono::duration<T, Ratio>>(std::chrono::duration<T>(seconds)).count();
+}
-static inline unsigned rand_bit(unsigned rnum, size_t mask) {
-        unsigned bit = mask ? rnum % __builtin_popcountl(mask) : 0;
-#if !defined(__BMI2__)
-        uint64_t v = mask;   // Input value to find position with rank r.
-        unsigned int r = bit + 1;// Input: bit's desired rank [1-64].
-        unsigned int s;      // Output: Resulting position of bit with rank r [1-64]
-        uint64_t a, b, c, d; // Intermediate temporaries for bit count.
-        unsigned int t;      // Bit count temporary.
-        // Do a normal parallel bit count for a 64-bit integer,
-        // but store all intermediate steps.
-        a =  v - ((v >> 1) & ~0UL/3);
-        b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
-        c = (b + (b >> 4)) & ~0UL/0x11;
-        d = (c + (c >> 8)) & ~0UL/0x101;
-        t = (d >> 32) + (d >> 48);
-        // Now do branchless select!
-        s  = 64;
-        s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
-        t  = (d >> (s - 16)) & 0xff;
-        s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
-        t  = (c >> (s - 8)) & 0xf;
-        s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
-        t  = (b >> (s - 4)) & 0x7;
-        s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
-        t  = (a >> (s - 2)) & 0x3;
-        s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
-        t  = (v >> (s - 1)) & 0x1;
-        s -= ((t - r) & 256) >> 8;
-        return s - 1;
-#else
-        uint64_t picked = _pdep_u64(1ul << bit, mask);
-        return picked ? __builtin_ctzl(picked) : 0;
-#endif
+}

driver/cfa.cc

-              ra505021
+              r8c50aed
                 args[nargs++] = "-lcfathread";
                 args[nargs++] = "-Wl,--pop-state";
-                args[nargs++] = "-Wl,--push-state,--no-as-needed";
                 args[nargs++] = "-lcfa";
-                args[nargs++] = "-Wl,--pop-state";
                 args[nargs++] = "-pthread";
                 args[nargs++] = "-ldl";

libcfa/prelude/Makefile.am

-              ra505021
+              r8c50aed
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Mon Feb  3 21:27:18 2020
 ## Update Count     : 208
+## Last Modified On : Wed Dec 14 15:00:35 2016
+## Update Count     : 205
 ###############################################################################
 …
 extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
-        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
 # create forward declarations for gcc builtins

libcfa/prelude/Makefile.in

-              ra505021
+              r8c50aed
 # Makefile.in generated by automake 1.16.1 from Makefile.am.
+# Makefile.in generated by automake 1.15 from Makefile.am.
 # @configure_input@
 # Copyright (C) 1994-2018 Free Software Foundation, Inc.
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 …
             cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
           *) \
             echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
             cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
         esac;
 …
+distdir: $(BUILT_SOURCES)
+        $(MAKE) $(AM_MAKEFLAGS) distdir-am
+distdir-am: $(DISTFILES)
+distdir: $(DISTFILES)
         @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
         topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 …
 extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
-        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
 # create forward declarations for gcc builtins

libcfa/prelude/extras.regx

-              ra505021
+              r8c50aed
 typedef.* char32_t;
 typedef.* wchar_t;
+extern.*\*malloc\(.*\).*
+extern.* free\(.*\).*
+extern.* exit\(.*\).*
+extern.* atexit\(.*\).*
+extern.* abort\(.*\).*
+extern.* printf\(.*\).*

libcfa/prelude/prototypes.awk

-              ra505021
+              r8c50aed
 # Created On       : Sat May 16 07:57:37 2015
 # Last Modified By : Peter A. Buhr
 # Last Modified On : Sat Feb  8 09:46:58 2020
 # Update Count     : 36
+# Last Modified On : Thu Jun  6 20:46:28 2019
+# Update Count     : 34
+#
 …
 BEGIN {
         FS = "[( )]"
+  FS = "[( )]"
         # order so string search is longest string
         i=-1
 …
 /BT_FN/ {
         for (i = 1; i <= NF; i += 1 ) {
                 if ( match($i, "BT_FN") != 0 ) {
                         prototypes[$i] = $i
+                }
+        for (i = 1; i <= NF; i++) {
+          if( match($i, "BT_FN") != 0 ) {
+                prototypes[$i] = $i
+          }
+        }
+}
+  }
 END {
 …
         for ( prototype in prototypes ) {
+                # printf( "//\"%s\"\n", prototype )
+                if ( index( "BT_LAST", prototype ) == 1 ) {
+                        continue
+          # printf( "//\"%s\"\n", prototype )
+          if ( index( "BT_LAST", prototype ) == 1 ) {
+                continue
+          } # if
+          printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
+          if ( sub( "BT_FN_", "", prototype ) == 0 ) {
+                printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
+                exit 0
+          } # if
+          # generate function return type as macro
+          for ( t = 0; t < N; t += 1 ) {                                        # find longest match
+                type = types[t];
+                if ( index( prototype, type ) == 1 ) {          # found match
+                  printf( "BT_%s, NAME", type )
+                  sub( type, "", prototype )
+                  break;
                 } # if
+          } # for
+                printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
+                if ( sub( "BT_FN_", "", prototype ) == 0 ) {
+                        printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
+          # generate function parameter types as macro
+          if ( index( prototype, "VAR" ) != 2 ) {                       # C-style empty parameters ?
+                for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                  sub( "_", "", prototype)                              # remove "_"
+                  printf( ", ", type )
+                  temp = prototype
+                  for ( t = 0; t < N; t += 1 ) {                        # find longest match
+                        type = types[t];
+                        if ( index( prototype, type ) == 1 ) { # found match
+                          printf( "BT_%s", type )
+                          sub( type, "", prototype )
+                          break;
+                        } # if
+                  } # for
+                  if ( temp == prototype ) {                            # no match found for parameter in macro table
+                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
                         exit 0
+                } # if
+                # generate function return type as macro
+                for ( t = 0; t < N; t += 1 ) {                                  # find longest match
+                        type = types[t];
+                        if ( index( prototype, type ) == 1 ) {          # found match
+                                printf( "BT_%s, NAME", type )
+                                sub( type, "", prototype )
+                                break;
+                        } # if
+                  } # if
                 } # for
+                # generate function parameter types as macro
+                if ( index( prototype, "VAR" ) != 2 ) {                 # C-style empty parameters ?
+                        for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+                                sub( "_", "", prototype)                                # remove "_"
+                                printf( ", ", type )
+                                temp = prototype
+                                for ( t = 0; t < N; t += 1 ) {                  # find longest match
+                                        type = types[t];
+                                        if ( index( prototype, type ) == 1 ) { # found match
+                                                printf( "BT_%s", type )
+                                                sub( type, "", prototype )
+                                                break;
+                                        } # if
+                                } # for
+                                if ( temp == prototype ) {                              # no match found for parameter in macro table
+                                        printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+                                        exit 0
+                                } # if
+                        } # for
+                } # if
+                printf( ")\n" )
+          } # if
+          printf( ")\n" )
         } # for

libcfa/src/assert.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
         // 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/debug.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
         #define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
         #define __cfaabi_dbg_ctx_param const char caller[]
         #define __cfaabi_dbg_ctx_param2 , const char caller[]
+        #define __cfaabi_dbg_ctx_param const char * caller
+        #define __cfaabi_dbg_ctx_param2 , const char * caller
 #else
         #define __cfaabi_dbg_debug_do(...)
 …
         #include <stdio.h>
         extern void __cfaabi_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

-              ra505021
+              r8c50aed
 // 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
 //
 …
                 #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/coroutine.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
+}
 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};

libcfa/src/concurrency/coroutine.hfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
 // 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 }; }
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/kernel.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
 static void * CtxInvokeProcessor(void * arg);
 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 ) );
 …
 __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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 };
 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 ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
 …
 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 ) /*__attribute__((const))*/ { return this.node.[next, prev]; }

libcfa/src/exception.c

-              ra505021
+              r8c50aed
+}
+#pragma GCC push_options
+#pragma GCC optimize("O0")
+#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 // PIC
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
 …
         // 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");
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
-#endif
         // Label which defines the start of the area for which the handler is setup.
 …
 // have a single call to the try routine.
-#ifdef __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)
-        // 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 (
 …
         "       .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__
+#pragma GCC pop_options
+#endif // PIC

libcfa/src/fstream.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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" );
 } // ?{}
 …
 } // ^?{}
 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 == 0p ) {
+        if ( file == 0 ) {
                 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 = 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" );
 } // ?{}
 …
 } // ^?{}
 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
 …
         } // 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

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

-              ra505021
+              r8c50aed
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb  9 09:56:54 2020
 // Update Count     : 31
+// Last Modified On : Sat Jul 13 15:25:05 2019
+// Update Count     : 27
 //
 …
 static inline {
         // constructor, zero_t/one_t are unnecessary because of relationship with signed/unsigned int
+        // constructor
         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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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

-              ra505021
+              r8c50aed
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb 17 10:18:53 2020
 // Update Count     : 166
+// Last Modified On : Thu Jan 30 17:47:32 2020
+// Update Count     : 156
 //
 …
 #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;
 …
 extern "C" {
         void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 abort( false, "%s", "" );
+                abort( false, NULL ); // FIX ME: 0p does not work
+        }
 …
 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; }
 …
 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
 …
                 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 == '(' ) {
 …
         __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
+        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 );
+                }
+        }
         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cfaabi_backtrace( signalAbort ? 4 : 2 );
+        __cfaabi_backtrace( signalAbort ? 4 : 3 );
         __cabi_libc.abort();                                                            // print stack trace in handler

libcfa/src/iostream.cfa

-              ra505021
+              r8c50aed
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 20 15:53:23 2020
 // Update Count     : 829
+// Last Modified On : Sat Jul 13 08:07:59 2019
+// Update Count     : 821
 //
 …
 #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 %c %c\n", &fmtstr[star], f.base, CODE ); */ \
+                        /* printf( "%s\n", &fmtstr[star] ); */ \
                         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

-              ra505021
+              r8c50aed
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 20 15:30:56 2020
 // Update Count     : 337
+// Last Modified On : Fri Jul 12 12:08:38 2019
+// Update Count     : 334
 //
 …
 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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

-              ra505021
+              r8c50aed
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  8 17:56:36 2020
 // Update Count     : 187
+// Last Modified On : Fri Jul 12 18:12:08 2019
+// Update Count     : 184
 //
 …
         } // 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
         #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

-              ra505021
+              r8c50aed
 // 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

-              ra505021
+              r8c50aed
 // 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

-              ra505021
+              r8c50aed
 // 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

-              ra505021
+              r8c50aed
 // 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

-              ra505021
+              r8c50aed
 // 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 //---------------------------------------
 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 } // 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

-              ra505021
+              r8c50aed
 // 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
 //
 …
 } // 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) -------------------------

longrun_tests/Makefile.in

-              ra505021
+              r8c50aed
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
-AM_V_PY = $(am__v_PY_@AM_V@)
-am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
-am__v_PY_0 = @echo "  PYTHON  " $@;
-am__v_PY_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_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_0 = @echo "  NODEJS     " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)

src/CodeGen/CodeGenerator.cc

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 08:32:48 2020
 // Update Count     : 532
+// Last Modified On : Fri Dec 13 23:13:28 2019
+// Update Count     : 508
 //
 #include "CodeGenerator.h"
 …
         int CodeGenerator::tabsize = 4;
         // The kinds of statements that would ideally be followed by whitespace.
+        // the kinds of statements that would ideally be followed by whitespace
         bool wantSpacing( Statement * stmt) {
                 return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
 …
+        }
+        // Using updateLocation at the beginning of a node and endl within a node should become the method of formating.
+        /* Using updateLocation at the beginning of a node and endl
+         * within a node should become the method of formating.
+         */
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
                 // skip if linemarks shouldn't appear or if codelocation is unset
 …
                 } else {
                         output << "\n# " << to.first_line << " \"" << to.filename
                                    << "\"\n" << indent;
+                               << "\"\n" << indent;
                         currentLocation = to;
+                }
 …
         void CodeGenerator::genAttributes( list< Attribute * > & attributes ) {
                 if ( attributes.empty() ) return;
+          if ( attributes.empty() ) return;
                 output << "__attribute__ ((";
                 for ( list< Attribute * >::iterator attr( attributes.begin() );; ) {
 …
                                 output << ")";
                         } // if
                         if ( ++attr == attributes.end() ) break;
+                  if ( ++attr == attributes.end() ) break;
                         output << ",";                                                          // separator
                 } // for
 …
                 previsit( (BaseSyntaxNode *)node );
                 GuardAction( [this, node](){
                                 if ( options.printExprTypes && node->result ) {
                                         output << " /* " << genType( node->result, "", options ) << " */ ";
+                                }
                         } );
+                        if ( options.printExprTypes && node->result ) {
+                                output << " /* " << genType( node->result, "", options ) << " */ ";
+                        }
+                } );
+        }
 …
                 extension( applicationExpr );
                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr* >( applicationExpr->get_function() ) ) {
                         const OperatorInfo * opInfo;
                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && ( opInfo = operatorLookup( varExpr->get_var()->get_name() ) ) ) {
+                        OperatorInfo opInfo;
+                        if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
                                 switch ( opInfo->type ) {
+                                switch ( opInfo.type ) {
                                   case OT_INDEX:
                                         assert( applicationExpr->get_args().size() == 2 );
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << ") /* " << opInfo->inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo->symbol;
+                                                output << opInfo.symbol;
                                                 (*arg)->accept( *visitor );
                                                 output << ") /* " << opInfo->inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
 …
                                         assert( applicationExpr->get_args().size() == 1 );
                                         output << "(";
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                                         assert( applicationExpr->get_args().size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         break;
 …
                                         output << "(";
                                         (*arg++)->accept( *visitor );
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
                         const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
                         if ( opInfo ) {
+                        OperatorInfo opInfo;
+                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
                                 std::list< Expression* >::iterator arg = untypedExpr->args.begin();
                                 switch ( opInfo->type ) {
+                                switch ( opInfo.type ) {
                                   case OT_INDEX:
                                         assert( untypedExpr->args.size() == 2 );
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << ") /* " << opInfo->inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo->symbol;
+                                                output << opInfo.symbol;
                                                 (*arg)->accept( *visitor );
                                                 output << ") /* " << opInfo->inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
 …
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo->symbol << "{ ";
+                                                output << opInfo.symbol << "{ ";
                                                 genCommaList( arg, untypedExpr->args.end() );
                                                 output << "}) /* " << opInfo->inputName << " */";
+                                                output << "}) /* " << opInfo.inputName << " */";
                                         } // if
                                         break;
 …
                                         assert( untypedExpr->args.size() == 1 );
                                         output << "(";
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
                                         assert( untypedExpr->args.size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         break;
 …
                                         output << "(";
                                         (*arg++)->accept( *visitor );
                                         output << opInfo->symbol;
+                                        output << opInfo.symbol;
                                         (*arg)->accept( *visitor );
                                         output << ")";
 …
         void CodeGenerator::postvisit( NameExpr * nameExpr ) {
                 extension( nameExpr );
                 const OperatorInfo * opInfo = operatorLookup( nameExpr->name );
                 if ( opInfo ) {
                         if ( opInfo->type == OT_CONSTANT ) {
                                 output << opInfo->symbol;
+                OperatorInfo opInfo;
+                if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                        if ( opInfo.type == OT_CONSTANT ) {
+                                output << opInfo.symbol;
                         } else {
                                 output << opInfo->outputName;
+                                output << opInfo.outputName;
+                        }
                 } else {
 …
         void CodeGenerator::postvisit( VariableExpr * variableExpr ) {
                 extension( variableExpr );
                 const OperatorInfo * opInfo;
                 if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && (opInfo = operatorLookup( variableExpr->get_var()->get_name() )) && opInfo->type == OT_CONSTANT ) {
                         output << opInfo->symbol;
+                OperatorInfo opInfo;
+                if ( variableExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( variableExpr->get_var()->get_name(), opInfo ) && opInfo.type == OT_CONSTANT ) {
+                        output << opInfo.symbol;
                 } else {
                         output << mangleName( variableExpr->get_var() );
 …
                   case BranchStmt::FallThroughDefault:
                         assertf( ! options.genC, "fallthru should not reach code generation." );
                         output << "fallthru";
+                  output << "fallthru";
                         break;
                 } // switch
 …
                 output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
                                    "throw" : "throwResume");
+                           "throw" : "throwResume");
                 if (throwStmt->get_expr()) {
                         output << " ";
 …
                 output << ((stmt->get_kind() == CatchStmt::Terminate) ?
                                    "catch" : "catchResume");
+                "catch" : "catchResume");
                 output << "( ";
                 stmt->decl->accept( *visitor );
 …
         std::string genName( DeclarationWithType * decl ) {
                 const OperatorInfo * opInfo = operatorLookup( decl->get_name() );
                 if ( opInfo ) {
                         return opInfo->outputName;
+                CodeGen::OperatorInfo opInfo;
+                if ( operatorLookup( decl->get_name(), opInfo ) ) {
+                        return opInfo.outputName;
                 } else {
                         return decl->get_name();

src/CodeGen/CodeGenerator.h

-              ra505021
+              r8c50aed
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:58:31 2020
 // Update Count     : 62
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 30 12:01:00 2019
+// Update Count     : 57
 //
 …
 namespace CodeGen {
         struct CodeGenerator : public WithShortCircuiting, public WithGuards, public WithVisitorRef<CodeGenerator> {
                 static int tabsize;
+          static int tabsize;
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
 …
                 void postvisit( AsmStmt * );
                 void postvisit( DirectiveStmt * );
                 void postvisit( AsmDecl * );                                    // special: statement in declaration context
+                void postvisit( AsmDecl * );                            // special: statement in declaration context
                 void postvisit( IfStmt * );
                 void postvisit( SwitchStmt * );
 …
                 LabelPrinter printLabels;
                 Options options;
           public:
+        public:
                 LineEnder endl;
           private:
+        private:
                 CodeLocation currentLocation;
 …
         template< class Iterator >
         void CodeGenerator::genCommaList( Iterator begin, Iterator end ) {
                 if ( begin == end ) return;
+          if ( begin == end ) return;
                 for ( ;; ) {
                         (*begin++)->accept( *visitor );
                         if ( begin == end ) break;
+                  if ( begin == end ) break;
                         output << ", ";                                                         // separator
                 } // for

src/CodeGen/FixMain.h

-              ra505021
+              r8c50aed
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:24:32 2020
 // Update Count     : 5
+// Last Modified On : Fri Dec 13 23:12:21 2019
+// Update Count     : 3
 //
 …
                 static std::unique_ptr<FunctionDecl> main_signature;
         };
 } // namespace CodeGen
+};

src/CodeGen/GenType.h

-              ra505021
+              r8c50aed
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 04:11:40 2020
 // Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 30 11:47:00 2019
+// Update Count     : 3
 //
 …
         std::string genType( Type *type, const std::string &baseString, const Options &options );
         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
         std::string genPrettyType( Type * type, const std::string & baseString );
+  std::string genPrettyType( Type * type, const std::string & baseString );
 } // namespace CodeGen

src/CodeGen/Generate.cc

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:01:51 2020
 // Update Count     : 9
+// Last Modified On : Fri Dec 13 23:38:56 2019
+// Update Count     : 8
 //
 #include "Generate.h"
 …
         void generate( BaseSyntaxNode * node, std::ostream & os ) {
                 if ( Type * type = dynamic_cast< Type * >( node ) ) {
                         os << genPrettyType( type, "" );
+                        os << CodeGen::genPrettyType( type, "" );
                 } else {
                         PassVisitor<CodeGenerator> cgv( os, true, false, false, false );

src/CodeGen/OperatorTable.cc

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 18 15:55:01 2020
 // Update Count     : 55
+// Last Modified On : Sat Jul 15 17:12:22 2017
+// Update Count     : 15
 //
 …
 #include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
 #include <utility>    // for pair
-using namespace std;
 #include "OperatorTable.h"
 …
 namespace CodeGen {
         const OperatorInfo CodeGen::tableValues[] = {
                 // inputName symbol   outputName                     friendlyName                  type
                 {       "?[?]",   "",     "_operator_index",             "Index",                      OT_INDEX          },
                 {       "?{}",    "=",    "_constructor",                "Constructor",                OT_CTOR           },
                 {       "^?{}",   "",     "_destructor",                 "Destructor",                 OT_DTOR           },
                 {       "?()",    "",     "_operator_call",              "Call Operator",              OT_CALL           },
                 {       "?++",    "++",   "_operator_postincr",          "Postfix Increment",          OT_POSTFIXASSIGN  },
                 {       "?--",    "--",   "_operator_postdecr",          "Postfix Decrement",          OT_POSTFIXASSIGN  },
                 {       "*?",     "*",    "_operator_deref",             "Dereference",                OT_PREFIX         },
                 {       "+?",     "+",    "_operator_unaryplus",         "Plus",                       OT_PREFIX         },
                 {       "-?",     "-",    "_operator_unaryminus",        "Minus",                      OT_PREFIX         },
                 {       "~?",     "~",    "_operator_bitnot",            "Bitwise Not",                OT_PREFIX         },
                 {       "!?",     "!",    "_operator_lognot",            "Logical Not",                OT_PREFIX         },
                 {       "++?",    "++",   "_operator_preincr",           "Prefix Increment",           OT_PREFIXASSIGN   },
                 {       "--?",    "--",   "_operator_predecr",           "Prefix Decrement",           OT_PREFIXASSIGN   },
                 {       "?\\?",   "\\",   "_operator_exponential",       "Exponentiation",             OT_INFIX          },
                 {       "?*?",    "*",    "_operator_multiply",          "Multiplication",             OT_INFIX          },
                 {       "?/?",    "/",    "_operator_divide",            "Division",                   OT_INFIX          },
                 {       "?%?",    "%",    "_operator_modulus",           "Modulo",                     OT_INFIX          },
                 {       "?+?",    "+",    "_operator_add",               "Addition",                   OT_INFIX          },
                 {       "?-?",    "-",    "_operator_subtract",          "Substraction",               OT_INFIX          },
                 {       "?<<?",   "<<",   "_operator_shiftleft",         "Shift Left",                 OT_INFIX          },
                 {       "?>>?",   ">>",   "_operator_shiftright",        "Shift Right",                OT_INFIX          },
                 {       "?<?",    "<",    "_operator_less",              "Less-than",                  OT_INFIX          },
                 {       "?>?",    ">",    "_operator_greater",           "Greater-than",               OT_INFIX          },
                 {       "?<=?",   "<=",   "_operator_lessequal",         "Less-than-or-Equal",         OT_INFIX          },
                 {       "?>=?",   ">=",   "_operator_greaterequal",      "Greater-than-or-Equal",      OT_INFIX          },
                 {       "?==?",   "==",   "_operator_equal",             "Equality",                   OT_INFIX          },
                 {       "?!=?",   "!=",   "_operator_notequal",          "Not-Equal",                  OT_INFIX          },
                 {       "?&?",    "&",    "_operator_bitand",            "Bitwise And",                OT_INFIX          },
                 {       "?^?",    "^",    "_operator_bitxor",            "Bitwise Xor",                OT_INFIX          },
                 {       "?|?",    "|",    "_operator_bitor",             "Bitwise Or",                 OT_INFIX          },
                 {       "?=?",    "=",    "_operator_assign",            "Assignment",                 OT_INFIXASSIGN    },
                 {       "?\\=?",  "\\=",  "_operator_expassign",         "Exponentiation Assignment",  OT_INFIXASSIGN    },
                 {       "?*=?",   "*=",   "_operator_multassign",        "Multiplication Assignment",  OT_INFIXASSIGN    },
                 {       "?/=?",   "/=",   "_operator_divassign",         "Division Assignment",        OT_INFIXASSIGN    },
                 {       "?%=?",   "%=",   "_operator_modassign",         "Modulo Assignment",          OT_INFIXASSIGN    },
                 {       "?+=?",   "+=",   "_operator_addassign",         "Addition Assignment",        OT_INFIXASSIGN    },
                 {       "?-=?",   "-=",   "_operator_subassign",         "Substrction Assignment",     OT_INFIXASSIGN    },
                 {       "?<<=?",  "<<=",  "_operator_shiftleftassign",   "Shift Left Assignment",      OT_INFIXASSIGN    },
                 {       "?>>=?",  ">>=",  "_operator_shiftrightassign",  "Shift Right Assignment",     OT_INFIXASSIGN    },
                 {       "?&=?",   "&=",   "_operator_bitandassign",      "Bitwise And Assignment",     OT_INFIXASSIGN    },
                 {       "?^=?",   "^=",   "_operator_bitxorassign",      "Bitwise Xor Assignment",     OT_INFIXASSIGN    },
                 {       "?|=?",   "|=",   "_operator_bitorassign",       "Bitwise Or Assignment",      OT_INFIXASSIGN    },
         }; // tableValues
+        namespace {
+                const OperatorInfo tableValues[] = {
+                        {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
+                        {       "?{}",          "=",    "_constructor",                                 OT_CTOR                         },
+                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
+                        {       "?()",          "",             "_operator_call",                               OT_CALL                         },
+                        {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },
+                        {       "?--",          "--",   "_operator_postdecr",                   OT_POSTFIXASSIGN        },
+                        {       "*?",           "*",    "_operator_deref",                              OT_PREFIX                       },
+                        {       "+?",           "+",    "_operator_unaryplus",                  OT_PREFIX                       },
+                        {       "-?",           "-",    "_operator_unaryminus",                 OT_PREFIX                       },
+                        {       "~?",           "~",    "_operator_bitnot",                             OT_PREFIX                       },
+                        {       "!?",           "!",    "_operator_lognot",                             OT_PREFIX                       },
+                        {       "++?",          "++",   "_operator_preincr",                    OT_PREFIXASSIGN         },
+                        {       "--?",          "--",   "_operator_predecr",                    OT_PREFIXASSIGN         },
+                        {       "?\\?",         "\\",   "_operator_exponential",                OT_INFIX                        },
+                        {       "?*?",          "*",    "_operator_multiply",                   OT_INFIX                        },
+                        {       "?/?",          "/",    "_operator_divide",                             OT_INFIX                        },
+                        {       "?%?",          "%",    "_operator_modulus",                    OT_INFIX                        },
+                        {       "?+?",          "+",    "_operator_add",                                OT_INFIX                        },
+                        {       "?-?",          "-",    "_operator_subtract",                   OT_INFIX                        },
+                        {       "?<<?",         "<<",   "_operator_shiftleft",                  OT_INFIX                        },
+                        {       "?>>?",         ">>",   "_operator_shiftright",                 OT_INFIX                        },
+                        {       "?<?",          "<",    "_operator_less",                               OT_INFIX                        },
+                        {       "?>?",          ">",    "_operator_greater",                    OT_INFIX                        },
+                        {       "?<=?",         "<=",   "_operator_lessequal",                  OT_INFIX                        },
+                        {       "?>=?",         ">=",   "_operator_greaterequal",               OT_INFIX                        },
+                        {       "?==?",         "==",   "_operator_equal",                              OT_INFIX                        },
+                        {       "?!=?",         "!=",   "_operator_notequal",                   OT_INFIX                        },
+                        {       "?&?",          "&",    "_operator_bitand",                             OT_INFIX                        },
+                        {       "?^?",          "^",    "_operator_bitxor",                             OT_INFIX                        },
+                        {       "?|?",          "|",    "_operator_bitor",                              OT_INFIX                        },
+                        {       "?=?",          "=",    "_operator_assign",                             OT_INFIXASSIGN          },
+                        {       "?\\=?",        "\\=",  "_operator_expassign",                  OT_INFIXASSIGN          },
+                        {       "?*=?",         "*=",   "_operator_multassign",                 OT_INFIXASSIGN          },
+                        {       "?/=?",         "/=",   "_operator_divassign",                  OT_INFIXASSIGN          },
+                        {       "?%=?",         "%=",   "_operator_modassign",                  OT_INFIXASSIGN          },
+                        {       "?+=?",         "+=",   "_operator_addassign",                  OT_INFIXASSIGN          },
+                        {       "?-=?",         "-=",   "_operator_subassign",                  OT_INFIXASSIGN          },
+                        {       "?<<=?",        "<<=",  "_operator_shiftleftassign",    OT_INFIXASSIGN          },
+                        {       "?>>=?",        ">>=",  "_operator_shiftrightassign",   OT_INFIXASSIGN          },
+                        {       "?&=?",         "&=",   "_operator_bitandassign",               OT_INFIXASSIGN          },
+                        {       "?^=?",         "^=",   "_operator_bitxorassign",               OT_INFIXASSIGN          },
+                        {       "?|=?",         "|=",   "_operator_bitorassign",                OT_INFIXASSIGN          },
+                };
         std::map< std::string, OperatorInfo > CodeGen::table;
+                const int numOps = sizeof( tableValues ) / sizeof( OperatorInfo );
+        CodeGen::CodeGen() {
+                enum { numOps = sizeof( tableValues ) / sizeof( OperatorInfo ) };
+                for ( int i = 0; i < numOps; i += 1 ) {
+                        table[ tableValues[i].inputName ] = tableValues[i];
+                } // for
+                std::map< std::string, OperatorInfo > table;
+                void initialize() {
+                        for ( int i = 0; i < numOps; ++i ) {
+                                table[ tableValues[i].inputName ] = tableValues[i];
+                        } // for
+                }
+        } // namespace
+        bool operatorLookup( const std::string & funcName, OperatorInfo & info ) {
+                static bool init = false;
+                if ( ! init ) {
+                        initialize();
+                } // if
+                std::map< std::string, OperatorInfo >::const_iterator i = table.find( funcName );
+                if ( i == table.end() ) {
+                        if ( isPrefix( funcName, "?`" ) ) {
+                                // handle literal suffixes, which are user-defined postfix operators
+                                info.inputName = funcName;
+                                info.symbol = funcName.substr(2);
+                                info.outputName = toString( "__operator_literal_", info.symbol );
+                                info.type = OT_POSTFIX;
+                                return true;
+                        }
+                        return false;
+                } else {
+                        info = i->second;
+                        return true;
+                } // if
+        }
+        const OperatorInfo * operatorLookup( const string & funcName ) {
+                if ( funcName.find_first_of( "?^*+-!", 0, 1 ) == string::npos ) return nullptr; // prefilter
+                const OperatorInfo * ret = &CodeGen::table.find( funcName )->second; // must be in the table
+                assert( ret );
+                return ret;
+        bool isOperator( const std::string & funcName ) {
+                OperatorInfo info;
+                return operatorLookup( funcName, info );
+        }
+        bool isOperator( const string & funcName ) {
+                return operatorLookup( funcName ) != nullptr;
+        }
+        string operatorFriendlyName( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->friendlyName;
+                return "";
+        }
+        bool isConstructor( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->type == OT_CTOR;
+        /// determines if a given function name is one of the operator types between [begin, end)
+        template<typename Iterator>
+        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
+                OperatorInfo info;
+                if ( operatorLookup( funcName, info ) ) {
+                        return std::find( begin, end, info.type ) != end;
+                }
                 return false;
+        }
+        bool isDestructor( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->type == OT_DTOR;
+                return false;
+        bool isConstructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtor( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->type <= OT_CONSTRUCTOR;
+                return false;
+        bool isDestructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isAssignment( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->type > OT_CONSTRUCTOR && info->type <= OT_ASSIGNMENT;
+                return false;
+        bool isAssignment( const std::string & funcName ) {
+                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtorAssign( const string & funcName ) {
+                const OperatorInfo * info = operatorLookup( funcName );
+                if ( info ) return info->type <= OT_ASSIGNMENT;
+                return false;
+        bool isCtorDtor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        CodeGen codegen;                                                                        // initialize singleton package
+        bool isCtorDtorAssign( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
 } // namespace CodeGen
 // Local Variables: //
 // tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
 // End: //

src/CodeGen/OperatorTable.h

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 08:13:34 2020
 // Update Count     : 26
+// Last Modified On : Fri Jul 21 22:17:11 2017
+// Update Count     : 6
 //
 …
 #include <string>
-#include <map>
 namespace CodeGen {
         enum OperatorType {
+                OT_INDEX,
                 OT_CTOR,
                 OT_DTOR,
+                OT_CONSTRUCTOR = OT_DTOR,
+                OT_CALL,
+                OT_PREFIX,
+                OT_POSTFIX,
+                OT_INFIX,
                 OT_PREFIXASSIGN,
                 OT_POSTFIXASSIGN,
                 OT_INFIXASSIGN,
-                OT_ASSIGNMENT = OT_INFIXASSIGN,
-                OT_CALL,
-                OT_PREFIX,
-                OT_INFIX,
-                OT_POSTFIX,
-                OT_INDEX,
                 OT_LABELADDRESS,
                 OT_CONSTANT
 …
                 std::string symbol;
                 std::string outputName;
-                std::string friendlyName;
                 OperatorType type;
         };
-        class CodeGen {
-                friend const OperatorInfo * operatorLookup( const std::string & funcName );
-                static const OperatorInfo tableValues[];
-                static std::map< std::string, OperatorInfo > table;
-          public:
-                CodeGen();
-        }; // CodeGen
         bool isOperator( const std::string & funcName );
+        const OperatorInfo * operatorLookup( const std::string & funcName );
+        std::string operatorFriendlyName( const std::string & funcName );
+        bool operatorLookup( const std::string & funcName, OperatorInfo & info );
         bool isConstructor( const std::string & );

src/CodeGen/Options.h

-              ra505021
+              r8c50aed
 // Author           : Andrew Beach
 // Created On       : Tue Apr 30 11:36:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 18:37:06 2020
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:45:00 2019
+// Update Count     : 2
 //
 #pragma once
+struct Options {
+        // External Options: Same thoughout a pass.
+        bool pretty;
+        bool genC;
+        bool lineMarks;
+        bool printExprTypes;
+namespace CodeGen {
+        struct Options {
+                // External Options: Same thoughout a pass.
+                bool pretty;
+                bool genC;
+                bool lineMarks;
+                bool printExprTypes;
         // Internal Options: Changed on some recurisive calls.
         bool anonymousUnused = false;
+                // Internal Options: Changed on some recurisive calls.
+                bool anonymousUnused = false;
         Options(bool pretty, bool genC, bool lineMarks, bool printExprTypes) :
                 pretty(pretty), genC(genC), lineMarks(lineMarks), printExprTypes(printExprTypes)
+                Options(bool pretty, bool genC, bool lineMarks, bool printExprTypes) :
+                        pretty(pretty), genC(genC), lineMarks(lineMarks), printExprTypes(printExprTypes)
                 {}
+};
+        };
+} // namespace CodeGen
 // Local Variables: //

src/CodeTools/ResolvProtoDump.cc

-              ra505021
+              r8c50aed
 // Author           : Aaron Moss
 // Created On       : Tue Sep 11 09:04:00 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 13:50:11 2020
 // Update Count     : 3
+// Last Modified By : Aaron Moss
+// Last Modified On : Tue Sep 11 09:04:00 2018
+// Update Count     : 1
 //
 …
                         // replace operator names
                         const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( name );
                         if ( opInfo ) {
+                        CodeGen::OperatorInfo info;
+                        if ( CodeGen::operatorLookup( name, info ) ) {
                                 ss << new_prefix(pre, "");
                                 op_name( opInfo->outputName, ss );
+                                op_name( info.outputName, ss );
                                 return;
+                        }

src/Common/PassVisitor.impl.h

-              ra505021
+              r8c50aed
         VISIT_START( node );
         indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
+        {
 …
         VISIT_START( node );
         indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
+        {
 …
         MUTATE_START( node );
         indexerAddUnion( node->name );
+        indexerAddStruct( node->name );
+        {

src/Common/SemanticError.h

-              ra505021
+              r8c50aed
 struct WarningData {
         const char * const name;
+        const char * const message;
         const Severity default_severity;
-        const char * const message;
 };
 constexpr WarningData WarningFormats[] = {
+        {"self-assign"            , Severity::Warn    , "self assignment of expression: %s"                          },
+        {"reference-conversion"   , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
+        {"qualifiers-zero_t-one_t", Severity::Warn    , "questionable use of type qualifier %s with %s"              },
+        {"aggregate-forward-decl" , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
+        {"superfluous-decl"       , Severity::Warn    , "declaration does not allocate storage: %s"                  },
+        {"gcc-attributes"         , Severity::Warn    , "invalid attribute: %s"                                      },
+        {"c++-like-copy"          , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
+        {"self-assign"            , "self assignment of expression: %s"            , Severity::Warn},
+        {"reference-conversion"   , "rvalue to reference conversion of rvalue: %s" , Severity::Warn},
+        {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
+        {"aggregate-forward-decl" , "forward declaration of nested aggregate: %s"  , Severity::Warn},
+        {"superfluous-decl"       , "declaration does not allocate storage: %s"    , Severity::Warn},
+        {"gcc-attributes"         , "invalid attribute: %s"                        , Severity::Warn},
 };
 …
         SuperfluousDecl,
         GccAttributes,
-        CppCopy,
         NUMBER_OF_WARNINGS, // This MUST be the last warning
 };

src/Common/utility.h

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 11 13:00:36 2020
 // Update Count     : 50
+// Last Modified On : Wed Jul 24 14:28:19 2019
+// Update Count     : 41
 //
 …
 #include <utility>
 #include <vector>
-#include <cstring>                                                                              // memcmp
 #include "Common/Indenter.h"
 …
+}
 // determines if pref is a prefix of str
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
+/// determines if `pref` is a prefix of `str`
+static inline bool isPrefix( const std::string & str, const std::string & pref ) {
         if ( pref.size() > str.size() ) return false;
     return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
         // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
+        auto its = std::mismatch( pref.begin(), pref.end(), str.begin() );
+        return its.first == pref.end();
+}

src/ControlStruct/Mutate.cc

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:22:07 2020
 // Update Count     : 10
+// Last Modified On : Thu Aug  4 11:39:08 2016
+// Update Count     : 9
 //
 …
                 mutateAll( translationUnit, formut );
+        }
 } // namespace ControlStruct
+} // namespace CodeGen
 // Local Variables: //

src/InitTweak/FixInit.cc

-              ra505021
+              r8c50aed
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 04:17:07 2020
 // Update Count     : 82
+// Last Modified On : Fri Dec 13 23:41:27 2019
+// Update Count     : 77
 //
 #include "FixInit.h"
 …
+                }
                 // to prevent warnings ('_unq0' may be used uninitialized in this function),
+                // to prevent warnings (‘_unq0’ may be used uninitialized in this function),
                 // insert an appropriate zero initializer for UniqueExpr temporaries.
                 Initializer * makeInit( Type * t ) {

src/InitTweak/FixInit.h

-              ra505021
+              r8c50aed
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 07:54:50 2020
 // Update Count     : 8
+// Last Modified On : Sat Jul 22 09:31:06 2017
+// Update Count     : 6
 //
 …
 namespace InitTweak {
+        /// replace constructor initializers with expression statements and unwrap basic C-style initializers
+  /// replace constructor initializers with expression statements
+  /// and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
 } // namespace

src/MakeLibCfa.cc

-              ra505021
+              r8c50aed
 // Created On       : Sat May 16 10:33:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:49:49 2020
 // Update Count     : 45
+// Last Modified On : Fri Dec 13 23:41:40 2019
+// Update Count     : 42
 //
 …
                         FunctionDecl *funcDecl = origFuncDecl->clone();
                         const CodeGen::OperatorInfo * opInfo;
                         opInfo = CodeGen::operatorLookup( funcDecl->get_name() );
                         assert( opInfo );
+                        CodeGen::OperatorInfo opInfo;
+                        bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
+                        assert( lookResult );
                         assert( ! funcDecl->get_statements() );
                         // build a recursive call - this is okay, as the call will actually be codegen'd using operator syntax
 …
                         Statement * stmt = nullptr;
                         switch ( opInfo->type ) {
+                        switch ( opInfo.type ) {
                           case CodeGen::OT_INDEX:
                           case CodeGen::OT_CALL:

src/Parser/ParseNode.h

-              ra505021
+              r8c50aed
 // 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
 //
 …
                                 * 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/ParserTypes.h

-              ra505021
+              r8c50aed
 // Created On       : Sat Sep 22 08:58:10 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 11:04:40 2020
 // Update Count     : 351
+// Last Modified On : Sat Jul 22 09:33:28 2017
+// Update Count     : 350
 //
 …
 // current location in the input
 extern int yylineno;
 extern char * yyfilename;
+extern char *yyfilename;
 struct Location {
     char * file;
+    char *file;
     int line;
 }; // Location
 struct Token {
     std::string * str;                                                                  // must be pointer as used in union
+    std::string *str;                                                                   // must be pointer as used in union
     Location loc;

src/Parser/TypedefTable.cc

-              ra505021
+              r8c50aed
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 08:06:36 2020
 // Update Count     : 259
+// Last Modified On : Wed Jul 25 15:32:35 2018
+// Update Count     : 258
 //
 …
 } // TypedefTable::~TypedefTable
 bool TypedefTable::exists( const string & identifier ) const {
+bool TypedefTable::exists( const string & identifier ) {
         return kindTable.find( identifier ) != kindTable.end();
 } // TypedefTable::exists
 bool TypedefTable::existsCurr( const string & identifier ) const {
+bool TypedefTable::existsCurr( const string & identifier ) {
         return kindTable.findAt( kindTable.currentScope() - 1, identifier ) != kindTable.end();
 } // TypedefTable::exists

src/Parser/TypedefTable.h

-              ra505021
+              r8c50aed
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 08:06:37 2020
 // Update Count     : 117
+// Last Modified On : Wed Jul 25 15:33:55 2018
+// Update Count     : 114
 //
 …
         ~TypedefTable();
         bool exists( const std::string & identifier ) const;
         bool existsCurr( const std::string & identifier ) const;
+        bool exists( const std::string & identifier );
+        bool existsCurr( const std::string & identifier );
         int isKind( const std::string & identifier ) const;
         void makeTypedef( const std::string & name, int kind = TYPEDEFname );

src/Parser/lex.ll

-              ra505021
+              r8c50aed
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sat Feb 15 11:05:50 2020
  * Update Count     : 737
+ * Last Modified On : Sat Feb  1 07:16:44 2020
+ * Update Count     : 724
  */
 …
 #include "ParseNode.h"
 #include "TypedefTable.h"
-string * build_postfix_name( string * name );
 char *yyfilename;
 …
                                 /* 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();
+}
 …
 "?"({op_unary_pre_post}|"()"|"[?]"|"{}") { IDENTIFIER_RETURN(); }
 "^?{}"                  { IDENTIFIER_RETURN(); }
+"?`"{identifier} {                                                                              // postfix operator
+        yylval.tok.str = new string( &yytext[2] );                      // remove ?`
+        yylval.tok.str = build_postfix_name( yylval.tok.str ); // add prefix
+        RETURN_LOCN( typedefTable.isKind( *yylval.tok.str ) );
+}
+"?`"{identifier} { IDENTIFIER_RETURN(); }                               // postfix operator
 "?"{op_binary_over}"?"  { IDENTIFIER_RETURN(); }                // binary
         /*

src/Parser/parser.yy

-              ra505021
+              r8c50aed
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb 21 14:47:29 2020
 // Update Count     : 4468
+// Last Modified On : Sat Feb  1 10:04:40 2020
+// Update Count     : 4440
 //
 …
 } // rebindForall
+string * build_postfix_name( string * name ) {
+        *name = string("__postfix_func_") + *name;
+        return name;
+NameExpr * build_postfix_name( const string * name ) {
+        NameExpr * new_name = build_varref( new string( "?`" + *name ) );
+        delete name;
+        return new_name;
 } // build_postfix_name
 …
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
 …
                 // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
                 // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
+        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
+        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
+        ;

src/ResolvExpr/Resolver.cc

-              ra505021
+              r8c50aed
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
-                void postvisit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 …
         void Resolver_old::previsit( CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have thenPart)
-                // holds, check it. This allows a check for when to decode the mangling.
-                if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
-                        assert( ifStmt->thenPart );
+                }
-                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
+                        IfStmt * ifStmt = new IfStmt( catchStmt->cond, nullptr, catchStmt->body );
+                        catchStmt->cond = nullptr;
+                        catchStmt->body = ifStmt;
+                }
+        }
+        void Resolver_old::postvisit( CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->condition );
+                        assert( ifStmt->elsePart );
+                        catchStmt->cond = ifStmt->condition;
+                        catchStmt->body = ifStmt->elsePart;
+                        ifStmt->condition = nullptr;
+                        ifStmt->elsePart = nullptr;
+                        delete ifStmt;
+                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                }
+        }
 …
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // TODO: This will need a fix for the decl/cond scoping problem.
                 if ( catchStmt->cond ) {
                         ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };

src/SymTab/Demangle.cc

-              ra505021
+              r8c50aed
 // Created On       : Thu Jul 19 12:52:41 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 11 15:09:18 2020
 // Update Count     : 10
+// Last Modified On : Fri Dec 13 14:54:15 2019
+// Update Count     : 4
 //
 …
 #include "CodeGen/GenType.h"
 #include "Common/PassVisitor.h"
-#include "Common/utility.h"                                                             // isPrefix
 #include "Mangler.h"
 #include "SynTree/Type.h"
 …
                         bool StringView::isPrefix(const std::string & pref) {
+                                // if ( pref.size() > str.size()-idx ) return false;
+                                // auto its = std::mismatch( pref.begin(), pref.end(), std::next(str.begin(), idx) );
+                                // if (its.first == pref.end()) {
+                                //      idx += pref.size();
+                                //      return true;
+                                // }
+                                // This update is untested because there are no tests for this code.
+                                if ( ::isPrefix( str, pref, idx ) ) {
+                                if ( pref.size() > str.size()-idx ) return false;
+                                auto its = std::mismatch( pref.begin(), pref.end(), std::next(str.begin(), idx) );
+                                if (its.first == pref.end()) {
                                         idx += pref.size();
                                         return true;
 …
                                 PRINT( std::cerr << "====== " << str.size() << " " << str << std::endl; )
                                 if (str.size() < 2+Encoding::manglePrefix.size()) return false; // +2 for at least _1 suffix
                                 if ( ! isPrefix(Encoding::manglePrefix) || ! isdigit(str.back() ) ) return false;
+                                if (! isPrefix(Encoding::manglePrefix) || ! isdigit(str.back())) return false;
                                 // get name

src/SymTab/Mangler.cc

-              ra505021
+              r8c50aed
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 13:55:12 2020
 // Update Count     : 33
+// Last Modified On : Fri Dec 13 23:43:49 2019
+// Update Count     : 28
 //
 #include "Mangler.h"
 …
                                 } // if
                                 mangleName << Encoding::manglePrefix;
                                 const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
                                 if ( opInfo ) {
                                         mangleName << opInfo->outputName.size() << opInfo->outputName;
+                                CodeGen::OperatorInfo opInfo;
+                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
+                                        mangleName << opInfo.outputName.size() << opInfo.outputName;
                                 } else {
                                         mangleName << declaration->name.size() << declaration->name;
 …
                         } // if
                         mangleName << Encoding::manglePrefix;
                         const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
                         if ( opInfo ) {
                                 mangleName << opInfo->outputName.size() << opInfo->outputName;
+                        CodeGen::OperatorInfo opInfo;
+                        if ( operatorLookup( decl->name, opInfo ) ) {
+                                mangleName << opInfo.outputName.size() << opInfo.outputName;
                         } else {
                                 mangleName << decl->name.size() << decl->name;

src/SymTab/Validate.cc

-              ra505021
+              r8c50aed
                         Stats::Heap::newPass("validate-A");
                         Stats::Time::BlockGuard guard("validate-A");
-                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                         acceptAll( translationUnit, hoistDecls );
                         ReplaceTypedef::replaceTypedef( translationUnit );
 …
                         Stats::Time::BlockGuard guard("validate-C");
                         acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                         ReturnChecker::checkFunctionReturns( translationUnit );
                         InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
 …
                 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
                                 SemanticError( funcDecl->location, "Constructors, destructors, and assignment functions require at least one parameter." );
+                                SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
+                        }
                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
                         if ( ! refType ) {
                                 SemanticError( funcDecl->location, "First parameter of a constructor, destructor, or assignment function must be a reference." );
+                                SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
+                        }
                         if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
+                                if(!returnVals.front()->get_type()->isVoid()) {
+                                        SemanticError( funcDecl->location, "Constructors and destructors cannot have explicit return values." );
+                                }
+                                SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
+                        }
+                }

src/SynTree/Attribute.h

-              ra505021
+              r8c50aed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb 13 21:34:08 2020
 // Update Count     : 40
+// Last Modified On : Sat Jul 22 09:54:14 2017
+// Update Count     : 39
 //
 …
         virtual ~Attribute();
         const std::string & get_name() const { return name; }
+        std::string get_name() const { return name; }
         void set_name( const std::string & newValue ) { name = newValue; }
         std::list< Expression * > & get_parameters() { return parameters; }

src/cfa.make

-              ra505021
+              r8c50aed
 am__v_GOC_1 =
-AM_V_PY = $(am__v_PY_@AM_V@)
-am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
-am__v_PY_0 = @echo "  PYTHON  " $@;
-am__v_PY_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_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_0 = @echo "  NODEJS     " $@;
 am__v_NODEJS_1 =

src/main.cc

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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
 …
         // 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;
 …
 } // 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
 …
         Signal( SIGSEGV, sigSegvBusHandler, SA_SIGINFO );
         Signal( SIGBUS, sigSegvBusHandler, SA_SIGINFO );
-        Signal( SIGFPE, sigFpeHandler, SA_SIGINFO );
         Signal( SIGABRT, sigAbortHandler, SA_SIGINFO );

tests/.expect/alloc-ERROR.txt

-              ra505021
+              r8c50aed
 alloc.cfa:310:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:311:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.cfa:311:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:312:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.cfa:312:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:313:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:
 …
 alloc.cfa:313:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:314:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:

tests/.expect/alloc.txt

ra505021	r8c50aed
2	2	CFA malloc 0xdeadbeef
3	3	CFA alloc 0xdeadbeef
	4	CFA array alloc, fill 0xde
4	5	CFA alloc, fill dededede
5	6	CFA alloc, fill 3

tests/.expect/nested-types-ERR1.txt

ra505021	r8c50aed
1		nested-types.cfa:83:1 error: Use of undefined type T
	1	nested-types.cfa:70:1 error: Use of undefined type T

tests/.expect/nested-types-ERR2.txt

-              ra505021
+              r8c50aed
 nested-types.cfa:86:1 error: Use of undefined global type Z
 nested-types.cfa:87:1 error: Qualified type requires an aggregate on the left, but has: signed int
 nested-types.cfa:88:1 error: Undefined type in qualified type: Qualified Type:
+nested-types.cfa:73:1 error: Use of undefined global type Z
+nested-types.cfa:74:1 error: Qualified type requires an aggregate on the left, but has: signed int
+nested-types.cfa:75:1 error: Undefined type in qualified type: Qualified Type:
   instance of struct S with body 1
   instance of type Z (not function type)

tests/.expect/rational.txt

ra505021	r8c50aed
1	1	constructor
2		3/1 4/1 0/1 ~~0/1 1/1~~
	2	3/1 4/1 0/1
3	3	1/2 5/7
4	4	2/3 -3/2

tests/Makefile.in

-              ra505021
+              r8c50aed
 am__v_GOC_0 = @echo "  GOC     " $@;
 am__v_GOC_1 =
-AM_V_PY = $(am__v_PY_@AM_V@)
-am__v_PY_ = $(am__v_PY_@AM_DEFAULT_V@)
-am__v_PY_0 = @echo "  PYTHON  " $@;
-am__v_PY_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_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_0 = @echo "  NODEJS     " $@;
 am__v_NODEJS_1 =
 AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)

tests/alloc.cfa

-              ra505021
+              r8c50aed
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 09:21:13 2020
 // Update Count     : 405
+// Last Modified On : Fri Nov 22 15:34:19 2019
+// Update Count     : 404
 //
 …
         p = alloc_set( fill );                                                          // CFA alloc, fill
+        printf( "CFA array alloc, fill %#hhx\n", fill );
         printf( "CFA alloc, fill %08x\n", *p );
         free( p );

tests/concurrent/examples/quickSort.cfa

-              ra505021
+              r8c50aed
 // Created On       : Wed Dec  6 12:15:52 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 12 18:24:47 2020
 // Update Count     : 177
+// Last Modified On : Thu Oct 10 13:58:18 2019
+// Update Count     : 176
 //
 …
 void ?{}( Quicksort & qs, int values[], int size, int depth ) {
         qs.[values, low, high, depth] = [values, 0, size, depth];
+        qs.values = values;  qs.low = 0;  qs.high = size;  qs.depth = depth;
 } // Quicksort
 …
                         values[counter] = size - counter;                       // descending values
                 } // for
                 for ( i; 200 ) {                                                                // random shuffle a few values
+                for ( int i = 0; i < 200; i +=1 ) {                             // random shuffle a few values
                         swap( values[rand() % size], values[rand() % size] );
                 } // for

tests/exceptions/except-0.cfa

-              ra505021
+              r8c50aed
 };
 void ?{}(signal_exit & this, const char * area) {
         this.area = area;
+}
 void ^?{}(signal_exit & this) {
         printf("Exiting: %s\n", this.area);
+void ?{}(signal_exit * this, const char * area) {
+        this->area = area;
+}
+void ^?{}(signal_exit * this) {
+        printf("Exiting: %s\n", this->area);
 //      sout | "Exiting:" | this->area;
+}
 …
         // Uncaught termination test.
-        /* Removed due to non-deterministic output.
         printf("Throw uncaught.\n");
         yang z;
         terminate(&z);
+        */
+}
+}

tests/exceptions/except-2.cfa

-              ra505021
+              r8c50aed
         struct TABLE(BASE_EXCEPT) const * parent;
         size_t size;
         void (*copy)(num_error &this, num_error & other);
         void (*free)(num_error &this);
+        void (*copy)(num_error *this, num_error * other);
+        void (*free)(num_error *this);
         const char * (*msg)(num_error *this);
         int (*code)(num_error *this);
 …
         if ( ! this->msg ) {
                 static const char * base = "Num Error with code: X";
                 this->msg = (char *)malloc(22);
+                this->msg = malloc(22);
                 for (int i = 0 ; (this->msg[i] = base[i]) ; ++i);
+        }
 …
         return this->msg;
+}
 void ?{}(num_error & this, int num) {
         this.virtual_table = &INSTANCE(num_error);
         this.msg = 0;
         this.num = num;
+void ?{}(num_error * this, int num) {
+        this->virtual_table = &INSTANCE(num_error);
+        this->msg = 0;
+        this->num = num;
+}
 void ?{}(num_error & this, num_error & other) {
         this.virtual_table = other.virtual_table;
         this.msg = 0;
         this.num = other.num;
+void ?{}(num_error * this, num_error * other) {
+        this->virtual_table = other->virtual_table;
+        this->msg = 0;
+        this->num = other->num;
+}
 void ^?{}(num_error & this) {
         if( this.msg ) free( this.msg );
+void ^?{}(num_error * this) {
+        if( this->msg ) free( this->msg );
+}
 int num_error_code( num_error * this ) {

tests/labelledExit.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
         // 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/nested-types.cfa

-              ra505021
+              r8c50aed
 // Created On       : Mon Jul 9 10:20:03 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 12 18:21:15 2020
 // Update Count     : 3
+// Last Modified On : Tue Nov  6 17:59:40 2018
+// Update Count     : 2
 //
 …
 //   double d;
 // };
-// struct S {
-//     enum C { R, G, B };
-//     int i;
-//     struct T {
-//      int i;
-//     };
-//     T t;
-// };
-// S s;
-// S.C c;
-// S.T t;
 int main() {

tests/pybin/tools.py

-              ra505021
+              r8c50aed
 def which(program):
+        fpath, fname = os.path.split(program)
+        if fpath:
+                if is_exe(program):
+                        return program
+        else:
+                for path in os.environ["PATH"].split(os.pathsep):
+                        exe_file = os.path.join(path, program)
+                        if is_exe(exe_file):
+                                return exe_file
+        return None
+    fpath, fname = os.path.split(program)
+    if fpath:
+        if is_exe(program):
+            return program
+    else:
+        for path in os.environ["PATH"].split(os.pathsep):
+            exe_file = os.path.join(path, program)
+            if is_exe(exe_file):
+                return exe_file
+    return None
 @contextlib.contextmanager
 …
 class Timed:
         def __enter__(self):
                 self.start = time.time()
                 return self
         def __exit__(self, *args):
                 self.end = time.time()
                 self.duration = self.end - self.start
+    def __enter__(self):
+        self.start = time.time()
+        return self
+    def __exit__(self, *args):
+        self.end = time.time()
+        self.duration = self.end - self.start
 def timed(src, timeout):
         expire = time.time() + timeout
         i = iter(src)
+        with contextlib.suppress(StopIteration):
+                while True:
+                        yield i.next(max(expire - time.time(), 0))
+        while True:
+                yield i.next(max(expire - time.time(), 0))

tests/quotedKeyword.cfa

-              ra505021
+              r8c50aed
 // 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
 //
 …
 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``;
+}

tests/rational.cfa

-              ra505021
+              r8c50aed
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  8 18:46:23 2020
 // Update Count     : 86
+// Last Modified On : Wed Mar 27 07:37:17 2019
+// Update Count     : 80
 //
 …
 #include <fstream.hfa>
+typedef Rational(int) RatInt;
+double convert( int i ) { return (double)i; }                   // used by narrow/widen
+double convert( int i ) { return (double)i; }
 int convert( double d ) { return (int)d; }
 int main() {
         sout | "constructor";
         RatInt a = { 3 }, b = { 4 }, c, d = 0, e = 1;
         sout | a | b | c | d | e;
+        Rational(int) a = { 3 }, b = { 4 }, c;
+        sout | a | b | c;
         a = (RatInt){ 4, 8 };
         b = (RatInt){ 5, 7 };
+        a = (Rational(int)){ 4, 8 };
+        b = (Rational(int)){ 5, 7 };
         sout | a | b;
         a = (RatInt){ -2, -3 };
         b = (RatInt){ 3, -2 };
+        a = (Rational(int)){ -2, -3 };
+        b = (Rational(int)){ 3, -2 };
         sout | a | b;
         a = (RatInt){ -2, 3 };
         b = (RatInt){ 3, 2 };
+        a = (Rational(int)){ -2, 3 };
+        b = (Rational(int)){ 3, 2 };
         sout | a | b;
         sout | "logical";
         a = (RatInt){ -2 };
         b = (RatInt){ -3, 2 };
+        a = (Rational(int)){ -2 };
+        b = (Rational(int)){ -3, 2 };
         sout | a | b;
 //      sout | a == 1; // FIX ME
 …
         sout | "conversion";
         a = (RatInt){ 3, 4 };
+        a = (Rational(int)){ 3, 4 };
         sout | widen( a );
         a = (RatInt){ 1, 7 };
+        a = (Rational(int)){ 1, 7 };
         sout | widen( a );
         a = (RatInt){ 355, 113 };
+        a = (Rational(int)){ 355, 113 };
         sout | widen( a );
         sout | narrow( 0.75, 4 );
 …
         sout | "more tests";
         RatInt x = { 1, 2 }, y = { 2 };
+        Rational(int) x = { 1, 2 }, y = { 2 };
         sout | x - y;
         sout | x > y;
 …
         sout | y | denominator( y, -2 ) | y;
         RatInt z = { 0, 5 };
+        Rational(int) z = { 0, 5 };
         sout | z;
         sout | x | numerator( x, 0 ) | x;
         x = (RatInt){ 1, MAX } + (RatInt){ 1, MAX };
+        x = (Rational(int)){ 1, MAX } + (Rational(int)){ 1, MAX };
         sout | x;
         x = (RatInt){ 3, MAX } + (RatInt){ 2, MAX };
+        x = (Rational(int)){ 3, MAX } + (Rational(int)){ 2, MAX };
         sout | x;

tests/test.py

ra505021	r8c50aed
152	152	# run everything in a temp directory to make sure core file are handled properly
153	153	with tempdir():
154		# if the make command succeeds continue otherwise skip to diff
	154	# if the make command succeds continue otherwise skip to diff
155	155	if success(make_ret):
156	156	with Timed() as run_dur:

tests/userLiterals.cfa

-              ra505021
+              r8c50aed
 // file "LICENCE" distributed with Cforall.
 //
 // userLiterals.cfa --
+// user_literals.cfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Sep  6 21:40:50 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 19 07:48:45 2020
 // Update Count     : 74
+// Last Modified On : Tue Dec  4 22:03:10 2018
+// Update Count     : 56
 //
 …
 int ?`__thingy_( int x ) { sout | "_thingy_" | x; return x; }
 int ?`s( const char * s ) { sout | "s" | s; return 0; }
 int ?`m( const char16_t * m ) { sout | "m" | m; return 0;}
 int ?`h( const char32_t * h ) { sout | "h" | h; return 0; }
+int ?`s( const char * s ) { sout | "secs" | s; return 0; }
+int ?`m( const char16_t * m ) { sout | "mins" | m; return 0;}
+int ?`h( const char32_t * h ) { sout | "hours" | h; return 0; }
 int ?`_A_( const wchar_t * str ) { sout | "_A_" | str; return 0; }
 int ?`__thingy_( const char * str ) { sout | "_thingy_" | str; return 0; }
 …
         return (Weight){ l.stones + r.stones };
+}
+ofstream & ?|?( ofstream & os, Weight w ) { return os | wd(1,1, w.stones); }
+void ?|?( ofstream & os, Weight w ) { (ofstream)(os | w); ends( os ); }
+ofstream & ?|?( ofstream & os, Weight w ) { return os | w.stones; }
 Weight ?`st( double w ) { return (Weight){ w }; }               // backquote for user literals
 …
         sout | w;
 `s;
+//      0`secs;
 `s;
 `s;
 …
         "abc"`s;
+        // FIX ME: requires char16_t, char32_t, and wchar_t be unique types
+        // u"abc"`m;
+        // U_"abc"`h;
+        // L"abc"`_A_;
+//      u"abc"`m;
+//      U_"abc"`h;
+//      L"abc"`_A_;
         u8_"abc"`__thingy_;
 } // main
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa userLiterals.cfa" //
+// compile-command: "cfa user_literals.cfa" //
 // End: //

Context Navigation

Changes in / [a505021:8c50aed]

Legend:

Download in other formats: