Diff [3d5701e14a6d4f307682f895f813314afe663a4d:9fb8f01d220653c3f0b46da4a12ae9e1302579b9] for / – Cforall

.gitignore

-              r3d5701e
+              r9fb8f01
 .deps
 .dirstamp
 /bin
 /lib
 /include
 /share
 /build
+bin
+lib
+include
+share
+build
 *.class

Jenkins/FullBuild

-              r3d5701e
+              r9fb8f01
                                 parallel (
+                                        clang_x86: { trigger_build( 'gcc-8',   'x86' ) },
+                                        gcc_5_x86: { trigger_build( 'gcc-7',   'x86' ) },
+                                        gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
                                         gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
-                                        gcc_9_x64: { trigger_build( 'gcc-9',   'x64' ) },
-                                        gcc_8_x64: { trigger_build( 'gcc-8',   'x64' ) },
-                                        gcc_7_x64: { trigger_build( 'gcc-7',   'x64' ) },
-                                        gcc_6_x64: { trigger_build( 'gcc-6',   'x64' ) },
                                         gcc_5_x64: { trigger_build( 'gcc-5',   'x64' ) },
+                                        gcc_5_x86: { trigger_build( 'gcc-5',   'x86' ) },
                                         clang_x64: { trigger_build( 'clang',   'x64' ) },
+                                        clang_x86: { trigger_build( 'clang',   'x86' ) },
+                                )
+                        }

Jenkinsfile

-              r3d5701e
+              r9fb8f01
                 echo GitLogMessage()
-                // This is a complete hack but it solves problems with automake thinking it needs to regenerate makefiles
-                // We fudged automake/missing to handle that but automake stills bakes prints inside the makefiles
-                // and these cause more problems.
-                sh 'find . -name Makefile.in -exec touch {} +'
+        }
+}
 …
 def test() {
+        try {
+                build_stage('Test: short', !Settings.RunAllTests) {
+                        dir (BuildDir) {
+                                //Run the tests from the tests directory
+                                sh "make --no-print-directory -C tests archiveerrors=${BuildDir}/tests/crashes/short"
+                        }
+                }
+                build_stage('Test: full', Settings.RunAllTests) {
+                        dir (BuildDir) {
+                                        //Run the tests from the tests directory
+                                        sh """make --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=yes archiveerrors=${BuildDir}/tests/crashes/full-debug"""
+                                        sh """make --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=no  archiveerrors=${BuildDir}/tests/crashes/full-nodebug"""
+                        }
+                }
+        }
+        catch (Exception err) {
+                echo "Archiving core dumps"
+                dir (BuildDir) {
+                        archiveArtifacts artifacts: "tests/crashes/**/*", fingerprint: true
+                }
+                throw err
+        build_stage('Test: short', !Settings.RunAllTests) {
+                dir (BuildDir) {
+                        //Run the tests from the tests directory
+                        sh 'make --no-print-directory -C tests'
+                }
+        }
+        build_stage('Test: full', Settings.RunAllTests) {
+                dir (BuildDir) {
+                        //Run the tests from the tests directory
+                        sh 'make --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=yes'
+                        sh 'make --no-print-directory -C tests timeouts="--timeout=600 --global-timeout=14400" all-tests debug=no '
+                }
+        }
+}
 …
                 //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)')
+        }
+}
 …
 //Routine responsible of sending the email notification once the build is completed
 //===========================================================================================================
-@NonCPS
-def SplitLines(String text) {
-        def list = []
-        text.eachLine {
-                list += it
+        }
-        return list
+}
 def GitLogMessage() {
         if (!Settings || !Settings.GitOldRef || !Settings.GitNewRef) return "\nERROR retrieveing git information!\n"
+        def oldRef = Settings.GitOldRef
+        def newRef = Settings.GitNewRef
+        def revText = sh(returnStdout: true, script: "git rev-list ${oldRef}..${newRef}").trim()
+        def revList = SplitLines( revText )
+        def gitUpdate = ""
+        revList.each { rev ->
+                def type = sh(returnStdout: true, script: "git cat-file -t ${rev}").trim()
+                gitUpdate = gitUpdate + "       via  ${rev} (${type})"
+        }
+        def rev = oldRef
+        def type = sh(returnStdout: true, script: "git cat-file -t ${rev}").trim()
+        gitUpdate = gitUpdate + "      from  ${rev} (${type})"
+        def gitLog    = sh(returnStdout: true, script: "git rev-list --format=short ${oldRef}...${newRef}").trim()
+        def gitDiff   = sh(returnStdout: true, script: "git diff --stat --color ${newRef} ${oldRef}").trim()
+        gitDiff = gitDiff.replace('[32m', '<span style="color: #00AA00;">')
+        gitDiff = gitDiff.replace('[31m', '<span style="color: #AA0000;">')
+        gitDiff = gitDiff.replace('[m', '</span>')
+        sh "${SrcDir}/tools/PrettyGitLogs.sh ${SrcDir} ${BuildDir} ${Settings.GitOldRef} ${Settings.GitNewRef}"
+        def gitUpdate = readFile("${BuildDir}/GIT_UPDATE")
+        def gitLog    = readFile("${BuildDir}/GIT_LOG")
+        def gitDiff   = readFile("${BuildDir}/GIT_DIFF")
         return """
 …
         BuildSettings(java.util.Collections$UnmodifiableMap param, String branch) {
                 switch( param.Compiler ) {
-                        case 'gcc-9':
-                                this.Compiler = new CC_Desc('gcc-9', 'g++-9', 'gcc-9')
-                        break
-                        case 'gcc-8':
-                                this.Compiler = new CC_Desc('gcc-8', 'g++-8', 'gcc-8')
-                        break
-                        case 'gcc-7':
-                                this.Compiler = new CC_Desc('gcc-7', 'g++-7', 'gcc-7')
-                        break
                         case 'gcc-6':
                                 this.Compiler = new CC_Desc('gcc-6', 'g++-6', 'gcc-6')
 …
                         break
                         case 'clang':
                                 this.Compiler = new CC_Desc('clang', 'clang++-6.0', 'gcc-6')
+                                this.Compiler = new CC_Desc('clang', 'clang++', 'gcc-6')
                         break
                         default :
 …
                                         description: 'Which compiler to use',                                   \
                                         name: 'Compiler',                                                                       \
                                         choices: 'gcc-9\ngcc-8\ngcc-7\ngcc-6\ngcc-5\ngcc-4.9\nclang',                                   \
                                         defaultValue: 'gcc-8',                                                          \
+                                        choices: 'gcc-6\ngcc-5\ngcc-4.9\nclang',                                        \
+                                        defaultValue: 'gcc-6',                                                          \
                                 ],                                                                                              \
                                 [$class: 'ChoiceParameterDefinition',                                           \

Makefile.in

-              r3d5701e
+              r9fb8f01
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@

benchmark/Makefile.am

-              r3d5701e
+              r9fb8f01
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Jan 25 09:20:44 2020
 ## Update Count     : 255
+## Last Modified On : Mon Jul 29 18:02:19 2019
+## Update Count     : 54
 ###############################################################################
 …
 AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
 AM_CFAFLAGS = -quiet -nodebug
+AM_CFAFLAGS = -quiet -nodebug -in-tree
 AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 …
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
 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_JAVAC = $(__bench_v_JAVAC_$(__quiet))
 __quiet = verbose
 …
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_GOC_quiet = @
+__bench_v_JAVAC_quiet = @
 __bench_v_UPP_quiet = @
-__bench_v_GOC_quiet = @
-__bench_v_RUSTC_quiet = @
-__bench_v_JAVAC_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 __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_NODEJS_verbose = $(AM_V_NODEJS)
-__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 …
 STATS    = ${abs_top_srcdir}/tools/stat.py
 # NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
 repeats  = 13 # 31 for benchmarks
+repeats  = 5 # 31 for benchmarks
 arch     = x64
 skipcompile = no
 …
 dummyC.c:
         echo "int main() { return 0; }" > ${@}
+        @echo "int main() { return 0; }" > ${@}
 dummyCXX.cpp:
+        echo "int main() { return 0; }" > ${@}
+.SILENT:                # do not print recipe
+        @echo "int main() { return 0; }" > ${@}
 .NOTPARALLEL:
+.PHONY: jenkins cleancsv
+## =========================================================================================================
+all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
+basic_loop_DURATION = 15000000000
+basic_function_DURATION = 10000000000
+basic_tls_fetch_add_DURATION = 10000000000
+basic_DURATION = 250000000
+ctxswitch_pthread_DURATION = 25000000
+ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
+ctxswitch_cfa_generator_DURATION = 5000000000
+ctxswitch_nodejs_await_DURATION = 5000000
+ctxswitch_DURATION = 100000000
+#mutex_java_DURATION = 10000000
+mutex_DURATION = 50000000
+schedint_pthread_DURATION = 1000000
+schedint_java_DURATION = $(schedint_pthread_DURATION)
+schedint_rust_DURATION = $(schedint_pthread_DURATION)
+schedint_DURATION = 10000000
+schedext_DURATION = 10000000
+creation_pthread_DURATION = 250000
+creation_rust_thread_DURATION = ${creation_pthread_DURATION}
+creation_java_thread_DURATION = ${creation_pthread_DURATION}
+creation_cfa_coroutine_DURATION = 100000000
+creation_cfa_coroutine_eager_DURATION = 10000000
+creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
+creation_cfa_thread_DURATION = 10000000
+creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
+creation_DURATION = 10000000
+.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
+## =========================================================================================================
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 %.run : %$(EXEEXT) ${REPEAT}
+        rm -f .result.log
+        echo "------------------------------------------------------"
+        echo $<
+        ${REPEAT} ${repeats} -- ./a.out\
+                $(if ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
+        ${STATS} .result.log
+        echo "------------------------------------------------------"
+        rm -f a.out .result.log *.class
+#       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
+        @rm -f .result.log
+        @echo "------------------------------------------------------"
+        @echo $<
+        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
+        @${STATS} .result.log
+        @echo "------------------------------------------------------"
+        @rm -f a.out .result.log *.class
 %.runquiet :
         +make $(basename $@) CFLAGS="-w" __quiet=quiet
         taskset -c 1 ./a.out
         rm -f a.out
+        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
+        @taskset -c 1 ./a.out
+        @rm -f a.out
 %.make :
         printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
         +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
+        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 ${REPEAT} :
         +make -C ${abs_top_builddir}/tools repeat
+        @+make -C ${abs_top_builddir}/tools repeat
 ## =========================================================================================================
 …
 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
+        @+make compile.csv
+        @-+make compile.diff.csv
 @DOendif@
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make scheduling.csv
         -+make scheduling.diff.csv
+        @+make ctxswitch.csv
+        @-+make ctxswitch.diff.csv
+        @+make mutex.csv
+        @-+make mutex.diff.csv
+        @+make signal.csv
+        @-+make signal.diff.csv
 @DOifskipcompile@
         cat compile.csv
 …
         cat mutex.csv
         -cat mutex.diff.csv
         cat scheduling.csv
         -cat scheduling.diff.csv
+        cat signal.csv
+        -cat signal.diff.csv
 compile.csv:
+        echo "building $@"
+        echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
+        @$(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
+        echo "building $@"
+        echo "generator,coroutine,thread" > $@
+        +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "generator,coroutine,thread" > $@
+        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_thread.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
 mutex.csv:
+        echo "building $@"
+        echo "1-monitor,2-monitor" > $@
+        +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make mutex-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+scheduling.csv:
+        echo "building $@"
+        echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
+        +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "1-monitor,2-monitor" > $@
+        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make mutex-cfa2.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
+signal.csv:
+        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
+        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make waitfor-cfa2.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
 %.diff.csv: %.csv
+        test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+## =========================================================================================================
+BASIC_DEPEND  =                                 \
+        basic-loop.run                          \
+        basic-function.run                      \
+        basic-fetch_add.run                     \
+        basic-ttst_lock.run                     \
+        basic-tls-fetch_add.run
+basic-loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
+basic-function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
+basic-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
+basic-ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
+basic-tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
+basic$(EXEEXT): $(BASIC_DEPEND)
+## =========================================================================================================
+CTXSWITCH_DEPEND  =                     \
+        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+## =========================================================================================================
+loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
+function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
+fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
+## =========================================================================================================
+CTXSWITCH_DEPEND  =                 \
+        loop.run                                \
+        function.run                    \
+        fetch_add.run                   \
+        ttst_lock.run                   \
+        tls-fetch_add.run                       \
+        ctxswitch-pthread.run           \
         ctxswitch-cfa_generator.run     \
         ctxswitch-cfa_coroutine.run     \
 …
         ctxswitch-upp_coroutine.run     \
         ctxswitch-upp_thread.run        \
+        ctxswitch-python_coroutine.run  \
+        ctxswitch-nodejs_coroutine.run  \
+        ctxswitch-nodejs_await.run      \
+        ctxswitch-goroutine_thread.run  \
+        ctxswitch-rust_thread.run       \
+        ctxswitch-nodejs_coroutine.run  \
+        ctxswitch-java_thread.run       \
+        ctxswitch-pthread.run
+        ctxswitch-goroutine.run         \
+        ctxswitch-java_thread.run
 if WITH_LIBFIBRE
 CTXSWITCH_DEPEND  +=                    \
         ctxswitch-kos_fibre.run         \
+CTXSWITCH_DEPEND  +=           \
+        ctxswitch-kos_fibre.run  \
         ctxswitch-kos_fibre2.run
 ctxswitch-kos_fibre$(EXEEXT):
 …
 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
 ctxswitch-cfa_generator$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
 ctxswitch-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 ctxswitch-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 ctxswitch-cfa_thread2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 ctxswitch-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 ctxswitch-upp_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
+ctxswitch-python_coroutine$(EXEEXT):
+        $(BENCH_V_PY)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 "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 "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
+        chmod a+x a.out
+ctxswitch-goroutine_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+ctxswitch-goroutine$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
-ctxswitch-rust_thread$(EXEEXT):
-        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
+## =========================================================================================================
+mutex$(EXEEXT) :                \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+## =========================================================================================================
+mutex$(EXEEXT) :\
+        loop.run                        \
+        function.run            \
+        fetch_add.run           \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
+        mutex-upp.run           \
+        mutex-go.run            \
+        mutex-rust.run          \
+        mutex-java.run          \
+        mutex-pthread.run
+mutex-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
+        mutex-java_thread.run
+mutex-pthread_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 mutex-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 mutex-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 mutex-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
+mutex-go$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
+mutex-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
+mutex-java$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+mutex-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+## =========================================================================================================
+schedint$(EXEEXT) :             \
+        schedint-cfa1.run       \
+        schedint-cfa2.run       \
+        schedint-cfa4.run       \
+        schedint-upp.run        \
+        schedint-rust.run       \
+        schedint-java.run       \
+        schedint-pthread.run
+schedint-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
+schedint-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
+schedint-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
+schedint-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
+schedint-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
+schedint-java$(EXEEXT):
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+## =========================================================================================================
+signal$(EXEEXT) :\
+        signal-pthread_cond.run \
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run         \
+        signal-java_thread.run
+signal-pthread_cond$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
+signal-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
+signal-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
+signal-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
+signal-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
+signal-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+schedint-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
+## =========================================================================================================
+schedext$(EXEEXT) :             \
+        schedext-cfa1.run       \
+        schedext-cfa2.run       \
+        schedext-cfa4.run       \
+        schedext-upp.run        \
+        schedext-goroutine.run
+schedext-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
+schedext-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
+schedext-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
+schedext-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
+schedext-goroutine$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
+## =========================================================================================================
+creation$(EXEEXT) :                             \
+        creation-cfa_generator.run              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+## =========================================================================================================
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
+waitfor-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
+waitfor-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
+waitfor-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
+## =========================================================================================================
+creation$(EXEEXT) :\
+        creation-pthread.run                    \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
 …
         creation-upp_coroutine.run              \
         creation-upp_thread.run                 \
+        creation-python_coroutine.run           \
+        creation-nodejs_coroutine.run           \
+        creation-goroutine_thread.run           \
+        creation-rust_thread.run                \
+        creation-java_thread.run                \
+        creation-pthread.run
+creation-cfa_generator$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
+        creation-goroutine.run                  \
+        creation-java_thread.run
 creation-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 creation-cfa_coroutine_eager$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 creation-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 creation-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 creation-upp_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
+creation-python_coroutine$(EXEEXT):
+        $(BENCH_V_PY)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 "nodejs $(srcdir)/creation/node_cor.js" >> a.out
+        chmod a+x a.out
+creation-goroutine_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
+creation-goroutine$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
-creation-rust_thread$(EXEEXT):
-        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
+## =========================================================================================================
+compile$(EXEEXT) :              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+## =========================================================================================================
+compile$(EXEEXT) :\
         compile-array.make      \
         compile-attributes.make \
 …
         compile-typeof.make
 testdir = $(top_srcdir)/tests
 compile-array$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 compile-attributes$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 compile-empty$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 compile-expression$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 compile-io$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 compile-monitor$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 compile-operators$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 compile-thread$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 compile-typeof$(EXEEXT):
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+## =========================================================================================================
+size$(EXEEXT) : size-cfa.runquiet
+size-cfa$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/size/size.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa

benchmark/Makefile.in

-              r3d5701e
+              r9fb8f01
 EXTRA_PROGRAMS = dummy$(EXEEXT)
 @WITH_LIBFIBRE_TRUE@am__append_1 = \
 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run         \
+@WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run  \
 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre2.run
 …
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@
 …
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
-AM_V_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_1 =
-AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
-am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS  " $@;
-am__v_NODEJS_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =
 # applies to both programs
 AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
 AM_CFAFLAGS = -quiet -nodebug
+AM_CFAFLAGS = -quiet -nodebug -in-tree
 AM_UPPFLAGS = -quiet -nodebug -multi -std=c++14
 BENCH_V_CC = $(__bench_v_CC_$(__quiet))
 BENCH_V_CFA = $(__bench_v_CFA_$(__quiet))
 BENCH_V_CXX = $(__bench_v_CXX_$(__quiet))
+BENCH_V_GOC = $(__bench_v_GOC_$(__quiet))
+BENCH_V_JAVAC = $(__bench_v_JAVAC_$(__quiet))
 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_JAVAC = $(__bench_v_JAVAC_$(__quiet))
 __quiet = verbose
 __bench_v_CC_quiet = @
 __bench_v_CFA_quiet = @
 __bench_v_CXX_quiet = @
+__bench_v_GOC_quiet = @
+__bench_v_JAVAC_quiet = @
 __bench_v_UPP_quiet = @
-__bench_v_GOC_quiet = @
-__bench_v_RUSTC_quiet = @
-__bench_v_JAVAC_quiet = @
 __bench_v_CC_verbose = $(AM_V_CC)
 __bench_v_CFA_verbose = $(AM_V_CFA)
 __bench_v_CXX_verbose = $(AM_V_CXX)
+__bench_v_GOC_verbose = $(AM_V_GOC)
+__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 __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_NODEJS_verbose = $(AM_V_NODEJS)
-__bench_v_JAVAC_verbose = $(AM_V_JAVAC)
 TOOLSDIR = ${abs_top_builddir}/tools/
 REPEAT = ${abs_top_builddir}/tools/repeat
 STATS = ${abs_top_srcdir}/tools/stat.py
 # NEED AT LEAST 4 DATA VALUES FOR BENCHMARKS BECAUSE THE MAX AND MIN VALUES ARE REMOVED
 repeats = 13 # 31 for benchmarks
+repeats = 5 # 31 for benchmarks
 arch = x64
 skipcompile = no
 …
 PRINT_FORMAT = %20s: #Comments needed for spacing
 dummy_SOURCES = dummyC.c dummyCXX.cpp
-basic_loop_DURATION = 15000000000
-basic_function_DURATION = 10000000000
-basic_tls_fetch_add_DURATION = 10000000000
-basic_DURATION = 250000000
-ctxswitch_pthread_DURATION = 25000000
-ctxswitch_rust_thread_DURATION = $(ctxswitch_pthread_DURATION)
-ctxswitch_cfa_generator_DURATION = 5000000000
-ctxswitch_nodejs_await_DURATION = 5000000
-ctxswitch_DURATION = 100000000
-#mutex_java_DURATION = 10000000
-mutex_DURATION = 50000000
-schedint_pthread_DURATION = 1000000
-schedint_java_DURATION = $(schedint_pthread_DURATION)
-schedint_rust_DURATION = $(schedint_pthread_DURATION)
-schedint_DURATION = 10000000
-schedext_DURATION = 10000000
-creation_pthread_DURATION = 250000
-creation_rust_thread_DURATION = ${creation_pthread_DURATION}
-creation_java_thread_DURATION = ${creation_pthread_DURATION}
-creation_cfa_coroutine_DURATION = 100000000
-creation_cfa_coroutine_eager_DURATION = 10000000
-creation_upp_coroutine_DURATION = ${creation_cfa_coroutine_eager_DURATION}
-creation_cfa_thread_DURATION = 10000000
-creation_upp_thread_DURATION = ${creation_cfa_thread_DURATION}
-creation_DURATION = 10000000
 FIX_NEW_LINES = cat $@ | tr "\n" "\t" | sed -r 's/\t,/,/' | tr "\t" "\n" > $@
+BASIC_DEPEND = \
+        basic-loop.run                          \
+        basic-function.run                      \
+        basic-fetch_add.run                     \
+        basic-ttst_lock.run                     \
+        basic-tls-fetch_add.run
+CTXSWITCH_DEPEND = ctxswitch-cfa_generator.run \
+        ctxswitch-cfa_coroutine.run ctxswitch-cfa_thread.run \
+        ctxswitch-cfa_thread2.run ctxswitch-upp_coroutine.run \
+        ctxswitch-upp_thread.run ctxswitch-python_coroutine.run \
+        ctxswitch-nodejs_coroutine.run ctxswitch-nodejs_await.run \
+        ctxswitch-goroutine_thread.run ctxswitch-rust_thread.run \
+        ctxswitch-nodejs_coroutine.run ctxswitch-java_thread.run \
+        ctxswitch-pthread.run $(am__append_1)
+CTXSWITCH_DEPEND = loop.run function.run fetch_add.run ttst_lock.run \
+        tls-fetch_add.run ctxswitch-pthread.run \
+        ctxswitch-cfa_generator.run ctxswitch-cfa_coroutine.run \
+        ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \
+        ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \
+        ctxswitch-goroutine.run ctxswitch-java_thread.run \
+        $(am__append_1)
 testdir = $(top_srcdir)/tests
 all: all-am
 …
 dummyC.c:
         echo "int main() { return 0; }" > ${@}
+        @echo "int main() { return 0; }" > ${@}
 dummyCXX.cpp:
+        echo "int main() { return 0; }" > ${@}
+.SILENT:                # do not print recipe
+        @echo "int main() { return 0; }" > ${@}
 .NOTPARALLEL:
 .PHONY: jenkins cleancsv
 all : basic$(EXEEXT) ctxswitch$(EXEEXT) mutex$(EXEEXT) schedint$(EXEEXT) schedext$(EXEEXT) creation$(EXEEXT)
+.PHONY: compile.csv ctxswitch.csv mutex.csv signal.csv
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 %.run : %$(EXEEXT) ${REPEAT}
+        rm -f .result.log
+        echo "------------------------------------------------------"
+        echo $<
+        ${REPEAT} ${repeats} -- ./a.out\
+                $(if ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(subst -,_,$(basename $@))_DURATION},\
+                        ${$(firstword $(subst -, ,$(basename $@)))_DURATION}) | tee -a .result.log
+        ${STATS} .result.log
+        echo "------------------------------------------------------"
+        rm -f a.out .result.log *.class
+#       ${REPEAT} ${repeats} -- /usr/bin/time -f "%Uu %Ss %Er %Mkb" ./a.out
+        @rm -f .result.log
+        @echo "------------------------------------------------------"
+        @echo $<
+        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
+        @${STATS} .result.log
+        @echo "------------------------------------------------------"
+        @rm -f a.out .result.log *.class
 %.runquiet :
         +make $(basename $@) CFLAGS="-w" __quiet=quiet
         taskset -c 1 ./a.out
         rm -f a.out
+        @+make $(basename $@) CFLAGS="-w" __quiet=quiet
+        @taskset -c 1 ./a.out
+        @rm -f a.out
 %.make :
         printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
         +/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
+        @printf "${PRINT_FORMAT}" $(basename $(subst compile-,,$@))
+        @+/usr/bin/time -f ${TIME_FORMAT} make $(basename $@) 2>&1
 ${REPEAT} :
+        +make -C ${abs_top_builddir}/tools repeat
+cleancsv:
+        rm -f compile.csv basic.csv ctxswitch.csv mutex.csv scheduling.csv
+jenkins$(EXEEXT): cleancsv
+        @+make -C ${abs_top_builddir}/tools repeat
+jenkins$(EXEEXT):
 @DOifskipcompile@
         +make compile.csv
         -+make compile.diff.csv
+        @+make compile.csv
+        @-+make compile.diff.csv
 @DOendif@
         +make ctxswitch.csv
         -+make ctxswitch.diff.csv
         +make mutex.csv
         -+make mutex.diff.csv
         +make scheduling.csv
         -+make scheduling.diff.csv
+        @+make ctxswitch.csv
+        @-+make ctxswitch.diff.csv
+        @+make mutex.csv
+        @-+make mutex.diff.csv
+        @+make signal.csv
+        @-+make signal.diff.csv
 @DOifskipcompile@
         cat compile.csv
 …
         cat mutex.csv
         -cat mutex.diff.csv
         cat scheduling.csv
         -cat scheduling.diff.csv
+        cat signal.csv
+        -cat signal.diff.csv
 compile.csv:
+        echo "building $@"
+        echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        +make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        +make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "array,attributes,empty,expression,io,monitor,operators,typeof" > $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-array.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-attributes.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-empty.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-expression.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-io.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-monitor.make >> $@
+        @+make TIME_FORMAT='%e,' PRINT_FORMAT='' compile-operators.make >> $@
+        @+make TIME_FORMAT='%e' PRINT_FORMAT='' compile-typeof.make >> $@
+        @$(srcdir)/fixcsv.sh $@
 ctxswitch.csv:
+        echo "building $@"
+        echo "generator,coroutine,thread" > $@
+        +make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        +make ctxswitch-cfa_thread.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "generator,coroutine,thread" > $@
+        @+make ctxswitch-cfa_generator.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_coroutine.runquiet >> $@ && echo -n ',' >> $@
+        @+make ctxswitch-cfa_thread.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
 mutex.csv:
+        echo "building $@"
+        echo "1-monitor,2-monitor" > $@
+        +make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make mutex-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+scheduling.csv:
+        echo "building $@"
+        echo "schedint-1,schedint-2,schedext-1,schedext-2" > $@
+        +make schedint-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedint-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        +make schedext-cfa2.runquiet >> $@
+        $(srcdir)/fixcsv.sh $@
+        @echo "1-monitor,2-monitor" > $@
+        @+make mutex-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make mutex-cfa2.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
+signal.csv:
+        @echo "signal-1,signal-2,waitfor-1,waitfor-2" > $@
+        @+make signal-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make signal-cfa2.runquiet >> $@ && echo -n ',' >> $@
+        @+make waitfor-cfa1.runquiet >> $@ && echo -n ',' >> $@
+        @+make waitfor-cfa2.runquiet >> $@
+        @$(srcdir)/fixcsv.sh $@
 %.diff.csv: %.csv
+        test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        $(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+basic-loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/loop.c
+basic-function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/function.c
+basic-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/fetch_add.c
+basic-ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/ttst_lock.c
+basic-tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/basic/tls_fetch_add.c
+basic$(EXEEXT): $(BASIC_DEPEND)
+        @test -e $(srcdir)/baselines/$(arch)/$< || (echo "Error : Missing baseline for ${<}" && false)
+        @$(srcdir)/baselines/calc.py $(srcdir)/baselines/$(arch)/$(<) $(<) > $@
+loop$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/loop.c
+function$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=5000000000 $(srcdir)/function.c
+fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/fetch_add.c
+ttst_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/ttst_lock.c
+tls-fetch_add$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) -DBENCH_N=500000000  $(srcdir)/tls-fetch_add.c
 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
 …
 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
 ctxswitch-cfa_generator$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_gen.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_gen.cfa
 ctxswitch-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.cfa
 ctxswitch-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.cfa
 ctxswitch-cfa_thread2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/ctxswitch/cfa_thrd2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.cfa
 ctxswitch-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
 ctxswitch-upp_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/ctxswitch/upp_thrd.cc
+ctxswitch-python_coroutine$(EXEEXT):
+        $(BENCH_V_PY)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 "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 "nodejs $(srcdir)/ctxswitch/node_await.js" >> a.out
+        chmod a+x a.out
+ctxswitch-goroutine_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
+ctxswitch-goroutine$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/ctxswitch/goroutine.go
-ctxswitch-rust_thread$(EXEEXT):
-        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/ctxswitch/rust_thrd.rs
 ctxswitch-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/ctxswitch/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+ctxswitch-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/ctxswitch/pthreads.c
+mutex$(EXEEXT) :                \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+mutex$(EXEEXT) :\
+        loop.run                        \
+        function.run            \
+        fetch_add.run           \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
         mutex-cfa1.run          \
         mutex-cfa2.run          \
         mutex-cfa4.run          \
+        mutex-upp.run           \
+        mutex-go.run            \
+        mutex-rust.run          \
+        mutex-java.run          \
+        mutex-pthread.run
+mutex-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/mutex/pthreads.c
+        mutex-java_thread.run
+mutex-pthread_lock$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/mutex/pthreads.c
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/mutex/upp.cc
 mutex-cfa1$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa1.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa1.cfa
 mutex-cfa2$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa2.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa2.cfa
 mutex-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/mutex/cfa4.cfa
+mutex-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/mutex/upp.cc
+mutex-go$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/mutex/goroutine.go
+mutex-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/mutex/rust.rs
+mutex-java$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=5000000  $(srcdir)/mutex/cfa4.cfa
+mutex-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/mutex/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+schedint$(EXEEXT) :             \
+        schedint-cfa1.run       \
+        schedint-cfa2.run       \
+        schedint-cfa4.run       \
+        schedint-upp.run        \
+        schedint-rust.run       \
+        schedint-java.run       \
+        schedint-pthread.run
+schedint-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa1.cfa
+schedint-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa2.cfa
+schedint-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedint/cfa4.cfa
+schedint-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedint/upp.cc
+schedint-rust$(EXEEXT):
+        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/schedint/rust.rs
+schedint-java$(EXEEXT):
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+signal$(EXEEXT) :\
+        signal-pthread_cond.run \
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run         \
+        signal-java_thread.run
+signal-pthread_cond$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=500000  $(srcdir)/schedint/pthreads.c
+signal-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedint/upp.cc
+signal-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa1.cfa
+signal-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa2.cfa
+signal-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedint/cfa4.cfa
+signal-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/schedint/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+schedint-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/schedint/pthreads.c
+schedext$(EXEEXT) :             \
+        schedext-cfa1.run       \
+        schedext-cfa2.run       \
+        schedext-cfa4.run       \
+        schedext-upp.run        \
+        schedext-goroutine.run
+schedext-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa1.cfa
+schedext-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa2.cfa
+schedext-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/schedext/cfa4.cfa
+schedext-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/schedext/upp.cc
+schedext-goroutine$(EXEEXT):
+        $(BENCH_V_GOC)go build -o a.out $(srcdir)/schedext/goroutine.go
+creation$(EXEEXT) :                             \
+        creation-cfa_generator.run              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=5000000 $(srcdir)/schedext/upp.cc
+waitfor-cfa1$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa1.cfa
+waitfor-cfa2$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa2.cfa
+waitfor-cfa4$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=500000  $(srcdir)/schedext/cfa4.cfa
+creation$(EXEEXT) :\
+        creation-pthread.run                    \
         creation-cfa_coroutine.run              \
         creation-cfa_coroutine_eager.run        \
 …
         creation-upp_coroutine.run              \
         creation-upp_thread.run                 \
+        creation-python_coroutine.run           \
+        creation-nodejs_coroutine.run           \
+        creation-goroutine_thread.run           \
+        creation-rust_thread.run                \
+        creation-java_thread.run                \
+        creation-pthread.run
+creation-cfa_generator$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_gen.cfa
+        creation-goroutine.run                  \
+        creation-java_thread.run
 creation-cfa_coroutine$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa
 creation-cfa_coroutine_eager$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_cor.cfa  -DEAGER
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_cor.cfa  -DEAGER
 creation-cfa_thread$(EXEEXT):
         $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/creation/cfa_thrd.cfa
+        $(BENCH_V_CFA)$(CFACOMPILE) -DBENCH_N=10000000 $(srcdir)/creation/cfa_thrd.cfa
 creation-upp_coroutine$(EXEEXT):
         $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_cor.cc
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_cor.cc
 creation-upp_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) $(srcdir)/creation/upp_thrd.cc
+creation-python_coroutine$(EXEEXT):
+        $(BENCH_V_PY)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 "nodejs $(srcdir)/creation/node_cor.js" >> a.out
+        chmod a+x a.out
+creation-goroutine_thread$(EXEEXT):
+        $(BENCH_V_UPP)$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/creation/upp_thrd.cc
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE)    -DBENCH_N=250000   $(srcdir)/creation/pthreads.c
+creation-goroutine$(EXEEXT):
         $(BENCH_V_GOC)go build -o a.out $(srcdir)/creation/goroutine.go
-creation-rust_thread$(EXEEXT):
-        $(BENCH_V_RUSTC)rustc -C opt-level=3 -o a.out $(srcdir)/creation/rust_thrd.rs
 creation-java_thread$(EXEEXT):
         $(BENCH_V_JAVAC)javac -d $(builddir) $(srcdir)/creation/JavaThread.java
+        echo "#!/bin/sh" > a.out
+        echo "java JavaThread" >> a.out
+        chmod a+x a.out
+creation-pthread$(EXEEXT):
+        $(BENCH_V_CC)$(COMPILE) $(srcdir)/creation/pthreads.c
+compile$(EXEEXT) :              \
+        @echo "#!/bin/sh" > a.out
+        @echo "java JavaThread" >> a.out
+        @chmod a+x a.out
+compile$(EXEEXT) :\
         compile-array.make      \
         compile-attributes.make \
 …
 compile-array$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/array.cfa
 compile-attributes$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/attributes.cfa
 compile-empty$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(srcdir)/compile/empty.cfa
 compile-expression$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/expression.cfa
 compile-io$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/io1.cfa
 compile-monitor$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/monitor.cfa
 compile-operators$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/operators.cfa
 compile-thread$(EXEEXT):
         $(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/concurrent/thread.cfa
 compile-typeof$(EXEEXT):
+        $(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
+size$(EXEEXT) : size-cfa.runquiet
+size-cfa$(EXEEXT):
+        $(BENCH_V_CFA)$(CFACOMPILE) $(srcdir)/size/size.cfa
+        @$(CFACOMPILE) -fsyntax-only -w $(testdir)/typeof.cfa
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

benchmark/bench.h

-              r3d5701e
+              r9fb8f01
 #endif
         #include <stdlib.h>
+        #include <stdint.h>                             // uint64_t
+        #include <unistd.h>                             // sysconf
+        #include <unistd.h>                                     // sysconf
 #if ! defined(__cforall)
         #include <time.h>
 …
+static inline uint64_t bench_time() {
+        struct timespec ts;
+        clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
+        return 1000000000LL * ts.tv_sec + ts.tv_nsec;
+} // bench_time
+static inline unsigned long long int bench_time() {
+    struct timespec ts;
+    clock_gettime(
+#if defined( __linux__ )
+         CLOCK_THREAD_CPUTIME_ID,
+#elif defined( __freebsd__ )
+         CLOCK_PROF,
+#elif defined( __solaris__ )
+         CLOCK_HIGHRES,
+#else
+    #error uC++ : internal error, unsupported architecture
+#endif
+         &ts );
+    return 1000000000LL * ts.tv_sec + ts.tv_nsec;
+} // Time
 #ifndef BENCH_N
 #define BENCH_N 10000000
+#define BENCH_N 500 //10000000
 #endif
-size_t times = BENCH_N;
-#define BENCH_START()                           \
-        if ( argc > 2 ) exit( EXIT_FAILURE );   \
-        if ( argc == 2 ) {                      \
-                times = atoi( argv[1] );        \
+        }
 #define BENCH(statement, output)                \
+        uint64_t StartTime, EndTime;            \
+        size_t n = BENCH_N;                     \
+        if( argc > 2 ) return 1;                \
+        if( argc == 2 ) {                               \
+                n = atoi(argv[1]);              \
+        }                                               \
+        long long int StartTime, EndTime;       \
         StartTime = bench_time();               \
         statement;                              \
+        statement;                                      \
         EndTime = bench_time();                 \
         double output = (double)( EndTime - StartTime ) / times;
+        double output =         \
+            (double)( EndTime - StartTime ) / n;
 #if defined(__cforall)
 …
+}
 #endif
-#if defined(__U_CPLUSPLUS__)
-unsigned int uDefaultPreemption() {
-        return 0;
+}
-#endif

benchmark/creation/JavaThread.java

-              r3d5701e
+              r9fb8f01
         static int x = 2;
         static private int times = Integer.parseInt("10000") ;
+        static private final int NoOfTimes = Integer.parseInt("10000") ;
         public static class MyThread extends Thread {
 …
+        }
         public static void helper() throws InterruptedException {
                 for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         MyThread m = new MyThread();
                         x = nextRandom( x );
 …
                 helper();
                 long end = System.nanoTime();
                 System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
+        }
         public static void main(String[] args) throws InterruptedException {
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+                for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
                         InnerMain();
                         Thread.sleep(2000);             // 2 seconds
+                        Thread.sleep(2000);     // 2 seconds
                         x = nextRandom(x);
+                }
 …
+        }
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/cfa_cor.cfa

-              r3d5701e
+              r9fb8f01
 coroutine MyCoroutine {};
 void ?{}( MyCoroutine & this ) {
+void ?{} (MyCoroutine & this) {
 #ifdef EAGER
         resume( this );
+        resume(this);
 #endif
+}
 void main( MyCoroutine & ) {}
+void main(MyCoroutine &) {}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for ( times ) {
                         MyCoroutine c;
+                for ( i; n ) {
+                        MyCoroutine m;
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/cfa_thrd.cfa

-              r3d5701e
+              r9fb8f01
 void main(MyThread &) {}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for ( times ) {
+                for ( i; n ) {
                         MyThread m;
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/goroutine.go

-              r3d5701e
+              r9fb8f01
 import (
+        "fmt"
+        "time"
+        "os"
+        "strconv"
+    "fmt"
+    "time"
+)
 …
 func main() {
+        var times int = 10000000
+        if len( os.Args ) > 2 { os.Exit( 1 ) }
+        if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
+        const NoOfTimes = 500000
         start := time.Now()
         for i := 1; i <= times; i += 1 {
+        for i := 1; i <= NoOfTimes; i += 1 {
                 go noop()               // creation
-                <- shake                // wait for completion
+        }
         end := time.Now()
+        fmt.Printf( "%d\n", end.Sub(start) / time.Duration(times) )
+        fmt.Printf("%d\n", end.Sub(start) / time.Duration(NoOfTimes))
+        <- shake
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/pthreads.c

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
 static void * foo(void *arg) {
+static void *foo(void *arg) {
     return arg;
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         pthread_t thread;
                         if (pthread_create(&thread, NULL, foo, NULL) < 0) {
 …
                                 return 1;
+                        }
                         if (pthread_join( thread, NULL) < 0) {
                                 perror( "failure" );
 …
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/upp_cor.cc

-              r3d5701e
+              r9fb8f01
 _Coroutine MyCor {
         void main() {}
-  public:
-        MyCor() { resume(); }
 };
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         MyCor m;
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/creation/upp_thrd.cc

-              r3d5701e
+              r9fb8f01
 };
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         MyThread m;
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/JavaThread.java

-              r3d5701e
+              r9fb8f01
         static int x = 2;
         static private int times = Integer.parseInt("100000");
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
         public static void helper() {
                 for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         Thread.yield();
+                }
 …
                 helper();
                 long end = System.nanoTime();
                 System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
+        }
         public static void main(String[] args) throws InterruptedException {
+                if ( args.length > 2 ) System.exit( 1 );
+                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
+                for (int i = Integer.parseInt("5"); --i >= 0 ; ) {
+                for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
                         InnerMain();
                         Thread.sleep(2000);     // 2 seconds
+                        Thread.sleep(2000);     // 2 seconds
                         x = nextRandom(x);
+                }
 …
+        }
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_cor.cfa

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+coroutine C {} c;
+void main( __attribute__((unused)) C & ) {
+        while () {
+coroutine GreatSuspender {};
+void ?{}( GreatSuspender & this ) {
+        prime(this);
+}
+void main( __attribute__((unused)) GreatSuspender & this ) {
+        while( true ) {
                 suspend();
+        }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
         BENCH(
                 for ( times ) {
                         resume( c );
+                for ( i; n ) {
+                        resume( s );
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_cor_then.cfa

-              r3d5701e
+              r9fb8f01
 void noOp(void) {}
 coroutine C {} c;
+coroutine GreatSuspender {};
 void ?{}( C & this ) {
+void ?{}( GreatSuspender & this ) {
         prime(this);
+}
 void main( __attribute__((unused)) C & this ) {
         while () {
+void main( __attribute__((unused)) GreatSuspender & this ) {
+        while( true ) {
                 suspend_then(noOp);
+        }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
         BENCH(
                 for ( times ) {
                         resume( c );
+                for ( i; n ) {
+                        resume( s );
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_gen.cfa

-              r3d5701e
+              r9fb8f01
 typedef struct {
         void * next;
 } C;
+} GreatSuspender;
 void comain( C * c ) {
         if ( __builtin_expect(c->next != 0, 1) ) goto *(c->next);
         c->next = &&s1;
+void comain( GreatSuspender * this ) {
+    if ( __builtin_expect(this->next != 0, 1) ) goto *(this->next);
+    this->next = &&s1;
         for () {
                 return;
+            return;
           s1: ;
+        }
+}
 int main( int argc, char * argv[] ) {
+        BENCH_START()
+        C c = { 0 };
+int main(int argc, char* argv[]) {
+    GreatSuspender s = { 0 };
         BENCH(
                 for ( times ) {
                         comain( &c );
+                for ( i; n ) {
+                        comain( &s );
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_thrd.cfa

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for ( times ) {
+                for ( i; n ) {
                         yield();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/cfa_thrd2.cfa

-              r3d5701e
+              r9fb8f01
 void main(__attribute__((unused)) Fibre & this) {
         while ( ! done ) {
+        while(!done) {
                 yield();
+        }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         Fibre f1;
         BENCH(
                 for ( times ) {
+                for ( i; n ) {
                         yield();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
         done = true;
+        return 0;
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/goroutine.go

-              r3d5701e
+              r9fb8f01
 import (
+        "fmt"
+        "time"
+        "os"
+        "strconv"
+        "runtime"
+    "fmt"
+    "runtime"
+    "time"
+)
 …
 func main() {
+        var times int = 10000000
+        if len( os.Args ) > 2 { os.Exit( 1 ) }
+        if len( os.Args ) == 2 { times, _ = strconv.Atoi(os.Args[1]) }
+        go ContextSwitch( times )               // context switch
+        const NoOfTimes = 10000000
+        go ContextSwitch( NoOfTimes )           // context switch
         <- shake
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/kos_fibre.cpp

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         Fibre::yield();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+        return 0;
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/kos_fibre2.cpp

-              r3d5701e
+              r9fb8f01
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         Fibre* f1 = (new Fibre)->run(f1main);
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         Fibre::yield();
                 },
                 result
+        )
         printf( "%g\n", result );
+        printf("%g\n", result);
         done = true;
         Fibre::yield();
         f1->join();
+        return 0;
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/pthreads.c

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         sched_yield();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}

benchmark/ctxswitch/upp_cor.cc

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+_Coroutine C {
+_Coroutine GreatSuspender {
+public:
+        GreatSuspender() {
+                resume();
+        }
+        void do_resume() {
+                resume();
+        }
+private:
         void main() {
                 while( true ) {
 …
+                }
+        }
+  public:
+        void do_resume() {
+                resume();
+        }
+} c;
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+};
+int main(int argc, char* argv[]) {
+        GreatSuspender s;
         BENCH(
                 for (size_t i = 0; i < times; i++) {
                         c.do_resume();
+                for (size_t i = 0; i < n; i++) {
+                        s.do_resume();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/ctxswitch/upp_thrd.cc

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for (size_t i = 0; i < times; i++) {
+                for (size_t i = 0; i < n; i++) {
                         uThisTask().yield();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/JavaThread.java

-              r3d5701e
+              r9fb8f01
         static int x = 2;
         static private int times = Integer.parseInt("100000000");
+        static private final int NoOfTimes = Integer.parseInt("100000000") ;
         public synchronized void noop() {
 …
                 // Inhibit biased locking ...
                 x = (j.hashCode() ^ System.identityHashCode(j)) | 1 ;
                 for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         x = nextRandom(x);
                         j.noop();
 …
                 helper();
                 long end = System.nanoTime();
                 System.out.println( (end - start) / times );
+                System.out.println( (end - start) / NoOfTimes );
+        }
         public static void main(String[] args) throws InterruptedException {
-                if ( args.length > 2 ) System.exit( 1 );
-                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
                 for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
                         InnerMain();
 …
+        }
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/cfa1.cfa

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
 monitor M {} m1;
 void __attribute__((noinline)) call( M & mutex p1 ) {}
+monitor M {};
+void __attribute__((noinline)) call( M & mutex m ) {}
 int main( int argc, char * argv[] ) {
         BENCH_START()
+int main(int argc, char* argv[]) {
+        M m;
         BENCH(
                 for ( times ) {
                         call( m1 );
+                for ( i; n ) {
+                        call(m);
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/cfa2.cfa

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+monitor M {} m1, m2;
+monitor M {};
+void __attribute__((noinline)) call( M & mutex m1, M & mutex m2 ) {}
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
+        M m1, m2;
         BENCH(
                 for ( times ) {
                         call( m1, m2 );
+                for ( i; n ) {
+                        call(m1, m2);
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/cfa4.cfa

-              r3d5701e
+              r9fb8f01
 monitor M {} m1, m2, m3, m4;
 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
+monitor M {};
+void __attribute__((noinline)) call( M & mutex m1, M & mutex m2, M & mutex m3, M & mutex m4 ) {}
 int main( int argc, char * argv[] ) {
         BENCH_START()
+int main(int argc, char* argv[]) {
+        M m1, m2, m3, m4;
         BENCH(
                 for ( times ) {
                         call( m1, m2, m3, m4 );
+                for ( i; n ) {
+                        call(m1, m2, m3, m4);
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/pthreads.c

-              r3d5701e
+              r9fb8f01
 void __attribute__((noinline)) call() {
          pthread_mutex_lock( &mutex );
          pthread_mutex_unlock( &mutex );
+         pthread_mutex_lock  (&mutex);
+         pthread_mutex_unlock(&mutex);
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         BENCH(
                 for ( size_t i = 0; i < times; i++ ) {
+                for (size_t i = 0; i < n; i++) {
                         call();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/mutex/upp.cc

-              r3d5701e
+              r9fb8f01
 };
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int argc, char* argv[]) {
         MyMonitor m;
         BENCH(
                 for ( size_t i = 0; i < times; i++ ) {
+                for (size_t i = 0; i < n; i++) {
                         m.call();
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedext/cfa1.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+monitor M {} m1;
+int argc;
+char** argv;
+volatile int go = 0;
+void __attribute__((noinline)) call( M & mutex p1 ) {}
+void __attribute__((noinline)) wait( M & mutex p1 ) {
+        for ( times ) {
+                waitfor( call : p1 );
+        }
+monitor M {};
+M m1;
+void __attribute__((noinline)) call( M & mutex a1 ) {}
+int  __attribute__((noinline)) wait( M & mutex a1 ) {
+        go = 1;
+        BENCH(
+                for ( i; n ) {
+                        waitfor(call, a1);
+                },
+                result
+        )
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
 thread T {};
+void ^?{}( T & mutex this ) {}
 void main( T & ) {
+        BENCH(
+                for ( times ) { call( m1 ); },
+                result
+        )
+        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1); }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
         wait( m1 );
+        return wait(m1);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedext/cfa2.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+monitor M {} m1, m2;
+int argc;
+char** argv;
+volatile int go = 0;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
+        for ( times ) {
+                waitfor( call : p1, p2 );
+        }
+}
+thread T {};
+void main( T & ) {
+monitor M {};
+M m1, m2;
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {}
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
+        go = 1;
         BENCH(
                 for ( times ) {
                         call( m1, m2 );
+                for ( i; n ) {
+                        waitfor(call, a1, a2);
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        wait( m1, m2 );
+thread T {};
+void ^?{}( T & mutex this ) {}
+void main( T & ) {
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2); }
+}
+// Local Variables: //
+// tab-width: 4 //
+// End: //
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+        T t;
+        return wait(m1, m2);
+}

benchmark/schedext/cfa4.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+monitor M {} m1, m2, m3, m4;
+int argc;
+char** argv;
+volatile int go = 0;
+void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
+        for ( times ) {
+                waitfor( call : p1, p2, p3, p4 );
+        }
+}
+thread T {};
+void main( T & ) {
+monitor M {};
+M m1, m2, m3, m4;
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {}
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
+        go = 1;
         BENCH(
                 for ( times ) {
                         call( m1, m2, m3, m4 );
+                for ( i; n ) {
+                        waitfor(call, a1, a2, a3, a4);
                 },
                 result
+        )
+        printf( "%g\n", result );
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+        T t;
+        wait( m1, m2, m3, m4 );
+thread T {};
+void ^?{}( T & mutex this ) {}
+void main( T & ) {
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2, m3, m4); }
+}
+// Local Variables: //
+// tab-width: 4 //
+// End: //
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
+        T t;
+        return wait(m1, m2, m3, m4);
+}

benchmark/schedext/upp.cc

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int argc;
+char** argv;
+volatile int go = 0;
 _Monitor M {
 public:
         void __attribute__((noinline)) call() {}
+        void __attribute__((noinline)) wait() {
+                for ( size_t i = 0; i < times; i++ ) {
+                        _Accept(call);
+                }
+        int __attribute__((noinline)) wait() {
+                go = 1;
+                BENCH(
+                        for (size_t i = 0; i < n; i++) {
+                                _Accept(call);
+                        },
+                        result
+                )
+                printf("%g\n", result);
+                go = 0;
+                return 0;
+        }
+} m;
+};
+M m;
 _Task T {
         void main() {
+                BENCH(
+                        for ( size_t i = 0; i < times; i++ ) {
+                                m.call();
+                        },
+                        result
+                )
+                printf( "%g\n", result );
+                while(go == 0) { yield(); }
+                while(go == 1) { m.call(); }
+        }
 };
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(int margc, char* margv[]) {
+        argc = margc;
+        argv = margv;
         T t;
         m.wait();
+        return m.wait();
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/JavaThread.java

-              r3d5701e
+              r9fb8f01
         static int x = 2;
         static private int times = Integer.parseInt("1000000");
+        static private final int NoOfTimes = Integer.parseInt("1000000") ;
         public static void helper( Monitor m ) throws InterruptedException {
                 for(int i = 1; i <= times; i += 1) {
+                for(int i = 1; i <= NoOfTimes; i += 1) {
                         m.wait();               // relase monitor lock
                         m.next = true;
 …
                 synchronized(m) {
                         s.start();
                         while( ! Monitor.go ) { // waiter must start first
+                        while( !Monitor.go ) {
                                 Thread.yield();
+                        }
 …
                 Monitor.go = false;
                 s.join();
                 System.out.println( (end - start) / times);
+                System.out.println( (end - start) / NoOfTimes);
+        }
         public static void main(String[] args) throws InterruptedException {
-                if ( args.length > 2 ) System.exit( 1 );
-                if ( args.length == 2 ) { times = Integer.parseInt(args[1]); }
                 for (int n = Integer.parseInt("5"); --n >= 0 ; ) {
                         InnerMain();
 …
+        }
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/cfa1.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+int argc;
+char** argv;
 volatile int go = 0;
 condition c;
+monitor M {} m1;
+monitor M {};
+M m1;
 void __attribute__((noinline)) call( M & mutex p1 ) {
         signal( c );
+void __attribute__((noinline)) call( M & mutex a1 ) {
+        signal(c);
+}
+void __attribute__((noinline)) wait( M & mutex p1 ) {
+int  __attribute__((noinline)) wait( M & mutex a1 ) {
         go = 1;
+        for ( times ) {
+                wait( c );
+        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
 thread T {};
+void ^?{}( T & mutex ) {}
 void main( T & ) {
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1 ); },
+                result
+        )
+        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1); }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
         wait( m1 );
+        return wait(m1);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/cfa2.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+int argc;
+char** argv;
 volatile int go = 0;
 condition c;
+monitor M {} m1, m2;
+monitor M {};
+M m1, m2;
 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2 ) {
         signal( c );
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
+        signal(c);
+}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2 ) {
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2 ) {
         go = 1;
+        for ( times ) {
+                wait( c );
+        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
 thread T {};
+void ^?{}( T & mutex this ) {}
 void main( T & ) {
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1, m2 ); },
+                result
+        )
+        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2); }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
         wait( m1, m2 );
+        return wait(m1, m2);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/cfa4.cfa

-              r3d5701e
+              r9fb8f01
 #include <stdio.h>
 #include "../bench.h"
+#include "bench.h"
+int argc;
+char** argv;
 volatile int go = 0;
 condition c;
+monitor M {} m1, m2, m3, m4;
+monitor M {};
+M m1, m2, m3, m4;
 void __attribute__((noinline)) call( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
         signal( c );
+void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
+        signal(c);
+}
+void __attribute__((noinline)) wait( M & mutex p1, M & mutex p2, M & mutex p3, M & mutex p4 ) {
+int  __attribute__((noinline)) wait( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
         go = 1;
+        for ( times ) {
+                wait( c );
+        }
+        BENCH(
+                for ( i; n ) {
+                        wait(c);
+                },
+                result
+        )
+        printf("%g\n", result);
+        go = 0;
+        return 0;
+}
 thread T {};
+void ^?{}( T & mutex this ) {}
 void main( T & ) {
+        while ( go == 0 ) { yield(); } // waiter must start first
+        BENCH(
+                for ( times ) { call( m1, m2, m3, m4 ); },
+                result
+        )
+        printf( "%g\n", result );
+        while(go == 0) { yield(); }
+        while(go == 1) { call(m1, m2, m3, m4); }
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
         wait( m1, m2, m3, m4 );
+        return wait(m1, m2, m3, m4);
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/pthreads.c

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int argc;
+char** argv;
 volatile int go = 0;
+pthread_cond_t c;
 pthread_mutex_t m;
-pthread_cond_t c;
 void __attribute__((noinline)) call() {
         pthread_mutex_lock( &m );
         pthread_cond_signal( &c );
         pthread_mutex_unlock( &m );
+        pthread_mutex_lock(&m);
+        pthread_cond_signal(&c);
+        pthread_mutex_unlock(&m);
+}
 void __attribute__((noinline)) wait() {
+int  __attribute__((noinline)) wait() {
         pthread_mutex_lock(&m);
         go = 1;
+        for ( size_t i = 0; i < times; i++ ) {
+                pthread_cond_wait( &c, &m );
+        }
+        BENCH(
+                for (size_t i = 0; i < n; i++) {
+                        pthread_cond_wait(&c, &m);
+                },
+                result
+        )
+        printf("%g\n", result);
         go = 0;
+        pthread_mutex_unlock( &m );
+        pthread_mutex_unlock(&m);
+        return 0;
+}
+void * thread_main( __attribute__((unused)) void * arg ) {
+        while ( go == 0 ) { sched_yield(); } // waiter must start first
+        // barging for lock acquire => may not execute N times
+        BENCH(
+                while ( go == 1 ) { call(); },
+                result
+        )
+        printf( "%g\n", result );
+void* thread_main(__attribute__((unused)) void * arg ) {
+        while(go == 0) { sched_yield(); }
+        while(go == 1) { call(); }
         return NULL;
+}
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         pthread_t thread;
         if ( pthread_create( &thread, NULL, thread_main, NULL ) < 0 ) {
+        if (pthread_create(&thread, NULL, thread_main, NULL) < 0) {
                 perror( "failure" );
                 return 1;
+        }
         wait();
         if ( pthread_join( thread, NULL ) < 0 ) {
+        if (pthread_join( thread, NULL) < 0) {
                 perror( "failure" );
                 return 1;
+        }
+        return 0;
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

benchmark/schedint/upp.cc

-              r3d5701e
+              r9fb8f01
 #include "bench.h"
+int argc;
+char** argv;
 volatile int go = 0;
 …
                 cond.signal();
+        }
+        void __attribute__((noinline)) wait() {
+        int __attribute__((noinline)) wait() {
                 go = 1;
+                for ( size_t i = 0; i < times; i++ ) {
+                        cond.wait();
+                }
+                BENCH(
+                        for (size_t i = 0; i < n; i++) {
+                                cond.wait();
+                        },
+                        result
+                )
+                printf("%g\n", result);
+                go = 0;
+                return 0;
+        }
+} m;
+};
+M m;
 _Task T {
         void main() {
+                while ( go == 0 ) { yield(); } // waiter must start first
+                BENCH(
+                        for ( size_t i = 0; i < times; i++ ) {
+                                m.call();
+                        },
+                        result
+                )
+                printf( "%g\n", result );
+                while(go == 0) { yield(); }
+                while(go == 1) { m.call(); }
+        }
 };
+int main( int argc, char * argv[] ) {
+        BENCH_START()
+int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[]) {
         T t;
         m.wait();
+        return m.wait();
+}
-// Local Variables: //
-// tab-width: 4 //
-// End: //

configure

-              r3d5701e
+              r9fb8f01
 ac_ct_DUMPBIN
 DUMPBIN
+LD
 FGREP
 EGREP
 …
 LDFLAGS
 CXXFLAGS
+CXX
 CFA_FLAGS
 LIBCFA_TARGET_MAKEFILES
 …
 BUILD_IN_TREE_FLAGS
 CFACPP
-CFACC_INSTALL
 CFACC
 DRIVER_DIR
 …
 CFA_INCDIR
 CFA_PREFIX
-HAS_DISTCC
-LD
-CXX
-ENABLE_DISTCC_FALSE
-ENABLE_DISTCC_TRUE
 DOendif
 DOifskipcompile
 …
 enable_silent_rules
 with_cfa_name
-enable_distcc
 with_target_hosts
 enable_gprofiler
 …
   --enable-silent-rules   less verbose build output (undo: "make V=1")
   --disable-silent-rules  verbose build output (undo: "make V=0")
-  --enable-distcc     whether or not to enable distributed compilation
   --enable-gprofiler     whether or not to enable gprofiler tools (if available)
   --enable-demangler     whether or not to build the demangler (executable and library)
 …
 #==============================================================================
-# distcc support
-# Check whether --enable-distcc was given.
-if test "${enable_distcc+set}" = set; then :
-  enableval=$enable_distcc; enable_distcc=$enableval
-else
-  enable_distcc=no
-fi
- if test x$enable_distcc = xyes; then
-  ENABLE_DISTCC_TRUE=
-  ENABLE_DISTCC_FALSE='#'
-else
-  ENABLE_DISTCC_TRUE='#'
-  ENABLE_DISTCC_FALSE=
-fi
-HAS_DISTCC="False"
-if test x$enable_distcc = xyes; then
-        CXX="distcc ${CXX}"
-        LD="distcc ${LD} -lstdc++"
-        HAS_DISTCC="True"
-        echo "Enabling distributed builds"
-fi
-#==============================================================================
 # Installation paths
 …
 DRIVER_DIR=${TOP_BUILDDIR}driver/
 CFACC=${DRIVER_DIR}cfa
-CFACC_INSTALL=${CFA_BINDIR}${CFA_NAME}
 CFACPP=${DRIVER_DIR}cfa-cpp
 …
 fi
-if test -z "${ENABLE_DISTCC_TRUE}" && test -z "${ENABLE_DISTCC_FALSE}"; then
-  as_fn_error $? "conditional \"ENABLE_DISTCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
 if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
   as_fn_error $? "conditional \"AMDEP\" was never defined.

configure.ac

-              r3d5701e
+              r9fb8f01
 #==============================================================================
-# distcc support
-AC_ARG_ENABLE(distcc,
-        [  --enable-distcc     whether or not to enable distributed compilation],
-        enable_distcc=$enableval, enable_distcc=no)
-AM_CONDITIONAL([ENABLE_DISTCC], [test x$enable_distcc = xyes])
-HAS_DISTCC="False"
-if test x$enable_distcc = xyes; then
-        CXX="distcc ${CXX}"
-        LD="distcc ${LD} -lstdc++"
-        HAS_DISTCC="True"
-        echo "Enabling distributed builds"
-fi
-AC_SUBST(CXX)
-AC_SUBST(LD)
-AC_SUBST(HAS_DISTCC)
-#==============================================================================
 # Installation paths
 M4CFA_PARSE_PREFIX
 …
 DRIVER_DIR=${TOP_BUILDDIR}driver/
 CFACC=${DRIVER_DIR}cfa
-CFACC_INSTALL=${CFA_BINDIR}${CFA_NAME}
 CFACPP=${DRIVER_DIR}cfa-cpp
 AC_SUBST(DRIVER_DIR)
 AC_SUBST(CFACC)
-AC_SUBST(CFACC_INSTALL)
 AC_SUBST(CFACPP)

doc/papers/concurrency/Paper.tex

-              r3d5701e
+              r9fb8f01
 \lstMakeShortInline@%
-\newcommand{\commenttd}[1]{{\color{red}{Thierry : #1}}}
 \let\OLDthebibliography\thebibliography
 \renewcommand\thebibliography[1]{
 …
 % }
 % int main() {
+%
+%
 %       for ( int i = 0; i < 10; i += 1 ) {
 %               printf( "%d\n", fib() );
 …
                 if ( random() % 3 ) transfer( b1, b2, 7 );
+        }
+}
+}
 int main() {
         `Person p1 = { b1, b2 }, p2 = { b2, b1 };`
 …
                 if ( random() % 3 ) transfer( b1, b2, 7 );
+        }
+}
+}
 int main() {
         `thread p1(person, ref(b1), ref(b2)), p2(person, ref(b2), ref(b1));`
 …
 % \section{Parallelism}
 % \label{s:Parallelism}
+%
+%
 % Historically, computer performance was about processor speeds.
 % However, with heat dissipation being a direct consequence of speed increase, parallelism is the new source for increased performance~\cite{Sutter05, Sutter05b}.
 …
 % However, kernel threads are better as an implementation tool because of complexity and higher cost.
 % Therefore, different abstractions are often layered onto kernel threads to simplify them, \eg pthreads.
+%
+%
+%
+%
 % \subsection{User Threads}
+%
+%
 % A direct improvement on kernel threads is user threads, \eg Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
 % This approach provides an interface that matches the language paradigms, gives more control over concurrency by the language runtime, and an abstract (and portable) interface to the underlying kernel threads across operating systems.
 …
 % Like kernel threads, user threads support preemption, which maximizes nondeterminism, but increases the potential for concurrency errors: race, livelock, starvation, and deadlock.
 % \CFA adopts user-threads to provide more flexibility and a low-cost mechanism to build any other concurrency approach, \eg thread pools and actors~\cite{Actors}.
+%
+%
 % A variant of user thread is \newterm{fibres}, which removes preemption, \eg Go~\cite{Go} @goroutine@s.
 % Like functional programming, which removes mutation and its associated problems, removing preemption from concurrency reduces nondeterminism, making race and deadlock errors more difficult to generate.

driver/Makefile.in

-              r3d5701e
+              r9fb8f01
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@

driver/cc1.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 20 08:14:33 2019
 // Update Count     : 385
+// Last Modified On : Fri Aug 23 15:06:27 2019
+// Update Count     : 371
 //
 …
+static string compiler_path( CFA_BACKEND_CC );                  // C compiler path/name
+static string installlibdir( CFA_LIBDIR );                              // fixed location of cc1 and cfa-cpp commands when installed
+static string compiler_path( CFA_BACKEND_CC );                  // path/name of C compiler
 static bool CFA_flag = false;                                                   // -CFA flag
 static bool save_temps = false;                                                 // -save-temps flag
 static string o_file;
-static string bprefix;
 …
 static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );               // "N__=" suffix
+static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );
 static void checkEnv1( const char * args[], int & nargs ) { // stage 1
 …
                 if ( prefix( arg, __CFA_FLAGPREFIX__ ) ) {
                         string val( arg.substr( arg.find_first_of( "=" ) + 1 ) );
+                        string val( arg.substr( __CFA_FLAGPREFIX__.size() + 4 ) );
                         if ( prefix( val, "-compiler=" ) ) {
                                 compiler_path = val.substr( 10 );
 …
                 if ( prefix( arg, __CFA_FLAGPREFIX__ ) ) {
                         string val( arg.substr( arg.find_first_of( "=" ) + 1 ) );
+                        string val( arg.substr( __CFA_FLAGPREFIX__.size() + 4 ) );
                         if ( prefix( val, "-compiler=" ) ) {
                                 compiler_path = val.substr( 10 );
 …
                         } else if ( prefix( val, "-o=" ) ) {            // output file for -CFA
                                 o_file = val.substr( 3 );
+                        } else if ( prefix( val, "-B=" ) ) {            // location of cfa-cpp
+                                bprefix = val.substr( 3 );
+                        } else {                                                                        // normal flag for cfa-cpp
+                                args[nargs++] = ( *new string( arg.substr( arg.find_first_of( "=" ) + 1 ) ) ).c_str();
+                        } else {
+                                args[nargs++] = ( *new string( arg.substr( __CFA_FLAGPREFIX__.size() + 4 ) ) ).c_str();
                         } // if
                 } // if
 …
 static char tmpname[] = P_tmpdir "/CFAXXXXXX.ifa";
+static char tmpname[] = P_tmpdir "/CFAXXXXXX.i";
 static int tmpfilefd = -1;
 static bool startrm = false;
 …
                 execvp( args[0], (char * const *)args );                // should not return
+                perror( "CC1 Translator error: stage 1 cpp, execvp" );
+                cerr << " invoked " << args[0] << endl;
+                perror( "CC1 Translator error: stage 1, execvp" );
                 exit( EXIT_FAILURE );
         } // if
 …
         #endif // __DEBUG_H__
-        enum {
-                Color_Auto   = 0,
-                Color_Always = 1,
-                Color_Never  = 2,
-        } color_arg = Color_Auto;
-        const char * color_names[3] = { "--colors=auto", "--colors=always", "--colors=never" };
         // process all the arguments
 …
                 if ( prefix( arg, "-" ) ) {
                         // strip inappropriate flags
-                        if ( prefix( arg, "-fdiagnostics-color=" ) ) {
-                                string choice = arg.substr(20);
-                                     if(choice == "always") color_arg = Color_Always;
-                                else if(choice == "never" ) color_arg = Color_Never;
-                                else if(choice == "auto"  ) color_arg = Color_Auto;
-                        } else if ( arg == "-fno-diagnostics-color" ) {
-                                color_arg = Color_Auto;
+                        }
                         if ( arg == "-quiet" || arg == "-version" || arg == "-fpreprocessed" ||
 …
                         } // if
                 } else {
                         tmpfilefd = mkstemps( tmpname, 4 );
+                        tmpfilefd = mkstemps( tmpname, 2 );
                         if ( tmpfilefd == -1 ) {
                                 perror( "CC1 Translator error: stage 2, mkstemp" );
 …
         if ( fork() == 0 ) {                                                            // child runs CFA
+                cargs[0] = ( *new string( bprefix + "cfa-cpp" ) ).c_str();
+                cargs[0] = ( *new string( installlibdir + "cfa-cpp" ) ).c_str();
                 cargs[ncargs++] = cpp_in;
 …
                         cargs[ncargs++] = cfa_cpp_out.c_str();
                 } // if
+                cargs[ncargs++] = color_names[color_arg];
+                cargs[ncargs] = nullptr;                                                // terminate argument list
+                cargs[ncargs] = nullptr;                                                        // terminate argument list
                 #ifdef __DEBUG_H__
 …
                 execvp( cargs[0], (char * const *)cargs );              // should not return
+                perror( "CC1 Translator error: stage 2 cfa-cpp, execvp" );
+                cerr << " invoked " << cargs[0] << endl;
+                perror( "CC1 Translator error: stage 2, execvp" );
                 exit( EXIT_FAILURE );
         } // if
 …
                 args[0] = compiler_path.c_str();
                 args[nargs++] = "-S";                                                   // only compile and put assembler output in specified file
+                args[nargs++] = "-x";
+                args[nargs++] = "cpp-output";
+                if ( save_temps ) {                                                             // make gcc accept .ifa suffix
+                        args[nargs++] = "-x";
+                        args[nargs++] = "cpp-output";
+                } // if
                 args[nargs++] = cfa_cpp_out.c_str();
                 args[nargs] = nullptr;                                                  // terminate argument list
 …
                 execvp( args[0], (char * const *)args );                // should not return
+                perror( "CC1 Translator error: stage 2 cc1, execvp" );
+                cerr << " invoked " << args[0] << endl;
+                perror( "CC1 Translator error: stage 2, execvp" );
                 exit( EXIT_FAILURE );                                                   // tell gcc not to go any further
         } // if
         wait( &code );                                                                          // wait for child to finish
+        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
+                rmtmpfile();                                                                    // remove tmpname
+                cerr << "CC1 Translator error: stage 2, child failed " << WTERMSIG(code) << endl;
+                exit( EXIT_FAILURE );
+        } // if
+        #ifdef __DEBUG_H__
+        cerr << "return code from gcc cc1:" << WEXITSTATUS(code) << endl;
+        #endif // __DEBUG_H__
         rmtmpfile();                                                                            // remove tmpname
-        if ( WIFSIGNALED(code) ) {                                                      // child failed ?
-                cerr << "CC1 Translator error: stage 2, child failed " << WTERMSIG(code) << endl;
-                exit( EXIT_FAILURE );
-        } // if
-        #ifdef __DEBUG_H__
-        cerr << "return code from gcc cc1:" << WEXITSTATUS(code) << endl;
-        #endif // __DEBUG_H__
         exit( WEXITSTATUS( code ) );                                            // stop regardless of success or failure
 } // Stage2

driver/cfa.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jan 31 16:48:03 2020
 // Update Count     : 421
+// Last Modified On : Fri Aug 23 16:27:07 2019
+// Update Count     : 411
 //
 #include <iostream>
+#include <cstdio>      // perror
+#include <cstdlib>     // putenv, exit
+#include <climits>     // PATH_MAX
+#include <unistd.h>    // execvp
+#include <string>      // STL version
+#include <string.h>    // strcmp
+#include <algorithm>   // find
+#include <cstdio>                                                                               // perror
+#include <cstdlib>                                                                              // putenv, exit
+#include <unistd.h>                                                                             // execvp
+#include <string>                                                                               // STL version
+#include <string.h>                                                                             // strcmp
+#include <algorithm>                                                                    // find
 #include <sys/types.h>
 …
 using std::to_string;
+// #define __DEBUG_H__
+// "N__=" suffix
+static string __CFA_FLAGPREFIX__( "__CFA_FLAG" );
+//#define __DEBUG_H__
 void Putenv( char * argv[], string arg ) {
+        // environment variables must have unique names
+        static int flags = 0;
+        if ( putenv( (char *)( *new string( string( __CFA_FLAGPREFIX__ + to_string( flags++ ) + "__=" ) + arg ) ).c_str() ) ) {
+        static int flags = 0;                                                           // environment variables must have unique names
+        if ( putenv( (char *)( *new string( string( "__CFA_FLAG" + to_string( flags++ ) + "__=" ) + arg ) ).c_str() ) ) {
                 cerr << argv[0] << " error, cannot set environment variable." << endl;
                 exit( EXIT_FAILURE );
 …
 } // Putenv
+// check if string has prefix
 bool prefix( const string & arg, const string & pre ) {
+bool prefix( const string & arg, const string & pre ) { // check if string has prefix
         return arg.substr( 0, pre.size() ) == pre;
 } // prefix
+inline bool ends_with(const string & str, const string & sfix) {
+        if (sfix.size() > str.size()) return false;
+        return std::equal(str.rbegin(), str.rbegin() + sfix.size(), sfix.rbegin(), sfix.rend());
+}
+// check if string has suffix
+bool suffix( const string & arg ) {
+bool suffix( const string & arg ) {                                             // check if string has suffix
         enum { NumSuffixes = 3 };
         static const string suffixes[NumSuffixes] = { "cfa", "hfa", "ifa" };
 …
     struct stat info;
     if ( stat( path.c_str(), &info ) != 0 ) return false;
+        return (info.st_mode & S_IFDIR) != 0;
+    if ( info.st_mode & S_IFDIR ) return true;
+        return false;
 } // dirExists
-static inline string dir(const string & path) {
-        return path.substr(0, path.find_last_of('/'));
+}
-// Different path modes
-enum PathMode {
-        Installed,     // cfa is installed, use prefix
-        BuildTree,     // cfa is in the tree, use source and build tree
-        Distributed    // cfa is distributed, use build tree for includes and executable directory for .cfs
-};
-// Get path mode from /proc
-PathMode FromProc() {
-        std::string abspath;
-        abspath.resize(PATH_MAX);
-        // get executable path from /proc/self/exe
-        ssize_t size = readlink("/proc/self/exe", const_cast<char*>(abspath.c_str()), abspath.size());
-        if(size <= 0) {
-                std::cerr << "Error could not evaluate absolute path from /proc/self/exe" << std::endl;
-                std::cerr << "Failed with " << std::strerror(errno) << std::endl;
-                std::exit(1);
+        }
-        // Trim extra characters
-        abspath.resize(size);
-        // Are we installed
-        if(abspath.rfind(CFA_BINDIR  , 0) == 0) { return Installed; }
-        // Is this the build tree
-        if(abspath.rfind(TOP_BUILDDIR, 0) == 0) { return BuildTree; }
-        // Does this look like distcc
-        if(abspath.find("/.cfadistcc/") != std::string::npos) { return Distributed; }
-        // None of the above? Give up since we don't know where the prelude or include directories are
-        std::cerr << "Cannot find required files from excutable path " << abspath << std::endl;
-        std::exit(1);
+}
 …
         string heading;                                                                         // banner printed at start of cfa compilation
         string arg;                                                                                     // current command-line argument during command-line parsing
         string bprefix;                                                                         // path where gcc looks for compiler steps
+        string Bprefix;                                                                         // path where gcc looks for compiler command steps
         string langstd;                                                                         // language standard
 …
         bool m32 = false;                                                                       // -m32 flag
         bool m64 = false;                                                                       // -m64 flag
         bool compiling_libs = false;
+        bool intree = false;                                                            // build in tree
         int o_file = 0;                                                                         // -o filename position
-        PathMode path = FromProc();
         const char *args[argc + 100];                                           // cfa command line values, plus some space for additional flags
 …
                         } else if ( arg == "-XCFA" ) {                          // CFA pass through
                                 i += 1;
-                                if ( i == argc ) continue;                              // next argument available ?
                                 Putenv( argv, argv[i] );
 …
                         } else if ( arg == "-no-include-stdhdr" ) {
                                 noincstd_flag = true;                                   // strip the no-include-stdhdr flag
                         } else if ( arg == "-cfalib") {
                                 compiling_libs = true;
+                        } else if ( arg == "-in-tree" ) {
+                                intree = true;
                         } else if ( arg == "-compiler" ) {
                                 // use the user specified compiler
 …
                                 } // if
                         } else if ( prefix( arg, "-B" ) ) {
+                                bprefix = arg.substr(2);                                // strip the -B flag
+                                Bprefix = arg.substr(2);                                // strip the -B flag
+                                args[nargs++] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
                         } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) {
                                 args[nargs++] = argv[i];                                // pass argument along
 …
         // -E flag stops at cc1 stage 1, so cfa-cpp in cc1 stage 2 is never executed.
         if ( cpp_flag && CFA_flag ) {
                 CFA_flag = false;
                 cerr << argv[0] << " warning, both -E and -CFA flags specified, using -E and ignoring -CFA." << endl;
+                cerr << argv[0] << " error, cannot use -E and -CFA flags together." << endl;
+                exit( EXIT_FAILURE );
         } // if
         // add the CFA include-library paths, which allow direct access to header files without directory qualification
+        string libbase;
+        switch(path) {
+        case Installed:
+        if ( ! intree ) {
                 args[nargs++] = "-I" CFA_INCDIR;
+                // do not use during build
+                if ( ! noincstd_flag ) {
+                if ( ! noincstd_flag ) {                                                // do not use during build
                         args[nargs++] = "-I" CFA_INCDIR "stdhdr";
                 } // if
                 args[nargs++] = "-I" CFA_INCDIR "concurrency";
                 args[nargs++] = "-I" CFA_INCDIR "containers";
+                libbase = CFA_LIBDIR;
+                break;
+        case BuildTree:
+        case Distributed:
+        } else {
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src";
+                // do not use during build
+                if ( ! noincstd_flag ) {
+                if ( ! noincstd_flag ) {                                                // do not use during build
                         args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/stdhdr";
                 } // if
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/concurrency";
                 args[nargs++] = "-I" TOP_SRCDIR "libcfa/src" "/containers";
-                libbase = TOP_BUILDDIR "libcfa/";
-                break;
         } // if
 …
         args[nargs++] = "stdbool.h";
+        if( compiling_libs ) {
+        string libbase;
+        if ( ! intree ) {
+                libbase = CFA_LIBDIR;
+        } else {
+                libbase = TOP_BUILDDIR "libcfa/";
                 Putenv( argv, "-t" );
         } // if
 …
         } // if
+        const char * config = nolib ? "nolib" : (debug ? "debug": "nodebug");
+        string libdir = libbase + arch + "-" + config;
+        if (path != Distributed) {
+                if ( ! nolib && ! dirExists( libdir ) ) {
+                        cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
+                        cerr << "Was looking for " << libdir << endl;
+                        for(int i = 1; i < argc; i++) {
+                                cerr << argv[i] << " ";
+                        }
+                        cerr << endl;
+                        libdir = libbase + arch + "-" + "nolib";
+                } // if
+                if ( ! dirExists( libdir ) ) {
+                        cerr << argv[0] << " internal error, cannot find prelude directory." << endl;
+                        cerr << "Was looking for " << libdir << endl;
+                        exit( EXIT_FAILURE );
+                } // if
+        } // if
+        switch(path) {
+        case Installed   : Putenv( argv, "--prelude-dir=" + libdir ); break;
+        case BuildTree   : Putenv( argv, "--prelude-dir=" + libdir + "/prelude" ); break;
+        case Distributed : Putenv( argv, "--prelude-dir=" + dir(argv[0]) ); break;
+        }
+        string libdir( libbase + arch + "-" + (nolib ? "nolib" : (debug ? "debug": "nodebug")) );
+        if ( ! dirExists( libdir ) ) {
+                cerr << argv[0] << " internal error, cannot find prelude directory " << libdir << endl;
+                exit( EXIT_FAILURE );
+        } // if
         for ( int i = 0; i < nlibs; i += 1 ) {                          // copy non-user libraries after all user libraries
 …
                 args[nargs++] = "-Xlinker";
                 args[nargs++] = "--undefined=__cfaabi_appready_startup";
+                args[nargs++] = "-z";
+                args[nargs++] = "execstack";
+                // include the cfa library in case it is needed
+                args[nargs++] = ( *new string( string("-L" ) + libdir + (path != Installed ? "/src/.libs" : "")) ).c_str();
+                args[nargs++] = ( *new string( string("-Wl,-rpath," ) + libdir + (path != Installed ? "/src/.libs" : "")) ).c_str();
+                // include the cfa library in case it's needed
+                args[nargs++] = ( *new string( string("-L" ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
+                args[nargs++] = ( *new string( string("-Wl,-rpath," ) + libdir + (intree ? "/src/.libs" : "")) ).c_str();
                 args[nargs++] = "-Wl,--push-state,--as-needed";
                 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++] = "-lpthread";
                 args[nargs++] = "-ldl";
                 args[nargs++] = "-lrt";
 …
         } // if
+        Putenv( argv, "--prelude-dir=" + libdir + (intree ? "/prelude" : "") );
         if ( debug ) {
                 heading += " (debug)";
 …
         } // if
+        if ( bprefix.length() == 0 ) {
+                switch(path) {
+                case Installed   : bprefix = installlibdir; break;
+                case BuildTree   : bprefix = srcdriverdir ; break;
+                case Distributed : bprefix = dir(argv[0]) ; break;
+                }
+                if ( bprefix[bprefix.length() - 1] != '/' ) bprefix += '/';
+                Putenv( argv, string("-B=") + bprefix );
+        if ( Bprefix.length() == 0 ) {
+                Bprefix = ! intree ? installlibdir : srcdriverdir;
+                if ( Bprefix[Bprefix.length() - 1] != '/' ) Bprefix += '/';
+                args[nargs++] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
         } // if
 …
                 args[nargs++] = "-fgnu89-inline";
                 args[nargs++] = "-D__int8_t_defined";                   // prevent gcc type-size attributes
                 args[nargs++] = ( *new string( string("-B") + bprefix ) ).c_str();
+                args[nargs++] = ( *new string( string("-B") + Bprefix ) ).c_str();
         } else {
                 cerr << argv[0] << " error, compiler \"" << compiler_name << "\" unsupported." << endl;
 …
                 cerr << " \"" << args[i] << "\"" << endl;
         } // for
-        cerr << endl;
         #endif // __DEBUG_H__
         if ( ! quiet ) {
                 cerr << "CFA " << "Version " << Version << heading << endl;
                 if ( help ) {
                         cerr <<

libcfa/Makefile.in

-              r3d5701e
+              r9fb8f01
 CFACC = @CFACC@
 CFACPP = @CFACPP@
-CFADIR_HASH = @CFADIR_HASH@
 CFA_BINDIR = @CFA_BINDIR@
 CFA_INCDIR = @CFA_INCDIR@
 …
 LIPO = @LIPO@
 LN_S = @LN_S@
-LOCAL_CC1 = @LOCAL_CC1@
-LOCAL_CFACC = @LOCAL_CFACC@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@

libcfa/automake/missing

Property mode changed from 100644 to 120000

r3d5701e	r9fb8f01
1		#! /bin/sh
2		# Tdelisle : having the Makefiles.in automatically regenerated causes problems
3		# when using multiple versions of automake, even if only on end user machines
4		# therefore I am disabling that feature by commenting this script
5		exit 0
	1	/usr/share/automake-1.15/missing

libcfa/configure

-              r3d5701e
+              r9fb8f01
 CONFIG_CFLAGS
 ARCH_FLAGS
-CFADIR_HASH
-LOCAL_CC1
-LOCAL_CFACC
 CFACPP
 CFACC
-ENABLE_DISTCC_FALSE
-ENABLE_DISTCC_TRUE
 CFA_VERSION
 DRIVER_DIR
 …
 enable_option_checking
 enable_silent_rules
-enable_distcc
 with_cfa_name
 enable_shared
 …
   --enable-silent-rules   less verbose build output (undo: "make V=1")
   --disable-silent-rules  verbose build output (undo: "make V=0")
-  --enable-distcc     whether or not to enable distributed compilation
   --enable-shared[=PKGS]  build shared libraries [default=yes]
   --enable-static[=PKGS]  build static libraries [default=yes]
 …
+# Check whether --enable-distcc was given.
+if test "${enable_distcc+set}" = set; then :
+  enableval=$enable_distcc; enable_distcc=$enableval
+else
+  enable_distcc=no
+fi
+echo -n "checking for distributated build... "
+if test x$enable_distcc = xno; then
+        CFACC=${DRIVER_DIR}cfa
+        echo "no"
+else
+        tools="$(readlink -m $ac_confdir/)/../tools/build"
+        config=$(basename $(readlink -f .))
+        echo "$tools/distcc_hash $config"
+        CFADIR_HASH=$($tools/distcc_hash $config)
+        CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
+        echo "yes (hash=${CFADIR_HASH})"
+fi
+CFACC=${DRIVER_DIR}cfa
 CFACPP=${DRIVER_DIR}cfa-cpp
-LOCAL_CFACC=${DRIVER_DIR}cfa
-LOCAL_CC1=${DRIVER_DIR}cc1
- if test x$enable_distcc = xyes; then
-  ENABLE_DISTCC_TRUE=
-  ENABLE_DISTCC_FALSE='#'
-else
-  ENABLE_DISTCC_TRUE='#'
-  ENABLE_DISTCC_FALSE=
-fi
 …
 case $CONFIGURATION in
         "debug"   )
                 CONFIG_CFLAGS="-O0 -g"
+                CONFIG_CFLAGS="-Og -g"
                 CONFIG_CFAFLAGS="-debug"
                 CONFIG_BUILDLIB="yes"
 …
 fi
-if test -z "${ENABLE_DISTCC_TRUE}" && test -z "${ENABLE_DISTCC_FALSE}"; then
-  as_fn_error $? "conditional \"ENABLE_DISTCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
 if test -z "${BUILDLIB_TRUE}" && test -z "${BUILDLIB_FALSE}"; then
   as_fn_error $? "conditional \"BUILDLIB\" was never defined.

libcfa/configure.ac

-              r3d5701e
+              r9fb8f01
 AC_ARG_VAR(CFA_VERSION, [The long version of cfa])
+AC_ARG_ENABLE(distcc,
+        [  --enable-distcc     whether or not to enable distributed compilation],
+        enable_distcc=$enableval, enable_distcc=no)
+echo -n "checking for distributated build... "
+if test x$enable_distcc = xno; then
+        CFACC=${DRIVER_DIR}cfa
+        echo "no"
+else
+        tools="$(readlink -m $ac_confdir/)/../tools/build"
+        config=$(basename $(readlink -f .))
+        echo "$tools/distcc_hash $config"
+        CFADIR_HASH=$($tools/distcc_hash $config)
+        CFACC="distcc ~/.cfadistcc/${CFADIR_HASH}/cfa"
+        echo "yes (hash=${CFADIR_HASH})"
+fi
+CFACC=${DRIVER_DIR}cfa
 CFACPP=${DRIVER_DIR}cfa-cpp
-LOCAL_CFACC=${DRIVER_DIR}cfa
-LOCAL_CC1=${DRIVER_DIR}cc1
-AM_CONDITIONAL([ENABLE_DISTCC], [test x$enable_distcc = xyes])
 AC_SUBST(CFACC)
 AC_SUBST(CFACPP)
-AC_SUBST(LOCAL_CFACC)
-AC_SUBST(LOCAL_CC1)
-AC_SUBST(CFADIR_HASH)
 AC_SUBST(CFA_VERSION)
 …
 case $CONFIGURATION in
         "debug"   )
                 CONFIG_CFLAGS="-O0 -g"
+                CONFIG_CFLAGS="-Og -g"
                 CONFIG_CFAFLAGS="-debug"
                 CONFIG_BUILDLIB="yes"

libcfa/prelude/Makefile.am

-              r3d5701e
+              r9fb8f01
 ## 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
 ###############################################################################
 …
 cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
 CC = @LOCAL_CFACC@
+CC = @CFACC@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CFAFLAGS = @CONFIG_CFAFLAGS@
 …
 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
 …
 # create forward declarations for cfa builtins
 builtins.cf : builtins.c @LOCAL_CFACC@
+builtins.cf : builtins.c ${CC}
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
         ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 …
 MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa
 MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
-if ENABLE_DISTCC
-distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c $(srcdir)/../../tools/build/push2dist.sh
-        ${AM_V_GEN}$(srcdir)/../../tools/build/push2dist.sh @CFADIR_HASH@
-        @echo "Dummy file to track distribution to remote hosts" > ${@}
-all: all-am distribution
-endif ENABLE_DISTCC

libcfa/prelude/Makefile.in

-              r3d5701e
+              r9fb8f01
 # 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
 …
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @LOCAL_CFACC@
+CC = @CFACC@
 CCAS = @CCAS@
 CCASDEPMODE = @CCASDEPMODE@
 …
 CFACC = @CFACC@
 CFACPP = @CFACPP@
-CFADIR_HASH = @CFADIR_HASH@
 CFA_BINDIR = @CFA_BINDIR@
 CFA_INCDIR = @CFA_INCDIR@
 …
 LIPO = @LIPO@
 LN_S = @LN_S@
-LOCAL_CC1 = @LOCAL_CC1@
-LOCAL_CFACC = @LOCAL_CFACC@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 …
             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
 …
 # create forward declarations for cfa builtins
 builtins.cf : builtins.c @LOCAL_CFACC@
+builtins.cf : builtins.c ${CC}
         ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
         ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 …
 maintainer-clean-local :
         rm -rf $(DEPDIR)
-@ENABLE_DISTCC_TRUE@distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c $(srcdir)/../../tools/build/push2dist.sh
-@ENABLE_DISTCC_TRUE@    ${AM_V_GEN}$(srcdir)/../../tools/build/push2dist.sh @CFADIR_HASH@
-@ENABLE_DISTCC_TRUE@    @echo "Dummy file to track distribution to remote hosts" > ${@}
-@ENABLE_DISTCC_TRUE@all: all-am distribution
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

libcfa/prelude/builtins.c

-              r3d5701e
+              r9fb8f01
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov 21 16:31:39 2019
 // Update Count     : 101
+// Last Modified On : Tue Jun 25 18:06:52 2019
+// Update Count     : 97
 //
 …
 // universal typed pointer constant
+static inline forall( dtype DT ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
+// Compiler issue: there is a problem with anonymous types that do not have a size.
+static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
 // exponentiation operator implementation

libcfa/prelude/extras.regx

-              r3d5701e
+              r9fb8f01
 typedef.* uint32_t;
 typedef.* uint64_t;
-typedef.* __uint_least16_t;
-typedef.* __uint_least32_t;
 typedef.* char16_t;
 typedef.* char32_t;
 typedef.* wchar_t;
+extern.*\*malloc\(.*\).*
+extern.* free\(.*\).*
+extern.* exit\(.*\).*
+extern.* atexit\(.*\).*
+extern.* abort\(.*\).*
+extern.* printf\(.*\).*

libcfa/prelude/prototypes.awk

-              r3d5701e
+              r9fb8f01
 # 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/prelude/sync-builtins.cf

-              r3d5701e
+              r9fb8f01
 char __sync_fetch_and_add(volatile char *, char,...);
+char __sync_fetch_and_add_1(volatile char *, char,...);
 signed char __sync_fetch_and_add(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_add_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_add(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_add_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_add(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_add_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_add(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_add_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_add(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_add_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_add(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_add(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_add(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_add_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_add(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_add_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_add(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_add_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_add(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_add_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_add(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_add_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_fetch_and_sub(volatile char *, char,...);
+char __sync_fetch_and_sub_1(volatile char *, char,...);
 signed char __sync_fetch_and_sub(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_sub_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_sub(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_sub_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_sub(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_sub_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_sub(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_sub_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_sub(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_sub_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_sub(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_sub(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_sub(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_sub_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_sub(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_sub_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_sub(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_sub_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_sub(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_sub_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_sub(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_sub_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_fetch_and_or(volatile char *, char,...);
+char __sync_fetch_and_or_1(volatile char *, char,...);
 signed char __sync_fetch_and_or(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_or_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_or(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_or_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_or(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_or_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_or(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_or_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_or(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_or_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_or(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_or(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_or(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_or_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_or(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_or_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_or(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_or_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_or(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_or_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_or(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_or_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_fetch_and_and(volatile char *, char,...);
+char __sync_fetch_and_and_1(volatile char *, char,...);
 signed char __sync_fetch_and_and(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_and_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_and(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_and_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_and(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_and_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_and(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_and_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_and(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_and_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_and(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_and(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_and(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_and_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_and(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_and_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_and(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_and_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_and(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_and_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_and(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_and_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_fetch_and_xor(volatile char *, char,...);
+char __sync_fetch_and_xor_1(volatile char *, char,...);
 signed char __sync_fetch_and_xor(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_xor_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_xor(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_xor_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_xor(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_xor_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_xor(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_xor_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_xor(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_xor_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_xor(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_xor(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_xor(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_xor_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_xor(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_xor_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_xor(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_xor_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_xor(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_xor_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_xor(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_xor_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_fetch_and_nand(volatile char *, char,...);
+char __sync_fetch_and_nand_1(volatile char *, char,...);
 signed char __sync_fetch_and_nand(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_nand_1(volatile signed char *, signed char,...);
 unsigned char __sync_fetch_and_nand(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_nand_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_fetch_and_nand(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_nand_2(volatile signed short *, signed short,...);
 unsigned short __sync_fetch_and_nand(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_nand_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_fetch_and_nand(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_nand_4(volatile signed int *, signed int,...);
 unsigned int __sync_fetch_and_nand(volatile unsigned int *, unsigned int,...);
+signed long int __sync_fetch_and_nand(volatile signed long int *, signed long int,...);
+unsigned long int __sync_fetch_and_nand(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_fetch_and_nand_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_fetch_and_nand(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_nand_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_fetch_and_nand(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_nand_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_fetch_and_nand(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_nand_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_fetch_and_nand(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_nand_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_add_and_fetch(volatile char *, char,...);
+char __sync_add_and_fetch_1(volatile char *, char,...);
 signed char __sync_add_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_add_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_add_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_add_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_add_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_add_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_add_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_add_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_add_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_add_and_fetch_4(volatile signed int *, signed int,...);
 signed int __sync_add_and_fetch(volatile signed int *, signed int,...);
+signed long int __sync_add_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_add_and_fetch(volatile unsigned long int *, unsigned long int,...);
+signed int __sync_add_and_fetch_4(volatile signed int *, signed int,...);
 signed long long int __sync_add_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_add_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_add_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_add_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_add_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_add_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_add_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_add_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_sub_and_fetch(volatile char *, char,...);
+char __sync_sub_and_fetch_1(volatile char *, char,...);
 signed char __sync_sub_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_sub_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_sub_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_sub_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_sub_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_sub_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_sub_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_sub_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_sub_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_sub_and_fetch_4(volatile signed int *, signed int,...);
 unsigned int __sync_sub_and_fetch(volatile unsigned int *, unsigned int,...);
+signed long int __sync_sub_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_sub_and_fetch(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_sub_and_fetch_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_sub_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_sub_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_sub_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_sub_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_sub_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_sub_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_sub_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_sub_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_or_and_fetch(volatile char *, char,...);
+char __sync_or_and_fetch_1(volatile char *, char,...);
 signed char __sync_or_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_or_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_or_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_or_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_or_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_or_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_or_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_or_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_or_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_or_and_fetch_4(volatile signed int *, signed int,...);
 unsigned int __sync_or_and_fetch(volatile unsigned int *, unsigned int,...);
+signed long int __sync_or_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_or_and_fetch(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_or_and_fetch_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_or_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_or_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_or_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_or_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_or_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_or_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_or_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_or_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_and_and_fetch(volatile char *, char,...);
+char __sync_and_and_fetch_1(volatile char *, char,...);
 signed char __sync_and_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_and_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_and_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_and_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_and_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_and_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_and_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_and_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_and_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_and_and_fetch_4(volatile signed int *, signed int,...);
 unsigned int __sync_and_and_fetch(volatile unsigned int *, unsigned int,...);
+signed long int __sync_and_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_and_and_fetch(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_and_and_fetch_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_and_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_and_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_and_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_and_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_and_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_and_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_and_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_and_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_xor_and_fetch(volatile char *, char,...);
+char __sync_xor_and_fetch_1(volatile char *, char,...);
 signed char __sync_xor_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_xor_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_xor_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_xor_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_xor_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_xor_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_xor_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_xor_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_xor_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_xor_and_fetch_4(volatile signed int *, signed int,...);
 unsigned int __sync_xor_and_fetch(volatile unsigned int *, unsigned int,...);
+signed long int __sync_xor_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_xor_and_fetch(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_xor_and_fetch_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_xor_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_xor_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_xor_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_xor_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_xor_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_xor_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_xor_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_xor_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 char __sync_nand_and_fetch(volatile char *, char,...);
+char __sync_nand_and_fetch_1(volatile char *, char,...);
 signed char __sync_nand_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_nand_and_fetch_1(volatile signed char *, signed char,...);
 unsigned char __sync_nand_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_nand_and_fetch_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_nand_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_nand_and_fetch_2(volatile signed short *, signed short,...);
 unsigned short __sync_nand_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_nand_and_fetch_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_nand_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_nand_and_fetch_4(volatile signed int *, signed int,...);
 unsigned int __sync_nand_and_fetch(volatile unsigned int *, unsigned int,...);
+signed long int __sync_nand_and_fetch(volatile signed long int *, signed long int,...);
+unsigned long int __sync_nand_and_fetch(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_nand_and_fetch_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_nand_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_nand_and_fetch_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_nand_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_nand_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_nand_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_nand_and_fetch_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_nand_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_nand_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 _Bool __sync_bool_compare_and_swap(volatile char *, char, char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile char *, char, char,...);
 _Bool __sync_bool_compare_and_swap(volatile signed char *, signed char, signed char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile signed char *, signed char, signed char,...);
 _Bool __sync_bool_compare_and_swap(volatile unsigned char *, unsigned char, unsigned char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile unsigned char *, unsigned char, unsigned char,...);
 _Bool __sync_bool_compare_and_swap(volatile short *, signed short, signed short,...);
+_Bool __sync_bool_compare_and_swap_2(volatile short *, signed short, signed short,...);
 _Bool __sync_bool_compare_and_swap(volatile short *, unsigned short, unsigned short,...);
+_Bool __sync_bool_compare_and_swap_2(volatile short *, unsigned short, unsigned short,...);
 _Bool __sync_bool_compare_and_swap(volatile signed int *, signed int, signed int,...);
+_Bool __sync_bool_compare_and_swap_4(volatile signed int *, signed int, signed int,...);
 _Bool __sync_bool_compare_and_swap(volatile unsigned int *, unsigned int, unsigned int,...);
+_Bool __sync_bool_compare_and_swap(volatile signed long int *, signed long int, signed long int,...);
+_Bool __sync_bool_compare_and_swap(volatile unsigned long int *, unsigned long int, unsigned long int,...);
+_Bool __sync_bool_compare_and_swap_4(volatile unsigned int *, unsigned int, unsigned int,...);
 _Bool __sync_bool_compare_and_swap(volatile signed long long int *, signed long long int, signed long long int,...);
+_Bool __sync_bool_compare_and_swap_8(volatile signed long long int *, signed long long int, signed long long int,...);
 _Bool __sync_bool_compare_and_swap(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+_Bool __sync_bool_compare_and_swap_8(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 _Bool __sync_bool_compare_and_swap(volatile signed __int128 *, signed __int128, signed __int128,...);
+_Bool __sync_bool_compare_and_swap_16(volatile signed __int128 *, signed __int128, signed __int128,...);
 _Bool __sync_bool_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+_Bool __sync_bool_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
 #endif
 forall(dtype T) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...);
 char __sync_val_compare_and_swap(volatile char *, char, char,...);
+char __sync_val_compare_and_swap_1(volatile char *, char, char,...);
 signed char __sync_val_compare_and_swap(volatile signed char *, signed char, signed char,...);
+signed char __sync_val_compare_and_swap_1(volatile signed char *, signed char, signed char,...);
 unsigned char __sync_val_compare_and_swap(volatile unsigned char *, unsigned char, unsigned char,...);
+unsigned char __sync_val_compare_and_swap_1(volatile unsigned char *, unsigned char, unsigned char,...);
 signed short __sync_val_compare_and_swap(volatile signed short *, signed short, signed short,...);
+signed short __sync_val_compare_and_swap_2(volatile signed short *, signed short, signed short,...);
 unsigned short __sync_val_compare_and_swap(volatile unsigned short *, unsigned short, unsigned short,...);
+unsigned short __sync_val_compare_and_swap_2(volatile unsigned short *, unsigned short, unsigned short,...);
 signed int __sync_val_compare_and_swap(volatile signed int *, signed int, signed int,...);
+signed int __sync_val_compare_and_swap_4(volatile signed int *, signed int, signed int,...);
 unsigned int __sync_val_compare_and_swap(volatile unsigned int *, unsigned int, unsigned int,...);
+signed long int __sync_val_compare_and_swap(volatile signed long int *, signed long int, signed long int,...);
+unsigned long int __sync_val_compare_and_swap(volatile unsigned long int *, unsigned long int, unsigned long int,...);
+unsigned int __sync_val_compare_and_swap_4(volatile unsigned int *, unsigned int, unsigned int,...);
 signed long long int __sync_val_compare_and_swap(volatile signed long long int *, signed long long int, signed long long int,...);
+signed long long int __sync_val_compare_and_swap_8(volatile signed long long int *, signed long long int, signed long long int,...);
 unsigned long long int __sync_val_compare_and_swap(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+unsigned long long int __sync_val_compare_and_swap_8(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_val_compare_and_swap(volatile signed __int128 *, signed __int128, signed __int128,...);
+signed __int128 __sync_val_compare_and_swap_16(volatile signed __int128 *, signed __int128, signed __int128,...);
 unsigned __int128 __sync_val_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+unsigned __int128 __sync_val_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
 #endif
 forall(dtype T) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...);
 char __sync_lock_test_and_set(volatile char *, char,...);
+char __sync_lock_test_and_set_1(volatile char *, char,...);
 signed char __sync_lock_test_and_set(volatile signed char *, signed char,...);
+signed char __sync_lock_test_and_set_1(volatile signed char *, signed char,...);
 unsigned char __sync_lock_test_and_set(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_lock_test_and_set_1(volatile unsigned char *, unsigned char,...);
 signed short __sync_lock_test_and_set(volatile signed short *, signed short,...);
+signed short __sync_lock_test_and_set_2(volatile signed short *, signed short,...);
 unsigned short __sync_lock_test_and_set(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_lock_test_and_set_2(volatile unsigned short *, unsigned short,...);
 signed int __sync_lock_test_and_set(volatile signed int *, signed int,...);
+signed int __sync_lock_test_and_set_4(volatile signed int *, signed int,...);
 unsigned int __sync_lock_test_and_set(volatile unsigned int *, unsigned int,...);
+signed long int __sync_lock_test_and_set(volatile signed long int *, signed long int,...);
+unsigned long int __sync_lock_test_and_set(volatile unsigned long int *, unsigned long int,...);
+unsigned int __sync_lock_test_and_set_4(volatile unsigned int *, unsigned int,...);
 signed long long int __sync_lock_test_and_set(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_lock_test_and_set_8(volatile signed long long int *, signed long long int,...);
 unsigned long long int __sync_lock_test_and_set(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_lock_test_and_set_8(volatile unsigned long long int *, unsigned long long int,...);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __sync_lock_test_and_set(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_lock_test_and_set_16(volatile signed __int128 *, signed __int128,...);
 unsigned __int128 __sync_lock_test_and_set(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_lock_test_and_set_16(volatile unsigned __int128 *, unsigned __int128,...);
 #endif
 void __sync_lock_release(volatile char *,...);
+void __sync_lock_release_1(volatile char *,...);
 void __sync_lock_release(volatile signed char *,...);
+void __sync_lock_release_1(volatile signed char *,...);
 void __sync_lock_release(volatile unsigned char *,...);
+void __sync_lock_release_1(volatile unsigned char *,...);
 void __sync_lock_release(volatile signed short *,...);
+void __sync_lock_release_2(volatile signed short *,...);
 void __sync_lock_release(volatile unsigned short *,...);
+void __sync_lock_release_2(volatile unsigned short *,...);
 void __sync_lock_release(volatile signed int *,...);
+void __sync_lock_release_4(volatile signed int *,...);
 void __sync_lock_release(volatile unsigned int *,...);
+void __sync_lock_release(volatile signed long int *,...);
+void __sync_lock_release(volatile unsigned long int *,...);
+void __sync_lock_release_4(volatile unsigned int *,...);
 void __sync_lock_release(volatile signed long long int *,...);
+void __sync_lock_release_8(volatile signed long long int *,...);
 void __sync_lock_release(volatile unsigned long long int *,...);
+void __sync_lock_release_8(volatile unsigned long long int *,...);
 #if defined(__SIZEOF_INT128__)
 void __sync_lock_release(volatile signed __int128 *,...);
+void __sync_lock_release_16(volatile signed __int128 *,...);
 void __sync_lock_release(volatile unsigned __int128 *,...);
+void __sync_lock_release_16(volatile unsigned __int128 *,...);
 #endif
 …
 _Bool __atomic_test_and_set(volatile signed int *, int);
 _Bool __atomic_test_and_set(volatile unsigned int *, int);
-_Bool __atomic_test_and_set(volatile signed long int *, int);
-_Bool __atomic_test_and_set(volatile unsigned long int *, int);
 _Bool __atomic_test_and_set(volatile signed long long int *, int);
 _Bool __atomic_test_and_set(volatile unsigned long long int *, int);
 …
 void __atomic_clear(volatile signed int *, int);
 void __atomic_clear(volatile unsigned int *, int);
-void __atomic_clear(volatile signed long int *, int);
-void __atomic_clear(volatile unsigned long int *, int);
 void __atomic_clear(volatile signed long long int *, int);
 void __atomic_clear(volatile unsigned long long int *, int);
 …
 #endif
-_Bool __atomic_exchange_n(volatile _Bool *, _Bool, int);
-void __atomic_exchange(volatile _Bool *, volatile _Bool *, volatile _Bool *, int);
 char __atomic_exchange_n(volatile char *, char, int);
+char __atomic_exchange_1(volatile char *, char, int);
 void __atomic_exchange(volatile char *, volatile char *, volatile char *, int);
 signed char __atomic_exchange_n(volatile signed char *, signed char, int);
+signed char __atomic_exchange_1(volatile signed char *, signed char, int);
 void __atomic_exchange(volatile signed char *, volatile signed char *, volatile signed char *, int);
 unsigned char __atomic_exchange_n(volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_exchange_1(volatile unsigned char *, unsigned char, int);
 void __atomic_exchange(volatile unsigned char *, volatile unsigned char *, volatile unsigned char *, int);
 signed short __atomic_exchange_n(volatile signed short *, signed short, int);
+signed short __atomic_exchange_2(volatile signed short *, signed short, int);
 void __atomic_exchange(volatile signed short *, volatile signed short *, volatile signed short *, int);
 unsigned short __atomic_exchange_n(volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_exchange_2(volatile unsigned short *, unsigned short, int);
 void __atomic_exchange(volatile unsigned short *, volatile unsigned short *, volatile unsigned short *, int);
 signed int __atomic_exchange_n(volatile signed int *, signed int, int);
+signed int __atomic_exchange_4(volatile signed int *, signed int, int);
 void __atomic_exchange(volatile signed int *, volatile signed int *, volatile signed int *, int);
 unsigned int __atomic_exchange_n(volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_exchange_4(volatile unsigned int *, unsigned int, int);
 void __atomic_exchange(volatile unsigned int *, volatile unsigned int *, volatile unsigned int *, int);
-signed long int __atomic_exchange_n(volatile signed long int *, signed long int, int);
-void __atomic_exchange(volatile signed long int *, volatile signed long int *, volatile signed long int *, int);
-unsigned long int __atomic_exchange_n(volatile unsigned long int *, unsigned long int, int);
-void __atomic_exchange(volatile unsigned long int *, volatile unsigned long int *, volatile unsigned long int *, int);
 signed long long int __atomic_exchange_n(volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_exchange_8(volatile signed long long int *, signed long long int, int);
 void __atomic_exchange(volatile signed long long int *, volatile signed long long int *, volatile signed long long int *, int);
 unsigned long long int __atomic_exchange_n(volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_exchange_8(volatile unsigned long long int *, unsigned long long int, int);
 void __atomic_exchange(volatile unsigned long long int *, volatile unsigned long long int *, volatile unsigned long long int *, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_exchange_n(volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_exchange_16(volatile signed __int128 *, signed __int128, int);
 void __atomic_exchange(volatile signed __int128 *, volatile signed __int128 *, volatile signed __int128 *, int);
 unsigned __int128 __atomic_exchange_n(volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_exchange_16(volatile unsigned __int128 *, unsigned __int128, int);
 void __atomic_exchange(volatile unsigned __int128 *, volatile unsigned __int128 *, volatile unsigned __int128 *, int);
 #endif
 …
 void __atomic_load(const volatile _Bool *, volatile _Bool *, int);
 char __atomic_load_n(const volatile char *, int);
+char __atomic_load_1(const volatile char *, int);
 void __atomic_load(const volatile char *, volatile char *, int);
 signed char __atomic_load_n(const volatile signed char *, int);
+signed char __atomic_load_1(const volatile signed char *, int);
 void __atomic_load(const volatile signed char *, volatile signed char *, int);
 unsigned char __atomic_load_n(const volatile unsigned char *, int);
+unsigned char __atomic_load_1(const volatile unsigned char *, int);
 void __atomic_load(const volatile unsigned char *, volatile unsigned char *, int);
 signed short __atomic_load_n(const volatile signed short *, int);
+signed short __atomic_load_2(const volatile signed short *, int);
 void __atomic_load(const volatile signed short *, volatile signed short *, int);
 unsigned short __atomic_load_n(const volatile unsigned short *, int);
+unsigned short __atomic_load_2(const volatile unsigned short *, int);
 void __atomic_load(const volatile unsigned short *, volatile unsigned short *, int);
 signed int __atomic_load_n(const volatile signed int *, int);
+signed int __atomic_load_4(const volatile signed int *, int);
 void __atomic_load(const volatile signed int *, volatile signed int *, int);
 unsigned int __atomic_load_n(const volatile unsigned int *, int);
+unsigned int __atomic_load_4(const volatile unsigned int *, int);
 void __atomic_load(const volatile unsigned int *, volatile unsigned int *, int);
-signed long int __atomic_load_n(const volatile signed long int *, int);
-void __atomic_load(const volatile signed long int *, volatile signed long int *, int);
-unsigned long int __atomic_load_n(const volatile unsigned long int *, int);
-void __atomic_load(const volatile unsigned long int *, volatile unsigned long int *, int);
 signed long long int __atomic_load_n(const volatile signed long long int *, int);
+signed long long int __atomic_load_8(const volatile signed long long int *, int);
 void __atomic_load(const volatile signed long long int *, volatile signed long long int *, int);
 unsigned long long int __atomic_load_n(const volatile unsigned long long int *, int);
+unsigned long long int __atomic_load_8(const volatile unsigned long long int *, int);
 void __atomic_load(const volatile unsigned long long int *, volatile unsigned long long int *, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_load_n(const volatile signed __int128 *, int);
+signed __int128 __atomic_load_16(const volatile signed __int128 *, int);
 void __atomic_load(const volatile signed __int128 *, volatile signed __int128 *, int);
 unsigned __int128 __atomic_load_n(const volatile unsigned __int128 *, int);
+unsigned __int128 __atomic_load_16(const volatile unsigned __int128 *, int);
 void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int);
 #endif
 …
 _Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile char *, char *, char, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile char *, char *, char *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile signed char *, signed char *, signed char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile signed char *, signed char *, signed char, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile signed char *, signed char *, signed char *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile unsigned char *, unsigned char *, unsigned char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile unsigned char *, unsigned char *, unsigned char, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile unsigned char *, unsigned char *, unsigned char *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile signed short *, signed short *, signed short, _Bool, int, int);
+_Bool __atomic_compare_exchange_2(volatile signed short *, signed short *, signed short, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile signed short *, signed short *, signed short *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile unsigned short *, unsigned short *, unsigned short, _Bool, int, int);
+_Bool __atomic_compare_exchange_2(volatile unsigned short *, unsigned short *, unsigned short, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile unsigned short *, unsigned short *, unsigned short *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile signed int *, signed int *, signed int, _Bool, int, int);
+_Bool __atomic_compare_exchange_4(volatile signed int *, signed int *, signed int, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile signed int *, signed int *, signed int *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile unsigned int *, unsigned int *, unsigned int, _Bool, int, int);
+_Bool __atomic_compare_exchange_4(volatile unsigned int *, unsigned int *, unsigned int, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile unsigned int *, unsigned int *, unsigned int *, _Bool, int, int);
-_Bool __atomic_compare_exchange_n(volatile signed long int *, signed long int *, signed long int, _Bool, int, int);
-_Bool __atomic_compare_exchange  (volatile signed long int *, signed long int *, signed long int *, _Bool, int, int);
-_Bool __atomic_compare_exchange_n(volatile unsigned long int *, unsigned long int *, unsigned long int, _Bool, int, int);
-_Bool __atomic_compare_exchange  (volatile unsigned long int *, unsigned long int *, unsigned long int *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile signed long long int *, signed long long int *, signed long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange_8(volatile signed long long int *, signed long long int *, signed long long int, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile signed long long int *, signed long long int *, signed long long int *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n(volatile unsigned long long int *, unsigned long long int *, unsigned long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange_8(volatile unsigned long long int *, unsigned long long int *, unsigned long long int, _Bool, int, int);
 _Bool __atomic_compare_exchange  (volatile unsigned long long int *, unsigned long long int *, unsigned long long int *, _Bool, int, int);
 #if defined(__SIZEOF_INT128__)
 _Bool __atomic_compare_exchange_n (volatile signed __int128 *, signed __int128 *, signed __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange_16(volatile signed __int128 *, signed __int128 *, signed __int128, _Bool, int, int);
 _Bool __atomic_compare_exchange   (volatile signed __int128 *, signed __int128 *, signed __int128 *, _Bool, int, int);
 _Bool __atomic_compare_exchange_n (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange_16(volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128, _Bool, int, int);
 _Bool __atomic_compare_exchange   (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int);
 #endif
 …
 void __atomic_store(volatile _Bool *, _Bool *, int);
 void __atomic_store_n(volatile char *, char, int);
+void __atomic_store_1(volatile char *, char, int);
 void __atomic_store(volatile char *, char *, int);
 void __atomic_store_n(volatile signed char *, signed char, int);
+void __atomic_store_1(volatile signed char *, signed char, int);
 void __atomic_store(volatile signed char *, signed char *, int);
 void __atomic_store_n(volatile unsigned char *, unsigned char, int);
+void __atomic_store_1(volatile unsigned char *, unsigned char, int);
 void __atomic_store(volatile unsigned char *, unsigned char *, int);
 void __atomic_store_n(volatile signed short *, signed short, int);
+void __atomic_store_2(volatile signed short *, signed short, int);
 void __atomic_store(volatile signed short *, signed short *, int);
 void __atomic_store_n(volatile unsigned short *, unsigned short, int);
+void __atomic_store_2(volatile unsigned short *, unsigned short, int);
 void __atomic_store(volatile unsigned short *, unsigned short *, int);
 void __atomic_store_n(volatile signed int *, signed int, int);
+void __atomic_store_4(volatile signed int *, signed int, int);
 void __atomic_store(volatile signed int *, signed int *, int);
 void __atomic_store_n(volatile unsigned int *, unsigned int, int);
+void __atomic_store_4(volatile unsigned int *, unsigned int, int);
 void __atomic_store(volatile unsigned int *, unsigned int *, int);
-void __atomic_store_n(volatile signed long int *, signed long int, int);
-void __atomic_store(volatile signed long int *, signed long int *, int);
-void __atomic_store_n(volatile unsigned long int *, unsigned long int, int);
-void __atomic_store(volatile unsigned long int *, unsigned long int *, int);
 void __atomic_store_n(volatile signed long long int *, signed long long int, int);
+void __atomic_store_8(volatile signed long long int *, signed long long int, int);
 void __atomic_store(volatile signed long long int *, signed long long int *, int);
 void __atomic_store_n(volatile unsigned long long int *, unsigned long long int, int);
+void __atomic_store_8(volatile unsigned long long int *, unsigned long long int, int);
 void __atomic_store(volatile unsigned long long int *, unsigned long long int *, int);
 #if defined(__SIZEOF_INT128__)
 void __atomic_store_n(volatile signed __int128 *, signed __int128, int);
+void __atomic_store_16(volatile signed __int128 *, signed __int128, int);
 void __atomic_store(volatile signed __int128 *, signed __int128 *, int);
 void __atomic_store_n(volatile unsigned __int128 *, unsigned __int128, int);
+void __atomic_store_16(volatile unsigned __int128 *, unsigned __int128, int);
 void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int);
 #endif
 …
 char __atomic_add_fetch  (volatile char *, char, int);
+char __atomic_add_fetch_1(volatile char *, char, int);
 signed char __atomic_add_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_add_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_add_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_add_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_add_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_add_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_add_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_add_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_add_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_add_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_add_fetch  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_add_fetch  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_add_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_add_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_add_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_add_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_add_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_add_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_add_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_add_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_add_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_add_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_sub_fetch  (volatile char *, char, int);
+char __atomic_sub_fetch_1(volatile char *, char, int);
 signed char __atomic_sub_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_sub_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_sub_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_sub_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_sub_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_sub_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_sub_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_sub_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_sub_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_sub_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_sub_fetch  (volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_sub_fetch  (volatile signed long int *, signed long int, int);
+unsigned long long int __atomic_sub_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_sub_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_sub_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_sub_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_sub_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_sub_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_sub_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_sub_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_sub_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_sub_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_and_fetch  (volatile char *, char, int);
+char __atomic_and_fetch_1(volatile char *, char, int);
 signed char __atomic_and_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_and_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_and_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_and_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_and_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_and_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_and_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_and_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_and_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_and_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_and_fetch  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_and_fetch  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_and_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_and_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_and_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_and_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_and_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_and_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_and_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_and_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_and_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_and_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_nand_fetch  (volatile char *, char, int);
+char __atomic_nand_fetch_1(volatile char *, char, int);
 signed char __atomic_nand_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_nand_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_nand_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_nand_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_nand_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_nand_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_nand_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_nand_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_nand_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_nand_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_nand_fetch  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_nand_fetch  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_nand_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_nand_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_nand_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_nand_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_nand_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_nand_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_nand_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_nand_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_nand_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_nand_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_xor_fetch  (volatile char *, char, int);
+char __atomic_xor_fetch_1(volatile char *, char, int);
 signed char __atomic_xor_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_xor_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_xor_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_xor_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_xor_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_xor_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_xor_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_xor_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_xor_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_xor_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_xor_fetch  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_xor_fetch  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_xor_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_xor_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_xor_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_xor_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_xor_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_xor_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_xor_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_xor_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_xor_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_xor_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_or_fetch  (volatile char *, char, int);
+char __atomic_or_fetch_1(volatile char *, char, int);
 signed char __atomic_or_fetch  (volatile signed char *, signed char, int);
+signed char __atomic_or_fetch_1(volatile signed char *, signed char, int);
 unsigned char __atomic_or_fetch  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_or_fetch_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_or_fetch  (volatile signed short *, signed short, int);
+signed short __atomic_or_fetch_2(volatile signed short *, signed short, int);
 unsigned short __atomic_or_fetch  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_or_fetch_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_or_fetch  (volatile signed int *, signed int, int);
+signed int __atomic_or_fetch_4(volatile signed int *, signed int, int);
 unsigned int __atomic_or_fetch  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_or_fetch  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_or_fetch  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_or_fetch_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_or_fetch  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_or_fetch_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_or_fetch  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_or_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_or_fetch   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_or_fetch_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_or_fetch   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_or_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_add  (volatile char *, char, int);
+char __atomic_fetch_add_1(volatile char *, char, int);
 signed char __atomic_fetch_add  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_add_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_add  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_add_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_add  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_add_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_add  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_add_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_add  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_add_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_add  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_add  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_add  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_add_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_add  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_add_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_add  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_add_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_add   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_add_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_add   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_add_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_sub  (volatile char *, char, int);
+char __atomic_fetch_sub_1(volatile char *, char, int);
 signed char __atomic_fetch_sub  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_sub_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_sub  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_sub_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_sub  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_sub_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_sub  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_sub_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_sub  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_sub_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_sub  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_sub  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_sub  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_sub_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_sub  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_sub_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_sub  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_sub_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_sub   (volatile signed  __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_sub_16(volatile signed  __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_sub   (volatile unsigned  __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_sub_16(volatile unsigned  __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_and  (volatile char *, char, int);
+char __atomic_fetch_and_1(volatile char *, char, int);
 signed char __atomic_fetch_and  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_and_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_and  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_and_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_and  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_and_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_and  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_and_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_and  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_and_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_and  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_and  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_and  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_and_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_and  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_and_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_and  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_and_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_and   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_and_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_and   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_and_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_nand  (volatile char *, char, int);
+char __atomic_fetch_nand_1(volatile char *, char, int);
 signed char __atomic_fetch_nand  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_nand_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_nand  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_nand_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_nand  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_nand_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_nand  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_nand_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_nand  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_nand_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_nand  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_nand  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_nand  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_nand_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_nand  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_nand_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_nand  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_nand_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_nand   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_nand_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_nand   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_nand_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_xor  (volatile char *, char, int);
+char __atomic_fetch_xor_1(volatile char *, char, int);
 signed char __atomic_fetch_xor  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_xor_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_xor  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_xor_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_xor  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_xor_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_xor  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_xor_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_xor  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_xor_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_xor  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_xor  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_xor  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_xor_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_xor  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_xor_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_xor  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_xor_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_xor   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_xor_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_xor   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_xor_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif
 char __atomic_fetch_or  (volatile char *, char, int);
+char __atomic_fetch_or_1(volatile char *, char, int);
 signed char __atomic_fetch_or  (volatile signed char *, signed char, int);
+signed char __atomic_fetch_or_1(volatile signed char *, signed char, int);
 unsigned char __atomic_fetch_or  (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_or_1(volatile unsigned char *, unsigned char, int);
 signed short __atomic_fetch_or  (volatile signed short *, signed short, int);
+signed short __atomic_fetch_or_2(volatile signed short *, signed short, int);
 unsigned short __atomic_fetch_or  (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_or_2(volatile unsigned short *, unsigned short, int);
 signed int __atomic_fetch_or  (volatile signed int *, signed int, int);
+signed int __atomic_fetch_or_4(volatile signed int *, signed int, int);
 unsigned int __atomic_fetch_or  (volatile unsigned int *, unsigned int, int);
+signed long int __atomic_fetch_or  (volatile signed long int *, signed long int, int);
+unsigned long int __atomic_fetch_or  (volatile unsigned long int *, unsigned long int, int);
+unsigned int __atomic_fetch_or_4(volatile unsigned int *, unsigned int, int);
 signed long long int __atomic_fetch_or  (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_or_8(volatile signed long long int *, signed long long int, int);
 unsigned long long int __atomic_fetch_or  (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_or_8(volatile unsigned long long int *, unsigned long long int, int);
 #if defined(__SIZEOF_INT128__)
 signed __int128 __atomic_fetch_or   (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_or_16(volatile signed __int128 *, signed __int128, int);
 unsigned __int128 __atomic_fetch_or   (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_or_16(volatile unsigned __int128 *, unsigned __int128, int);
 #endif

libcfa/src/Makefile.am

-              r3d5701e
+              r9fb8f01
 # use -no-include-stdhdr to prevent rebuild cycles
 # The built sources must not depend on the installed headers
 AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
+AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb)  @CONFIG_CFAFLAGS@
+AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
 CFACC = @CFACC@
 …
 # add dependency of cfa files
 libobjs = $(addsuffix .lo, $(basename $(filter %.cfa,$(libsrc))))
 $(libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
+$(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
 thread_libobjs = $(addsuffix .lo, $(basename $(filter %.cfa,$(thread_libsrc))))
 $(thread_libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
+$(thread_libobjs) : @CFACC@ @CFACPP@ prelude.cfa
 …
+if ENABLE_DISTCC
+prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
+        ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
+../prelude/distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ ../prelude/gcc-builtins.cf ../prelude/builtins.cf ../prelude/extras.cf ../prelude/prelude.cfa ../prelude/bootloader.c $(srcdir)/../../tools/build/push2dist.sh
+        @+make -C ../prelude distribution
+prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
+        ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
+        $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
-prelude.o prelude.lo $(libobjs) $(thread_libobjs) : ../prelude/distribution
-endif ENABLE_DISTCC
-prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
-        ${AM_V_GEN}$(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
-prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
-        ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
-        $(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/Makefile.in

-              r3d5701e
+              r9fb8f01
 CFACC = @CFACC@
 CFACPP = @CFACPP@
-CFADIR_HASH = @CFADIR_HASH@
 CFA_BINDIR = @CFA_BINDIR@
 CFA_INCDIR = @CFA_INCDIR@
 …
 LIPO = @LIPO@
 LN_S = @LN_S@
-LOCAL_CC1 = @LOCAL_CC1@
-LOCAL_CFACC = @LOCAL_CFACC@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 …
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
-AM_V_RUST = $(am__v_RUST_@AM_V@)
-am__v_RUST_ = $(am__v_RUST_@AM_DEFAULT_V@)
-am__v_RUST_0 = @echo "  RUST     " $@;
-am__v_RUST_1 =
-AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
-am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS     " $@;
-am__v_NODEJS_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =
 lib_LTLIBRARIES = libcfa.la libcfathread.la
 gdbwaittarget = ""
 …
 # use -no-include-stdhdr to prevent rebuild cycles
 # The built sources must not depend on the installed headers
 AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@
 AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@
+AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb)  @CONFIG_CFAFLAGS@
+AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
 AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
 @BUILDLIB_FALSE@headers_nosrc =
 …
         $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
         $(am__mv) $$depbase.Tpo $$depbase.Plo
 $(libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
 $(thread_libobjs) : @LOCAL_CFACC@ @CFACPP@ prelude.cfa
+$(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
+$(thread_libobjs) : @CFACC@ @CFACPP@ prelude.cfa
 -include $(libdeps)
 …
 -include $(thread_libdeps)
+@ENABLE_DISTCC_TRUE@../prelude/distribution: @LOCAL_CFACC@ @LOCAL_CC1@ @CFACPP@ ../prelude/gcc-builtins.cf ../prelude/builtins.cf ../prelude/extras.cf ../prelude/prelude.cfa ../prelude/bootloader.c $(srcdir)/../../tools/build/push2dist.sh
+@ENABLE_DISTCC_TRUE@    @+make -C ../prelude distribution
+@ENABLE_DISTCC_TRUE@prelude.o prelude.lo $(libobjs) $(thread_libobjs) : ../prelude/distribution
+prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
+        ${AM_V_GEN}$(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @LOCAL_CFACC@ @CFACPP@
+prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
+        ${AM_V_GEN}$(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
+prelude.lo: prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
         ${AM_V_GEN}$(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile \
         $(CFACOMPILE) -quiet -XCFA -l ${<} -c -o ${@}
+        $(CFACOMPILE) -quiet -in-tree -XCFA -l ${<} -c -o ${@}
 #----------------------------------------------------------------------------------------------------------------

libcfa/src/assert.cfa

-              r3d5701e
+              r9fb8f01
 // 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 Jul 20 15:10:26 2017
+// Update Count     : 2
 //
 …
 #include <stdarg.h>                                                             // varargs
 #include <stdio.h>                                                              // fprintf
-#include <unistd.h>                                                             // STDERR_FILENO
 #include "bits/debug.hfa"
 …
         // called by macro assert in assert.h
         void __assert_fail( const char assertion[], const char file[], unsigned int line, const char function[] ) {
                 __cfaabi_bits_print_safe( STDERR_FILENO, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
+        void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
+                __cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
                 abort();
+        }
         // called by macro assertf
         void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) {
                 __cfaabi_bits_acquire();
                 __cfaabi_bits_print_nolock( STDERR_FILENO, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
+        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
+                __cfaabi_dbg_bits_acquire();
+                __cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
                 va_list args;
                 va_start( args, fmt );
                 __cfaabi_bits_print_vararg( STDERR_FILENO, fmt, args );
+                __cfaabi_dbg_bits_print_vararg( fmt, args );
                 va_end( args );
                 __cfaabi_bits_print_nolock( STDERR_FILENO, "\n" );
                 __cfaabi_bits_release();
+                __cfaabi_dbg_bits_print_nolock( "\n" );
+                __cfaabi_dbg_bits_release();
                 abort();
+        }

libcfa/src/bits/align.hfa

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

libcfa/src/bits/containers.hfa

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

libcfa/src/bits/debug.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Jul 14 22:17:35 2019
+// Update Count     : 4
 //
 …
 extern "C" {
+        void __cfaabi_bits_write( int fd, const char in_buffer[], int len ) {
+        void __cfaabi_dbg_bits_write( const char *in_buffer, int len ) {
                 // ensure all data is written
                 for ( int count = 0, retcode; count < len; count += retcode ) {
 …
                         for ( ;; ) {
                                 retcode = write( fd, in_buffer, len - count );
+                                retcode = write( STDERR_FILENO, in_buffer, len - count );
                                 // not a timer interrupt ?
 …
+        }
         void __cfaabi_bits_acquire() __attribute__((__weak__)) {}
         void __cfaabi_bits_release() __attribute__((__weak__)) {}
+        void __cfaabi_dbg_bits_acquire() __attribute__((__weak__)) {}
+        void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {}
         void __cfaabi_bits_print_safe  ( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) )) {
+        void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
                 va_list args;
                 va_start( args, fmt );
                 __cfaabi_bits_acquire();
+                __cfaabi_dbg_bits_acquire();
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_bits_write( fd, buffer, len );
+                __cfaabi_dbg_bits_write( buffer, len );
                 __cfaabi_bits_release();
+                __cfaabi_dbg_bits_release();
                 va_end( args );
+        }
         void __cfaabi_bits_print_nolock( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) )) {
+        void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
                 va_list args;
 …
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_bits_write( fd, buffer, len );
+                __cfaabi_dbg_bits_write( buffer, len );
                 va_end( args );
+        }
         void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list args ) {
+        void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list args ) {
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __cfaabi_bits_write( fd, buffer, len );
+                __cfaabi_dbg_bits_write( buffer, len );
+        }
         void __cfaabi_bits_print_buffer( int fd, char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) )) {
+        void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) )) {
                 va_list args;
 …
                 int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
                 __cfaabi_bits_write( fd, in_buffer, len );
+                __cfaabi_dbg_bits_write( in_buffer, len );
                 va_end( args );

libcfa/src/bits/debug.hfa

-              r3d5701e
+              r9fb8f01
 // 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 Feb  8 12:35:19 2018
+// Update Count     : 2
 //
 …
         #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_acquire();
         extern void __cfaabi_bits_release();
         extern void __cfaabi_bits_print_safe  ( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) ));
         extern void __cfaabi_bits_print_nolock( int fd, const char fmt[], ... ) __attribute__(( format(printf, 2, 3) ));
         extern void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list arg );
         extern void __cfaabi_bits_print_buffer( int fd, char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) ));
+      extern void __cfaabi_dbg_bits_write( const char *buffer, int len );
+      extern void __cfaabi_dbg_bits_acquire();
+      extern void __cfaabi_dbg_bits_release();
+      extern void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list arg );
+      extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) ));
 #ifdef __cforall
+}
 …
 #ifdef __CFA_DEBUG_PRINT__
         #define __cfaabi_dbg_write( buffer, len )         __cfaabi_bits_write( STDERR_FILENO, buffer, len )
         #define __cfaabi_dbg_acquire()                    __cfaabi_bits_acquire()
         #define __cfaabi_dbg_release()                    __cfaabi_bits_release()
         #define __cfaabi_dbg_print_safe(...)              __cfaabi_bits_print_safe   (__VA_ARGS__)
         #define __cfaabi_dbg_print_nolock(...)            __cfaabi_bits_print_nolock (__VA_ARGS__)
         #define __cfaabi_dbg_print_buffer(...)            __cfaabi_bits_print_buffer (__VA_ARGS__)
         #define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len );
         #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_write( __dbg_text, __dbg_len );
+        #define __cfaabi_dbg_write( buffer, len )         __cfaabi_dbg_bits_write( buffer, len )
+        #define __cfaabi_dbg_acquire()                    __cfaabi_dbg_bits_acquire()
+        #define __cfaabi_dbg_release()                    __cfaabi_dbg_bits_release()
+        #define __cfaabi_dbg_print_safe(...)              __cfaabi_dbg_bits_print_safe   (__VA_ARGS__)
+        #define __cfaabi_dbg_print_nolock(...)            __cfaabi_dbg_bits_print_nolock (__VA_ARGS__)
+        #define __cfaabi_dbg_print_buffer(...)            __cfaabi_dbg_bits_print_buffer (__VA_ARGS__)
+        #define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
+        #define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
 #else
         #define __cfaabi_dbg_write(...)               ((void)0)

libcfa/src/bits/defs.hfa

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

libcfa/src/bits/locks.hfa

-              r3d5701e
+              r9fb8f01
 // 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)
                 #endif
+        }
+        extern void yield( unsigned int );
         static inline void ?{}( __spinlock_t & this ) {
 …
         // Lock the spinlock, return false if already acquired
         static inline bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-                disable_interrupts();
                 bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
                 if( result ) {
+                        disable_interrupts();
                         __cfaabi_dbg_record( this, caller );
-                } else {
-                        enable_interrupts_noPoll();
+                }
                 return result;
 …
                 #endif
-                disable_interrupts();
                 for ( unsigned int i = 1;; i += 1 ) {
                         if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
 …
                         #endif
+                }
+                disable_interrupts();
                 __cfaabi_dbg_record( this, caller );
+        }
         static inline void unlock( __spinlock_t & this ) {
+                enable_interrupts_noPoll();
                 __atomic_clear( &this.lock, __ATOMIC_RELEASE );
-                enable_interrupts_noPoll();
+        }

libcfa/src/bits/signal.hfa

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

libcfa/src/clock.hfa

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

libcfa/src/concurrency/CtxSwitch-arm.S

-              r3d5701e
+              r9fb8f01
         .text
         .align  2
         .global __cfactx_switch
         .type   __cfactx_switch, %function
+        .global CtxSwitch
+        .type   CtxSwitch, %function
 __cfactx_switch:
+CtxSwitch:
         @ save callee-saved registers: r4-r8, r10, r11, r13(sp) (plus r9 depending on platform specification)
         @ I've seen reference to 31 registers on 64-bit, if this is the case, more need to be saved
 …
         mov r15, r14
         #endif // R9_SPECIAL
         .text
         .align  2
         .global __cfactx_invoke_stub
         .type   __cfactx_invoke_stub, %function
+        .global CtxInvokeStub
+        .type   CtxInvokeStub, %function
 __cfactx_invoke_stub:
+CtxInvokeStub:
         ldmfd r13!, {r0-r1}
         mov r15, r1

libcfa/src/concurrency/CtxSwitch-i386.S

-              r3d5701e
+              r9fb8f01
         .text
         .align 2
         .globl __cfactx_switch
         .type  __cfactx_switch, @function
 __cfactx_switch:
+        .globl CtxSwitch
+        .type  CtxSwitch, @function
+CtxSwitch:
         // Copy the "from" context argument from the stack to register eax
 …
         ret
         .size  __cfactx_switch, .-__cfactx_switch
+        .size  CtxSwitch, .-CtxSwitch
 // Local Variables: //

libcfa/src/concurrency/CtxSwitch-x86_64.S

-              r3d5701e
+              r9fb8f01
         .text
         .align 2
         .globl __cfactx_switch
         .type  __cfactx_switch, @function
 __cfactx_switch:
+        .globl CtxSwitch
+        .type  CtxSwitch, @function
+CtxSwitch:
         // Save volatile registers on the stack.
 …
         ret
         .size  __cfactx_switch, .-__cfactx_switch
+        .size  CtxSwitch, .-CtxSwitch
 //-----------------------------------------------------------------------------
 …
         .text
         .align 2
         .globl __cfactx_invoke_stub
         .type    __cfactx_invoke_stub, @function
 __cfactx_invoke_stub:
+        .globl CtxInvokeStub
+        .type    CtxInvokeStub, @function
+CtxInvokeStub:
         movq %rbx, %rdi
+        movq %r12, %rsi
+        jmp *%r13
+        .size  __cfactx_invoke_stub, .-__cfactx_invoke_stub
+        jmp *%r12
+        .size  CtxInvokeStub, .-CtxInvokeStub
 // Local Variables: //

libcfa/src/concurrency/alarm.cfa

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

libcfa/src/concurrency/alarm.hfa

-              r3d5701e
+              r9fb8f01
 #include "time.hfa"
 struct $thread;
+struct thread_desc;
 struct processor;
 …
         union {
                 $thread * thrd; // thrd who created event
+                thread_desc * thrd;     // thrd who created event
                 processor * proc;               // proc who created event
         };
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );

libcfa/src/concurrency/coroutine.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Fri Mar 30 17:20:57 2018
+// Update Count     : 9
 //
 …
 extern "C" {
         void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
 …
+}
 void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
+void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) {
+        (this.context){NULL, NULL};
         (this.stack){storage, storageSize};
         this.name = name;
         state = Start;
         starter = 0p;
         last = 0p;
         cancellation = 0p;
+}
 void ^?{}($coroutine& this) {
+        starter = NULL;
+        last = NULL;
+        cancellation = NULL;
+}
+void ^?{}(coroutine_desc& this) {
         if(this.state != Halted && this.state != Start && this.state != Primed) {
                 $coroutine * src = TL_GET( this_thread )->curr_cor;
                 $coroutine * dst = &this;
+                coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+                coroutine_desc * dst = &this;
                 struct _Unwind_Exception storage;
 …
+                }
                 $ctx_switch( src, dst );
+                CoroutineCtxSwitch( src, dst );
+        }
+}
 …
 forall(dtype T | is_coroutine(T))
 void prime(T& cor) {
         $coroutine* this = get_coroutine(cor);
+        coroutine_desc* this = get_coroutine(cor);
         assert(this->state == Start);
 …
 [void *, size_t] __stack_alloc( size_t storageSize ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
+        static const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
         assert(__page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
 …
 void __stack_prepare( __stack_info_t * this, size_t create_size ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
+        static const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
         bool userStack;
         void * storage;
 …
 // is not inline (We can't inline Cforall in C)
 extern "C" {
+        void __cfactx_cor_leave( struct $coroutine * src ) {
+                $coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
+        void __suspend_internal(void) {
+                suspend();
+        }
+        void __leave_coroutine( coroutine_desc * src ) {
+                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
                 src->state = Halted;
 …
                         src->name, src, starter->name, starter );
+                $ctx_switch( src, starter );
+        }
+        struct $coroutine * __cfactx_cor_finish(void) {
+                struct $coroutine * cor = kernelTLS.this_thread->curr_cor;
+                if(cor->state == Primed) {
+                        suspend();
+                }
+                cor->state = Active;
+                return cor;
+                CoroutineCtxSwitch( src, starter );
+        }
+}

libcfa/src/concurrency/coroutine.hfa

-              r3d5701e
+              r9fb8f01
 // 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 : Fri Jun 21 17:49:39 2019
+// Update Count     : 9
 //
 …
 trait is_coroutine(dtype T) {
       void main(T & this);
       $coroutine * get_coroutine(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 #define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 //-----------------------------------------------------------------------------
 …
 // void ^?{}( coStack_t & this );
 void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
 void ^?{}( $coroutine & this );
+void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
+void ^?{}( coroutine_desc & this );
 static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
 static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
 static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
 static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
 static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", NULL, 0 }; }
+static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", NULL, stackSize }; }
+static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
+static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, NULL, 0 }; }
+static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, NULL, stackSize }; }
 //-----------------------------------------------------------------------------
 …
 void prime(T & cor);
 static inline struct $coroutine * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
 //-----------------------------------------------------------------------------
 …
 // Start coroutine routines
 extern "C" {
+        void __cfactx_invoke_coroutine(void (*main)(void *), void * this);
+      forall(dtype T | is_coroutine(T))
+      void CtxInvokeCoroutine(T * this);
         forall(dtype T)
         void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+      forall(dtype T | is_coroutine(T))
+      void CtxStart(T * this, void ( *invoke)(T *));
         extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
+        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
         extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
+        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+}
 // Private wrappers for context switch and stack creation
 // Wrapper for co
 static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
+static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
 …
         // context switch to specified coroutine
         verify( dst->context.SP );
         __cfactx_switch( &src->context, &dst->context );
         // when __cfactx_switch returns we are back in the src coroutine
+        CtxSwitch( &src->context, &dst->context );
+        // when CtxSwitch returns we are back in the src coroutine
         // set state of new coroutine to active
         src->state = Active;
         if( unlikely(src->cancellation != 0p) ) {
                 __cfactx_coroutine_unwind(src->cancellation, src);
+        if( unlikely(src->cancellation != NULL) ) {
+                _CtxCoroutine_Unwind(src->cancellation, src);
+        }
+}
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         $coroutine * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
         assertf( src->last != 0,
 …
                 src->name, src, src->last->name, src->last );
         $ctx_switch( src, src->last );
+        CoroutineCtxSwitch( src, src->last );
+}
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         $coroutine * src = TL_GET( this_thread )->curr_cor;
         $coroutine * dst = get_coroutine(cor);
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * dst = get_coroutine(cor);
+        if( unlikely(dst->context.SP == 0p) ) {
+                TL_GET( this_thread )->curr_cor = dst;
+        if( unlikely(dst->context.SP == NULL) ) {
                 __stack_prepare(&dst->stack, 65000);
+                __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
+                TL_GET( this_thread )->curr_cor = src;
+                CtxStart(&cor, CtxInvokeCoroutine);
+        }
 …
         // always done for performance testing
         $ctx_switch( src, dst );
+        CoroutineCtxSwitch( src, dst );
         return cor;
+}
 static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
+static inline void resume(coroutine_desc * dst) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if
 …
         // will also migrate which means this value will
         // stay in syn with the TLS
         $coroutine * src = TL_GET( this_thread )->curr_cor;
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
         // not resuming self ?
 …
         // always done for performance testing
         $ctx_switch( src, dst );
+        CoroutineCtxSwitch( src, dst );
+}

libcfa/src/concurrency/invoke.c

-              r3d5701e
+              r9fb8f01
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 extern struct $coroutine * __cfactx_cor_finish(void);
 extern void __cfactx_cor_leave ( struct $coroutine * );
 extern void __cfactx_thrd_leave();
+extern void __suspend_internal(void);
+extern void __leave_coroutine( struct coroutine_desc * );
+extern void __finish_creation( struct thread_desc * );
+extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
 void __cfactx_invoke_coroutine(
+void CtxInvokeCoroutine(
         void (*main)(void *),
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
+        // Finish setting up the coroutine by setting its state
+        struct $coroutine * cor = __cfactx_cor_finish();
+        struct coroutine_desc* cor = get_coroutine( this );
+        // Call the main of the coroutine
+        if(cor->state == Primed) {
+                __suspend_internal();
+        }
+        cor->state = Active;
         main( this );
         //Final suspend, should never return
         __cfactx_cor_leave( cor );
+        __leave_coroutine( cor );
         __cabi_abort( "Resumed dead coroutine" );
+}
 static _Unwind_Reason_Code __cfactx_coroutine_unwindstop(
+static _Unwind_Reason_Code _CtxCoroutine_UnwindStop(
         __attribute((__unused__)) int version,
         _Unwind_Action actions,
 …
                 // We finished unwinding the coroutine,
                 // leave it
                 __cfactx_cor_leave( param );
+                __leave_coroutine( param );
                 __cabi_abort( "Resumed dead coroutine" );
+        }
 …
+}
 void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__));
 void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) {
         _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) __attribute__ ((__noreturn__));
+void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) {
+        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, cor );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
+}
+void __cfactx_invoke_thread(
+void CtxInvokeThread(
+        void (*dtor)(void *),
         void (*main)(void *),
+        struct thread_desc *(*get_thread)(void *),
         void *this
 ) {
+        // Fetch the thread handle from the user defined thread structure
+        struct thread_desc* thrd = get_thread( this );
+        // First suspend, once the thread arrives here,
+        // the function pointer to main can be invalidated without risk
+        __finish_creation( thrd );
         // Officially start the thread by enabling preemption
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         // The order of these 4 operations is very important
         //Final suspend, should never return
         __cfactx_thrd_leave();
+        __leave_thread_monitor( thrd );
         __cabi_abort( "Resumed dead thread" );
+}
+void __cfactx_start(
+void CtxStart(
         void (*main)(void *),
         struct $coroutine * cor,
+        struct coroutine_desc *(*get_coroutine)(void *),
         void *this,
         void (*invoke)(void *)
 ) {
+        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 …
         fs->dummyReturn = NULL;
+        fs->argument[0] = main;     // argument to invoke
+        fs->argument[1] = this;     // argument to invoke
+        fs->argument[0] = this;     // argument to invoke
         fs->rturn = invoke;
 …
         fs->dummyReturn = NULL;
+        fs->rturn = __cfactx_invoke_stub;
+        fs->fixedRegisters[0] = main;
+        fs->fixedRegisters[1] = this;
+        fs->fixedRegisters[2] = invoke;
+        fs->rturn = CtxInvokeStub;
+        fs->fixedRegisters[0] = this;
+        fs->fixedRegisters[1] = invoke;
 #elif defined( __ARM_ARCH )
+#error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
         struct FakeStack {
                 float fpRegs[16];                       // floating point registers
 …
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
         fs->intRegs[8] = __cfactx_invoke_stub;
+        fs->intRegs[8] = CtxInvokeStub;
         fs->arg[0] = this;
         fs->arg[1] = invoke;

libcfa/src/concurrency/invoke.h

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  5 16:26:03 2019
 // Update Count     : 44
+// Last Modified On : Sat Jun 22 18:19:13 2019
+// Update Count     : 40
 //
 …
         #ifdef __cforall
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
                         struct $thread    * volatile this_thread;
+                extern thread_local struct KernelThreadData {
+                        struct thread_desc    * volatile this_thread;
                         struct processor      * volatile this_processor;
 …
                                 volatile bool in_progress;
                         } preemption_state;
-                        uint32_t rand_seed;
                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
+        }
 …
         };
+        enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun };
+        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
+        struct $coroutine {
+                // context that is switch during a __cfactx_switch
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+        struct coroutine_desc {
+                // context that is switch during a CtxSwitch
                 struct __stack_context_t context;
 …
                 // first coroutine to resume this one
                 struct $coroutine * starter;
+                struct coroutine_desc * starter;
                 // last coroutine to resume this one
                 struct $coroutine * last;
+                struct coroutine_desc * last;
                 // If non-null stack must be unwound with this exception
 …
         };
         struct $monitor {
+        struct monitor_desc {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
                 // current owner of the monitor
                 struct $thread * owner;
+                struct thread_desc * owner;
                 // queue of threads that are blocked waiting for the monitor
                 __queue_t(struct $thread) entry_queue;
+                __queue_t(struct thread_desc) entry_queue;
                 // stack of conditions to run next once we exit the monitor
 …
         struct __monitor_group_t {
                 // currently held monitors
                 __cfa_anonymous_object( __small_array_t($monitor*) );
+                __cfa_anonymous_object( __small_array_t(monitor_desc*) );
                 // last function that acquired monitors
 …
         };
         struct $thread {
+        struct thread_desc {
                 // Core threading fields
                 // context that is switch during a __cfactx_switch
+                // context that is switch during a CtxSwitch
                 struct __stack_context_t context;
                 // current execution status for coroutine
+                volatile int state;
+                enum __Preemption_Reason preempted;
+                enum coroutine_state state;
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
                 // coroutine body used to store context
                 struct $coroutine  self_cor;
+                struct coroutine_desc  self_cor;
                 // current active context
                 struct $coroutine * curr_cor;
+                struct coroutine_desc * curr_cor;
                 // monitor body used for mutual exclusion
                 struct $monitor    self_mon;
+                struct monitor_desc    self_mon;
                 // pointer to monitor with sufficient lifetime for current monitors
                 struct $monitor *  self_mon_p;
+                struct monitor_desc *  self_mon_p;
                 // pointer to the cluster on which the thread is running
 …
                 // Link lists fields
                 // instrusive link field for threads
                 struct $thread * next;
+                struct thread_desc * next;
                 struct {
                         struct $thread * next;
                         struct $thread * prev;
+                        struct thread_desc * next;
+                        struct thread_desc * prev;
                 } node;
         };
 …
         #ifdef __cforall
         extern "Cforall" {
                 static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
+                static inline thread_desc *& get_next( thread_desc & this ) {
                         return this.next;
+                }
                 static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
                         return this.node.[next, prev];
+                }
                 static inline void ?{}(__monitor_group_t & this) {
                         (this.data){0p};
+                        (this.data){NULL};
                         (this.size){0};
                         (this.func){NULL};
+                }
                 static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};
 …
+                }
                 static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
 …
         // assembler routines that performs the context switch
         extern void __cfactx_invoke_stub( void );
         extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
+        extern void CtxInvokeStub( void );
+        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
         // void CtxStore ( void * this ) asm ("CtxStore");
         // void CtxRet   ( void * dst  ) asm ("CtxRet");

libcfa/src/concurrency/kernel.cfa

-              r3d5701e
+              r9fb8f01
 // 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 Jun 20 17:21:23 2019
+// Update Count     : 25
 //
 …
 #include <signal.h>
 #include <unistd.h>
-#include <limits.h>                                                                             // PTHREAD_STACK_MIN
-#include <sys/mman.h>                                                                   // mprotect
+}
 …
 //-----------------------------------------------------------------------------
 // Some assembly required
 #if defined( __i386 )
+#if   defined( __i386 )
         #define CtxGet( ctx )        \
                 __asm__ volatile (     \
 …
 //-----------------------------------------------------------------------------
 //Start and stop routine for the kernel, declared first to make sure they run first
 static void __kernel_startup (void) __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
 static void __kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
 //-----------------------------------------------------------------------------
 …
 KERNEL_STORAGE(cluster,         mainCluster);
 KERNEL_STORAGE(processor,       mainProcessor);
 KERNEL_STORAGE($thread, mainThread);
+KERNEL_STORAGE(thread_desc,     mainThread);
 KERNEL_STORAGE(__stack_t,       mainThreadCtx);
 cluster     * mainCluster;
 processor   * mainProcessor;
 $thread * mainThread;
+thread_desc * mainThread;
 extern "C" {
         struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+}
 …
 // Global state
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
-        NULL,                                                                                           // cannot use 0p
         NULL,
         { 1, false, false },
 u //this should be seeded better but due to a bug calling rdtsc doesn't work
+        NULL,
+        { 1, false, false }
 };
 …
 // Struct to steal stack
 struct current_stack_info_t {
         __stack_t * storage;                                                            // pointer to stack object
         void * base;                                                                            // base of stack
         void * limit;                                                                           // stack grows towards stack limit
         void * context;                                                                         // address of cfa_context_t
+        __stack_t * storage;            // pointer to stack object
+        void *base;                             // base of stack
+        void *limit;                    // stack grows towards stack limit
+        void *context;                  // address of cfa_context_t
 };
 …
 // Main thread construction
 void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
+void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
 …
         name = "Main Thread";
         state = Start;
         starter = 0p;
         last = 0p;
         cancellation = 0p;
+}
 void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
+        starter = NULL;
+        last = NULL;
+        cancellation = NULL;
+}
+void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
         state = Start;
         self_cor{ info };
 …
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
         next = 0p;
         node.next = 0p;
         node.prev = 0p;
+        next = NULL;
+        node.next = NULL;
+        node.prev = NULL;
         doregister(curr_cluster, this);
 …
+}
+static void * __invoke_processor(void * arg);
+void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
+static void start(processor * this);
+void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
         this.name = name;
         this.cltr = &cltr;
         terminated{ 0 };
-        destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
+        preemption_alarm = NULL;
         pending_preemption = false;
         runner.proc = &this;
 …
         idleLock{};
+        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", &this);
+        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
+        __cfaabi_dbg_print_safe("Kernel : core %p started\n", &this);
+        start( &this );
+}
 …
+        }
+        pthread_join( kernel_thread, 0p );
+        free( this.stack );
+}
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
+        pthread_join( kernel_thread, NULL );
+}
+void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
 …
 // Kernel Scheduling logic
 //=============================================================================================
 static $thread * __next_thread(cluster * this);
 static void __run_thread(processor * this, $thread * dst);
 static void __halt(processor * this);
+static void runThread(processor * this, thread_desc * dst);
+static void finishRunning(processor * this);
+static void halt(processor * this);
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
-        // Because of a bug, we couldn't initialized the seed on construction
-        // Do it here
-        kernelTLS.rand_seed ^= rdtscl();
         processor * this = runner.proc;
         verify(this);
 …
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+                $thread * readyThread = 0p;
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
+                        readyThread = __next_thread( this->cltr );
+                        if(readyThread) {
+                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                                /* paranoid */ verifyf( readyThread->state == Inactive || readyThread->state == Start || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
+                                /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
+                                __run_thread(this, readyThread);
+                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
+                {
+                        readyThread = nextThread( this->cltr );
+                        if(readyThread)
+                        {
+                                verify( ! kernelTLS.preemption_state.enabled );
+                                runThread(this, readyThread);
+                                verify( ! kernelTLS.preemption_state.enabled );
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
                                 spin_count = 0;
+                        } else {
+                        }
+                        else
+                        {
                                 // spin(this, &spin_count);
                                 __halt(this);
+                                halt(this);
+                        }
+                }
 …
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
+static void __run_thread(processor * this, $thread * thrd_dst) {
+        $coroutine * proc_cor = get_coroutine(this->runner);
+static void runThread(processor * this, thread_desc * thrd_dst) {
+        coroutine_desc * proc_cor = get_coroutine(this->runner);
+        // Reset the terminating actions here
+        this->finish.action_code = No_Action;
         // Update global state
         kernelTLS.this_thread = thrd_dst;
+        // set state of processor coroutine to inactive
+        verify(proc_cor->state == Active);
+        proc_cor->state = Inactive;
+        // Actually run the thread
+        RUNNING:  while(true) {
+                if(unlikely(thrd_dst->preempted)) {
+                        thrd_dst->preempted = __NO_PREEMPTION;
+                        verify(thrd_dst->state == Active || thrd_dst->state == Rerun);
+                } else {
+                        verify(thrd_dst->state == Start || thrd_dst->state == Primed || thrd_dst->state == Inactive);
+                        thrd_dst->state = Active;
+        // set state of processor coroutine to inactive and the thread to active
+        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
+        thrd_dst->state = Active;
+        // set context switch to the thread that the processor is executing
+        verify( thrd_dst->context.SP );
+        CtxSwitch( &proc_cor->context, &thrd_dst->context );
+        // when CtxSwitch returns we are back in the processor coroutine
+        // set state of processor coroutine to active and the thread to inactive
+        thrd_dst->state = thrd_dst->state == Halted ? Halted : Inactive;
+        proc_cor->state = Active;
+}
+// KERNEL_ONLY
+static void returnToKernel() {
+        coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        thread_desc * thrd_src = kernelTLS.this_thread;
+        // set state of current coroutine to inactive
+        thrd_src->state = thrd_src->state == Halted ? Halted : Inactive;
+        proc_cor->state = Active;
+        int local_errno = *__volatile_errno();
+        #if defined( __i386 ) || defined( __x86_64 )
+                __x87_store;
+        #endif
+        // set new coroutine that the processor is executing
+        // and context switch to it
+        verify( proc_cor->context.SP );
+        CtxSwitch( &thrd_src->context, &proc_cor->context );
+        // set state of new coroutine to active
+        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
+        thrd_src->state = Active;
+        #if defined( __i386 ) || defined( __x86_64 )
+                __x87_load;
+        #endif
+        *__volatile_errno() = local_errno;
+}
+// KERNEL_ONLY
+// Once a thread has finished running, some of
+// its final actions must be executed from the kernel
+static void finishRunning(processor * this) with( this->finish ) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        choose( action_code ) {
+        case No_Action:
+                break;
+        case Release:
+                unlock( *lock );
+        case Schedule:
+                ScheduleThread( thrd );
+        case Release_Schedule:
+                unlock( *lock );
+                ScheduleThread( thrd );
+        case Release_Multi:
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
+                }
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                // set context switch to the thread that the processor is executing
+                verify( thrd_dst->context.SP );
+                __cfactx_switch( &proc_cor->context, &thrd_dst->context );
+                // when __cfactx_switch returns we are back in the processor coroutine
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                // We just finished running a thread, there are a few things that could have happened.
+                // 1 - Regular case : the thread has blocked and now one has scheduled it yet.
+                // 2 - Racy case    : the thread has blocked but someone has already tried to schedule it.
+                // 3 - Polite Racy case : the thread has blocked, someone has already tried to schedule it, but the thread is nice and wants to go through the ready-queue any way
+                // 4 - Preempted
+                // In case 1, we may have won a race so we can't write to the state again.
+                // In case 2, we lost the race so we now own the thread.
+                // In case 3, we lost the race but can just reschedule the thread.
+                if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
+                        // The thread was preempted, reschedule it and reset the flag
+                        __schedule_thread( thrd_dst );
+                        break RUNNING;
+        case Release_Multi_Schedule:
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
+                }
+                // set state of processor coroutine to active and the thread to inactive
+                static_assert(sizeof(thrd_dst->state) == sizeof(int));
+                enum coroutine_state old_state = __atomic_exchange_n(&thrd_dst->state, Inactive, __ATOMIC_SEQ_CST);
+                switch(old_state) {
+                        case Halted:
+                                // The thread has halted, it should never be scheduled/run again, leave it back to Halted and move on
+                                thrd_dst->state = Halted;
+                                // We may need to wake someone up here since
+                                unpark( this->destroyer );
+                                this->destroyer = 0p;
+                                break RUNNING;
+                        case Active:
+                                // This is case 1, the regular case, nothing more is needed
+                                break RUNNING;
+                        case Rerun:
+                                // This is case 2, the racy case, someone tried to run this thread before it finished blocking
+                                // In this case, just run it again.
+                                continue RUNNING;
+                        default:
+                                // This makes no sense, something is wrong abort
+                                abort("Finished running a thread that was Inactive/Start/Primed %d\n", old_state);
+                for(int i = 0; i < thrd_count; i++) {
+                        ScheduleThread( thrds[i] );
+                }
+        }
+        // Just before returning to the processor, set the processor coroutine to active
+        proc_cor->state = Active;
+}
+// KERNEL_ONLY
+void returnToKernel() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        $coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        $thread * thrd_src = kernelTLS.this_thread;
+        // Run the thread on this processor
+        {
+                int local_errno = *__volatile_errno();
+                #if defined( __i386 ) || defined( __x86_64 )
+                        __x87_store;
+                #endif
+                verify( proc_cor->context.SP );
+                __cfactx_switch( &thrd_src->context, &proc_cor->context );
+                #if defined( __i386 ) || defined( __x86_64 )
+                        __x87_load;
+                #endif
+                *__volatile_errno() = local_errno;
+        }
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        case Callback:
+                callback();
+        default:
+                abort("KERNEL ERROR: Unexpected action to run after thread");
+        }
+}
 …
 // This is the entry point for processors (kernel threads)
 // It effectively constructs a coroutine by stealing the pthread stack
 static void * __invoke_processor(void * arg) {
+static void * CtxInvokeProcessor(void * arg) {
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
         kernelTLS.this_thread    = 0p;
+        kernelTLS.this_thread    = NULL;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
 …
         //Set global state
         kernelTLS.this_thread = 0p;
+        kernelTLS.this_thread    = NULL;
         //We now have a proper context from which to schedule threads
 …
         __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
+        return 0p;
+}
+static void Abort( int ret, const char func[] ) {
+        if ( ret ) {                                                                            // pthread routines return errno values
+                abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
+        } // if
+} // Abort
+void * __create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+        pthread_attr_t attr;
+        Abort( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+        size_t stacksize;
+        // default stack size, normally defined by shell limit
+        Abort( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+        assert( stacksize >= PTHREAD_STACK_MIN );
+        void * stack;
+        __cfaabi_dbg_debug_do(
+                stack = memalign( __page_size, stacksize + __page_size );
+                // pthread has no mechanism to create the guard page in user supplied stack.
+                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                        abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
+                } // if
+        );
+        __cfaabi_dbg_no_debug_do(
+                stack = malloc( stacksize );
+        );
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        return stack;
+        return NULL;
+}
+static void start(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
+        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
+        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+}
 // KERNEL_ONLY
+static void __kernel_first_resume( processor * this ) {
+        $thread * src = mainThread;
+        $coroutine * dst = get_coroutine(this->runner);
+        verify( ! kernelTLS.preemption_state.enabled );
+        kernelTLS.this_thread->curr_cor = dst;
+void kernel_first_resume( processor * this ) {
+        thread_desc * src = mainThread;
+        coroutine_desc * dst = get_coroutine(this->runner);
+        verify( ! kernelTLS.preemption_state.enabled );
         __stack_prepare( &dst->stack, 65000 );
         __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
+        CtxStart(&this->runner, CtxInvokeCoroutine);
         verify( ! kernelTLS.preemption_state.enabled );
 …
         // context switch to specified coroutine
         verify( dst->context.SP );
+        __cfactx_switch( &src->context, &dst->context );
+        // when __cfactx_switch returns we are back in the src coroutine
+        mainThread->curr_cor = &mainThread->self_cor;
+        CtxSwitch( &src->context, &dst->context );
+        // when CtxSwitch returns we are back in the src coroutine
         // set state of new coroutine to active
 …
 // KERNEL_ONLY
 static void __kernel_last_resume( processor * this ) {
         $coroutine * src = &mainThread->self_cor;
         $coroutine * dst = get_coroutine(this->runner);
+void kernel_last_resume( processor * this ) {
+        coroutine_desc * src = &mainThread->self_cor;
+        coroutine_desc * dst = get_coroutine(this->runner);
         verify( ! kernelTLS.preemption_state.enabled );
 …
         // context switch to the processor
         __cfactx_switch( &src->context, &dst->context );
+        CtxSwitch( &src->context, &dst->context );
+}
 //-----------------------------------------------------------------------------
 // Scheduler routines
 // KERNEL ONLY
+void __schedule_thread( $thread * thrd ) with( *thrd->curr_cluster ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
+        /* paranoid */ if( thrd->state == Inactive || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
+                          "Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
+                          "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ #endif
+        /* paranoid */ verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
+        lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+        bool was_empty = !(ready_queue != 0);
+        append( ready_queue, thrd );
+void ScheduleThread( thread_desc * thrd ) {
+        verify( thrd );
+        verify( thrd->state != Halted );
+        verify( ! kernelTLS.preemption_state.enabled );
+        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
+        with( *thrd->curr_cluster ) {
+                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                bool was_empty = !(ready_queue != 0);
+                append( ready_queue, thrd );
+                unlock( ready_queue_lock );
+                if(was_empty) {
+                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                        if(idles) {
+                                wake_fast(idles.head);
+                        }
+                        unlock    (proc_list_lock);
+                }
+                else if( struct processor * idle = idles.head ) {
+                        wake_fast(idle);
+                }
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+}
+// KERNEL ONLY
+thread_desc * nextThread(cluster * this) with( *this ) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
+        if(was_empty) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                if(idles) {
+                        wake_fast(idles.head);
+                }
+                unlock    (proc_list_lock);
+        }
+        else if( struct processor * idle = idles.head ) {
+                wake_fast(idle);
+        }
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
+        return head;
+}
+void BlockInternal() {
+        disable_interrupts();
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal( __spinlock_t * lock ) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release;
+                finish.lock        = lock;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal( thread_desc * thrd ) {
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Schedule;
+                finish.thrd        = thrd;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
+        assert(thrd);
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Schedule;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal(__spinlock_t * locks [], unsigned short count) {
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi;
+                finish.locks       = locks;
+                finish.lock_count  = count;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi_Schedule;
+                finish.locks       = locks;
+                finish.lock_count  = lock_count;
+                finish.thrds       = thrds;
+                finish.thrd_count  = thrd_count;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void BlockInternal(__finish_callback_fptr_t callback) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Callback;
+                finish.callback    = callback;
+        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
 // KERNEL ONLY
+static $thread * __next_thread(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        $thread * head = pop_head( ready_queue );
+        unlock( ready_queue_lock );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        return head;
+}
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+        disable_interrupts();
+        static_assert(sizeof(thrd->state) == sizeof(int));
+        enum coroutine_state old_state = __atomic_exchange_n(&thrd->state, Rerun, __ATOMIC_SEQ_CST);
+        switch(old_state) {
+                case Active:
+                        // Wake won the race, the thread will reschedule/rerun itself
+                        break;
+                case Inactive:
+                        /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
+                        // Wake lost the race,
+                        thrd->state = Inactive;
+                        __schedule_thread( thrd );
+                        break;
+                case Rerun:
+                        abort("More than one thread attempted to schedule thread %p\n", thrd);
+                        break;
+                case Halted:
+                case Start:
+                case Primed:
+                default:
+                        // This makes no sense, something is wrong abort
+                        abort();
+        }
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+void park( void ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+        disable_interrupts();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = thrd ? Release_Schedule : Release;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
         returnToKernel();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        enable_interrupts( __cfaabi_dbg_ctx );
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+}
-// KERNEL ONLY
-void __leave_thread() {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        abort();
+}
-// KERNEL ONLY
-bool force_yield( __Preemption_Reason reason ) {
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
-        disable_interrupts();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        $thread * thrd = kernelTLS.this_thread;
-        /* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
-        // SKULLDUGGERY: It is possible that we are preempting this thread just before
-        // it was going to park itself. If that is the case and it is already using the
-        // intrusive fields then we can't use them to preempt the thread
-        // If that is the case, abandon the preemption.
-        bool preempted = false;
-        if(thrd->next == 0p) {
-                preempted = true;
-                thrd->preempted = reason;
-                returnToKernel();
+        }
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        enable_interrupts_noPoll();
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
-        return preempted;
+}
 …
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
 static void __kernel_startup(void) {
+static void kernel_startup(void) {
         verify( ! kernelTLS.preemption_state.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 …
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
         mainThread = ($thread *)&storage_mainThread;
+        mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
 …
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
                 this.__cor.starter = 0p;
+                this.__cor.starter = NULL;
                 this.proc = proc;
+        }
 …
                 terminated{ 0 };
                 do_terminate = false;
                 preemption_alarm = 0p;
+                preemption_alarm = NULL;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
 …
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
         __schedule_thread(mainThread);
+        ScheduleThread(mainThread);
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through __cfactx_invoke_thread, like all other threads. The trick here is that
+        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
         __kernel_first_resume( kernelTLS.this_processor );
+        kernel_first_resume( kernelTLS.this_processor );
 …
+}
 static void __kernel_shutdown(void) {
+static void kernel_shutdown(void) {
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 …
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
         __kernel_last_resume( kernelTLS.this_processor );
+        kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;
 …
 // Kernel Quiescing
 //=============================================================================================
 static void __halt(processor * this) with( *this ) {
+static void halt(processor * this) with( *this ) {
         // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 …
                 sigemptyset( &mask );
                 sigaddset( &mask, SIGALRM );            // block SIGALRM signals
+                sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
+                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
+                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+        }
         else {
 …
 void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
         $thread * thrd = kernel_data;
+        thread_desc * thrd = kernel_data;
         if(thrd) {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
                 __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                __cfaabi_dbg_bits_write( abort_text, len );
                 if ( &thrd->self_cor != thrd->curr_cor ) {
                         len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
                         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                        __cfaabi_dbg_bits_write( abort_text, len );
+                }
                 else {
                         __cfaabi_bits_write( STDERR_FILENO, ".\n", 2 );
+                        __cfaabi_dbg_bits_write( ".\n", 2 );
+                }
+        }
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
                 __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                __cfaabi_dbg_bits_write( abort_text, len );
+        }
+}
 …
 extern "C" {
         void __cfaabi_bits_acquire() {
+        void __cfaabi_dbg_bits_acquire() {
                 lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
+        }
         void __cfaabi_bits_release() {
+        void __cfaabi_dbg_bits_release() {
                 unlock( kernel_debug_lock );
+        }
 …
                 // atomically release spin lock and block
+                unlock( lock );
+                park();
+                BlockInternal( &lock );
+        }
         else {
 …
 void V(semaphore & this) with( this ) {
         $thread * thrd = 0p;
+        thread_desc * thrd = NULL;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
 …
         // make new owner
         unpark( thrd );
+        WakeThread( thrd );
+}
 …
+}
 void doregister( cluster * cltr, $thread & thrd ) {
+void doregister( cluster * cltr, thread_desc & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
 …
+}
 void unregister( cluster * cltr, $thread & thrd ) {
+void unregister( cluster * cltr, thread_desc & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );
 …
 __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;
 …
 //-----------------------------------------------------------------------------
 // Debug
 bool threading_enabled(void) __attribute__((const)) {
+bool threading_enabled(void) {
         return true;
+}

libcfa/src/concurrency/kernel.hfa

-              r3d5701e
+              r9fb8f01
 // 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 : Sat Jun 22 11:39:17 2019
+// Update Count     : 16
 //
 …
 #include "invoke.h"
 #include "time_t.hfa"
-#include "coroutine.hfa"
 extern "C" {
 …
         __spinlock_t lock;
         int count;
         __queue_t($thread) waiting;
+        __queue_t(thread_desc) waiting;
 };
 …
 // Processor
 extern struct cluster * mainCluster;
+enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
+typedef void (*__finish_callback_fptr_t)(void);
+//TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
+struct FinishAction {
+        FinishOpCode action_code;
+        /*
+        // Union of possible actions
+        union {
+                // Option 1 : locks and threads
+                struct {
+                        // 1 thread or N thread
+                        union {
+                                thread_desc * thrd;
+                                struct {
+                                        thread_desc ** thrds;
+                                        unsigned short thrd_count;
+                                };
+                        };
+                        // 1 lock or N lock
+                        union {
+                                __spinlock_t * lock;
+                                struct {
+                                        __spinlock_t ** locks;
+                                        unsigned short lock_count;
+                                };
+                        };
+                };
+                // Option 2 : action pointer
+                __finish_callback_fptr_t callback;
+        };
+        /*/
+        thread_desc * thrd;
+        thread_desc ** thrds;
+        unsigned short thrd_count;
+        __spinlock_t * lock;
+        __spinlock_t ** locks;
+        unsigned short lock_count;
+        __finish_callback_fptr_t callback;
+        //*/
+};
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = NULL;
+        this.lock = NULL;
+}
+static inline void ^?{}(FinishAction &) {}
 // Processor
 …
         // RunThread data
         // Action to do after a thread is ran
         $thread * destroyer;
+        struct FinishAction finish;
         // Preemption data
 …
         // Termination synchronisation
         semaphore terminated;
-        // pthread Stack
-        void * stack;
         // Link lists fields
 …
 };
 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 [processor *&, processor *& ] __get( processor & this ) __attribute__((const)) { return this.node.[next, prev]; }
+static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+static inline [processor *&, processor *& ] __get( processor & this ) {
+        return this.node.[next, prev];
+}
 //-----------------------------------------------------------------------------
 …
         // Ready queue for threads
         __queue_t($thread) ready_queue;
+        __queue_t(thread_desc) ready_queue;
         // Name of the cluster
 …
         // List of threads
         __spinlock_t thread_list_lock;
         __dllist_t(struct $thread) threads;
+        __dllist_t(struct thread_desc) threads;
         unsigned int nthreads;
 …
 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 [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; }
+static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+static inline [cluster *&, cluster *& ] __get( cluster & this ) {
+        return this.node.[next, prev];
+}
 static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE

libcfa/src/concurrency/kernel_private.hfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Nov 30 19:25:02 2019
 // Update Count     : 8
+// Last Modified On : Thu Mar 29 14:06:40 2018
+// Update Count     : 3
 //
 …
+}
+void __schedule_thread( $thread * ) __attribute__((nonnull (1)));
+void ScheduleThread( thread_desc * );
+static inline void WakeThread( thread_desc * thrd ) {
+        if( !thrd ) return;
+        disable_interrupts();
+        ScheduleThread( thrd );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+thread_desc * nextThread(cluster * this);
 //Block current thread and release/wake-up the following resources
+void __leave_thread() __attribute__((noreturn));
+void BlockInternal(void);
+void BlockInternal(__spinlock_t * lock);
+void BlockInternal(thread_desc * thrd);
+void BlockInternal(__spinlock_t * lock, thread_desc * thrd);
+void BlockInternal(__spinlock_t * locks [], unsigned short count);
+void BlockInternal(__spinlock_t * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
+void BlockInternal(__finish_callback_fptr_t callback);
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd);
 //-----------------------------------------------------------------------------
 // Processor
 void main(processorCtx_t *);
-void * __create_pthread( pthread_t *, void * (*)(void *), void * );
 static inline void wake_fast(processor * this) {
 …
 // Threads
 extern "C" {
+      void __cfactx_invoke_thread(void (*main)(void *), void * this);
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
+}
+extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
 __cfaabi_dbg_debug_do(
         extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
         extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
+        extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
+        extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+)
 …
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
-static inline uint32_t __tls_rand() {
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;
-        kernelTLS.rand_seed ^= kernelTLS.rand_seed << 7;
-        return kernelTLS.rand_seed;
+}
 void doregister( struct cluster & cltr );
 void unregister( struct cluster & cltr );
 void doregister( struct cluster * cltr, struct $thread & thrd );
 void unregister( struct cluster * cltr, struct $thread & thrd );
+void doregister( struct cluster * cltr, struct thread_desc & thrd );
+void unregister( struct cluster * cltr, struct thread_desc & thrd );
 void doregister( struct cluster * cltr, struct processor * proc );

libcfa/src/concurrency/monitor.cfa

-              r3d5701e
+              r9fb8f01
 // file "LICENCE" distributed with Cforall.
 //
 // $monitor.c --
+// monitor_desc.c --
 //
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:55:14 2019
 // Update Count     : 10
+// Last Modified On : Fri Mar 30 14:30:26 2018
+// Update Count     : 9
 //
 …
 //-----------------------------------------------------------------------------
 // Forward declarations
 static inline void __set_owner ( $monitor * this, $thread * owner );
 static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
 static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
 static inline void reset_mask( $monitor * this );
 static inline $thread * next_thread( $monitor * this );
 static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor_desc * this );
+static inline thread_desc * next_thread( monitor_desc * this );
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
 static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
 static inline void unlock_all( $monitor * locks [], __lock_size_t count );
 static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
 static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
 static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
 static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
 static inline $thread *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
+static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline thread_desc *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
 static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
 forall(dtype T | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
 static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 //-----------------------------------------------------------------------------
 …
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
         $monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
 …
 //-----------------------------------------------------------------------------
 // Enter/Leave routines
+// Enter single monitor
+static void __enter( $monitor * this, const __monitor_group_t & group ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+        if( !this->owner ) {
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+                __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor, just note how many times we took it
+                this->recursion += 1;
+                __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+        }
+        else if( is_accepted( this, group) ) {
+                // Some one was waiting for us, enter
+                __set_owner( this, thrd );
+                // Reset mask
+                reset_mask( this );
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+                unlock( this->lock );
+                park();
+extern "C" {
+        // Enter single monitor
+        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+                if( !this->owner ) {
+                        // No one has the monitor, just take it
+                        set_owner( this, thrd );
+                        __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+                }
+                else if( this->owner == thrd) {
+                        // We already have the monitor, just note how many times we took it
+                        this->recursion += 1;
+                        __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+                }
+                else if( is_accepted( this, group) ) {
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+                        // Reset mask
+                        reset_mask( this );
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+                }
+                else {
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+                        // Some one else has the monitor, wait in line for it
+                        append( this->entry_queue, thrd );
+                        BlockInternal( &this->lock );
+                        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                return;
+        }
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        /* paranoid */ verify( this->lock.lock );
+        // Release the lock and leave
+        unlock( this->lock );
+        return;
+}
+static void __dtor_enter( $monitor * this, fptr_t func ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+        if( !this->owner ) {
+                __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                // Release the lock and leave
                 unlock( this->lock );
                 return;
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor... but where about to destroy it so the nesting will fail
+                // Abort!
+                abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+        }
+        __lock_size_t count = 1;
+        $monitor ** monitors = &this;
+        __monitor_group_t group = { &this, 1, func };
+        if( is_accepted( this, group) ) {
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
+                // Wake the thread that is waiting for this
+                __condition_criterion_t * urgent = pop( this->signal_stack );
+                /* paranoid */ verify( urgent );
+                // Reset mask
+                reset_mask( this );
+                // Create the node specific to this wait operation
+                wait_ctx_primed( thrd, 0 )
+                // Some one else has the monitor, wait for him to finish and then run
+        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                if( !this->owner ) {
+                        __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
+                        // No one has the monitor, just take it
+                        set_owner( this, thrd );
+                        unlock( this->lock );
+                        return;
+                }
+                else if( this->owner == thrd) {
+                        // We already have the monitor... but where about to destroy it so the nesting will fail
+                        // Abort!
+                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+                }
+                __lock_size_t count = 1;
+                monitor_desc ** monitors = &this;
+                __monitor_group_t group = { &this, 1, func };
+                if( is_accepted( this, group) ) {
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
+                        // Wake the thread that is waiting for this
+                        __condition_criterion_t * urgent = pop( this->signal_stack );
+                        verify( urgent );
+                        // Reset mask
+                        reset_mask( this );
+                        // Create the node specific to this wait operation
+                        wait_ctx_primed( thrd, 0 )
+                        // Some one else has the monitor, wait for him to finish and then run
+                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+                }
+                else {
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+                        wait_ctx( thrd, 0 )
+                        this->dtor_node = &waiter;
+                        // Some one else has the monitor, wait in line for it
+                        append( this->entry_queue, thrd );
+                        BlockInternal( &this->lock );
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
+                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+        }
+        // Leave single monitor
+        void __leave_monitor_desc( monitor_desc * this ) {
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                // Leaving a recursion level, decrement the counter
+                this->recursion -= 1;
+                // If we haven't left the last level of recursion
+                // it means we don't need to do anything
+                if( this->recursion != 0) {
+                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
+                        unlock( this->lock );
+                        return;
+                }
+                // Get the next thread, will be null on low contention monitor
+                thread_desc * new_owner = next_thread( this );
+                // We can now let other threads in safely
                 unlock( this->lock );
+                // Release the next thread
+                /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                unpark( urgent->owner->waiting_thread );
+                // Park current thread waiting
+                park();
+                // Some one was waiting for us, enter
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+                wait_ctx( thrd, 0 )
+                this->dtor_node = &waiter;
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+                unlock( this->lock );
+                // Park current thread waiting
+                park();
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                return;
+        }
+        __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+}
+// Leave single monitor
+void __leave( $monitor * this ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        // Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+        // If we haven't left the last level of recursion
+        // it means we don't need to do anything
+        if( this->recursion != 0) {
+                __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
+                unlock( this->lock );
+                return;
+        }
+        // Get the next thread, will be null on low contention monitor
+        $thread * new_owner = next_thread( this );
+        // Check the new owner is consistent with who we wake-up
+        // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        // We can now let other threads in safely
+        unlock( this->lock );
+        //We need to wake-up the thread
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        unpark( new_owner );
+}
+// Leave single monitor for the last time
+void __dtor_leave( $monitor * this ) {
+        __cfaabi_dbg_debug_do(
+                if( TL_GET( this_thread ) != this->owner ) {
+                        abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
+                }
+                if( this->recursion != 1 ) {
+                        abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                }
+        )
+}
+extern "C" {
+                //We need to wake-up the thread
+                WakeThread( new_owner );
+        }
+        // Leave single monitor for the last time
+        void __leave_dtor_monitor_desc( monitor_desc * this ) {
+                __cfaabi_dbg_debug_do(
+                        if( TL_GET( this_thread ) != this->owner ) {
+                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
+                        }
+                        if( this->recursion != 1 ) {
+                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
+        }
         // Leave the thread monitor
         // last routine called by a thread.
         // Should never return
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
+        void __leave_thread_monitor( thread_desc * thrd ) {
+                monitor_desc * this = &thrd->self_mon;
                 // Lock the monitor now
 …
                 disable_interrupts();
                 thrd->state = Halted;
                 /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                thrd->self_cor.state = Halted;
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
                 // Leaving a recursion level, decrement the counter
 …
                 // Fetch the next thread, can be null
+                $thread * new_owner = next_thread( this );
+                // Release the monitor lock
+                unlock( this->lock );
+                // Unpark the next owner if needed
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
+                /* paranoid */ verify( thrd->state == Halted );
+                kernelTLS.this_processor->destroyer = new_owner;
+                // Leave the thread
+                __leave_thread();
+                thread_desc * new_owner = next_thread( this );
+                // Leave the thread, this will unlock the spinlock
+                // Use leave thread instead of BlockInternal which is
+                // specialized for this case and supports null new_owner
+                LeaveThread( &this->lock, new_owner );
                 // Control flow should never reach here!
 …
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
                 __enter( monitors[i], monitors );
+                __enter_monitor_desc( monitors[i], monitors );
+        }
+}
 …
 // Leave multiple monitor
 // relies on the monitor array being sorted
 static inline void leave($monitor * monitors [], __lock_size_t count) {
+static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
                 __leave( monitors[i] );
+                __leave_monitor_desc( monitors[i] );
+        }
+}
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
         $thread * thrd = TL_GET( this_thread );
+void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
+        thread_desc * thrd = TL_GET( this_thread );
         // Store current array
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
         // optimization
         $thread * thrd = TL_GET( this_thread );
+        thread_desc * thrd = TL_GET( this_thread );
         // Store current array
 …
         (thrd->monitors){m, 1, func};
         __dtor_enter( this.m, func );
+        __enter_monitor_dtor( this.m, func );
+}
 …
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
         __dtor_leave( this.m );
+        __leave_dtor_monitor_desc( this.m );
         // Restore thread context
 …
 //-----------------------------------------------------------------------------
 // Internal scheduling types
 void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
         this.next = 0p;
+        this.next = NULL;
         this.user_info = user_info;
+}
 …
 void ?{}(__condition_criterion_t & this ) with( this ) {
         ready  = false;
         target = 0p;
         owner  = 0p;
         next   = 0p;
+}
 void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
+        target = NULL;
+        owner  = NULL;
+        next   = NULL;
+}
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
         this.owner  = &owner;
         this.next   = 0p;
+        this.next   = NULL;
+}
 …
         // Check that everything is as expected
         assertf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
+        assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
         verifyf( this.monitor_count < 32u, "Excessive monitor count (%"PRIiFAST16")", this.monitor_count );
 …
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
-        /* paranoid */ verify( waiter.next == 0p );
         append( this.blocked, &waiter );
-        /* paranoid */ verify( waiter.next == 1p );
         // Lock all monitors (aggregates the locks as well)
 …
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
         $thread * threads[ count ];
+        thread_desc * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 …
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
                 $thread * new_owner = next_thread( monitors[i] );
+                thread_desc * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
+        }
-        // Unlock the locks, we don't need them anymore
-        for(int i = 0; i < count; i++) {
-                unlock( *locks[i] );
+        }
-        // Wake the threads
-        for(int i = 0; i < thread_count; i++) {
-                unpark( threads[i] );
+        }
         // Everything is ready to go to sleep
         park();
+        BlockInternal( locks, count, threads, thread_count );
         // We are back, restore the owners and recursions
 …
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
                 $thread * this_thrd = TL_GET( this_thread );
+                thread_desc * this_thrd = TL_GET( this_thread );
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
 …
         // Lock all monitors
         lock_all( this.monitors, 0p, count );
+        lock_all( this.monitors, NULL, count );
         //Pop the head of the waiting queue
 …
         //Check that everything is as expected
         verifyf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
 …
         //Find the thread to run
+        $thread * signallee = pop_head( this.blocked )->waiting_thread;
+        /* paranoid */ verify( signallee->next == 0p );
+        __set_owner( monitors, count, signallee );
+        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+        set_owner( monitors, count, signallee );
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
-        // unlock all the monitors
-        unlock_all( locks, count );
-        // unpark the thread we signalled
-        unpark( signallee );
         //Everything is ready to go to sleep
         park();
+        BlockInternal( locks, count, &signallee, 1 );
 …
         // Create one!
         __lock_size_t max = count_max( mask );
         $monitor * mon_storage[max];
+        monitor_desc * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
 …
+        {
                 // Check if the entry queue
                 $thread * next; int index;
+                thread_desc * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 …
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
                                 $monitor * mon2dtor = accepted[0];
+                                monitor_desc * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 …
                                 // Set the owners to be the next thread
+                                __set_owner( monitors, count, next );
+                                // unlock all the monitors
+                                unlock_all( locks, count );
+                                // unpark the thread we signalled
+                                unpark( next );
+                                //Everything is ready to go to sleep
+                                park();
+                                set_owner( monitors, count, next );
+                                // Everything is ready to go to sleep
+                                BlockInternal( locks, count, &next, 1 );
                                 // We are back, restore the owners and recursions
 …
+        }
-        // unlock all the monitors
-        unlock_all( locks, count );
         //Everything is ready to go to sleep
         park();
+        BlockInternal( locks, count );
 …
 // Utilities
 static inline void __set_owner( $monitor * this, $thread * owner ) {
         /* paranoid */ verify( this->lock.lock );
+static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
+        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
         //Pass the monitor appropriately
 …
+}
+static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
+        /* paranoid */ verify ( monitors[0]->lock.lock );
+        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
+        monitors[0]->owner        = owner;
+        monitors[0]->recursion    = 1;
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
+        monitors[0]->owner     = owner;
+        monitors[0]->recursion = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
+                /* paranoid */ verify ( monitors[i]->lock.lock );
+                /* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
+                monitors[i]->owner        = owner;
+                monitors[i]->recursion    = 0;
+        }
+}
+static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+                monitors[i]->owner     = owner;
+                monitors[i]->recursion = 0;
+        }
+}
+static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
 …
+}
 static inline void reset_mask( $monitor * this ) {
         this->mask.accepted = 0p;
         this->mask.data = 0p;
+static inline void reset_mask( monitor_desc * this ) {
+        this->mask.accepted = NULL;
+        this->mask.data = NULL;
         this->mask.size = 0;
+}
 static inline $thread * next_thread( $monitor * this ) {
+static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
 …
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
+                /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                __set_owner( this,  urgent->owner->waiting_thread );
+                set_owner( this,  urgent->owner->waiting_thread );
                 return check_condition( urgent );
 …
         // No signaller thread
         // Get the next thread in the entry_queue
+        $thread * new_owner = pop_head( this->entry_queue );
+        /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        /* paranoid */ verify( !new_owner || new_owner->next == 0p );
+        __set_owner( this, new_owner );
+        thread_desc * new_owner = pop_head( this->entry_queue );
+        set_owner( this, new_owner );
         return new_owner;
+}
 static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
 …
+}
 static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
 …
+}
 static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
 …
+}
 static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
 …
+}
 static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
 …
 static inline void save(
         $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
 …
 static inline void restore(
         $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
 …
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
 static inline $thread * check_condition( __condition_criterion_t * target ) {
+static inline thread_desc * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
 …
+        }
         __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : 0p );
         return ready2run ? node->waiting_thread : 0p;
+        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
+        return ready2run ? node->waiting_thread : NULL;
+}
 static inline void brand_condition( condition & this ) {
         $thread * thrd = TL_GET( this_thread );
+        thread_desc * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
                 assertf( thrd->monitors.data != 0p, "No current monitor to brand condition %p", thrd->monitors.data );
+                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;
                 this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];
 …
+}
 static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
         __queue_t($thread) & entry_queue = monitors[0]->entry_queue;
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
+        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
         // For each thread in the entry-queue
         for(    $thread ** thrd_it = &entry_queue.head;
                 *thrd_it != 1p;
+        for(    thread_desc ** thrd_it = &entry_queue.head;
+                *thrd_it;
                 thrd_it = &(*thrd_it)->next
         ) {
 …
+}
 static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {

libcfa/src/concurrency/monitor.hfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 07:55:32 2019
 // Update Count     : 11
+// Last Modified On : Sat Oct  7 18:06:45 2017
+// Update Count     : 10
 //
 …
 trait is_monitor(dtype T) {
         $monitor * get_monitor( T & );
+        monitor_desc * get_monitor( T & );
         void ^?{}( T & mutex );
 };
 static inline void ?{}($monitor & this) with( this ) {
+static inline void ?{}(monitor_desc & this) with( this ) {
         lock{};
         entry_queue{};
         signal_stack{};
         owner         = 0p;
+        owner         = NULL;
         recursion     = 0;
         mask.accepted = 0p;
         mask.data     = 0p;
+        mask.accepted = NULL;
+        mask.data     = NULL;
         mask.size     = 0;
         dtor_node     = 0p;
+        dtor_node     = NULL;
+}
-static inline void ^?{}($monitor & ) {}
 struct monitor_guard_t {
         $monitor **     m;
+        monitor_desc **         m;
         __lock_size_t           count;
         __monitor_group_t prev;
 };
 void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 struct monitor_dtor_guard_t {
         $monitor *    m;
+        monitor_desc *    m;
         __monitor_group_t prev;
 };
 void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)() );
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
 void ^?{}( monitor_dtor_guard_t & this );
 …
         // The monitor this criterion concerns
         $monitor * target;
+        monitor_desc * target;
         // The parent node to which this criterion belongs
 …
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
         $thread * waiting_thread;
+        thread_desc * waiting_thread;
         // Array of criteria (Criterions are contiguous in memory)
 …
+}
 void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
 void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 struct condition {
 …
         // Array of monitor pointers (Monitors are NOT contiguous in memory)
         $monitor ** monitors;
+        monitor_desc ** monitors;
         // Number of monitors in the array
 …
 static inline void ?{}( condition & this ) {
         this.monitors = 0p;
+        this.monitors = NULL;
         this.monitor_count = 0;
+}
 …
               bool signal      ( condition & this );
               bool signal_block( condition & this );
 static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
+static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
          uintptr_t front       ( condition & this );

libcfa/src/concurrency/mutex.cfa

-              r3d5701e
+              r9fb8f01
 // Author           : Thierry Delisle
 // Created On       : Fri May 25 01:37:11 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:16:39 2019
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Fri May 25 01:37:51 2018
+// Update Count     : 0
 //
 …
         if( is_locked ) {
                 append( blocked_threads, kernelTLS.this_thread );
+                unlock( lock );
+                park();
+                BlockInternal( &lock );
+        }
         else {
 …
         lock( this.lock __cfaabi_dbg_ctx2 );
         this.is_locked = (this.blocked_threads != 0);
         unpark(
+        WakeThread(
                 pop_head( this.blocked_threads )
         );
 …
         this.lock{};
         this.blocked_threads{};
         this.owner = 0p;
+        this.owner = NULL;
         this.recursion_count = 0;
+}
 …
 void lock(recursive_mutex_lock & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         if( owner == 0p ) {
+        if( owner == NULL ) {
                 owner = kernelTLS.this_thread;
                 recursion_count = 1;
 …
         else {
                 append( blocked_threads, kernelTLS.this_thread );
+                unlock( lock );
+                park();
+                BlockInternal( &lock );
+        }
+}
 …
         bool ret = false;
         lock( lock __cfaabi_dbg_ctx2 );
         if( owner == 0p ) {
+        if( owner == NULL ) {
                 owner = kernelTLS.this_thread;
                 recursion_count = 1;
 …
         recursion_count--;
         if( recursion_count == 0 ) {
                 $thread * thrd = pop_head( blocked_threads );
+                thread_desc * thrd = pop_head( blocked_threads );
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);
                 unpark( thrd );
+                WakeThread( thrd );
+        }
         unlock( lock );
 …
 void notify_one(condition_variable & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
         unpark(
+        WakeThread(
                 pop_head( this.blocked_threads )
         );
 …
         lock( lock __cfaabi_dbg_ctx2 );
         while(this.blocked_threads) {
                 unpark(
+                WakeThread(
                         pop_head( this.blocked_threads )
                 );
 …
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
+        unlock( this.lock );
+        park();
+        BlockInternal( &this.lock );
+}
 …
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
+        unlock(l);
+        unlock(this.lock);
+        park();
+        void __unlock(void) {
+                unlock(l);
+                unlock(this.lock);
+        }
+        BlockInternal( __unlock );
         lock(l);
+}

libcfa/src/concurrency/mutex.hfa

-              r3d5701e
+              r9fb8f01
 // Author           : Thierry Delisle
 // Created On       : Fri May 25 01:24:09 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:16:53 2019
 // Update Count     : 1
+// Last Modified By : Thierry Delisle
+// Last Modified On : Fri May 25 01:24:12 2018
+// Update Count     : 0
 //
 …
         // List of blocked threads
         __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread_desc) blocked_threads;
         // Locked flag
 …
         // List of blocked threads
         __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread_desc) blocked_threads;
         // Current thread owning the lock
         struct $thread * owner;
+        struct thread_desc * owner;
         // Number of recursion level
 …
         // List of blocked threads
         __queue_t(struct $thread) blocked_threads;
+        __queue_t(struct thread_desc) blocked_threads;
 };
 …
         static inline void ?{}(lock_scope(L) & this) {
                 this.locks = 0p;
+                this.locks = NULL;
                 this.count = 0;
+        }

libcfa/src/concurrency/preemption.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec  5 16:34:05 2019
 // Update Count     : 43
+// Last Modified On : Tue Jun  5 17:35:49 2018
+// Update Count     : 37
 //
 …
 #include <string.h>
 #include <unistd.h>
-#include <limits.h>                                                                             // PTHREAD_STACK_MIN
+}
 …
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
 static void timeout( $thread * this );
+static void timeout( thread_desc * this );
 // FwdDeclarations : Signal handlers
 …
 event_kernel_t * event_kernel;                        // kernel public handle to even kernel
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
-static void * alarm_stack;                                                        // pthread stack for alarm thread
 static void ?{}(event_kernel_t & this) with( this ) {
 …
 // Get next expired node
 static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
         if( !alarms->head ) return 0p;                                          // If no alarms return null
         if( alarms->head->alarm >= currtime ) return 0p;        // If alarms head not expired return null
         return pop(alarms);                                                                     // Otherwise just pop head
+        if( !alarms->head ) return NULL;                          // If no alarms return null
+        if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
+        return pop(alarms);                                       // Otherwise just pop head
+}
 // Tick one frame of the Discrete Event Simulation for alarms
 static void tick_preemption() {
         alarm_node_t * node = 0p;                                                       // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;          // Local copy for ease of reading
         Time currtime = __kernel_get_time();                            // Check current time once so everything "happens at once"
+        alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
+        alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
+        Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
         //Loop throught every thing expired
 …
         // Enable interrupts by decrementing the counter
         // If counter reaches 0, execute any pending __cfactx_switch
+        // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
                 with( kernelTLS.preemption_state ){
 …
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
                                         force_yield( __POLL_PREEMPTION );
+                                        BlockInternal( thrd );
+                                }
+                        }
 …
         // Disable interrupts by incrementint the counter
         // Don't execute any pending __cfactx_switch even if counter reaches 0
+        // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
                 unsigned short prev = kernelTLS.preemption_state.disable_count;
 …
         sigaddset( &mask, sig );
         if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
+        if ( pthread_sigmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
         sigaddset( &mask, sig );
         if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
 // reserved for future use
 static void timeout( $thread * this ) {
+static void timeout( thread_desc * this ) {
         //TODO : implement waking threads
+}
 // KERNEL ONLY
 // Check if a __cfactx_switch signal handler shoud defer
+// Check if a CtxSwitch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
 …
         // Setup proper signal handlers
         __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART );         // CtxSwitch handler
         signal_block( SIGALRM );
         alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
+        pthread_create( &alarm_thread, NULL, alarm_loop, NULL );
+}
 …
         sigset_t mask;
         sigfillset( &mask );
         sigprocmask( SIG_BLOCK, &mask, 0p );
+        sigprocmask( SIG_BLOCK, &mask, NULL );
         // Notify the alarm thread of the shutdown
 …
         // Wait for the preemption thread to finish
+        pthread_join( alarm_thread, 0p );
+        free( alarm_stack );
+        pthread_join( alarm_thread, NULL );
         // Preemption is now fully stopped
 …
         static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
         #endif
         if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
+        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) {
                 abort( "internal error, sigprocmask" );
+        }
 …
         // Preemption can occur here
         force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch
+        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
+}
 …
         sigset_t mask;
         sigfillset(&mask);
         if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
+        }
 …
                                         {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );}
                                         continue;
                                 case EINVAL :
+                        case EINVAL :
                                         abort( "Timeout was invalid." );
                                 default:
 …
 EXIT:
         __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
         return 0p;
+        return NULL;
+}
 …
         sigset_t oldset;
         int ret;
         ret = pthread_sigmask(0, 0p, &oldset);
+        ret = pthread_sigmask(0, NULL, &oldset);
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }

libcfa/src/concurrency/thread.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:17:49 2019
 // Update Count     : 9
+// Last Modified On : Fri Mar 30 17:19:52 2018
+// Update Count     : 8
 //
 …
 #include "invoke.h"
+extern "C" {
+        #include <fenv.h>
+        #include <stddef.h>
+}
+//extern volatile thread_local processor * this_processor;
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
 void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
         context{ 0p, 0p };
+void ?{}(thread_desc & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
+        context{ NULL, NULL };
         self_cor{ name, storage, storageSize };
         state = Start;
-        preempted = __NO_PREEMPTION;
         curr_cor = &self_cor;
         self_mon.owner = &this;
 …
         self_mon_p = &self_mon;
         curr_cluster = &cl;
         next = 0p;
+        next = NULL;
         node.next = 0p;
         node.prev = 0p;
+        node.next = NULL;
+        node.prev = NULL;
         doregister(curr_cluster, this);
 …
+}
 void ^?{}($thread& this) with( this ) {
+void ^?{}(thread_desc& this) with( this ) {
         unregister(curr_cluster, this);
         ^self_cor{};
+}
-//-----------------------------------------------------------------------------
-// Starting and stopping threads
-forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
-        $thread * this_thrd = get_thread(this);
-        disable_interrupts();
-        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
-        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
-        verify( this_thrd->context.SP );
-        __schedule_thread(this_thrd);
-        enable_interrupts( __cfaabi_dbg_ctx );
+}
-//-----------------------------------------------------------------------------
-// Support for threads that don't ues the thread keyword
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
         __thrd_start(handle, main);
+        __thrd_start(handle);
+}
 …
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
         __thrd_start(handle, main);
+        __thrd_start(handle);
+}
 …
+}
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+forall( dtype T | is_thread(T) )
+void __thrd_start( T& this ) {
+        thread_desc * this_thrd = get_thread(this);
+        thread_desc * curr_thrd = TL_GET( this_thread );
+        disable_interrupts();
+        CtxStart(&this, CtxInvokeThread);
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        verify( this_thrd->context.SP );
+        CtxSwitch( &curr_thrd->context, &this_thrd->context );
+        ScheduleThread(this_thrd);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+extern "C" {
+        // KERNEL ONLY
+        void __finish_creation(thread_desc * this) {
+                // set new coroutine that the processor is executing
+                // and context switch to it
+                verify( kernelTLS.this_thread != this );
+                verify( kernelTLS.this_thread->context.SP );
+                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
+        }
+}
+void yield( void ) {
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
+        BlockInternal( TL_GET( this_thread ) );
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
+}
+void yield( unsigned times ) {
+        for( unsigned i = 0; i < times; i++ ) {
+                yield();
+        }
+}
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec  4 09:18:14 2019
 // Update Count     : 6
+// Last Modified On : Fri Jun 21 17:51:33 2019
+// Update Count     : 5
 //
 …
       void ^?{}(T& mutex this);
       void main(T& this);
       $thread* get_thread(T& this);
+      thread_desc* get_thread(T& this);
 };
+// define that satisfies the trait without using the thread keyword
+#define DECL_THREAD(X) $thread* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
+// Inline getters for threads/coroutines/monitors
+forall( dtype T | is_thread(T) )
+static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 forall( dtype T | is_thread(T) )
+static inline $monitor  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
+static inline coroutine_desc* get_coroutine(T & this) {
+        return &get_thread(this)->self_cor;
+}
+static inline $coroutine* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; }
+static inline $monitor  * get_monitor  ($thread * this) __attribute__((const)) { return &this->self_mon; }
+forall( dtype T | is_thread(T) )
+static inline monitor_desc* get_monitor(T & this) {
+        return &get_thread(this)->self_mon;
+}
+//-----------------------------------------------------------------------------
+// forward declarations needed for threads
+static inline coroutine_desc* get_coroutine(thread_desc * this) {
+        return &this->self_cor;
+}
+static inline monitor_desc* get_monitor(thread_desc * this) {
+        return &this->self_mon;
+}
 extern struct cluster * mainCluster;
 forall( dtype T | is_thread(T) )
 void __thrd_start( T & this, void (*)(T &) );
+void __thrd_start( T & this );
 //-----------------------------------------------------------------------------
 // Ctors and dtors
 void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
 void ^?{}($thread & this);
+void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}(thread_desc & this);
 static inline void ?{}($thread & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
 static inline void ?{}($thread & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
 static inline void ?{}($thread & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
 static inline void ?{}($thread & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
 static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
 static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
 static inline void ?{}($thread & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, NULL, 65000 }; }
+static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, NULL, stackSize }; }
+static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, NULL, 65000 }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, NULL, stackSize }; }
+static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
+static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, NULL, 65000 }; }
+static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, NULL, 65000 }; }
+static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, NULL, stackSize }; }
 //-----------------------------------------------------------------------------
 …
 void ^?{}( scoped(T)& this );
+//-----------------------------------------------------------------------------
+// Thread getters
+static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
+void yield();
+void yield( unsigned times );
+//-----------------------------------------------------------------------------
+// Scheduler API
+//----------
+// Park thread: block until corresponding call to unpark, won't block if unpark is already called
+void park( void );
+//----------
+// Unpark a thread, if the thread is already blocked, schedule it
+//                  if the thread is not yet block, signal that it should rerun immediately
+void unpark( $thread * this );
+forall( dtype T | is_thread(T) )
+static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
+//----------
+// Yield: force thread to block and be rescheduled
+bool force_yield( enum __Preemption_Reason );
+static inline void yield() {
+        force_yield(__MANUAL_PREEMPTION);
+}
+// Yield: yield N times
+static inline void yield( unsigned times ) {
+        for( times ) {
+                yield();
+        }
+}
+static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }
 // Local Variables: //

libcfa/src/exception.c

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

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

libcfa/src/fstream.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Mon Jul 15 18:11:26 2019
+// Update Count     : 349
 //
 …
 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 ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
+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
 static ofstream soutFile = { (FILE *)stdout };
+static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_) };
 ofstream & sout = soutFile, & stdout = soutFile;
 static ofstream serrFile = { (FILE *)stderr };
+static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_) };
 ofstream & serr = serrFile, & stderr = serrFile;
 static ofstream exitFile = { (FILE *)stdout };
+static ofstream exitFile = { (FILE *)(&_IO_2_1_stdout_) };
 ofstream & exit = exitFile;
 static ofstream abortFile = { (FILE *)stderr };
+static ofstream abortFile = { (FILE *)(&_IO_2_1_stderr_) };
 ofstream & abort = abortFile;
 …
 // 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 ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
+void nlOn( ifstream & os ) { os.$nlOnOff = true; }
+void nlOff( ifstream & os ) { os.$nlOnOff = false; }
+bool getANL( ifstream & os ) { return os.$nlOnOff; }
+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
 …
 } // fmt
+static ifstream sinFile = { (FILE *)stdin };
+static ifstream sinFile = { (FILE *)(&_IO_2_1_stdin_) };
 ifstream & sin = sinFile, & stdin = sinFile;

libcfa/src/fstream.hfa

-              r3d5701e
+              r9fb8f01
 // 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 : Mon Jul 15 18:10:23 2019
+// Update Count     : 167
 //
 …
 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 );
+void ?{}( ofstream & os, const char * name, const char * mode );
+void ?{}( ofstream & os, const char * name );
 extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
 …
 struct ifstream {
         void * $file;
         bool $nlOnOff;
+        void * file;
+        bool nlOnOff;
 }; // ifstream
 …
 int fail( ifstream & is );
 int eof( ifstream & is );
 void open( ifstream & is, const char name[], const char mode[] );
 void open( ifstream & is, const char name[] );
+void open( ifstream & is, const char * name, const char * mode );
+void open( ifstream & is, const char * name );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
 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 );
+void ?{}( ifstream & is, const char * name, const char * mode );
+void ?{}( ifstream & is, const char * name );
 extern ifstream & sin, & stdin;                                                 // aliases

libcfa/src/gmp.hfa

-              r3d5701e
+              r9fb8f01
 // 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

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

libcfa/src/interpose.cfa

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

libcfa/src/iostream.cfa

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 : Wed Jul 25 16:42:01 2018
+// Update Count     : 11
 //
-#include <time.h>                                                                               // tzset
 #include "startup.hfa"
+#include <unistd.h>
 extern "C" {
     void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
+    static void __cfaabi_appready_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_startup( void ) {
-                tzset();                                                                                // initialize time global variables
                 #ifdef __CFA_DEBUG__
                 extern void heapAppStart();
 …
     } // __cfaabi_appready_startup
     void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
+    static void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
     void __cfaabi_appready_shutdown( void ) {
                 #ifdef __CFA_DEBUG__
 …
 struct __spinlock_t;
 extern "C" {
         void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
+        void __cfaabi_dbg_record(struct __spinlock_t & this, const char * prev_name) __attribute__(( weak )) {}
+}

libcfa/src/stdhdr/assert.h

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Jul 22 13:49:30 2018
+// Update Count     : 4
 //
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Jul 22 13:49:58 2018
+// Update Count     : 4
 //
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Jul 22 13:50:24 2018
+// Update Count     : 4
 //
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 : Thu Feb 22 18:16:07 2018
+// Update Count     : 13
 //
 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

-              r3d5701e
+              r9fb8f01
 // 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 : Thu Feb  8 23:50:44 2018
+// Update Count     : 4
 //
 #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

-              r3d5701e
+              r9fb8f01
 // 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 : Mon Jun 24 17:34:44 2019
+// Update Count     : 462
 //
 …
 #include <string.h>                                                                             // memcpy, memset
 #include <malloc.h>                                                                             // malloc_usable_size
 //#include <math.h>                                                                             // fabsf, fabs, fabsl
+#include <math.h>                                                                               // fabsf, fabs, fabsl
 #include <complex.h>                                                                    // _Complex_I
 #include <assert.h>
 …
 //---------------------------------------
+forall( dtype T | sized(T) ) {
+        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_set
+        T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
+                size_t olen = malloc_usable_size( ptr );                // current allocation
+                void * nptr = (void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+                // char * nptr = alloc_align( ptr, align );
+                size_t nlen = malloc_usable_size( nptr );               // new allocation
+                if ( nlen > olen ) {                                                    // larger ?
+                        memset( (char *)nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+                } // if
+                return (T *)nptr;
+        } // alloc_align_set
+} // distribution
+// resize, non-array types
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
+        size_t olen = malloc_usable_size( ptr );                        // current allocation
+    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+        size_t nlen = malloc_usable_size( nptr );                       // new allocation
+        if ( nlen > olen ) {                                                            // larger ?
+                memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
+        } //
+    return (T *)nptr;
+} // alloc
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
         return &(*malloc()){ p };                                                       // run constructor
+        return &(*malloc()){ p };                                                               // run constructor
 } // new
 …
 void delete( T * ptr ) {
         if ( ptr ) {                                                                            // ignore null
                 ^(*ptr){};                                                                              // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
 …
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {                                                                            // ignore null
                 ^(*ptr){};                                                                              // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
 …
 //---------------------------------------
 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

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Jul 23 14:14:59 2019
+// Update Count     : 373
 //
 …
         void * memset( void * dest, int fill, size_t size ); // string.h
         void * memcpy( void * dest, const void * src, size_t size ); // string.h
     void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
+    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA
 } // extern "C"
-void * realloc( void * oaddr, size_t nalign, size_t size ); // CFA heap
 //---------------------------------------
 …
         } // calloc
+        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
+                return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
+        T * realloc( T * ptr, size_t size ) {
+                if ( unlikely( ptr == 0 ) ) return malloc();
+                return (T *)(void *)realloc( (void *)ptr, size );
         } // realloc
         T * memalign( size_t align ) {
                 return (T *)memalign( align, sizeof(T) );               // C memalign
+                return (T *)memalign( align, sizeof(T) );
         } // memalign
-        T * cmemalign( size_t align, size_t dim  ) {
-                return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
-        } // cmemalign
         T * aligned_alloc( size_t align ) {
                 return (T *)aligned_alloc( align, sizeof(T) );  // C aligned_alloc
+                return (T *)aligned_alloc( align, sizeof(T) );
         } // aligned_alloc
 …
         } // posix_memalign
         // Cforall dynamic allocation
 …
         } // alloc
+        T * alloc( char fill ) {
+                T * ptr;
+                if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc
         T * alloc( size_t dim ) {
                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) );
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
                 else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
         } // alloc
+        T * alloc( T ptr[], size_t dim ) {                                      // realloc
+                return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+        } // alloc
+        T * alloc_set( char fill ) {
+                return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc
+        T * alloc_set( T fill ) {
+                return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
+        } // alloc
+        T * alloc_set( size_t dim, char fill ) {
+        T * alloc( size_t dim, char fill ) {
                 return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
         } // alloc
+        T * alloc_set( size_t dim, T fill ) {
+                T * r = (T *)alloc( dim );
+                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
+                return r;
+        } // alloc
+        T * alloc_set( size_t dim, const T fill[] ) {
+                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc
+} // distribution
+forall( dtype T | sized(T) ) {
+        T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
+} // distribution
+static inline forall( dtype T | sized(T) ) {
+        T * alloc_align( size_t align ) {
+        T * alloc( T ptr[], size_t dim ) {
+                return realloc( ptr, dim * sizeof(T) );
+        } // alloc
+} // distribution
+static inline forall( dtype T | sized(T) ) {
+        T * align_alloc( size_t align ) {
                 return (T *)memalign( align, sizeof(T) );
+        } // alloc_align
+        T * alloc_align( size_t align, size_t dim ) {
+        } // align_alloc
+        T * align_alloc( size_t align, char fill ) {
+                T * ptr = (T *)memalign( align, sizeof(T) );
+                return (T *)memset( ptr, (int)fill, sizeof(T) );
+        } // align_alloc
+        T * align_alloc( size_t align, size_t dim ) {
                 return (T *)memalign( align, dim * sizeof(T) );
+        } // alloc_align
+        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
+        } // alloc_align
+        T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+                return (T *)(void *)realloc( (void *)ptr, align, dim * sizeof(T) ); // CFA realloc
+        } // alloc_align
+        T * alloc_align_set( size_t align, char fill ) {
+                return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
+        } // alloc_align
+        T * alloc_align_set( size_t align, T fill ) {
+                return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
+        } // alloc_align
+        T * alloc_align_set( size_t align, size_t dim, char fill ) {
+                return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+        } // alloc_align
+        T * alloc_align_set( size_t align, size_t dim, T fill ) {
+                T * r = (T *)alloc_align( align, dim );
+                for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
+                return r;
+        } // alloc_align
+        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
+                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
+        } // alloc_align
+} // distribution
+forall( dtype T | sized(T) ) {
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
+} // distribution
+        } // align_alloc
+        T * align_alloc( size_t align, size_t dim, char fill ) {
+                if ( fill == '\0' ) {
+                        return (T *)cmemalign( align, dim, sizeof(T) );
+                } else {
+                        return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
+                } // if
+        } // align_alloc
+} // distribution
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
 static inline forall( dtype T | sized(T) ) {
         // data, non-array types
         T * memset( T * dest, char fill ) {
                 return (T *)memset( dest, fill, sizeof(T) );
 …
 static inline forall( dtype T | sized(T) ) {
         // data, array types
         T * amemset( T dest[], char fill, size_t dim ) {
                 return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset
 …
 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, 0, 10 ); }
+        unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
+        long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
+        unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
+        long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
+        unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
+        float ato( const char * sptr ) { return strtof( sptr, 0 ); }
+        double ato( const char * sptr ) { return strtod( sptr, 0 ); }
+        long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
+        float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+        double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
+        long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
 } // distribution

libcfa/src/time.cfa

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

libcfa/src/time.hfa

-              r3d5701e
+              r9fb8f01
 // 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 : Sat Sep 22 12:25:34 2018
+// Update Count     : 643
 //
 …
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
         Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
         Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn + rhs.tn }; }
+        Duration +?( Duration rhs ) with( rhs ) {       return (Duration)@{ +tv }; }
+        Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
         Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
         Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tn }; }
         Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
+        Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
+        Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
         Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
         Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn * rhs }; }
         Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tn }; }
+        Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
+        Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
         Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
         int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tn / rhs.tn; }
         Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tn / rhs }; }
+        int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
+        Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
         Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
         double div( Duration lhs, Duration rhs ) { return (double)lhs.tn / (double)rhs.tn; }
         Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
+        double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
+        Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
         bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
         bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tn != rhs.tn; }
         bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tn <  rhs.tn; }
         bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tn <= rhs.tn; }
         bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
         bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
         bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
         bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
         bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
         bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
         bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
         bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
         Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
+        bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
+        bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
+        bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
+        bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
+        bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
+        bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
+        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv == 0; }
+        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv != 0; }
+        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <  0; }
+        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv <= 0; }
+        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >  0; }
+        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tv >= 0; }
+        Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
         Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
 …
         Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
         int64_t ?`ns( Duration dur ) { return dur.tn; }
         int64_t ?`us( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000_000LL); }
         int64_t ?`ms( Duration dur ) { return dur.tn / (TIMEGRAN / 1_000LL); }
         int64_t ?`s( Duration dur ) { return dur.tn / TIMEGRAN; }
         int64_t ?`m( Duration dur ) { return dur.tn / (60LL * TIMEGRAN); }
         int64_t ?`h( Duration dur ) { return dur.tn / (60LL * 60LL * TIMEGRAN); }
         int64_t ?`d( Duration dur ) { return dur.tn / (24LL * 60LL * 60LL * TIMEGRAN); }
         int64_t ?`w( Duration dur ) { return dur.tn / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
         Duration max( Duration lhs, Duration rhs ) { return  (lhs.tn < rhs.tn) ? rhs : lhs;}
         Duration min( Duration lhs, Duration rhs ) { return !(rhs.tn < lhs.tn) ? lhs : rhs;}
+        int64_t ?`ns( Duration dur ) { return dur.tv; }
+        int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
+        int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
+        int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
+        int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
+        int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
+        int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
+        int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+        Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
+        Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
 } // distribution
 …
 //######################### Time #########################
 void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
+void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
 static inline {
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
         void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
         void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+        void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
                 return time;
         } // ?=?
         Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tn + rhs.tn }; }
+        Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
         Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
         Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
         Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tn - rhs.tn }; }
         Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tn - rhs.tn }; }
+        Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+        Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
         Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+        bool ?==?( Time lhs, Time rhs ) { return lhs.tn == rhs.tn; }
+        bool ?!=?( Time lhs, Time rhs ) { return lhs.tn != rhs.tn; }
+        bool ?<?( Time lhs, Time rhs ) { return lhs.tn < rhs.tn; }
+        bool ?<=?( Time lhs, Time rhs ) { return lhs.tn <= rhs.tn; }
+        bool ?>?( Time lhs, Time rhs ) { return lhs.tn > rhs.tn; }
+        bool ?>=?( Time lhs, Time rhs ) { return lhs.tn >= rhs.tn; }
+        int64_t ?`ns( Time t ) { return t.tn; }
+        bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
+        bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
+        bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
+        bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
+        bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
+        bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
 } // distribution
 …
 } // dmy
 size_t strftime( char buf[], size_t size, const char fmt[], Time time );
+size_t strftime( char * buf, size_t size, const char * fmt, Time time );
 //------------------------- timeval (cont) -------------------------
 static inline void ?{}( timeval & t, Time time ) with( t, time ) {
         tv_sec = tn / TIMEGRAN;                                                         // seconds
         tv_usec = tn % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
+        tv_sec = tv / TIMEGRAN;                                                         // seconds
+        tv_usec = tv % TIMEGRAN / (TIMEGRAN / 1_000_000LL);     // microseconds
 } // ?{}
 …
 static inline void ?{}( timespec & t, Time time ) with( t, time ) {
         tv_sec = tn / TIMEGRAN;                                                         // seconds
         tv_nsec = tn % TIMEGRAN;                                                        // nanoseconds
+        tv_sec = tv / TIMEGRAN;                                                         // seconds
+        tv_nsec = tv % TIMEGRAN;                                                        // nanoseconds
 } // ?{}

libcfa/src/time_t.hfa

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

longrun_tests/Makefile.am

-              r3d5701e
+              r9fb8f01
         -I$(abs_top_srcdir)/tests \
         -I$(srcdir) \
+        -DTEST_$(shell cat .type | tr a-z A-Z)
+        -DTEST_$(shell cat .type | tr a-z A-Z) \
+        -in-tree
 TESTS = block coroutine create disjoint enter enter3 processor stack wait yield

longrun_tests/Makefile.in

-              r3d5701e
+              r9fb8f01
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@
 …
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
-AM_V_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_1 =
-AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
-am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS  " $@;
-am__v_NODEJS_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =
 repeats = 10
 max_time = 600
 …
         -I$(abs_top_srcdir)/tests \
         -I$(srcdir) \
+        -DTEST_$(shell cat .type | tr a-z A-Z)
+        -DTEST_$(shell cat .type | tr a-z A-Z) \
+        -in-tree
 TESTS = block coroutine create disjoint enter enter3 processor stack wait yield

src/AST/Convert.cpp

-              r3d5701e
+              r9fb8f01
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:39:32 2019
 // Update Count     : 33
+// Last Modified On : Thu Jul 25 22:21:46 2019
+// Update Count     : 13
 //
 …
                 auto decl = new StructDecl(
                         node->name,
                         (AggregateDecl::Aggregate)node->kind,
+                        node->kind,
                         get<Attribute>().acceptL( node->attributes ),
                         LinkageSpec::Spec( node->linkage.val )
 …
         const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
+                AggregateDecl::Aggregate castTarget = (AggregateDecl::Aggregate)node->target;
+                assert( AggregateDecl::Generator <= castTarget && castTarget <= AggregateDecl::Thread );
+                KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
+                switch (node->target) {
+                        case ast::KeywordCastExpr::Coroutine:
+                                castTarget = KeywordCastExpr::Coroutine;
+                                break;
+                        case ast::KeywordCastExpr::Thread:
+                                castTarget = KeywordCastExpr::Thread;
+                                break;
+                        case ast::KeywordCastExpr::Monitor:
+                                castTarget = KeywordCastExpr::Monitor;
+                                break;
+                        default:
+                                break;
+                }
+                assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
                 auto expr = visitBaseExpr( node,
                         new KeywordCastExpr(
 …
                 auto expr = visitBaseExpr( node,
                         new AsmExpr(
                                 new std::string(node->inout),
+                                get<Expression>().accept1(node->inout),
                                 get<Expression>().accept1(node->constraint),
                                 get<Expression>().accept1(node->operand)
 …
                                 cv( node ),
                                 node->name,
                                 node->kind == ast::TypeDecl::Ftype,
+                                node->kind == ast::TypeVar::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
                         };
 …
                         old->location,
                         old->name,
                         (ast::AggregateDecl::Aggregate)old->kind,
+                        old->kind,
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->linkage.val }
 …
                         { old->storageClasses.val },
                         GET_ACCEPT_1(base, Type),
                         (ast::TypeDecl::Kind)(unsigned)old->kind,
+                        (ast::TypeVar::Kind)(unsigned)old->kind,
                         old->sized,
                         GET_ACCEPT_1(init, Type)
 …
+        }
+        virtual void visit( const KeywordCastExpr * old ) override final {
+                ast::AggregateDecl::Aggregate castTarget = (ast::AggregateDecl::Aggregate)old->target;
+                assert( ast::AggregateDecl::Generator <= castTarget && castTarget <= ast::AggregateDecl::Thread );
+        virtual void visit( const KeywordCastExpr * old) override final {
+                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
+                switch (old->target) {
+                        case KeywordCastExpr::Coroutine:
+                                castTarget = ast::KeywordCastExpr::Coroutine;
+                                break;
+                        case KeywordCastExpr::Thread:
+                                castTarget = ast::KeywordCastExpr::Thread;
+                                break;
+                        case KeywordCastExpr::Monitor:
+                                castTarget = ast::KeywordCastExpr::Monitor;
+                                break;
+                        default:
+                                break;
+                }
+                assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
                 this->node = visitBaseExpr( old,
                         new ast::KeywordCastExpr(
 …
                         new ast::AsmExpr(
                                 old->location,
                                 old->inout,
+                                GET_ACCEPT_1(inout, Expr),
                                 GET_ACCEPT_1(constraint, Expr),
                                 GET_ACCEPT_1(operand, Expr)
 …
                         ty = new ast::TypeInstType{
                                 old->name,
                                 old->isFtype ? ast::TypeDecl::Ftype : ast::TypeDecl::Dtype,
+                                old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
                                 cv( old ),
                                 GET_ACCEPT_V( attributes, Attribute )

src/AST/Decl.cpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 16:23:15 2019
 // Update Count     : 20
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu May 9 10:00:00 2019
+// Update Count     : 1
 //
 …
 #include <cassert>             // for assert, strict_dynamic_cast
 #include <iostream>
+#include <string>
 #include <unordered_map>
 …
 #include "Node.hpp"            // for readonly
 #include "Type.hpp"            // for readonly
+#include "Parser/ParseNode.h"  // for DeclarationNode
 namespace ast {
 …
 // --- TypeDecl
+const char * TypeDecl::typeString() const {
+        static const char * kindNames[] = { "sized data type", "sized object type", "sized function type", "sized tuple type" };
+        static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
+        assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
+        return sized ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0'
+std::string TypeDecl::typeString() const {
+        static const std::string kindNames[] = { "object type", "function type", "tuple type" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1,
+                "typeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
+        return (sized ? "sized " : "") + kindNames[ kind ];
+}
 const char * TypeDecl::genTypeString() const {
         static const char * kindNames[] = { "dtype", "otype", "ftype", "ttype" };
         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "genTypeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
+std::string TypeDecl::genTypeString() const {
+        static const std::string kindNames[] = { "dtype", "ftype", "ttype" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
         return kindNames[ kind ];
+}
 …
 std::ostream & operator<< ( std::ostream & out, const TypeDecl::Data & data ) {
         return out << data.kind << ", " << data.isComplete;
+}
-// --- AggregateDecl
-// These must harmonize with the corresponding AggregateDecl::Aggregate enumerations.
-static const char * aggregateNames[] = { "struct", "union", "enum", "exception", "trait", "generator", "coroutine", "monitor", "thread", "NoAggregateName" };
-const char * AggregateDecl::aggrString( AggregateDecl::Aggregate aggr ) {
-        return aggregateNames[aggr];
+}

src/AST/Decl.hpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 17:38:33 2019
 // Update Count     : 29
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu May 9 10:00:00 2019
+// Update Count     : 1
 //
 …
 #include <unordered_map>
 #include <vector>
-#include <algorithm>
 #include "FunctionSpec.hpp"
 …
 #include "ParseNode.hpp"
 #include "StorageClasses.hpp"
+#include "TypeVar.hpp"
 #include "Visitor.hpp"
+#include "Common/utility.h"
+#include "Common/SemanticError.h"                                               // error_str
+#include "Parser/ParseNode.h"  // for DeclarationNode::Aggregate
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
 …
         std::vector< ptr<Expr> > withExprs;
         FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
+        FunctionDecl( const CodeLocation & loc, const std::string &name, FunctionType * type,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
 …
         bool has_body() const { return stmts; }
         const DeclWithType * accept( Visitor & v ) const override { return v.visit( this ); }
+        const DeclWithType * accept( Visitor &v ) const override { return v.visit( this ); }
 private:
         FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
 …
         /// Produces a name for the kind of alias
         virtual const char * typeString() const = 0;
+        virtual std::string typeString() const = 0;
 private:
 …
 /// Cforall type variable: `dtype T`
 class TypeDecl final : public NamedTypeDecl {
+  public:
+        enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS };
+        Kind kind;
+public:
+        TypeVar::Kind kind;
         bool sized;
         ptr<Type> init;
 …
         /// Data extracted from a type decl
         struct Data {
                 Kind kind;
+                TypeVar::Kind kind;
                 bool isComplete;
                 Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {}
+                Data() : kind( (TypeVar::Kind)-1 ), isComplete( false ) {}
                 Data( const TypeDecl * d ) : kind( d->kind ), isComplete( d->sized ) {}
                 Data( Kind k, bool c ) : kind( k ), isComplete( c ) {}
+                Data( TypeVar::Kind k, bool c ) : kind( k ), isComplete( c ) {}
                 Data( const Data & d1, const Data & d2 )
+                        : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
+                bool operator==( const Data & o ) const { return kind == o.kind && isComplete == o.isComplete; }
+                bool operator!=( const Data & o ) const { return !(*this == o); }
+                : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
+                bool operator== ( const Data & o ) const {
+                        return kind == o.kind && isComplete == o.isComplete;
+                }
+                bool operator!= ( const Data & o ) const { return !(*this == o); }
         };
         TypeDecl( const CodeLocation & loc, const std::string & name, Storage::Classes storage, Type * b,
                           Kind k, bool s, Type * i = nullptr )
                 : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ),
                 init( i ) {}
         const char * typeString() const override;
+        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
+                TypeVar::Kind k, bool s, Type* i = nullptr )
+        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ),
+          init( i ) {}
+        std::string typeString() const override;
         /// Produces a name for generated code
         const char * genTypeString() const;
+        std::string genTypeString() const;
         /// convenience accessor to match Type::isComplete()
 …
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
   private:
+private:
         TypeDecl * clone() const override { return new TypeDecl{ *this }; }
         MUTATE_FRIEND
 …
         : NamedTypeDecl( loc, name, storage, b, spec ) {}
         const char * typeString() const override { return "typedef"; }
+        std::string typeString() const override { return "typedef"; }
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 class AggregateDecl : public Decl {
 public:
-        enum Aggregate { Struct, Union, Enum, Exception, Trait, Generator, Coroutine, Monitor, Thread, NoAggregate };
-        static const char * aggrString( Aggregate aggr );
         std::vector<ptr<Decl>> members;
         std::vector<ptr<TypeDecl>> params;
 …
         /// Produces a name for the kind of aggregate
         virtual const char * typeString() const = 0;
+        virtual std::string typeString() const = 0;
 private:
 …
 class StructDecl final : public AggregateDecl {
 public:
         Aggregate kind;
+        DeclarationNode::Aggregate kind;
         StructDecl( const CodeLocation& loc, const std::string& name,
                 Aggregate kind = Struct,
+                DeclarationNode::Aggregate kind = DeclarationNode::Struct,
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
         : AggregateDecl( loc, name, std::move(attrs), linkage ), kind( kind ) {}
         bool is_coroutine() { return kind == Coroutine; }
         bool is_monitor() { return kind == Monitor; }
         bool is_thread() { return kind == Thread; }
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
         const char * typeString() const override { return aggrString( kind ); }
+        bool is_coroutine() { return kind == DeclarationNode::Coroutine; }
+        bool is_monitor() { return kind == DeclarationNode::Monitor; }
+        bool is_thread() { return kind == DeclarationNode::Thread; }
+        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
+        std::string typeString() const override { return "struct"; }
 private:
 …
         const Decl * accept( Visitor& v ) const override { return v.visit( this ); }
         const char * typeString() const override { return aggrString( Union ); }
+        std::string typeString() const override { return "union"; }
 private:
 …
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
         const char * typeString() const override { return aggrString( Enum ); }
+        std::string typeString() const override { return "enum"; }
 private:
 …
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
         const char * typeString() const override { return "trait"; }
+        std::string typeString() const override { return "trait"; }
 private:
 …
         ptr<AsmStmt> stmt;
         AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
+        AsmDecl( const CodeLocation & loc, AsmStmt *stmt )
         : Decl( loc, "", {}, {} ), stmt(stmt) {}
         const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         AsmDecl * clone() const override { return new AsmDecl( *this ); }
+        const AsmDecl * accept( Visitor &v ) const override { return v.visit( this ); }
+private:
+        AsmDecl *clone() const override { return new AsmDecl( *this ); }
         MUTATE_FRIEND
 };
 …
         : Decl( loc, "", {}, {} ), cond( condition ), msg( msg ) {}
         const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }
+        const StaticAssertDecl * accept( Visitor &v ) const override { return v.visit( this ); }
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }

src/AST/Expr.cpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Wed May 15 17:00:00 2019
 // Last Modified By : Peter A. Buhr
+// Last Modified By : Andrew Beach
 // Created On       : Thr Jun 13 13:38:00 2019
 // Update Count     : 6
+// Update Count     : 2
 //
 …
 // --- KeywordCastExpr
+const char * KeywordCastExpr::targetString() const {
+        return AggregateDecl::aggrString( target );
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}

src/AST/Expr.hpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Fri May 10 10:30:00 2019
 // Last Modified By : Peter A. Buhr
+// Last Modified By : Aaron B. Moss
 // Created On       : Fri May 10 10:30:00 2019
 // Update Count     : 7
+// Update Count     : 1
 //
 …
 #include "Fwd.hpp"        // for UniqueId
 #include "Label.hpp"
-#include "Decl.hpp"
 #include "ParseNode.hpp"
 #include "Visitor.hpp"
 …
 public:
         ptr<Expr> arg;
         ast::AggregateDecl::Aggregate target;
         KeywordCastExpr( const CodeLocation & loc, const Expr * a, ast::AggregateDecl::Aggregate t )
+        enum Target { Coroutine, Thread, Monitor, NUMBER_OF_TARGETS } target;
+        KeywordCastExpr( const CodeLocation & loc, const Expr * a, Target t )
         : Expr( loc ), arg( a ), target( t ) {}
         /// Get a name for the target type
         const char * targetString() const;
+        const std::string& targetString() const;
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 class AsmExpr final : public Expr {
 public:
         std::string inout;
+        ptr<Expr> inout;
         ptr<Expr> constraint;
         ptr<Expr> operand;
         AsmExpr( const CodeLocation & loc, const std::string & io, const Expr * con, const Expr * op )
+        AsmExpr( const CodeLocation & loc, const Expr * io, const Expr * con, const Expr * op )
         : Expr( loc ), inout( io ), constraint( con ), operand( op ) {}

src/AST/Pass.impl.hpp

r3d5701e	r9fb8f01
1300	1300	maybe_accept( node, &AsmExpr::result );
1301	1301	}
	1302	maybe_accept( node, &AsmExpr::inout );
1302	1303	maybe_accept( node, &AsmExpr::constraint );
1303	1304	maybe_accept( node, &AsmExpr::operand );

src/AST/Print.cpp

-              r3d5701e
+              r9fb8f01
                 os << "Asm Expression:" << endl;
                 ++indent;
                 if ( !node->inout.empty() ) os << "[" << node->inout << "] ";
+                if ( node->inout ) node->inout->accept( *this );
                 if ( node->constraint ) node->constraint->accept( *this );
                 if ( node->operand ) node->operand->accept( *this );
 …
                 preprint( node );
                 os << "instance of type " << node->name
                    << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
+                   << " (" << (node->kind == ast::TypeVar::Ftype ? "" : "not ") << "function type)";
                 print( node->params );

src/AST/Type.cpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 15 16:56:28 2019
 // Update Count     : 4
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon May 13 15:00:00 2019
+// Update Count     : 1
 //
 …
 // --- BasicType
+// GENERATED START, DO NOT EDIT
+// GENERATED BY BasicTypes-gen.cc
+const char * BasicType::typeNames[] = {
+const char *BasicType::typeNames[] = {
         "_Bool",
         "char",
 …
         "_Float128x _Complex",
 };
+// GENERATED END
+static_assert(
+        sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+        "Each basic type name should have a corresponding kind enum value"
+);
 // --- FunctionType

src/AST/Type.hpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:56:46 2019
 // Update Count     : 5
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu May 9 10:00:00 2019
+// Update Count     : 1
 //
 …
 #include "Fwd.hpp"
 #include "Node.hpp"          // for Node, ptr, ptr_base
+#include "TypeVar.hpp"
 #include "Visitor.hpp"
 …
 public:
         readonly<TypeDecl> base;
         TypeDecl::Kind kind;
+        TypeVar::Kind kind;
         TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
+        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}

src/AST/TypeEnvironment.cpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Wed May 29 11:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:49:13 2019
 // Update Count     : 4
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed May 29 11:00:00 2019
+// Update Count     : 1
 //
 …
                 return true;
         } else if ( auto typeInst = dynamic_cast< const TypeInstType * >( type ) ) {
                 return typeInst->kind == TypeDecl::Ftype;
+                return typeInst->kind == TypeVar::Ftype;
         } else return false;
+}
 …
         bool tyVarCompatible( const TypeDecl::Data & data, const Type * type ) {
                 switch ( data.kind ) {
                   case TypeDecl::Dtype:
+                  case TypeVar::Dtype:
                         // to bind to an object type variable, the type must not be a function type.
                         // if the type variable is specified to be a complete type then the incoming
 …
                         // xxx - should this also check that type is not a tuple type and that it's not a ttype?
                         return ! isFtype( type ) && ( ! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
+                  case TypeVar::Ftype:
                         return isFtype( type );
                   case TypeDecl::Ttype:
+                  case TypeVar::Ttype:
                         // ttype unifies with any tuple type
                         return dynamic_cast< const TupleType * >( type ) || Tuples::isTtype( type );

src/AST/TypeEnvironment.hpp

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron B. Moss
 // Created On       : Wed May 29 11:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:55:54 2019
 // Update Count     : 3
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed May 29 11:00:00 2019
+// Update Count     : 1
 //
 …
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
+#include "TypeVar.hpp"
 #include "Common/Indenter.h"
 #include "ResolvExpr/WidenMode.h"
 …
         /// Singleton class constructor from substitution
         EqvClass( const std::string & v, const Type * b )
         : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
+        : vars{ v }, bound( b ), allowWidening( false ), data( TypeVar::Dtype, false ) {}
         /// Single-var constructor (strips qualifiers from bound type)

src/AST/module.mk

-              r3d5701e
+              r9fb8f01
 ## Author           : Thierry Delisle
 ## Created On       : Thu May 09 16:05:36 2019
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Dec 14 07:29:10 2019
 ## Update Count     : 3
+## Last Modified By :
+## Last Modified On :
+## Update Count     :
 ###############################################################################
 …
         AST/TypeSubstitution.cpp
 SRC += $(SRC_AST)
 SRCDEMANGLE += $(SRC_AST)

src/BasicTypes-gen.cc

-              r3d5701e
+              r9fb8f01
         #define TypeH TOP_SRCDIR "src/SynTree/Type.h"
         resetInput( file, TypeH, buffer, code, str );
         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH );
+        #define Type TOP_SRCDIR "src/SynTree/Type.h"
+        resetInput( file, Type, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", Type );
         start += sizeof( STARTMK );                                                     // includes newline
         code << str.substr( 0, start );
 …
         code << "\t";                                                                           // indentation for end marker
         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH );
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", Type );
         code << str.substr( start );
         output( file, TypeH, code );
+        output( file, Type, code );
         // cout << code.str();
-        #define TypeC TOP_SRCDIR "src/SynTree/Type.cc"
-        resetInput( file, TypeC, buffer, code, str );
-        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC );
-        start += sizeof( STARTMK );                                                     // includes newline
-        code << str.substr( 0, start );
-        code << BYMK << endl;
-        code << "const char * BasicType::typeNames[] = {" << endl;
-        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
-                code << "\t\"" << graph[r].type << "\"," << endl;
-        } // for
-        code << "};" << endl;
-        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC );
-        code << str.substr( start );
-        output( file, TypeC, code );
-        // cout << code.str();
         // TEMPORARY DURING CHANGE OVER
         #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
         resetInput( file, TypeH_AST, buffer, code, str );
         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH_AST );
+        #define TypeAST TOP_SRCDIR "src/AST/Type.hpp"
+        resetInput( file, TypeAST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeAST );
         start += sizeof( STARTMK );                                                     // includes newline
         code << str.substr( 0, start );
 …
         code << "\t";                                                                           // indentation for end marker
         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeAST );
         code << str.substr( start );
+        output( file, TypeH_AST, code );
+        // cout << code.str();
+        #define TypeC_AST TOP_SRCDIR "src/AST/Type.cpp"
+        resetInput( file, TypeC_AST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC_AST );
+        start += sizeof( STARTMK );                                                     // includes newline
+        code << str.substr( 0, start );
+        code << BYMK << endl;
+        code << "const char * BasicType::typeNames[] = {" << endl;
+        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
+                code << "\t\"" << graph[r].type << "\"," << endl;
+        } // for
+        code << "};" << endl;
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC_AST );
+        code << str.substr( start );
+        output( file, TypeC_AST, code );
+        output( file, TypeAST, code );
         // cout << code.str();

src/CodeGen/CodeGenerator.cc

-              r3d5701e
+              r9fb8f01
 // 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 08:32:48 2020
 // Update Count     : 532
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 497
 //
 #include "CodeGenerator.h"
 …
 #include "InitTweak/InitTweak.h"     // for getPointerBase
 #include "OperatorTable.h"           // for OperatorInfo, operatorLookup
 #include "SynTree/LinkageSpec.h"     // for Spec, Intrinsic
+#include "Parser/LinkageSpec.h"      // for Spec, Intrinsic
 #include "SynTree/Attribute.h"       // for Attribute
 #include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
 …
         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 ) << " */ ";
+                        }
+                } );
+        }
 …
                 // deleted decls should never be used, so don't print them
                 if ( objectDecl->isDeleted && options.genC ) return;
+                // gcc allows an empty declarator (no name) for bit-fields and C states: 6.7.2.1 Structure and union specifiers,
+                // point 4, page 113: If the (bit field) value is zero, the declaration shall have no declarator.  For anything
+                // else, the anonymous name refers to the anonymous object for plan9 inheritance.
+                if ( objectDecl->get_name().empty() && options.genC && ! objectDecl->get_bitfieldWidth() ) {
+                if (objectDecl->get_name().empty() && options.genC ) {
                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
                         static UniqueName name = { "__anonymous_object" };
                         objectDecl->set_name( name.newName() );
                         // Stops unused parameter warnings.
                         if ( options.anonymousUnused ) {
                                 objectDecl->attributes.push_back( new Attribute( "unused" ) );
+                        }
+            // Stops unused parameter warnings.
+            if ( options.anonymousUnused ) {
+                objectDecl->attributes.push_back( new Attribute( "unused" ) );
+            }
+                }
 …
                 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() );
 …
         void CodeGenerator::postvisit( AsmExpr * asmExpr ) {
                 if ( !asmExpr->inout.empty() ) {
+                if ( asmExpr->get_inout() ) {
                         output << "[ ";
                         output << asmExpr->inout;
+                        asmExpr->get_inout()->accept( *visitor );
                         output << " ] ";
                 } // if
                 asmExpr->constraint->accept( *visitor );
+                asmExpr->get_constraint()->accept( *visitor );
                 output << " ( ";
                 asmExpr->operand->accept( *visitor );
+                asmExpr->get_operand()->accept( *visitor );
                 output << " )";
+        }
 …
                   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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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 Jul 21 22:16:59 2017
+// Update Count     : 1
 //
 …
 #include <memory>
 #include "SynTree/LinkageSpec.h"
+#include "Parser/LinkageSpec.h"
 class FunctionDecl;
 …
                 static std::unique_ptr<FunctionDecl> main_signature;
         };
 } // namespace CodeGen
+};

src/CodeGen/FixNames.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:39:14 2019
 // Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:26:00 2017
+// Update Count     : 20
 //
 …
 #include "Common/SemanticError.h"  // for SemanticError
 #include "FixMain.h"               // for FixMain
+#include "Parser/LinkageSpec.h"    // for Cforall, isMangled
 #include "SymTab/Mangler.h"        // for Mangler
-#include "SynTree/LinkageSpec.h"   // for Cforall, isMangled
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for FunctionDecl, ObjectDecl, Declarat...

src/CodeGen/GenType.cc

-              r3d5701e
+              r9fb8f01
                         typeString = "_Atomic " + typeString;
                 } // if
+                if ( type->get_lvalue() && ! options.genC ) {
+                        // when not generating C code, print lvalue for debugging.
+                        typeString = "lvalue " + typeString;
+                }
+        }
 } // namespace CodeGen

src/CodeGen/GenType.h

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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:01:51 2020
 // Update Count     : 9
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug 18 15:39:00 2017
+// Update Count     : 7
 //
 #include "Generate.h"
 …
 #include "GenType.h"                 // for genPrettyType
 #include "Common/PassVisitor.h"      // for PassVisitor
 #include "SynTree/LinkageSpec.h"     // for isBuiltin, isGeneratable
+#include "Parser/LinkageSpec.h"      // for isBuiltin, isGeneratable
 #include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
 #include "SynTree/Declaration.h"     // for Declaration
 …
         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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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/CodeGen/module.mk

-              r3d5701e
+              r9fb8f01
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Dec 14 07:29:42 2019
 ## Update Count     : 4
+## Last Modified On : Tue Jun  2 11:17:02 2015
+## Update Count     : 3
 ###############################################################################
 …
         CodeGen/OperatorTable.cc
 SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
 SRCDEMANGLE += $(SRC_CODEGEN)

src/CodeTools/DeclStats.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Aaron Moss
 // Created On       : Wed Jan 31 16:40:00 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:39:33 2019
 // Update Count     : 2
+// Last Modified By : Aaron Moss
+// Last Modified On : Wed Jan 31 16:40:00 2016
+// Update Count     : 1
 //
 …
 #include "Common/VectorMap.h"      // for VectorMap
 #include "GenPoly/GenPoly.h"       // for hasPolyBase
 #include "SynTree/LinkageSpec.h"   // for ::NoOfSpecs, Spec
+#include "Parser/LinkageSpec.h"    // for ::NoOfSpecs, Spec
 #include "SynTree/Declaration.h"   // for FunctionDecl, TypeDecl, Declaration
 #include "SynTree/Expression.h"    // for UntypedExpr, Expression

src/CodeTools/ResolvProtoDump.cc

-              r3d5701e
+              r9fb8f01
 // 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/Debug.h

-              r3d5701e
+              r9fb8f01
 // Author           : Rob Schluntz
 // Created On       : Fri Sep 1 11:09:14 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:39:42 2019
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Sep 1 11:09:36 2017
+// Update Count     : 2
 //
 …
 #include "CodeGen/Generate.h"
 #include "SynTree/LinkageSpec.h"
+#include "Parser/LinkageSpec.h"
 #include "SynTree/Declaration.h"

src/Common/PassVisitor.impl.h

-              r3d5701e
+              r9fb8f01
         indexerScopedAccept( node->result    , *this );
+        maybeAccept_impl   ( node->inout     , *this );
         maybeAccept_impl   ( node->constraint, *this );
         maybeAccept_impl   ( node->operand   , *this );
 …
         indexerScopedAccept( node->result    , *this );
+        maybeAccept_impl   ( node->inout     , *this );
         maybeAccept_impl   ( node->constraint, *this );
         maybeAccept_impl   ( node->operand   , *this );
 …
         indexerScopedMutate( node->env       , *this );
         indexerScopedMutate( node->result    , *this );
+        maybeMutate_impl   ( node->inout     , *this );
         maybeMutate_impl   ( node->constraint, *this );
         maybeMutate_impl   ( node->operand   , *this );
 …
         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.cc

-              r3d5701e
+              r9fb8f01
 // Helpers
 namespace ErrorHelpers {
-        Colors colors = Colors::Auto;
-        static inline bool with_colors() {
-                return colors == Colors::Auto ? isatty( STDERR_FILENO ) : bool(colors);
+        }
         const std::string & error_str() {
                 static std::string str = with_colors() ? "\e[31merror:\e[39m " : "error: ";
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[31merror:\e[39m " : "error: ";
                 return str;
+        }
         const std::string & warning_str() {
                 static std::string str = with_colors() ? "\e[95mwarning:\e[39m " : "warning: ";
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[95mwarning:\e[39m " : "warning: ";
                 return str;
+        }
         const std::string & bold_ttycode() {
                 static std::string str = with_colors() ? "\e[1m" : "";
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : "";
                 return str;
+        }
         const std::string & reset_font_ttycode() {
                 static std::string str = with_colors() ? "\e[0m" : "";
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[0m" : "";
                 return str;
+        }

src/Common/SemanticError.h

-              r3d5701e
+              r9fb8f01
 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
 };
 …
 // Helpers
 namespace ErrorHelpers {
-        enum class Colors {
-                Never = false,
-                Always = true,
-                Auto,
-        };
-        extern Colors colors;
         const std::string & error_str();
         const std::string & warning_str();

src/Common/Stats/Time.h

-              r3d5701e
+              r9fb8f01
 // Author           : Thierry Delisle
 // Created On       : Fri Mar 01 15:14:11 2019
 // Last Modified By : Andrew Beach
+// Last Modified By :
 // Last Modified On :
 // Update Count     :
 …
                                 f();
+                        }
-                        template<typename ret_t = void, typename func_t, typename... arg_t>
-                        inline ret_t TimeCall(
-                                        const char *, func_t func, arg_t&&... arg) {
-                                return func(std::forward<arg_t>(arg)...);
+                        }
 #               else
                         void StartGlobal();
 …
                                 func();
+                        }
-                        template<typename ret_t = void, typename func_t, typename... arg_t>
-                        inline ret_t TimeCall(
-                                        const char * name, func_t func, arg_t&&... arg) {
-                                BlockGuard guard(name);
-                                return func(std::forward<arg_t>(arg)...);
+                        }
 #               endif
+        }

src/Common/utility.h

-              r3d5701e
+              r9fb8f01
 // 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/Concurrency/Keywords.cc

-              r3d5701e
+              r9fb8f01
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 10
+// Update Count     : 5
 //
 …
 #include "CodeGen/OperatorTable.h" // for isConstructor
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "SynTree/LinkageSpec.h"   // for Cforall
+#include "Parser/LinkageSpec.h"    // for Cforall
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
 …
           public:
                 ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, KeywordCastExpr::Target cast_target ) :
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
 …
                 Declaration * postmutate( StructDecl * decl );
-                DeclarationWithType * postmutate( FunctionDecl * decl );
                 void handle( StructDecl * );
 …
                 const std::string context_error;
                 bool needs_main;
+                AggregateDecl::Aggregate cast_target;
+                StructDecl   * type_decl = nullptr;
+                FunctionDecl * dtor_decl = nullptr;
+                KeywordCastExpr::Target cast_target;
+                StructDecl* type_decl = nullptr;
         };
 …
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
         //                                =>             $thread __thrd_d;
+        //                                =>             thread_desc __thrd_d;
         // };                                        };
         //                                           static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; }
+        //                                           static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
         //
         class ThreadKeyword final : public ConcurrentSueKeyword {
 …
                 ThreadKeyword() : ConcurrentSueKeyword(
                         "$thread",
+                        "thread_desc",
                         "__thrd",
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "thread keyword requires threads to be in scope, add #include <thread.hfa>",
                         true,
                         AggregateDecl::Thread
+                        KeywordCastExpr::Thread
+                )
                 {}
 …
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
         //                                =>             $coroutine __cor_d;
+        //                                =>             coroutine_desc __cor_d;
         // };                                        };
         //                                           static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
+        //                                           static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
         //
         class CoroutineKeyword final : public ConcurrentSueKeyword {
 …
                 CoroutineKeyword() : ConcurrentSueKeyword(
                         "$coroutine",
+                        "coroutine_desc",
                         "__cor",
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>",
                         true,
                         AggregateDecl::Coroutine
+                        KeywordCastExpr::Coroutine
+                )
                 {}
 …
         //      int data;                                  int data;
         //      a_struct_t more_data;                      a_struct_t more_data;
         //                                =>             $monitor __mon_d;
+        //                                =>             monitor_desc __mon_d;
         // };                                        };
         //                                           static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
+        //                                           static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
         //
         class MonitorKeyword final : public ConcurrentSueKeyword {
 …
                 MonitorKeyword() : ConcurrentSueKeyword(
                         "$monitor",
+                        "monitor_desc",
                         "__mon",
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>",
                         false,
                         AggregateDecl::Monitor
+                        KeywordCastExpr::Monitor
+                )
                 {}
 …
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
         //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
 …
         //Handles mutex routines definitions :
         // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
         //                                                                       $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
         //                                                                       monitor_guard_t __guard = { __monitors, 2 };
         //    /*Some code*/                                       =>           /*Some code*/
 …
+        }
-        DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
-                if( !type_decl ) return decl;
-                if( !CodeGen::isDestructor( decl->name ) ) return decl;
-                auto params = decl->type->parameters;
-                if( params.size() != 1 ) return decl;
-                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
-                if( !type ) return decl;
-                auto stype = dynamic_cast<StructInstType*>( type->base );
-                if( !stype ) return decl;
-                if( stype->baseStruct != type_decl ) return decl;
-                if( !dtor_decl ) dtor_decl = decl;
-                return decl;
+        }
         Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
                 if ( cast_target == cast->target ) {
                         // convert (thread &)t to ($thread &)*get_thread(t), etc.
+                        // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
                         if( !type_decl ) SemanticError( cast, context_error );
+                        if( !dtor_decl ) SemanticError( cast, context_error );
+                        assert( cast->result == nullptr );
+                        cast->set_result( new ReferenceType( noQualifiers, new StructInstType( noQualifiers, type_decl ) ) );
+                        cast->concrete_target.field  = field_name;
+                        cast->concrete_target.getter = getter_name;
+                        Expression * arg = cast->arg;
+                        cast->arg = nullptr;
+                        delete cast;
+                        return new CastExpr(
+                                UntypedExpr::createDeref(
+                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
+                                ),
+                                new ReferenceType(
+                                        noQualifiers,
+                                        new StructInstType( noQualifiers, type_decl ) )
+                                );
+                }
                 return cast;
 …
                 if( !type_decl ) SemanticError( decl, context_error );
-                if( !dtor_decl ) SemanticError( decl, context_error );
                 FunctionDecl * func = forwardDeclare( decl );
 …
                         get_type,
                         nullptr,
                         { new Attribute("const") },
+                        noAttributes,
                         Type::Inline
                 );
 …
         void MutexKeyword::postvisit(StructDecl* decl) {
                 if( decl->name == "$monitor" && decl->body ) {
+                if( decl->name == "monitor_desc" && decl->body ) {
                         assert( !monitor_decl );
                         monitor_decl = decl;
 …
                 );
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors) );
+        }
 …
                 );
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
                 body->push_front( new DeclStmt( monitors) );
+        }
 …
         //=============================================================================================
         void ThreadStarter::previsit( StructDecl * decl ) {
                 if( decl->name == "$thread" && decl->body ) {
+                if( decl->name == "thread_desc" && decl->body ) {
                         assert( !thread_decl );
                         thread_decl = decl;
 …
                                 new UntypedExpr(
                                         new NameExpr( "__thrd_start" ),
                                         { new VariableExpr( param ), new NameExpr("main") }
+                                        { new VariableExpr( param ) }
+                                )
+                        )

src/Concurrency/Waitfor.cc

-              r3d5701e
+              r9fb8f01
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 12
+// Update Count     : 7
 //
 …
 #include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/SemanticError.h"  // for SemanticError
-#include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for deleteAll, map_range
 #include "CodeGen/OperatorTable.h" // for isConstructor
 #include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "Parser/LinkageSpec.h"    // for Cforall
 #include "ResolvExpr/Resolver.h"   // for findVoidExpression
-#include "SynTree/LinkageSpec.h"   // for Cforall
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
 …
 void foo() {
         while( true ) {
                 when( a < 1 ) waitfor( f : a ) { bar(); }
+                when( a < 1 ) waitfor( f, a ) { bar(); }
                 or timeout( swagl() );
                 or waitfor( g : a ) { baz(); }
                 or waitfor( ^?{} : a ) { break; }
+                or waitfor( g, a ) { baz(); }
+                or waitfor( ^?{}, a ) { break; }
                 or waitfor( ^?{} ) { break; }
+        }
 …
                         decl_mask = decl;
+                }
                 else if( decl->name == "$monitor" ) {
+                else if( decl->name == "monitor_desc" ) {
                         assert( !decl_monitor );
                         decl_monitor = decl;

src/ControlStruct/ExceptTranslate.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:15 2019
 // Update Count     : 12
+// Last Modified On : Wed Feb 13 18:15:29 2019
+// Update Count     : 11
 //
 …
 #include "Common/SemanticError.h"     // for SemanticError
 #include "Common/utility.h"           // for CodeLocation
 #include "SynTree/LinkageSpec.h"      // for Cforall
+#include "Parser/LinkageSpec.h"       // for Cforall
 #include "SynTree/Attribute.h"        // for Attribute
 #include "SynTree/Constant.h"         // for Constant

src/ControlStruct/LabelFixer.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Jan 21 10:32:00 2020
 // Update Count     : 160
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:02 2019
+// Update Count     : 159
 //
 …
 #include "ControlStruct/LabelGenerator.h"  // for LabelGenerator
 #include "LabelFixer.h"
 #include "MLEMutator.h"                    // for MultiLevelExitMutator
+#include "MLEMutator.h"                    // for MLEMutator
 #include "SynTree/Declaration.h"           // for FunctionDecl
 #include "SynTree/Expression.h"            // for NameExpr, Expression, Unty...
 …
         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
+                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+                // We start in the body so we can stop when we hit another FunctionDecl.
+                maybeMutate( functionDecl->statements, mlem );
+                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
+                functionDecl->acceptMutator( mlemut );
+        }
 …
         // Sets the definition of the labelTable entry to be the provided statement for every label in
         // the list parameter. Happens for every kind of statement.
+        // sets the definition of the labelTable entry to be the provided statement for every label in the list
+        // parameter. Happens for every kind of statement
         Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
                 assert( definition != 0 );
                 assert( llabel.size() > 0 );
+                Entry * e = new Entry( definition );
                 for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
 …
                         l.set_statement( definition ); // attach statement to the label to be used later
                         if ( labelTable.find( l ) == labelTable.end() ) {
+                                // All labels on this statement need to use the same entry,
+                                // so this should only be created once.
+                                // all labels on this statement need to use the same entry, so this should only be created once
                                 // undefined and unused until now, add an entry
                                 labelTable[ l ] = new Entry( definition );
+                                labelTable[ l ] =  e;
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
+                                SemanticError( l.get_statement()->location,
+                                        "Duplicate definition of label: " + l.get_name() );
+                        } else {
+                                SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
+                        }       else {
                                 // used previously, but undefined until now -> link with this entry
-                                // Question: Is changing objects important?
                                 delete labelTable[ l ];
                                 labelTable[ l ] = new Entry( definition );
+                                labelTable[ l ] = e;
                         } // if
                 } // for
+                // Produce one of the labels attached to this statement to be temporarily used as the
+                // canonical label.
+                // produce one of the labels attached to this statement to be temporarily used as the canonical label
                 return labelTable[ llabel.front() ]->get_label();
+        }

src/ControlStruct/MLEMutator.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jan 22 11:50:00 2020
 // Update Count     : 223
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar  8 17:08:25 2018
+// Update Count     : 219
 //
 …
 namespace ControlStruct {
         MultiLevelExitMutator::~MultiLevelExitMutator() {
+        MLEMutator::~MLEMutator() {
                 delete targetTable;
                 targetTable = 0;
+        }
         namespace {
+                bool isLoop( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
+                                || dynamic_cast< ForStmt * >( e.get_controlStructure() );
+                }
+                bool isSwitch( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< SwitchStmt *>( e.get_controlStructure() );
+                }
+                bool isBreakTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e ) || isSwitch( e )
+                                || dynamic_cast< CompoundStmt *>( e.get_controlStructure() );
+                }
+                bool isContinueTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e );
+                }
+                bool isFallthroughTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< CaseStmt *>( e.get_controlStructure() );
+                }
+                bool isFallthroughDefaultTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isSwitch( e );
+                }
+                bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); }
+                bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); }
+                bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); }
+                bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); }
+                bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; }
+                bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); }
         } // namespace
-        void MultiLevelExitMutator::premutate( FunctionDecl * ) {
-                visit_children = false;
+        }
         // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
         // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
         // body of statements
         void MultiLevelExitMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
+        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
                 SemanticErrorException errors;
 …
+        }
         void MultiLevelExitMutator::premutate( CompoundStmt *cmpndStmt ) {
+        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
                 visit_children = false;
                 bool labeledBlock = !(cmpndStmt->labels.empty());
 …
+                        }
+                }
+                assertf( false, "Could not find label '%s' on statement %s",
+                        originalTarget.get_name().c_str(), toString( stmt ).c_str() );
+        }
+        Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt )
+                        throw ( SemanticErrorException ) {
+                assertf( false, "Could not find label '%s' on statement %s", originalTarget.get_name().c_str(), toString( stmt ).c_str() );
+        }
+        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException ) {
                 std::string originalTarget = branchStmt->originalTarget;
 …
+        }
+        Statement *MultiLevelExitMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+                // ensure loop body is a block
+                CompoundStmt *newBody;
+                if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
+                        newBody = new CompoundStmt();
+                        newBody->get_kids().push_back( bodyLoop );
+                } // if
                 // only generate these when needed
-                if( !e.isContUsed() && !e.isBreakUsed() ) return bodyLoop;
-                // ensure loop body is a block
-                CompoundStmt * newBody = new CompoundStmt();
-                newBody->get_kids().push_back( bodyLoop );
                 if ( e.isContUsed() ) {
 …
         template< typename LoopClass >
         void MultiLevelExitMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
+        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
                 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
                 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
 …
         template< typename LoopClass >
         Statement * MultiLevelExitMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
+        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
                 assert( ! enclosingControlStructures.empty() );
                 Entry &e = enclosingControlStructures.back();
 …
+        }
         void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
+        void MLEMutator::premutate( WhileStmt * whileStmt ) {
                 return prehandleLoopStmt( whileStmt );
+        }
         void MultiLevelExitMutator::premutate( ForStmt * forStmt ) {
+        void MLEMutator::premutate( ForStmt * forStmt ) {
                 return prehandleLoopStmt( forStmt );
+        }
         Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
+        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
                 return posthandleLoopStmt( whileStmt );
+        }
         Statement * MultiLevelExitMutator::postmutate( ForStmt * forStmt ) {
+        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
                 return posthandleLoopStmt( forStmt );
+        }
         void MultiLevelExitMutator::premutate( IfStmt * ifStmt ) {
+        void MLEMutator::premutate( IfStmt * ifStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(ifStmt->get_labels().empty());
 …
+        }
         Statement * MultiLevelExitMutator::postmutate( IfStmt * ifStmt ) {
+        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
                 bool labeledBlock = !(ifStmt->get_labels().empty());
                 if ( labeledBlock ) {
 …
+        }
+        void MultiLevelExitMutator::premutate( TryStmt * tryStmt ) {
+                // generate a label for breaking out of a labeled if
+                bool labeledBlock = !(tryStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        Label brkLabel = generator->newLabel("blockBreak", tryStmt);
+                        enclosingControlStructures.push_back( Entry( tryStmt, brkLabel ) );
+                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
+                } // if
+        }
+        Statement * MultiLevelExitMutator::postmutate( TryStmt * tryStmt ) {
+                bool labeledBlock = !(tryStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
+                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
+                        } // if
+                } // if
+                return tryStmt;
+        }
+        void MultiLevelExitMutator::premutate( FinallyStmt * ) {
+                GuardAction([this, old = std::move(enclosingControlStructures)]() {
+                        enclosingControlStructures = std::move(old);
+                });
+                enclosingControlStructures = std::list<Entry>();
+                GuardValue( inFinally );
+                inFinally = true;
+        }
+        void MultiLevelExitMutator::premutate( ReturnStmt *returnStmt ) {
+                if ( inFinally ) {
+                        SemanticError( returnStmt->location, "'return' may not appear in a finally clause" );
+                }
+        }
+        void MultiLevelExitMutator::premutate( CaseStmt *caseStmt ) {
+        void MLEMutator::premutate( CaseStmt *caseStmt ) {
                 visit_children = false;
 …
+        }
         void MultiLevelExitMutator::premutate( SwitchStmt *switchStmt ) {
+        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
                 // generate a label for breaking out of a labeled switch
                 Label brkLabel = generator->newLabel("switchBreak", switchStmt);
 …
+        }
         Statement * MultiLevelExitMutator::postmutate( SwitchStmt * switchStmt ) {
+        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
                 Entry &e = enclosingControlStructures.back();
                 assert ( e == switchStmt );

src/ControlStruct/MLEMutator.h

-              r3d5701e
+              r9fb8f01
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jan 22 11:50:00 2020
 // Update Count     : 48
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar  8 16:42:32 2018
+// Update Count     : 41
 //
 …
         class LabelGenerator;
+        class MultiLevelExitMutator : public WithVisitorRef<MultiLevelExitMutator>,
+                        public WithShortCircuiting, public WithGuards {
+        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
           public:
                 class Entry;
+                MultiLevelExitMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) :
+                        targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MultiLevelExitMutator();
+                void premutate( FunctionDecl * );
+                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MLEMutator();
                 void premutate( CompoundStmt *cmpndStmt );
 …
                 void premutate( SwitchStmt *switchStmt );
                 Statement * postmutate( SwitchStmt *switchStmt );
-                void premutate( ReturnStmt *returnStmt );
-                void premutate( TryStmt *tryStmt );
-                Statement * postmutate( TryStmt *tryStmt );
-                void premutate( FinallyStmt *finallyStmt );
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
 …
                         explicit Entry( SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
                                 stmt( stmt ), breakExit( breakExit ), fallDefaultExit( fallDefaultExit ) {}
-                        explicit Entry( TryStmt *stmt, Label breakExit ) :
-                                stmt( stmt ), breakExit( breakExit ) {}
                         bool operator==( const Statement *other ) { return stmt == other; }
 …
                 Label breakLabel;
                 LabelGenerator *generator;
-                bool inFinally = false;
                 template< typename LoopClass >

src/ControlStruct/Mutate.cc

-              r3d5701e
+              r9fb8f01
 // 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/GenPoly/Box.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:34 2019
 // Update Count     : 347
+// Last Modified On : Wed Jun 21 15:49:59 2017
+// Update Count     : 346
 //
 …
 #include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
 #include "Lvalue.h"                      // for generalizedLvalue
+#include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 …
 #include "SymTab/Indexer.h"              // for Indexer
 #include "SymTab/Mangler.h"              // for Mangler
-#include "SynTree/LinkageSpec.h"         // for C, Spec, Cforall, Intrinsic
 #include "SynTree/Attribute.h"           // for Attribute
 #include "SynTree/Constant.h"            // for Constant
 …
                                         deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
                                         deref->result = arg->get_type()->clone();
+                                        deref->result->set_lvalue( true );
                                         return deref;
                                 } // if

src/GenPoly/Lvalue.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:14:38 2019
 // Update Count     : 7
+// Last Modified On : Fri Mar 17 09:11:18 2017
+// Update Count     : 5
 //
 …
 #include <string>                        // for string
-#include "Common/UniqueName.h"
 #include "Common/PassVisitor.h"
 #include "GenPoly.h"                     // for isPolyType
 …
 #include "InitTweak/InitTweak.h"
+#include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
 #include "ResolvExpr/Unify.h"            // for unify
 #include "ResolvExpr/typeops.h"
 #include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/LinkageSpec.h"         // for Spec, isBuiltin, Intrinsic
 #include "SynTree/Declaration.h"         // for Declaration, FunctionDecl
 #include "SynTree/Expression.h"          // for Expression, ConditionalExpr
 …
                                 delete ret->result;
                                 ret->result = base->clone();
+                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
 …
+                }
                 struct ReferenceConversions final : public WithStmtsToAdd, public WithGuards {
+                struct ReferenceConversions final : public WithStmtsToAdd {
                         Expression * postmutate( CastExpr * castExpr );
                         Expression * postmutate( AddressExpr * addrExpr );
 …
                 struct FixIntrinsicResult final : public WithGuards {
-                        enum {
-                                NoSkip,
-                                Skip,
-                                SkipInProgress
-                        } skip = NoSkip;
-                        void premutate( AsmExpr * ) { GuardValue( skip ); skip = Skip; }
-                        void premutate( ApplicationExpr * ) { GuardValue( skip ); skip = (skip == Skip) ? SkipInProgress : NoSkip; }
                         Expression * postmutate( ApplicationExpr * appExpr );
                         void premutate( FunctionDecl * funcDecl );
 …
                 Expression * FixIntrinsicResult::postmutate( ApplicationExpr * appExpr ) {
                         if ( skip != SkipInProgress && isIntrinsicReference( appExpr ) ) {
+                        if ( isIntrinsicReference( appExpr ) ) {
                                 // eliminate reference types from intrinsic applications - now they return lvalues
                                 ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result );
                                 appExpr->result = result->base->clone();
+                                appExpr->result->set_lvalue( true );
                                 if ( ! inIntrinsic ) {
                                         // when not in an intrinsic function, add a cast to
 …
                                 delete ret->result;
                                 ret->result = castExpr->result;
                                 assert( ret->get_lvalue() ); // ensure result is lvalue
+                                ret->result->set_lvalue( true ); // ensure result is lvalue
                                 castExpr->env = nullptr;
                                 castExpr->arg = nullptr;

src/GenPoly/Specialize.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:49 2019
 // Update Count     : 32
+// Last Modified On : Thu Mar 16 07:53:59 2017
+// Update Count     : 31
 //
 …
 #include "GenPoly.h"                     // for getFunctionType
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
+#include "Parser/LinkageSpec.h"          // for C
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
 #include "Specialize.h"
-#include "SynTree/LinkageSpec.h"         // for C
 #include "SynTree/Attribute.h"           // for Attribute
 #include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...

src/InitTweak/FixGlobalInit.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:41:10 2019
 // Update Count     : 19
+// Last Modified On : Thu Mar 16 07:53:11 2017
+// Update Count     : 18
 //
 …
 #include "Common/UniqueName.h"     // for UniqueName
 #include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt
 #include "SynTree/LinkageSpec.h"   // for C
+#include "Parser/LinkageSpec.h"    // for C
 #include "SynTree/Attribute.h"     // for Attribute
 #include "SynTree/Constant.h"      // for Constant

src/InitTweak/FixInit.cc

-              r3d5701e
+              r9fb8f01
 // 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 : Wed Feb 13 18:15:56 2019
+// Update Count     : 76
 //
 #include "FixInit.h"
 …
 #include "GenPoly/GenPoly.h"           // for getFunctionType
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
+#include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
 #include "ResolvExpr/Resolver.h"       // for findVoidExpression
 #include "ResolvExpr/typeops.h"        // for typesCompatible
 …
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/LinkageSpec.h"       // for C, Spec, Cforall, isBuiltin
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
 …
+                }
                 // 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

-              r3d5701e
+              r9fb8f01
 // 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/InitTweak/GenInit.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:15:10 2019
 // Update Count     : 184
+// Last Modified On : Fri Mar 17 09:12:36 2017
+// Update Count     : 183
 //
 #include "GenInit.h"
 …
 #include "GenPoly/ScopedSet.h"         // for ScopedSet, ScopedSet<>::const_iter...
 #include "InitTweak.h"                 // for isConstExpr, InitExpander, checkIn...
+#include "Parser/LinkageSpec.h"        // for isOverridable, C
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Autogen.h"            // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/LinkageSpec.h"       // for isOverridable, C
 #include "SynTree/Declaration.h"       // for ObjectDecl, DeclarationWithType
 #include "SynTree/Expression.h"        // for VariableExpr, UntypedExpr, Address...

src/InitTweak/InitTweak.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:15:52 2019
 // Update Count     : 8
+// Last Modified On : Thu Jul 25 22:21:48 2019
+// Update Count     : 7
 //
 …
 #include "GenPoly/GenPoly.h"       // for getFunctionType
 #include "InitTweak.h"
+#include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
 #include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
-#include "SynTree/LinkageSpec.h"   // for Spec, isBuiltin, Intrinsic
 #include "SynTree/Attribute.h"     // for Attribute
 #include "SynTree/Constant.h"      // for Constant

src/MakeLibCfa.cc

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Feb 17 21:08:09 2019
+// Update Count     : 41
 //
 …
 #include "Common/SemanticError.h"   // for SemanticError
 #include "Common/UniqueName.h"      // for UniqueName
 #include "SynTree/LinkageSpec.h"    // for Spec, Intrinsic, C
+#include "Parser/LinkageSpec.h"     // for Spec, Intrinsic, C
 #include "SynTree/Declaration.h"    // for FunctionDecl, ObjectDecl, Declara...
 #include "SynTree/Expression.h"     // for NameExpr, UntypedExpr, VariableExpr
 …
                         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/Makefile.in

-              r3d5701e
+              r9fb8f01
         SymTab/Indexer.$(OBJEXT) SymTab/Mangler.$(OBJEXT) \
         SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT)
+am__objects_7 = SynTree/AddressExpr.$(OBJEXT) \
+        SynTree/AggregateDecl.$(OBJEXT) \
+        SynTree/ApplicationExpr.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
+        SynTree/AttrType.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
+        SynTree/BasicType.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
+        SynTree/CompoundStmt.$(OBJEXT) SynTree/Constant.$(OBJEXT) \
+        SynTree/DeclReplacer.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
+am__objects_7 = SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
+        SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
+        SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
+        SynTree/FunctionType.$(OBJEXT) \
+        SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
+        SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
+        SynTree/VarArgsType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT) \
+        SynTree/Constant.$(OBJEXT) SynTree/Expression.$(OBJEXT) \
+        SynTree/TupleExpr.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
+        SynTree/TypeExpr.$(OBJEXT) SynTree/ApplicationExpr.$(OBJEXT) \
+        SynTree/AddressExpr.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
+        SynTree/CompoundStmt.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
         SynTree/Declaration.$(OBJEXT) \
         SynTree/DeclarationWithType.$(OBJEXT) \
+        SynTree/Expression.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
+        SynTree/FunctionType.$(OBJEXT) SynTree/Initializer.$(OBJEXT) \
+        SynTree/LinkageSpec.$(OBJEXT) SynTree/NamedTypeDecl.$(OBJEXT) \
+        SynTree/ObjectDecl.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
+        SynTree/ReferenceToType.$(OBJEXT) \
+        SynTree/ReferenceType.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
+        SynTree/TupleExpr.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
+        SynTree/Type.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
+        SynTree/TypeExpr.$(OBJEXT) SynTree/TypeSubstitution.$(OBJEXT) \
+        SynTree/TypeofType.$(OBJEXT) SynTree/VarArgsType.$(OBJEXT) \
+        SynTree/VoidType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT)
+        SynTree/ObjectDecl.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
+        SynTree/AggregateDecl.$(OBJEXT) \
+        SynTree/NamedTypeDecl.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
+        SynTree/Initializer.$(OBJEXT) \
+        SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
+        SynTree/DeclReplacer.$(OBJEXT) SynTree/TopLvalue.$(OBJEXT)
 am__objects_8 = CompilationState.$(OBJEXT) $(am__objects_1) \
         $(am__objects_2) Concurrency/Keywords.$(OBJEXT) \
         $(am__objects_3) $(am__objects_4) GenPoly/GenPoly.$(OBJEXT) \
         GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
         InitTweak/InitTweak.$(OBJEXT) $(am__objects_5) \
         $(am__objects_6) SymTab/Demangle.$(OBJEXT) $(am__objects_7) \
         Tuples/TupleAssignment.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
+        $(am__objects_5) $(am__objects_6) SymTab/Demangle.$(OBJEXT) \
+        $(am__objects_7) Tuples/TupleAssignment.$(OBJEXT) \
         Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
         Tuples/Tuples.$(OBJEXT) Validate/HandleAttributes.$(OBJEXT) \
 …
         InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
         InitTweak/FixGlobalInit.$(OBJEXT) \
         InitTweak/InitTweak.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
         Parser/ExpressionNode.$(OBJEXT) \
         Parser/InitializerNode.$(OBJEXT) Parser/ParseNode.$(OBJEXT) \
         Parser/StatementNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
         Parser/TypedefTable.$(OBJEXT) Parser/lex.$(OBJEXT) \
         Parser/parser.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/parser.$(OBJEXT) \
+        Parser/lex.$(OBJEXT) Parser/TypedefTable.$(OBJEXT) \
+        Parser/ParseNode.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
+        Parser/ExpressionNode.$(OBJEXT) Parser/StatementNode.$(OBJEXT) \
+        Parser/InitializerNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
+        Parser/LinkageSpec.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
         $(am__objects_5) ResolvExpr/AlternativePrinter.$(OBJEXT) \
         $(am__objects_6) $(am__objects_7) \
 …
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@
 …
         InitTweak/GenInit.cc InitTweak/FixInit.cc \
         InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
         Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
         Parser/InitializerNode.cc Parser/ParseNode.cc \
         Parser/StatementNode.cc Parser/TypeData.cc \
         Parser/TypedefTable.cc Parser/lex.ll Parser/parser.yy \
         Parser/parserutility.cc $(SRC_RESOLVEXPR) \
         ResolvExpr/AlternativePrinter.cc $(SRC_SYMTAB) $(SRC_SYNTREE) \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Tuples/Tuples.cc \
+        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
+        Parser/ParseNode.cc Parser/DeclarationNode.cc \
+        Parser/ExpressionNode.cc Parser/StatementNode.cc \
+        Parser/InitializerNode.cc Parser/TypeData.cc \
+        Parser/LinkageSpec.cc Parser/parserutility.cc \
+        $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc \
+        $(SRC_SYMTAB) $(SRC_SYNTREE) Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc Tuples/Explode.cc Tuples/Tuples.cc \
         Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc \
         Virtual/ExpandCasts.cc
 …
         Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
         GenPoly/GenPoly.cc GenPoly/Lvalue.cc InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc $(SRC_RESOLVEXPR) $(SRC_SYMTAB) \
+        SymTab/Demangle.cc $(SRC_SYNTREE) Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc Tuples/Explode.cc Tuples/Tuples.cc \
+        InitTweak/InitTweak.cc Parser/LinkageSpec.cc $(SRC_RESOLVEXPR) \
+        $(SRC_SYMTAB) SymTab/Demangle.cc $(SRC_SYNTREE) \
+        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc Tuples/Tuples.cc \
         Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
 MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
 …
 SRC_SYNTREE = \
+      SynTree/Type.cc \
+      SynTree/VoidType.cc \
+      SynTree/BasicType.cc \
+      SynTree/PointerType.cc \
+      SynTree/ArrayType.cc \
+      SynTree/ReferenceType.cc \
+      SynTree/FunctionType.cc \
+      SynTree/ReferenceToType.cc \
+      SynTree/TupleType.cc \
+      SynTree/TypeofType.cc \
+      SynTree/AttrType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/ZeroOneType.cc \
+      SynTree/Constant.cc \
+      SynTree/Expression.cc \
+      SynTree/TupleExpr.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/TypeExpr.cc \
+      SynTree/ApplicationExpr.cc \
       SynTree/AddressExpr.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/ApplicationExpr.cc \
+      SynTree/ArrayType.cc \
+      SynTree/AttrType.cc \
+      SynTree/Attribute.cc \
+      SynTree/BasicType.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/Statement.cc \
       SynTree/CompoundStmt.cc \
-      SynTree/Constant.cc \
-      SynTree/DeclReplacer.cc \
       SynTree/DeclStmt.cc \
       SynTree/Declaration.cc \
       SynTree/DeclarationWithType.cc \
       SynTree/Expression.cc \
+      SynTree/ObjectDecl.cc \
       SynTree/FunctionDecl.cc \
+      SynTree/FunctionType.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
       SynTree/Initializer.cc \
-      SynTree/LinkageSpec.cc \
-      SynTree/NamedTypeDecl.cc \
-      SynTree/ObjectDecl.cc \
-      SynTree/PointerType.cc \
-      SynTree/ReferenceToType.cc \
-      SynTree/ReferenceType.cc \
-      SynTree/Statement.cc \
-      SynTree/TupleExpr.cc \
-      SynTree/TupleType.cc \
-      SynTree/Type.cc \
-      SynTree/TypeDecl.cc \
-      SynTree/TypeExpr.cc \
       SynTree/TypeSubstitution.cc \
+      SynTree/TypeofType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/VoidType.cc \
+      SynTree/ZeroOneType.cc
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc \
+      SynTree/TopLvalue.cc
 …
 InitTweak/InitTweak.$(OBJEXT): InitTweak/$(am__dirstamp) \
         InitTweak/$(DEPDIR)/$(am__dirstamp)
+Parser/$(am__dirstamp):
+        @$(MKDIR_P) Parser
+        @: > Parser/$(am__dirstamp)
+Parser/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) Parser/$(DEPDIR)
+        @: > Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/LinkageSpec.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/$(am__dirstamp):
         @$(MKDIR_P) ResolvExpr
 …
         @$(MKDIR_P) SynTree/$(DEPDIR)
         @: > SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
+SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/LinkageSpec.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+SynTree/TopLvalue.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
 …
 InitTweak/FixGlobalInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
         InitTweak/$(DEPDIR)/$(am__dirstamp)
+Parser/$(am__dirstamp):
+        @$(MKDIR_P) Parser
+        @: > Parser/$(am__dirstamp)
+Parser/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) Parser/$(DEPDIR)
+        @: > Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/parser.hh: Parser/parser.cc
+        @if test ! -f $@; then rm -f Parser/parser.cc; else :; fi
+        @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) Parser/parser.cc; else :; fi
+Parser/parser.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/lex.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/TypedefTable.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/ParseNode.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/DeclarationNode.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/ExpressionNode.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
+Parser/StatementNode.$(OBJEXT): Parser/$(am__dirstamp) \
+        Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/InitializerNode.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
-Parser/ParseNode.$(OBJEXT): Parser/$(am__dirstamp) \
-        Parser/$(DEPDIR)/$(am__dirstamp)
-Parser/StatementNode.$(OBJEXT): Parser/$(am__dirstamp) \
-        Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/TypeData.$(OBJEXT): Parser/$(am__dirstamp) \
-        Parser/$(DEPDIR)/$(am__dirstamp)
-Parser/TypedefTable.$(OBJEXT): Parser/$(am__dirstamp) \
-        Parser/$(DEPDIR)/$(am__dirstamp)
-Parser/lex.$(OBJEXT): Parser/$(am__dirstamp) \
-        Parser/$(DEPDIR)/$(am__dirstamp)
-Parser/parser.hh: Parser/parser.cc
-        @if test ! -f $@; then rm -f Parser/parser.cc; else :; fi
-        @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) Parser/parser.cc; else :; fi
-Parser/parser.$(OBJEXT): Parser/$(am__dirstamp) \
         Parser/$(DEPDIR)/$(am__dirstamp)
 Parser/parserutility.$(OBJEXT): Parser/$(am__dirstamp) \
 …
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/ExpressionNode.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/InitializerNode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/LinkageSpec.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/ParseNode.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/StatementNode.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/FunctionType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/Initializer.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/LinkageSpec.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/NamedTypeDecl.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/ObjectDecl.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/ReferenceType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/Statement.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TopLvalue.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/TupleType.Po@am__quote@

src/Parser/DeclarationNode.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:32:22 2019
 // Update Count     : 1133
+// Last Modified On : Thu Jul 25 22:17:10 2019
+// Update Count     : 1116
 //
 …
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for maybeClone, maybeBuild, CodeLocation
+#include "Parser/LinkageSpec.h"    // for Spec, linkageName, Cforall
 #include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
-#include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
 #include "SynTree/Attribute.h"     // for Attribute
 #include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, Declaration
 …
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
 const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
+const char * DeclarationNode::aggregateNames[] = { "struct", "union", "trait", "coroutine", "monitor", "thread", "NoAggregateNames" };
+const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
 const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" };
 …
 //      variable.name = nullptr;
         variable.tyClass = TypeDecl::NUMBER_OF_KINDS;
+        variable.tyClass = NoTypeClass;
         variable.assertions = nullptr;
         variable.initializer = nullptr;
 …
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
 …
+}
 DeclarationNode * DeclarationNode::newAggregate( AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
 …
 } // DeclarationNode::newFromTypeGen
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
+DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, const string * name ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = nullptr;
 …
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggregate.kind = Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
 …
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
         newnode->type->aggInst.aggregate->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggInst.aggregate->aggregate.kind = Trait;
         newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
 …
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
+        if ( variable.tyClass != NoTypeClass ) {
                 if ( variable.assertions ) {
                         variable.assertions->appendList( assertions );
 …
 DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
         assertf( variable.tyClass != TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
+        assertf( variable.tyClass != NoTypeClass, "Called addTypeInitializer on something that isn't a type variable." );
         variable.initializer = init;
         return this;
 …
         } // if
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
+        if ( variable.tyClass != NoTypeClass ) {
                 // otype is internally converted to dtype + otype parameters
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
                 static_assert( sizeof(kindMap)/sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
+                assertf( sizeof(kindMap)/sizeof(kindMap[0]) == NoTypeClass, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
                 TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
                 buildList( variable.assertions, ret->get_assertions() );
                 return ret;

src/Parser/ExpressionNode.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 18 21:14:58 2019
 // Update Count     : 981
+// Last Modified On : Sun Aug  4 20:57:55 2019
+// Update Count     : 978
 //
 …
         static const BasicType::Kind kind[2][12] = {
                 { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
                 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
+                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
         };
 …
 Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
         if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
+        if ( str[str.size()-1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
 …
 } // build_cast
 Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) {
+Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node ) {
         return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+}

src/Parser/ParseNode.h

-              r3d5701e
+              r9fb8f01
 // 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 : Thu Jul 25 22:17:10 2019
+// Update Count     : 876
 //
 …
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for maybeClone, maybeBuild
+#include "SynTree/LinkageSpec.h"   // for Spec
+#include "SynTree/Declaration.h"   // for Aggregate
+#include "Parser/LinkageSpec.h"    // for Spec
 #include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
 #include "SynTree/Label.h"         // for Label
 …
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
 Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
+Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node );
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
 …
         enum Length { Short, Long, LongLong, NoLength };
         static const char * lengthNames[];
+        enum Aggregate { Struct, Union, Exception, Trait, Coroutine, Monitor, Thread, NoAggregate };
+        static const char * aggregateNames[];
+        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
+        static const char * typeClassNames[];
         enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
         static const char * builtinTypeNames[];
 …
         static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
+        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newName( const std::string * );
         static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
         static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
+        static DeclarationNode * newTypeParam( TypeClass, const std::string * );
         static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
         static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
 …
         struct Variable_t {
 //              const std::string * name;
                 TypeDecl::Kind tyClass;
+                DeclarationNode::TypeClass tyClass;
                 DeclarationNode * assertions;
                 DeclarationNode * initializer;
 …
                                 * 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

-              r3d5701e
+              r9fb8f01
 // 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/TypeData.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 07:56:46 2019
 // Update Count     : 662
+// Last Modified On : Wed Feb 13 18:16:23 2019
+// Update Count     : 649
 //
 …
           case Aggregate:
                 // aggregate = new Aggregate_t;
                 aggregate.kind = AggregateDecl::NoAggregate;
+                aggregate.kind = DeclarationNode::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
 …
                 break;
           case Aggregate:
                 os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
+                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters" << endl;
 …
         for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
                 TypeDecl * td = static_cast<TypeDecl *>(*i);
                 if ( n->variable.tyClass == TypeDecl::Otype ) {
+                if ( n->variable.tyClass == DeclarationNode::Otype ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
 …
         switch ( td->kind ) {
           case TypeData::Unknown:
                 // fill in implicit int
                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+                        // fill in implicit int
+                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
           case TypeData::Basic:
                 return buildBasicType( td );
+                        return buildBasicType( td );
           case TypeData::Pointer:
                 return buildPointer( td );
+                        return buildPointer( td );
           case TypeData::Array:
                 return buildArray( td );
+                        return buildArray( td );
           case TypeData::Reference:
                 return buildReference( td );
+                        return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
+                        return buildFunction( td );
           case TypeData::AggregateInst:
                 return buildAggInst( td );
+                        return buildAggInst( td );
           case TypeData::EnumConstant:
                 // the name gets filled in later -- by SymTab::Validate
                 return new EnumInstType( buildQualifiers( td ), "" );
+                        // the name gets filled in later -- by SymTab::Validate
+                        return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
                 return buildSymbolicInst( td );
+                        return buildSymbolicInst( td );
           case TypeData::Tuple:
                 return buildTuple( td );
+                        return buildTuple( td );
           case TypeData::Typeof:
           case TypeData::Basetypeof:
                 return buildTypeof( td );
+                        return buildTypeof( td );
           case TypeData::Builtin:
+                switch ( td->builtintype ) {
+                  case DeclarationNode::Zero:
+                        return new ZeroType( noQualifiers );
+                  case DeclarationNode::One:
+                        return new OneType( noQualifiers );
+                  default:
+                        return new VarArgsType( buildQualifiers( td ) );
+                } // switch
+                        if (td->builtintype == DeclarationNode::Zero) {
+                                return new ZeroType( noQualifiers );
+                        }
+                        else if (td->builtintype == DeclarationNode::One) {
+                                return new OneType( noQualifiers );
+                        }
+                        else {
+                                return new VarArgsType( buildQualifiers( td ) );
+                        }
           case TypeData::GlobalScope:
                 return new GlobalScopeType();
           case TypeData::Qualified:
                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+                        return new GlobalScopeType();
+                case TypeData::Qualified:
+                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
                 assert( false );
+                        assert( false );
         } // switch
 …
         AggregateDecl * at;
         switch ( td->aggregate.kind ) {
           case AggregateDecl::Struct:
           case AggregateDecl::Coroutine:
           case AggregateDecl::Monitor:
           case AggregateDecl::Thread:
+          case DeclarationNode::Struct:
+          case DeclarationNode::Coroutine:
+          case DeclarationNode::Monitor:
+          case DeclarationNode::Thread:
                 at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case AggregateDecl::Union:
+          case DeclarationNode::Union:
                 at = new UnionDecl( *td->aggregate.name, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case AggregateDecl::Trait:
+          case DeclarationNode::Trait:
                 at = new TraitDecl( *td->aggregate.name, attributes, linkage );
                 buildList( td->aggregate.params, at->get_parameters() );
 …
                           AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
                           switch ( type->aggregate.kind ) {
                                 case AggregateDecl::Struct:
                                 case AggregateDecl::Coroutine:
                                 case AggregateDecl::Monitor:
                                 case AggregateDecl::Thread:
+                                case DeclarationNode::Struct:
+                                case DeclarationNode::Coroutine:
+                                case DeclarationNode::Monitor:
+                                case DeclarationNode::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
                                   break;
                                 case AggregateDecl::Union:
+                                case DeclarationNode::Union:
                                   ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
                                   break;
                                 case AggregateDecl::Trait:
+                                case DeclarationNode::Trait:
                                   assert( false );
                                   //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
 …
                   } else {
                           switch ( type->aggregate.kind ) {
                                 case AggregateDecl::Struct:
                                 case AggregateDecl::Coroutine:
                                 case AggregateDecl::Monitor:
                                 case AggregateDecl::Thread:
+                                case DeclarationNode::Struct:
+                                case DeclarationNode::Coroutine:
+                                case DeclarationNode::Monitor:
+                                case DeclarationNode::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
                                 case AggregateDecl::Union:
+                                case DeclarationNode::Union:
                                   ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
                                 case AggregateDecl::Trait:
+                                case DeclarationNode::Trait:
                                   ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
 …
           case TypeData::Aggregate: {
                   switch ( type->aggregate.kind ) {
                         case AggregateDecl::Struct:
                         case AggregateDecl::Coroutine:
                         case AggregateDecl::Monitor:
                         case AggregateDecl::Thread:
+                        case DeclarationNode::Struct:
+                        case DeclarationNode::Coroutine:
+                        case DeclarationNode::Monitor:
+                        case DeclarationNode::Thread:
                           ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case AggregateDecl::Union:
+                        case DeclarationNode::Union:
                           ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case AggregateDecl::Trait:
+                        case DeclarationNode::Trait:
                           ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;

src/Parser/TypeData.h

-              r3d5701e
+              r9fb8f01
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:42:35 2019
 // Update Count     : 199
+// Last Modified On : Thu Nov  1 20:56:46 2018
+// Update Count     : 196
 //
 …
 #include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
 #include "SynTree/LinkageSpec.h" // for Spec
+#include "Parser/LinkageSpec.h"  // for Spec
 #include "SynTree/Type.h"        // for Type, ReferenceToType (ptr only)
 #include "SynTree/SynTree.h"     // for Visitor Nodes
 …
         struct Aggregate_t {
                 AggregateDecl::Aggregate kind;
+                DeclarationNode::Aggregate kind;
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;

src/Parser/TypedefTable.cc

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
 // 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

-              r3d5701e
+              r9fb8f01
  * 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 : Sun Aug  4 20:53:47 2019
+ * Update Count     : 719
  */
 …
 #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 - 1] = '\0'; yytext += 1;                         // 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/module.mk

-              r3d5701e
+              r9fb8f01
 ## Created On       : Sat May 16 15:29:09 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Dec 14 07:34:47 2019
 ## Update Count     : 107
+## Last Modified On : Wed Jun 28 21:58:29 2017
+## Update Count     : 104
 ###############################################################################
 …
 AM_YFLAGS = -d -t -v
+SRC += \
+SRC += Parser/parser.yy \
+       Parser/lex.ll \
+       Parser/TypedefTable.cc \
+       Parser/ParseNode.cc \
        Parser/DeclarationNode.cc \
        Parser/ExpressionNode.cc \
+       Parser/StatementNode.cc \
        Parser/InitializerNode.cc \
-       Parser/ParseNode.cc \
-       Parser/StatementNode.cc \
        Parser/TypeData.cc \
+       Parser/TypedefTable.cc \
+       Parser/lex.ll \
+       Parser/parser.yy \
+       Parser/LinkageSpec.cc \
        Parser/parserutility.cc
+SRCDEMANGLE += \
+        Parser/LinkageSpec.cc
 MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

src/Parser/parser.yy

-              r3d5701e
+              r9fb8f01
 // 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 : Sun Aug  4 21:48:23 2019
+// Update Count     : 4364
 //
 …
 using namespace std;
-#include "SynTree/Declaration.h"
 #include "ParseNode.h"
 #include "TypedefTable.h"
 #include "TypeData.h"
 #include "SynTree/LinkageSpec.h"
+#include "LinkageSpec.h"
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 …
 } // 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
 …
         } // if
 } // forCtrl
 bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
 …
         ExpressionNode * en;
         DeclarationNode * decl;
         AggregateDecl::Aggregate aggKey;
         TypeDecl::Kind tclass;
+        DeclarationNode::Aggregate aggKey;
+        DeclarationNode::TypeClass tclass;
         StatementNode * sn;
         WaitForStmt * wfs;
 …
 %type<op> ptrref_operator                               unary_operator                          assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<en> cast_expression                               exponential_expression          multiplicative_expression       additive_expression
 %type<en> shift_expression                              relational_expression           equality_expression
 %type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
 …
 %type<decl> abstract_parameter_declaration
 %type<aggKey> aggregate_key aggregate_data aggregate_control
+%type<aggKey> aggregate_key
 %type<decl> aggregate_type aggregate_type_nobody
 …
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
+        | constant '`' IDENTIFIER                                                       // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
+        | string_literal '`' IDENTIFIER                                         // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
+        | IDENTIFIER '`' IDENTIFIER                                                     // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( build_varref( $1 ) ) ) ); }
+        | tuple '`' IDENTIFIER                                                          // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
+        | '(' comma_expression ')' '`' IDENTIFIER                       // CFA, postfix call
+                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
 …
         | postfix_expression '(' argument_expression_list ')'
                 { $$ = 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 ) ); }
-        | constant '`' identifier                                                       // CFA, postfix call
-                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( 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 ) ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
 …
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
-        | postfix_expression '.' aggregate_control
-                { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
         | postfix_expression ARROW identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
 …
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list '}' // CFA, destructor call
+        | '^' primary_expression '{' argument_expression_list '}' // CFA
+                {
                         Token fn;
 …
         | argument_expression
         | argument_expression_list ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
+        ;
 …
 field_name_list:                                                                                // CFA, tuple field selector
         field
         | field_name_list ',' field                                     { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | field_name_list ',' field                                     { $$ = (ExpressionNode *)$1->set_last( $3 ); }
+        ;
 …
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        | '(' aggregate_control '&' ')' cast_expression         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                // keyword cast cannot be grouped because of reduction in aggregate_key
+        | '(' GENERATOR '&' ')' cast_expression                         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
+        | '(' COROUTINE '&' ')' cast_expression                         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
+        | '(' THREAD '&' ')' cast_expression                            // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Thread, $5 ) ); }
+        | '(' MONITOR '&' ')' cast_expression                           // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Monitor, $5 ) ); }
                 // VIRTUAL cannot be opt because of look ahead issues
         | '(' VIRTUAL ')' cast_expression                                       // CFA
 …
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $6 ) ) ); }
+        ;
 …
         assignment_expression_opt
         | tuple_expression_list ',' assignment_expression_opt
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
+        ;
 …
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | '=' comma_expression                                                                  // CFA
-                { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression inclexcl comma_expression            // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
 …
                 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' '=' comma_expression                             // CFA
-                { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression ';' comma_expression inclexcl comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
 …
         WAITFOR '(' cast_expression ')'
                 { $$ = $3; }
+//      | WAITFOR '(' cast_expression ',' argument_expression_list ')'
+//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list ')'
+                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
+cast_expression_list:
+        cast_expression
+        | cast_expression_list ',' cast_expression
+                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | WAITFOR '(' cast_expression ',' argument_expression_list ')'
+                { $$ = (ExpressionNode *)$3->set_last( $5 ); }
+        ;
 …
         asm_operand
         | asm_operands_list ',' asm_operand
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
+        ;
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
                 { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild< Expression >( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
                 { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild< Expression >( $6 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ), $1, maybeMoveBuild< Expression >( $3 ) ) ); }
+        | '[' constant_expression ']' string_literal '(' constant_expression ')'
+                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( $2 ), $4, maybeMoveBuild< Expression >( $6 ) ) ); }
+        ;
 …
                 { $$ = new ExpressionNode( $1 ); }
         | asm_clobbers_list_opt ',' string_literal
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
+                // set_last returns ParseNode *
+                { $$ = (ExpressionNode *)$1->set_last( new ExpressionNode( $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 ); }
+        ;
 …
 aggregate_key:
-        aggregate_data
-        | aggregate_control
+        ;
-aggregate_data:
         STRUCT
                 { yyy = true; $$ = AggregateDecl::Struct; }
+                { yyy = true; $$ = DeclarationNode::Struct; }
         | UNION
+                { yyy = true; $$ = AggregateDecl::Union; }
+        | EXCEPTION                                                                                     // CFA
+                { yyy = true; $$ = AggregateDecl::Exception; }
+        ;
+aggregate_control:                                                                              // CFA
+        GENERATOR
+                { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { yyy = true; $$ = DeclarationNode::Union; }
+        | EXCEPTION
+                { yyy = true; $$ = DeclarationNode::Exception; }
+        | GENERATOR
+                { yyy = true; $$ = DeclarationNode::Coroutine; }
         | COROUTINE
                 { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { yyy = true; $$ = DeclarationNode::Coroutine; }
         | MONITOR
                 { yyy = true; $$ = AggregateDecl::Monitor; }
+                { yyy = true; $$ = DeclarationNode::Monitor; }
         | THREAD
                 { yyy = true; $$ = AggregateDecl::Thread; }
+                { yyy = true; $$ = DeclarationNode::Thread; }
+        ;
 …
                         distInl( $3 );
+                }
-        | INLINE aggregate_control ';'                                          // CFA
-                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
 …
         | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
         | initializer_list_opt ',' designation initializer
                 { $$ = (InitializerNode *)($1->set_last( $4->set_designators( $3 ) )); }
+                { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
+        ;
 …
         designator
         | designator_list designator
                 { $$ = (ExpressionNode *)($1->set_last( $2 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $2 ) ); }
         //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
+        ;
 …
         | type_specifier identifier_parameter_declarator
         | assertion_list
                 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( DeclarationNode::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+        ;
 type_class:                                                                                             // CFA
         OTYPE
                 { $$ = TypeDecl::Otype; }
+                { $$ = DeclarationNode::Otype; }
         | DTYPE
                 { $$ = TypeDecl::Dtype; }
+                { $$ = DeclarationNode::Dtype; }
         | FTYPE
                 { $$ = TypeDecl::Ftype; }
+                { $$ = DeclarationNode::Ftype; }
         | TTYPE
                 { $$ = TypeDecl::Ttype; }
+                { $$ = DeclarationNode::Ttype; }
+        ;
 …
                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
         | type_list ',' type
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) ) ); }
         | type_list ',' assignment_expression
                 { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }
 …
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
+                }
           '{' up external_definition_list_opt down '}'

src/ResolvExpr/AdjustExprType.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sat May 16 23:41:42 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:43:56 2019
 // Update Count     : 6
+// Last Modified On : Wed Mar  2 17:34:53 2016
+// Update Count     : 4
 //
 …
                         // replace known function-type-variables with pointer-to-function
                         if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
                                 if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
+                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
                                         return new ast::PointerType{ inst };
+                                }
                         } else if ( const ast::NamedTypeDecl * ntDecl = symtab.lookupType( inst->name ) ) {
                                 if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( ntDecl ) ) {
                                         if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
+                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
                                                 return new ast::PointerType{ inst };
+                                        }

src/ResolvExpr/AlternativeFinder.cc

-              r3d5701e
+              r9fb8f01
                 void postvisit( CastExpr * castExpr );
                 void postvisit( VirtualCastExpr * castExpr );
-                void postvisit( KeywordCastExpr * castExpr );
                 void postvisit( UntypedMemberExpr * memberExpr );
                 void postvisit( MemberExpr * memberExpr );
 …
+        }
-        void AlternativeFinder::Finder::postvisit( KeywordCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Cast target should have been set in Validate." );
-                auto ref = dynamic_cast<ReferenceType*>(castExpr->get_result());
-                assert(ref);
-                auto inst = dynamic_cast<StructInstType*>(ref->base);
-                assert(inst);
-                auto target = inst->baseStruct;
-                AlternativeFinder finder( indexer, env );
-                auto pick_alternatives = [target, this](AltList & found, bool expect_ref) {
-                        for(auto & alt : found) {
-                                Type * expr = alt.expr->get_result();
-                                if(expect_ref) {
-                                        auto res = dynamic_cast<ReferenceType*>(expr);
-                                        if(!res) { continue; }
-                                        expr = res->base;
+                                }
-                                if(auto insttype = dynamic_cast<TypeInstType*>(expr)) {
-                                        auto td = alt.env.lookup(insttype->name);
-                                        if(!td) { continue; }
-                                        expr = td->type;
+                                }
-                                if(auto base = dynamic_cast<StructInstType*>(expr)) {
-                                        if(base->baseStruct == target) {
-                                                alternatives.push_back(
-                                                        std::move(alt)
-                                                );
+                                        }
+                                }
+                        }
-                };
-                try {
-                        // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
-                        // Clone is purely for memory management
-                        std::unique_ptr<Expression> tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) };
-                        // don't prune here, since it's guaranteed all alternatives will have the same type
-                        finder.findWithoutPrune( tech1.get() );
-                        pick_alternatives(finder.alternatives, false);
-                        return;
-                } catch(SemanticErrorException & ) {}
-                // Fallback : turn (thread&)X into ($thread&)get_thread(X)
-                std::unique_ptr<Expression> fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) };
-                // don't prune here, since it's guaranteed all alternatives will have the same type
-                finder.findWithoutPrune( fallback.get() );
-                pick_alternatives(finder.alternatives, true);
-                // Whatever happens here, we have no more fallbacks
+        }
         namespace {
                 /// Gets name from untyped member expression (member must be NameExpr)

src/ResolvExpr/ConversionCost.cc

r3d5701e	r9fb8f01
157	157	if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
158	158	PRINT( std::cerr << "converting compatible base type" << std::endl; )
	159	assert( src->get_lvalue() == srcIsLvalue );
159	160	if ( srcIsLvalue ) {
160	161	PRINT(

src/ResolvExpr/PtrsCastable.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sun May 17 11:48:00 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 21:48:33 2019
 // Update Count     : 9
+// Last Modified On : Wed Mar  2 17:36:18 2016
+// Update Count     : 8
 //
 …
                         if ( const ast::NamedTypeDecl * named = symtab.lookupType( inst->name ) ) {
                                 if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( named ) ) {
                                         if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
+                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
                                                 return -1;
+                                        }
+                                }
                         } else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
                                 if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
+                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
                                         return -1;
+                                }

src/ResolvExpr/ResolveAssertions.cc

r3d5701e	r9fb8f01
156	156	for ( const auto& assn : x.assns ) {
157	157	// compute conversion cost from satisfying decl to assertion
	158	assert( !assn.match.adjType->get_lvalue() );
158	159	k += computeConversionCost(
159	160	assn.match.adjType, assn.decl->get_type(), false, indexer, x.env );

src/ResolvExpr/Resolver.cc

-              r3d5701e
+              r9fb8f01
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
-                void postvisit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 …
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
+                if ( asmExpr->get_inout() ) {
+                        findVoidExpression( asmExpr->inout, indexer );
+                } // if
+        }
 …
         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 );
+                }
+        }
 …
                         asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
+                if ( asmExpr->inout ) {
+                        asmExpr = ast::mutate_field(
+                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
+                }
                 return asmExpr;
+        }
 …
         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/ResolvExpr/Unify.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:27:10 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:43:05 2019
 // Update Count     : 46
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon Jun 18 11:58:00 2018
+// Update Count     : 43
 //
 …
 #include "Common/PassVisitor.h"     // for PassVisitor
 #include "FindOpenVars.h"           // for findOpenVars
 #include "SynTree/LinkageSpec.h"    // for C
+#include "Parser/LinkageSpec.h"     // for C
 #include "SynTree/Constant.h"       // for Constant
 #include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
 …
 #endif
                         if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
                                 common->tq = tq1.unify( tq2 );
+                                common->get_qualifiers() = tq1 | tq2;
 #ifdef DEBUG
                                 std::cerr << "unifyInexact: common type is ";
 …
                                 if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
                                         common = type1->clone();
                                         common->tq = tq1.unify( tq2 );
+                                        common->get_qualifiers() = tq1 | tq2;
                                         result = true;
                                 } else {
 …
                         } else {
                                 common = type1->clone();
                                 common->tq = tq1.unify( tq2 );
+                                common->get_qualifiers() = tq1 | tq2;
                                 result = true;
                         } // if
 …
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                         // expand ttype parameter into its actual type
                                         if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
+                                        if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
                                                 return clz->bound;
+                                        }

src/SymTab/Autogen.h

-              r3d5701e
+              r9fb8f01
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 16:38:06 2019
 // Update Count     : 16
+// Last Modified On : Sat Jul 22 09:50:25 2017
+// Update Count     : 15
 //
 …
 #include "SynTree/Expression.h"   // for NameExpr, ConstantExpr, UntypedExpr...
 #include "SynTree/Type.h"         // for Type, ArrayType, Type::Qualifiers
-#include "SynTree/Statement.h"    // for CompoundStmt, DeclStmt, ExprStmt
 class CompoundStmt;
 …
                         //   type->get_qualifiers() = Type::Qualifiers();
                         Type * castType = addCast->clone();
                         castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );

src/SymTab/Demangle.cc

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Jul 30 13:46:33 2019
+// Update Count     : 3
 //
 …
 #include "CodeGen/GenType.h"
 #include "Common/PassVisitor.h"
-#include "Common/utility.h"                                                             // isPrefix
 #include "Mangler.h"
 #include "SynTree/Type.h"
 …
                                 // type variable types
                                 for (size_t k = 0; k < TypeDecl::NUMBER_OF_KINDS; ++k) {
                                         static const std::string typeVariableNames[] = { "DT", "OT", "FT", "TT", };
+                                        static const std::string typeVariableNames[] = { "DT", "FT", "TT", };
                                         static_assert(
                                                 sizeof(typeVariableNames)/sizeof(typeVariableNames[0]) == TypeDecl::NUMBER_OF_KINDS,
 …
                         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/Indexer.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:43:19 2019
 // Update Count     : 22
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 21
 //
 …
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
+#include "Parser/LinkageSpec.h"    // for isMangled, isOverridable, Spec
 #include "ResolvExpr/typeops.h"    // for typesCompatible
-#include "SynTree/LinkageSpec.h"   // for isMangled, isOverridable, Spec
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for DeclarationWithType, FunctionDecl

src/SymTab/Mangler.cc

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Jul 30 13:46:10 2019
+// Update Count     : 26
 //
 #include "Mangler.h"
 …
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for toString
+#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
-#include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...
 #include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
 #include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
 …
                                 } // 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;
 …
                         // aside from the assert false.
                         assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
                         assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
+                        assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
                         mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
+                }
 …
                                         for ( const ast::TypeDecl * decl : ptype->forall ) {
                                                 switch ( decl->kind ) {
                                                 case ast::TypeDecl::Kind::Dtype:
+                                                case ast::TypeVar::Kind::Dtype:
                                                         dcount++;
                                                         break;
                                                 case ast::TypeDecl::Kind::Ftype:
+                                                case ast::TypeVar::Kind::Ftype:
                                                         fcount++;
                                                         break;
                                                 case ast::TypeDecl::Kind::Ttype:
+                                                case ast::TypeVar::Kind::Ttype:
                                                         vcount++;
                                                         break;

src/SymTab/ManglerCommon.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 14:54:38 2019
 // Update Count     : 28
+// Last Modified On : Thu Feb 14 17:06:37 2019
+// Update Count     : 26
 //
 …
                                 { Type::Atomic, "DA" }, // A is array, so need something unique for atmoic. For now, go with multiletter DA
                                 { Type::Mutex, "X" },
+                                { Type::Lvalue, "L" },
                         };
 …
                         const std::string typeVariables[] = {
                                 "BD", // dtype
-                                "BO", // otype
                                 "BF", // ftype
                                 "BT", // ttype

src/SymTab/Validate.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:43:34 2019
 // Update Count     : 363
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  7 6:42:00 2019
+// Update Count     : 360
 //
 …
 #include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
+#include "Parser/LinkageSpec.h"        // for C
 #include "ResolvExpr/typeops.h"        // for typesCompatible
 #include "ResolvExpr/Resolver.h"       // for findSingleExpression
 #include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
 #include "SymTab/Autogen.h"            // for SizeType
-#include "SynTree/LinkageSpec.h"       // for C
 #include "SynTree/Attribute.h"         // for noAttributes, Attribute
 #include "SynTree/Constant.h"          // for Constant
 …
 #include "SynTree/Label.h"             // for operator==, Label
 #include "SynTree/Mutator.h"           // for Mutator
+#include "SynTree/TopLvalue.h"         // for assertTopLvalue, clearInnerLvalue
 #include "SynTree/Type.h"              // for Type, TypeInstType, EnumInstType
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
 …
                 PassVisitor<FixQualifiedTypes> fixQual;
+                assertTopLvalue( translationUnit );
+                {
                         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 );
 …
                         acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
+                }
+                assertTopLvalue( translationUnit );
+                {
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Link Reference To Types", [&]() {
                                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
                                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
                                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
                                 EliminateTypedef::eliminateTypedef( translationUnit ); //
                         });
+                }
+                assertTopLvalue( translationUnit );
+                {
                         Stats::Heap::newPass("validate-C");
                         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
+                }
+                assertTopLvalue( translationUnit );
+                {
                         Stats::Heap::newPass("validate-D");
                         Stats::Time::BlockGuard guard("validate-D");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
                                 Concurrency::applyKeywords( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
                                 acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
                                 ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
                                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
                         });
+                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
+                {
                         Stats::Heap::newPass("validate-E");
                         Stats::Time::BlockGuard guard("validate-E");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
                                 Concurrency::implementMutexFuncs( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Thread Start", [&]() {
                                 Concurrency::implementThreadStarter( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Compound Literal", [&]() {
                                 mutateAll( translationUnit, compoundliteral );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
                                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
                         });
+                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
+                {
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeCall("Fix Object Type",
+                                FixObjectType::fix, translationUnit);
+                        Stats::Time::TimeCall("Array Length",
+                                ArrayLength::computeLength, translationUnit);
+                        Stats::Time::TimeCall("Find Special Declarations",
+                                Validate::findSpecialDecls, translationUnit);
+                        Stats::Time::TimeCall("Fix Label Address",
+                                mutateAll<LabelAddressFixer>, translationUnit, labelAddrFixer);
+                        Stats::Time::TimeCall("Handle Attributes",
+                                Validate::handleAttributes, translationUnit);
+                }
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
+                assertTopLvalue( translationUnit );
+        }
 …
                 Type * designatorType = tyDecl->base->stripDeclarator();
                 if ( StructInstType * aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
                         declsToAddBefore.push_back( new StructDecl( aggDecl->name, AggregateDecl::Struct, noAttributes, tyDecl->linkage ) );
+                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
                 } else if ( UnionInstType * aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
 …
                 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 " );
+                        }
+                }
 …
         void FixObjectType::previsit( ObjectDecl * objDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 objDecl->set_type( new_type );
+        }
 …
         void FixObjectType::previsit( FunctionDecl * funcDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 funcDecl->set_type( new_type );
+        }
 …
                 if ( typeDecl->get_base() ) {
                         Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
+                        new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                         typeDecl->set_base( new_type );
                 } // if

src/SynTree/AddressExpr.cc

r3d5701e	r9fb8f01
53	53	} // if
54	54	}
	55	// result of & is never an lvalue
	56	get_result()->set_lvalue( false );
55	57	}
56	58	}

src/SynTree/AggregateDecl.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:07:20 2019
 // Update Count     : 31
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug  4 14:22:00 2017
+// Update Count     : 22
 //
 …
 #include "Common/utility.h"      // for printAll, cloneAll, deleteAll
 #include "Declaration.h"         // for AggregateDecl, TypeDecl, Declaration
+#include "Initializer.h"
+#include "LinkageSpec.h"         // for Spec, linkageName, Cforall
+#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
 #include "Type.h"                // for Type, Type::StorageClasses
-// These must harmonize with the corresponding AggregateDecl::Aggregate enumerations.
-static const char * aggregateNames[] = { "struct", "union", "enum", "exception", "trait", "generator", "coroutine", "monitor", "thread", "NoAggregateName" };
-const char * AggregateDecl::aggrString( AggregateDecl::Aggregate aggr ) {
-        return aggregateNames[aggr];
+}
 AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, Type::StorageClasses(), linkage ), body( false ), attributes( attributes ) {
 …
         os << typeString() << " " << name << ":";
         if ( get_linkage() != LinkageSpec::Cforall ) {
                 os << " " << LinkageSpec::name( linkage );
+                os << " " << LinkageSpec::linkageName( linkage );
         } // if
         os << " with body " << has_body();
 …
+}
 const char * StructDecl::typeString() const { return aggrString( kind ); }
+std::string StructDecl::typeString() const { return "struct"; }
 const char * UnionDecl::typeString() const { return aggrString( Union ); }
+std::string UnionDecl::typeString() const { return "union"; }
 const char * EnumDecl::typeString() const { return aggrString( Enum ); }
+std::string EnumDecl::typeString() const { return "enum"; }
 const char * TraitDecl::typeString() const { return aggrString( Trait ); }
+std::string TraitDecl::typeString() const { return "trait"; }
 bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) {

src/SynTree/ApplicationExpr.cc

-              r3d5701e
+              r9fb8f01
 #include "Declaration.h"         // for Declaration
 #include "Expression.h"          // for ParamEntry, ApplicationExpr, Expression
-#include "InitTweak/InitTweak.h" // for getFunction
 #include "ResolvExpr/typeops.h"  // for extractResultType
 #include "Type.h"                // for Type, PointerType, FunctionType
 …
 bool ApplicationExpr::get_lvalue() const {
+        // from src/GenPoly/Lvalue.cc: isIntrinsicReference
+        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
+        if ( const DeclarationWithType * func = InitTweak::getFunction( this ) ) {
+                return func->linkage == LinkageSpec::Intrinsic && lvalueFunctions.count(func->name);
+        }
+        return false;
+        return result->get_lvalue();
+}

src/SynTree/ArrayType.cc

r3d5701e	r9fb8f01
26	26	ArrayType::ArrayType( const Type::Qualifiers &tq, Type base, Expression dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
27	27	: Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
	28	base->set_lvalue( false );
28	29	}
29	30

src/SynTree/Attribute.h

-              r3d5701e
+              r9fb8f01
 // 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/SynTree/CommaExpr.cc

-              r3d5701e
+              r9fb8f01
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
                 : Expression(), arg1( arg1 ), arg2( arg2 ) {
+        // xxx - result of a comma expression is never an lvalue, so should set lvalue
+        // to false on all result types. Actually doing this causes some strange things
+        // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
         set_result( maybeClone( arg2->get_result() ) );
+        // get_type->set_isLvalue( false );
+}
 …
 bool CommaExpr::get_lvalue() const {
+        // This is wrong by C, but the current implementation uses it.
+        // (ex: Specialize, Lvalue and Box)
+        return arg2->get_lvalue();
+        // xxx - as above, shouldn't be an lvalue but that information is used anyways.
+        return result->get_lvalue();
+}

src/SynTree/Declaration.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 16:39:56 2019
 // Update Count     : 36
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:38:00 2017
+// Update Count     : 25
 //
 …
 #include "SynTree/Statement.h"       // for AsmStmt
 #include "SynTree/SynTree.h"         // for UniqueId
-#include "SynTree/Expression.h"
 #include "Type.h"                    // for Type, Type::StorageClasses
-// To canonicalize declarations
 static UniqueId lastUniqueId = 0;

src/SynTree/Declaration.h

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:11:22 2019
 // Update Count     : 157
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 135
 //
 …
 #include "BaseSyntaxNode.h"      // for BaseSyntaxNode
 #include "Mutator.h"             // for Mutator
+#include "LinkageSpec.h"         // for Spec, Cforall
+#include "Parser/LinkageSpec.h"  // for Spec, Cforall
+#include "Parser/ParseNode.h"    // for DeclarationNode, DeclarationNode::Ag...
 #include "SynTree.h"             // for UniqueId
 #include "SynTree/Type.h"        // for Type, Type::StorageClasses, Type::Fu...
 …
         bool extension = false;
         Declaration( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
         Declaration( const Declaration & other );
+        Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
+        Declaration( const Declaration &other );
         virtual ~Declaration();
         const std::string & get_name() const { return name; }
+        const std::string &get_name() const { return name; }
         void set_name( std::string newValue ) { name = newValue; }
 …
         bool get_extension() const { return extension; }
         Declaration * set_extension( bool exten ) { extension = exten; return this; }
+        Declaration *set_extension( bool exten ) { extension = exten; return this; }
         void fixUniqueId( void );
         virtual Declaration * clone() const override = 0;
+        virtual Declaration *clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
         virtual void accept( Visitor & v ) const override = 0;
         virtual Declaration * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override = 0;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const = 0;
+        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
         UniqueId uniqueId;
 …
         int scopeLevel = 0;
         Expression * asmName;
+        Expression *asmName;
         std::list< Attribute * > attributes;
         bool isDeleted = false;
         DeclarationWithType( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
         DeclarationWithType( const DeclarationWithType & other );
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
+        DeclarationWithType( const DeclarationWithType &other );
         virtual ~DeclarationWithType();
 …
         DeclarationWithType * set_scopeLevel( int newValue ) { scopeLevel = newValue; return this; }
         Expression * get_asmName() const { return asmName; }
         DeclarationWithType * set_asmName( Expression * newValue ) { asmName = newValue; return this; }
+        Expression *get_asmName() const { return asmName; }
+        DeclarationWithType * set_asmName( Expression *newValue ) { asmName = newValue; return this; }
         std::list< Attribute * >& get_attributes() { return attributes; }
 …
         //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
         virtual DeclarationWithType * clone() const override = 0;
         virtual DeclarationWithType * acceptMutator( Mutator & m )  override = 0;
+        virtual DeclarationWithType *clone() const override = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
         virtual Type * get_type() const = 0;
 …
         typedef DeclarationWithType Parent;
   public:
         Type * type;
         Initializer * init;
         Expression * bitfieldWidth;
         ObjectDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression * bitfieldWidth, Type * type, Initializer * init,
+        Type *type;
+        Initializer *init;
+        Expression *bitfieldWidth;
+        ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         ObjectDecl( const ObjectDecl & other );
+        ObjectDecl( const ObjectDecl &other );
         virtual ~ObjectDecl();
         virtual Type * get_type() const override { return type; }
         virtual void set_type(Type * newType) override { type = newType; }
         Initializer * get_init() const { return init; }
         void set_init( Initializer * newValue ) { init = newValue; }
         Expression * get_bitfieldWidth() const { return bitfieldWidth; }
         void set_bitfieldWidth( Expression * newValue ) { bitfieldWidth = newValue; }
+        virtual void set_type(Type *newType) override { type = newType; }
+        Initializer *get_init() const { return init; }
+        void set_init( Initializer *newValue ) { init = newValue; }
+        Expression *get_bitfieldWidth() const { return bitfieldWidth; }
+        void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
         static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
         virtual ObjectDecl * clone() const override { return new ObjectDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         typedef DeclarationWithType Parent;
   public:
         FunctionType * type;
         CompoundStmt * statements;
+        FunctionType *type;
+        CompoundStmt *statements;
         std::list< Expression * > withExprs;
         FunctionDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType * type, CompoundStmt * statements,
+        FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
                                   const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         FunctionDecl( const FunctionDecl & other );
+        FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();
 …
         FunctionType * get_functionType() const { return type; }
         void set_functionType( FunctionType * newValue ) { type = newValue; }
         CompoundStmt * get_statements() const { return statements; }
         void set_statements( CompoundStmt * newValue ) { statements = newValue; }
+        void set_functionType( FunctionType *newValue ) { type = newValue; }
+        CompoundStmt *get_statements() const { return statements; }
+        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
         bool has_body() const { return NULL != statements; }
         static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
         virtual FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         typedef Declaration Parent;
   public:
         Type * base;
         std::list< TypeDecl * > parameters;
         std::list< DeclarationWithType * > assertions;
         NamedTypeDecl( const std::string & name, Type::StorageClasses scs, Type * type );
         NamedTypeDecl( const NamedTypeDecl & other );
+        Type *base;
+        std::list< TypeDecl* > parameters;
+        std::list< DeclarationWithType* > assertions;
+        NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
+        NamedTypeDecl( const NamedTypeDecl &other );
         virtual ~NamedTypeDecl();
         Type * get_base() const { return base; }
         void set_base( Type * newValue ) { base = newValue; }
         std::list< TypeDecl* > & get_parameters() { return parameters; }
         std::list< DeclarationWithType * >& get_assertions() { return assertions; }
         virtual const char * typeString() const = 0;
         virtual NamedTypeDecl * clone() const override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        Type *get_base() const { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        std::list< TypeDecl* >& get_parameters() { return parameters; }
+        std::list< DeclarationWithType* >& get_assertions() { return assertions; }
+        virtual std::string typeString() const = 0;
+        virtual NamedTypeDecl *clone() const override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         typedef NamedTypeDecl Parent;
   public:
         enum Kind { Dtype, Otype, Ftype, Ttype, NUMBER_OF_KINDS };
         Kind kind;
+        enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
+        Type * init;
         bool sized;
-        Type * init;
         /// Data extracted from a type decl
         struct Data {
                 Kind kind;
+                TypeDecl::Kind kind;
                 bool isComplete;
                 Data() : kind( NUMBER_OF_KINDS ), isComplete( false ) {}
                 Data( const TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
+                Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
+                Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
                 Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
                 Data( const Data & d1, const Data & d2 )
                         : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
                 bool operator==( const Data & other ) const { return kind == other.kind && isComplete == other.isComplete; }
                 bool operator!=( const Data & other ) const { return !(*this == other);}
+                Data( const Data& d1, const Data& d2 )
+                : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
+                bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
+                bool operator!=(const Data & other) const { return !(*this == other);}
         };
         TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init = nullptr );
         TypeDecl( const TypeDecl & other );
+        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
+        TypeDecl( const TypeDecl &other );
         virtual ~TypeDecl();
 …
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
+        virtual const char * typeString() const override;
+        virtual const char * genTypeString() const;
+        virtual TypeDecl * clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual std::string typeString() const override;
+        virtual std::string genTypeString() const;
+        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Kind kind;
 };
 …
         typedef NamedTypeDecl Parent;
   public:
         TypedefDecl( const std::string & name, CodeLocation location, Type::StorageClasses scs, Type * type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
+        TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
                 : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; }
         TypedefDecl( const TypedefDecl & other ) : Parent( other ) {}
         virtual const char * typeString() const override;
         virtual TypedefDecl * clone() const override { return new TypedefDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
+        virtual std::string typeString() const override;
+        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
 …
         typedef Declaration Parent;
   public:
-        enum Aggregate { Struct, Union, Enum, Exception, Trait, Generator, Coroutine, Monitor, Thread, NoAggregate };
-        static const char * aggrString( Aggregate aggr );
         std::list<Declaration*> members;
         std::list<TypeDecl*> parameters;
 …
         AggregateDecl * parent = nullptr;
         AggregateDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
         AggregateDecl( const AggregateDecl & other );
+        AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
+        AggregateDecl( const AggregateDecl &other );
         virtual ~AggregateDecl();
 …
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override final;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override final;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
   protected:
         virtual const char * typeString() const = 0;
+        virtual std::string typeString() const = 0;
 };
 …
         typedef AggregateDecl Parent;
   public:
         StructDecl( const std::string & name, Aggregate kind = Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
         StructDecl( const StructDecl & other ) : Parent( other ), kind( other.kind ) {}
         bool is_coroutine() { return kind == Coroutine; }
         bool is_monitor() { return kind == Monitor; }
         bool is_thread() { return kind == Thread; }
         virtual StructDecl * clone() const override { return new StructDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         Aggregate kind;
   private:
         virtual const char * typeString() const override;
+        StructDecl( const std::string &name, DeclarationNode::Aggregate kind = DeclarationNode::Struct, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ), kind( kind ) {}
+        StructDecl( const StructDecl &other ) : Parent( other ), kind( other.kind ) {}
+        bool is_coroutine() { return kind == DeclarationNode::Coroutine; }
+        bool is_monitor() { return kind == DeclarationNode::Monitor; }
+        bool is_thread() { return kind == DeclarationNode::Thread; }
+        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        DeclarationNode::Aggregate kind;
+  private:
+        virtual std::string typeString() const override;
 };
 …
         typedef AggregateDecl Parent;
   public:
         UnionDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         UnionDecl( const UnionDecl & other ) : Parent( other ) {}
         virtual UnionDecl * clone() const override { return new UnionDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
         virtual const char * typeString() const override;
+        UnionDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+        UnionDecl( const UnionDecl &other ) : Parent( other ) {}
+        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         typedef AggregateDecl Parent;
   public:
         EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
         EnumDecl( const EnumDecl & other ) : Parent( other ) {}
+        EnumDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {}
+        EnumDecl( const EnumDecl &other ) : Parent( other ) {}
         bool valueOf( Declaration * enumerator, long long int & value );
         virtual EnumDecl * clone() const override { return new EnumDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         std::unordered_map< std::string, long long int > enumValues;
         virtual const char * typeString() const override;
+        virtual std::string typeString() const override;
 };
 …
         typedef AggregateDecl Parent;
   public:
         TraitDecl( const std::string & name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
+        TraitDecl( const std::string &name, const std::list< Attribute * > & attributes, LinkageSpec::Spec linkage ) : Parent( name, attributes, linkage ) {
                 assertf( attributes.empty(), "attribute unsupported for traits" );
+        }
         TraitDecl( const TraitDecl & other ) : Parent( other ) {}
         virtual TraitDecl * clone() const override { return new TraitDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
   private:
         virtual const char * typeString() const override;
+        TraitDecl( const TraitDecl &other ) : Parent( other ) {}
+        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
 class AsmDecl : public Declaration {
   public:
         AsmStmt * stmt;
         AsmDecl( AsmStmt * stmt );
         AsmDecl( const AsmDecl & other );
+        AsmStmt *stmt;
+        AsmDecl( AsmStmt *stmt );
+        AsmDecl( const AsmDecl &other );
         virtual ~AsmDecl();
         AsmStmt * get_stmt() { return stmt; }
         void set_stmt( AsmStmt * newValue ) { stmt = newValue; }
         virtual AsmDecl * clone() const override { return new AsmDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual AsmDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        AsmStmt *get_stmt() { return stmt; }
+        void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
+        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual StaticAssertDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };

src/SynTree/DeclarationWithType.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:45:16 2019
 // Update Count     : 26
+// Last Modified On : Thu Mar 16 08:34:35 2017
+// Update Count     : 25
 //
 …
 #include "Common/utility.h"      // for cloneAll, deleteAll, maybeClone
 #include "Declaration.h"         // for DeclarationWithType, Declaration
 #include "LinkageSpec.h"         // for Spec
 #include "Expression.h"          // for ConstantExpr
+#include "Parser/LinkageSpec.h"  // for Spec
+#include "SynTree/Expression.h"  // for ConstantExpr
 #include "Type.h"                // for Type, Type::FuncSpecifiers, Type::St...

src/SynTree/Expression.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 07:55:15 2019
 // Update Count     : 70
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 15 13:43:00 2019
+// Update Count     : 64
 //
 …
 #include <iostream>                  // for ostream, operator<<, basic_ostream
 #include <list>                      // for list, _List_iterator, list<>::co...
-#include <set>                       // for set
 #include "Common/utility.h"          // for maybeClone, cloneAll, deleteAll
+#include "Declaration.h"             // for ObjectDecl, DeclarationWithType
 #include "Expression.h"              // for Expression, ImplicitCopyCtorExpr
 #include "InitTweak/InitTweak.h"     // for getCallArg, getPointerBase
 …
 bool Expression::get_lvalue() const {
+        assert( !result->get_lvalue() );
         return false;
+}
 …
         assert( var->get_type() );
         Type * type = var->get_type()->clone();
+        type->set_lvalue( true );
         // xxx - doesn't quite work yet - get different alternatives with the same cost
 …
         //      long long int value;
         //      if ( decl->valueOf( var, value ) ) {
         //              type->set_lvalue( false ); // Would have to move to get_lvalue.
+        //              type->set_lvalue( false );
         //      }
         // }
 …
 bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+        return result->get_lvalue();
+}
 …
 bool CastExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return arg->get_lvalue();
+        return result->get_lvalue();
+}
 …
+}
 KeywordCastExpr::KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target ) : Expression(), arg(arg), target( target ) {
+KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
 …
+}
+const char * KeywordCastExpr::targetString() const {
+        return AggregateDecl::aggrString( target );
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
 …
+}
-bool UntypedMemberExpr::get_lvalue() const {
-        return aggregate->get_lvalue();
+}
 void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
 …
         sub.apply( res );
         result = res;
+        result->set_lvalue( true );
         result->get_qualifiers() |= aggregate->result->get_qualifiers();
+}
 …
 bool MemberExpr::get_lvalue() const {
         // This is actually wrong by C, but it works with our current set-up.
+        assert( result->get_lvalue() );
         return true;
+}
 …
                         // if references are still allowed in the AST, dereference returns a reference
                         ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->result->set_lvalue( true );
+                }
+        }
 …
 bool UntypedExpr::get_lvalue() const {
+        // from src/GenPoly/Lvalue.cc: isIntrinsicReference
+        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
+        std::string fname = InitTweak::getFunctionName( const_cast< UntypedExpr * >( this ) );
+        return lvalueFunctions.count(fname);
+        return result->get_lvalue();
+}
 …
 bool ConditionalExpr::get_lvalue() const {
         return false;
+        return result->get_lvalue();
+}
 …
+}
 AsmExpr::AsmExpr( const AsmExpr & other ) : Expression( other ), inout( other.inout ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}
+AsmExpr::AsmExpr( const AsmExpr & other ) : Expression( other ), inout( maybeClone( other.inout ) ), constraint( maybeClone( other.constraint ) ), operand( maybeClone( other.operand ) ) {}
 void AsmExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( !inout.empty() ) os <<  "[" << inout << "] ";
+        if ( inout ) inout->print( os, indent+1 );
         if ( constraint ) constraint->print( os, indent+1 );
         if ( operand ) operand->print( os, indent+1 );
 …
 bool ConstructorExpr::get_lvalue() const {
         return false;
+        return result->get_lvalue();
+}
 …
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
+        type->set_lvalue( true );
         set_result( type );
+}
 …
 bool CompoundLiteralExpr::get_lvalue() const {
+        assert( result->get_lvalue() );
         return true;
+}
 …
+}
 bool StmtExpr::get_lvalue() const {
         return false;
+        return result->get_lvalue();
+}
 void StmtExpr::print( std::ostream & os, Indenter indent ) const {

src/SynTree/Expression.h

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 16:50:19 2019
 // Update Count     : 60
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 15 13:46:00 2019
+// Update Count     : 54
 //
 …
 #include "Label.h"                // for Label
 #include "Mutator.h"              // for Mutator
-#include "Declaration.h"          // for Aggregate
 #include "SynTree.h"              // for UniqueId
 #include "Visitor.h"              // for Visitor
 …
 public:
         Expression * arg;
+        struct Concrete {
+                std::string field;
+                std::string getter;
+        };
+        AggregateDecl::Aggregate target;
+        Concrete concrete_target;
+        KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target );
+        enum Target {
+                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
+        } target;
+        KeywordCastExpr( Expression * arg, Target target );
         KeywordCastExpr( const KeywordCastExpr & other );
         virtual ~KeywordCastExpr();
         const char * targetString() const;
+        const std::string & targetString() const;
         virtual KeywordCastExpr * clone() const override { return new KeywordCastExpr( * this ); }
 …
         UntypedMemberExpr( const UntypedMemberExpr & other );
         virtual ~UntypedMemberExpr();
-        bool get_lvalue() const final;
         Expression * get_member() const { return member; }
 …
 class AsmExpr : public Expression {
   public:
         std::string inout;
+        Expression * inout;
         Expression * constraint;
         Expression * operand;
         AsmExpr( const std::string * _inout, Expression * constraint, Expression * operand ) : inout( _inout ? *_inout : "" ), constraint( constraint ), operand( operand ) { delete _inout; }
+        AsmExpr( Expression * inout, Expression * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
         AsmExpr( const AsmExpr & other );
+        virtual ~AsmExpr() { delete constraint; delete operand; };
+        virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
+        Expression * get_inout() const { return inout; }
+        void set_inout( Expression * newValue ) { inout = newValue; }
+        Expression * get_constraint() const { return constraint; }
+        void set_constraint( Expression * newValue ) { constraint = newValue; }
+        Expression * get_operand() const { return operand; }
+        void set_operand( Expression * newValue ) { operand = newValue; }
         virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }

src/SynTree/FunctionDecl.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:11:20 2019
 // Update Count     : 77
+// Last Modified On : Thu Mar 16 08:33:41 2017
+// Update Count     : 74
 //
 …
 #include "Common/utility.h"      // for maybeClone, printAll
 #include "Declaration.h"         // for FunctionDecl, FunctionDecl::Parent
+#include "Expression.h"
+#include "LinkageSpec.h"         // for Spec, linkageName, Cforall
+#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
 #include "Statement.h"           // for CompoundStmt
 #include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
 …
         } // if
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if

src/SynTree/NamedTypeDecl.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:11:40 2019
 // Update Count     : 17
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 13:28:00 2017
+// Update Count     : 14
 //
 …
 #include "Common/utility.h"      // for printAll, cloneAll, deleteAll, maybe...
 #include "Declaration.h"         // for NamedTypeDecl, DeclarationWithType
 #include "LinkageSpec.h"         // for Spec, Cforall, linkageName
+#include "Parser/LinkageSpec.h"  // for Spec, Cforall, linkageName
 #include "Type.h"                // for Type, Type::StorageClasses
 …
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         get_storageClasses().print( os );
 …
+}
 const char * TypedefDecl::typeString() const { return "typedef"; }
+std::string TypedefDecl::typeString() const { return "typedef"; }
 // Local Variables: //

src/SynTree/ObjectDecl.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:12:03 2019
 // Update Count     : 61
+// Last Modified On : Thu Mar 16 08:34:27 2017
+// Update Count     : 59
 //
 …
 #include "Expression.h"          // for Expression
 #include "Initializer.h"         // for Initializer
 #include "LinkageSpec.h"         // for Spec, linkageName, Cforall
+#include "Parser/LinkageSpec.h"  // for Spec, linkageName, Cforall
 #include "Type.h"                // for Type, Type::StorageClasses, Type::Fu...
 …
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if

src/SynTree/Statement.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Jan 20 16:03:00 2020
 // Update Count     : 71
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Sep  3 20:46:44 2017
+// Update Count     : 68
 //
 …
 Statement::~Statement() {}
 ExprStmt::ExprStmt( Expression * expr ) : Statement(), expr( expr ) {}
 ExprStmt::ExprStmt( const ExprStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
+ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
+ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
 ExprStmt::~ExprStmt() {
 …
+}
 void ExprStmt::print( std::ostream & os, Indenter indent ) const {
+void ExprStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Expression Statement:" << endl << indent+1;
         expr->print( os, indent+1 );
 …
 AsmStmt::AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
 …
+}
 void AsmStmt::print( std::ostream & os, Indenter indent ) const {
+void AsmStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
         os << indent+1 << "instruction: " << endl << indent;
 …
 DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
 void DirectiveStmt::print( std::ostream & os, Indenter ) const {
+void DirectiveStmt::print( std::ostream &os, Indenter ) const {
         os << "GCC Directive:" << directive << endl;
+}
+const char * BranchStmt::brType[] = {
+        "Goto", "Break", "Continue", "Fall Through", "Fall Through Default",
+};
+const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
 …
+}
 BranchStmt::BranchStmt( Expression * computedTarget, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticErrorException ) :
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
 …
+}
+void BranchStmt::print( std::ostream & os, Indenter indent ) const {
+        assert(type < 5);
+void BranchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Branch (" << brType[type] << ")" << endl ;
         if ( target != "" ) os << indent+1 << "with target: " << target << endl;
 …
+}
 ReturnStmt::ReturnStmt( Expression * expr ) : Statement(), expr( expr ) {}
+ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
 …
+}
 void ReturnStmt::print( std::ostream & os, Indenter indent ) const {
+void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Return Statement, returning: ";
         if ( expr != nullptr ) {
 …
+}
 IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
+IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
         Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
 …
+}
 void IfStmt::print( std::ostream & os, Indenter indent ) const {
+void IfStmt::print( std::ostream &os, Indenter indent ) const {
         os << "If on condition: " << endl;
         os << indent+1;
 …
         thenPart->print( os, indent+1 );
         if ( elsePart != nullptr ) {
+        if ( elsePart != 0 ) {
                 os << indent << "... else: " << endl;
                 os << indent+1;
 …
+}
 SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> & statements ):
+SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
         Statement(), condition( condition ), statements( statements ) {
+}
 …
+}
 void SwitchStmt::print( std::ostream & os, Indenter indent ) const {
+void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
 …
+}
 CaseStmt::CaseStmt( Expression * condition, const std::list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticErrorException ) :
         Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
+        if ( isDefault() && condition != 0 ) SemanticError( condition, "default case with condition: " );
+}
 …
+}
 void CaseStmt::print( std::ostream & os, Indenter indent ) const {
+void CaseStmt::print( std::ostream &os, Indenter indent ) const {
         if ( isDefault() ) os << indent << "Default ";
         else {
 …
+}
 WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
+WhileStmt::WhileStmt( Expression *condition, Statement *body, std::list< Statement * > & initialization, bool isDoWhile ):
         Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
+}
 …
+}
 void WhileStmt::print( std::ostream & os, Indenter indent ) const {
+void WhileStmt::print( std::ostream &os, Indenter indent ) const {
         os << "While on condition: " << endl ;
         condition->print( os, indent+1 );
 …
         os << indent << "... with body: " << endl;
         if ( body != nullptr ) body->print( os, indent+1 );
+}
 ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
+        if ( body != 0 ) body->print( os, indent+1 );
+}
+ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
         Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+}
 …
+}
 void ForStmt::print( std::ostream & os, Indenter indent ) const {
+void ForStmt::print( std::ostream &os, Indenter indent ) const {
         Statement::print( os, indent ); // print labels
 …
+        }
         if ( body != nullptr ) {
+        if ( body != 0 ) {
                 os << "\n" << indent << "... with body: \n" << indent+1;
                 body->print( os, indent+1 );
 …
+}
 ThrowStmt::ThrowStmt( const ThrowStmt & other ) :
+ThrowStmt::ThrowStmt( const ThrowStmt &other ) :
         Statement ( other ), kind( other.kind ), expr( maybeClone( other.expr ) ), target( maybeClone( other.target ) ) {
+}
 …
+}
 void ThrowStmt::print( std::ostream & os, Indenter indent) const {
+void ThrowStmt::print( std::ostream &os, Indenter indent) const {
         if ( target ) os << "Non-Local ";
         os << "Throw Statement, raising: ";
 …
+}
 TryStmt::TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
+TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
         Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
+}
 TryStmt::TryStmt( const TryStmt & other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
+TryStmt::TryStmt( const TryStmt &other ) : Statement( other ), block( maybeClone( other.block ) ), finallyBlock( maybeClone( other.finallyBlock ) ) {
         cloneAll( other.handlers, handlers );
+}
 …
+}
 void TryStmt::print( std::ostream & os, Indenter indent ) const {
+void TryStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Try Statement" << endl;
         os << indent << "... with block:" << endl << indent+1;
 …
         // finally block
         if ( finallyBlock != nullptr ) {
+        if ( finallyBlock != 0 ) {
                 os << indent << "... and finally:" << endl << indent+1;
                 finallyBlock->print( os, indent+1 );
 …
+}
 CatchStmt::CatchStmt( Kind kind, Declaration * decl, Expression * cond, Statement * body ) :
+CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
         Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
                 assertf( decl, "Catch clause must have a declaration." );
 …
+}
 void CatchStmt::print( std::ostream & os, Indenter indent ) const {
+void CatchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
 …
 FinallyStmt::FinallyStmt( CompoundStmt * block ) : Statement(), block( block ) {
+FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
+}
 …
+}
 void FinallyStmt::print( std::ostream & os, Indenter indent ) const {
+void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Finally Statement" << endl;
         os << indent << "... with block:" << endl << indent+1;
 …
+}
 void WaitForStmt::print( std::ostream & os, Indenter indent ) const {
+void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
         indent += 1;
 …
+}
 void NullStmt::print( std::ostream & os, Indenter indent ) const {
+void NullStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Null Statement" << endl;
         Statement::print( os, indent );
 …
+}
 void ImplicitCtorDtorStmt::print( std::ostream & os, Indenter indent ) const {
+void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
         os << indent << "... with Ctor/Dtor: ";

src/SynTree/Statement.h

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jan 10 14:13:24 2020
 // Update Count     : 85
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 …
         Statement * body;
         ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
+        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
         ForStmt( const ForStmt & other );
         virtual ~ForStmt();
 …
         FinallyStmt * finallyBlock;
         TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
+        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
         TryStmt( const TryStmt & other );
         virtual ~TryStmt();

src/SynTree/TupleExpr.cc

-              r3d5701e
+              r9fb8f01
 bool TupleExpr::get_lvalue() const {
         return false;
+        return result->get_lvalue();
+}
 …
         assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
+        // like MemberExpr, TupleIndexExpr is always an lvalue
+        get_result()->set_lvalue( true );
+}
 …
 bool TupleIndexExpr::get_lvalue() const {
+        return tuple->get_lvalue();
+        assert( result->get_lvalue() );
+        return true;
+}

src/SynTree/TupleType.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:44:38 2019
 // Update Count     : 4
+// Last Modified On : Wed Feb  1 17:10:58 2017
+// Update Count     : 3
 //
 …
 #include "Declaration.h"         // for Declaration, ObjectDecl
 #include "Initializer.h"         // for ListInit
 #include "LinkageSpec.h"         // for Cforall
+#include "Parser/LinkageSpec.h"  // for Cforall
 #include "Type.h"                // for TupleType, Type, Type::Qualifiers

src/SynTree/Type.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Dec 15 16:52:37 2019
 // Update Count     : 49
+// Last Modified On : Sun Aug  4 21:05:07 2019
+// Update Count     : 45
 //
 #include "Type.h"
 …
 using namespace std;
-// GENERATED START, DO NOT EDIT
-// GENERATED BY BasicTypes-gen.cc
 const char * BasicType::typeNames[] = {
         "_Bool",
 …
         "float",
         "float _Complex",
+        //"float _Imaginary",
         "_Float32x",
         "_Float32x _Complex",
 …
         "double",
         "double _Complex",
+        //"double _Imaginary",
         "_Float64x",
         "_Float64x _Complex",
 …
         "long double",
         "long double _Complex",
+        //"long double _Imaginary",
         "_Float128x",
         "_Float128x _Complex",
 };
+// GENERATED END
+static_assert(
+        sizeof(BasicType::typeNames) / sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+        "Each basic type name should have a corresponding kind enum value"
+);
 Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
 …
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
 const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
+const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 Type * Type::stripDeclarator() {

src/SynTree/Type.h

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Sep  4 09:58:00 2019
 // Update Count     : 170
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb 14 17:11:24 2019
+// Update Count     : 169
 //
 …
         }; // StorageClasses
         enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
+        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
         static const char * QualifiersNames[];
         union Qualifiers {
                 enum { Mask = ~Restrict };
+                enum { Mask = ~(Restrict | Lvalue) };
                 unsigned int val;
                 struct {
 …
                         bool is_restrict : 1;
                         bool is_volatile : 1;
+                        bool is_lvalue : 1;
                         bool is_mutex : 1;
                         bool is_atomic : 1;
 …
                 bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
                 BFCommon( Qualifiers, NumTypeQualifier )
-                Qualifiers unify( Qualifiers const & other ) const {
-                        int or_flags = Mask & (val | other.val);
-                        int and_flags = val & other.val;
-                        return Qualifiers( or_flags | and_flags );
+                }
         }; // Qualifiers
 …
         bool get_volatile() const { return tq.is_volatile; }
         bool get_restrict() const { return tq.is_restrict; }
+        bool get_lvalue() const { return tq.is_lvalue; }
         bool get_mutex() const { return tq.is_mutex; }
         bool get_atomic() const { return tq.is_atomic; }
 …
         void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
         void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
+        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
         void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }

src/SynTree/TypeDecl.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 15:26:14 2019
 // Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:35:00 2017
+// Update Count     : 6
 //
 …
 #include "Type.h"            // for Type, Type::StorageClasses
 TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Ttype || sized ), kind( kind ) {
+}
 TypeDecl::TypeDecl( const TypeDecl & other ) : Parent( other ), kind( other.kind ), sized( other.sized ), init( maybeClone( other.init ) ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), init( maybeClone( other.init ) ), sized( other.sized ), kind( other.kind ) {
+}
 TypeDecl::~TypeDecl() {
         delete init;
+  delete init;
+}
 const char * TypeDecl::typeString() const {
         static const char * kindNames[] = { "sized data type", "sized object type", "sized function type", "sized tuple type" };
         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
         return isComplete() ? kindNames[ kind ] : &kindNames[ kind ][ sizeof("sized") ]; // sizeof includes '\0'
+std::string TypeDecl::typeString() const {
+        static const std::string kindNames[] = { "object type", "function type", "tuple type" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "typeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
+        return (isComplete() ? "sized " : "") + kindNames[ kind ];
+}
 const char * TypeDecl::genTypeString() const {
         static const char * kindNames[] = { "dtype", "otype", "ftype", "ttype" };
         static_assert( sizeof(kindNames)/sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "genTypeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );
+std::string TypeDecl::genTypeString() const {
+        static const std::string kindNames[] = { "dtype", "ftype", "ttype" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
         return kindNames[ kind ];
+}
 void TypeDecl::print( std::ostream &os, Indenter indent ) const {
         NamedTypeDecl::print( os, indent );
         if ( init ) {
                 os << std::endl << indent << "with type initializer: ";
                 init->print( os, indent + 1 );
+        } // if
+  NamedTypeDecl::print( os, indent );
+  if ( init ) {
+    os << std::endl << indent << "with type initializer: ";
+    init->print( os, indent + 1 );
+  }
+}
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
         return os << data.kind << ", " << data.isComplete;
+  return os << data.kind << ", " << data.isComplete;
+}

src/SynTree/module.mk

-              r3d5701e
+              r9fb8f01
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Sat Dec 14 07:26:43 2019
 ## Update Count     : 2
+## Last Modified On : Mon Jun  1 17:54:09 2015
+## Update Count     : 1
 ###############################################################################
 SRC_SYNTREE = \
+      SynTree/Type.cc \
+      SynTree/VoidType.cc \
+      SynTree/BasicType.cc \
+      SynTree/PointerType.cc \
+      SynTree/ArrayType.cc \
+      SynTree/ReferenceType.cc \
+      SynTree/FunctionType.cc \
+      SynTree/ReferenceToType.cc \
+      SynTree/TupleType.cc \
+      SynTree/TypeofType.cc \
+      SynTree/AttrType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/ZeroOneType.cc \
+      SynTree/Constant.cc \
+      SynTree/Expression.cc \
+      SynTree/TupleExpr.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/TypeExpr.cc \
+      SynTree/ApplicationExpr.cc \
       SynTree/AddressExpr.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/ApplicationExpr.cc \
+      SynTree/ArrayType.cc \
+      SynTree/AttrType.cc \
+      SynTree/Attribute.cc \
+      SynTree/BasicType.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/Statement.cc \
       SynTree/CompoundStmt.cc \
-      SynTree/Constant.cc \
-      SynTree/DeclReplacer.cc \
       SynTree/DeclStmt.cc \
       SynTree/Declaration.cc \
       SynTree/DeclarationWithType.cc \
       SynTree/Expression.cc \
+      SynTree/ObjectDecl.cc \
       SynTree/FunctionDecl.cc \
+      SynTree/FunctionType.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
       SynTree/Initializer.cc \
-      SynTree/LinkageSpec.cc \
-      SynTree/NamedTypeDecl.cc \
-      SynTree/ObjectDecl.cc \
-      SynTree/PointerType.cc \
-      SynTree/ReferenceToType.cc \
-      SynTree/ReferenceType.cc \
-      SynTree/Statement.cc \
-      SynTree/TupleExpr.cc \
-      SynTree/TupleType.cc \
-      SynTree/Type.cc \
-      SynTree/TypeDecl.cc \
-      SynTree/TypeExpr.cc \
       SynTree/TypeSubstitution.cc \
+      SynTree/TypeofType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/VoidType.cc \
+      SynTree/ZeroOneType.cc
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc \
+      SynTree/TopLvalue.cc
 SRC += $(SRC_SYNTREE)

src/Tuples/TupleAssignment.cc

-              r3d5701e
+              r9fb8f01
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:45:33 2019
 // Update Count     : 9
+// Last Modified On : Fri Mar 17 09:43:03 2017
+// Update Count     : 8
 //
 …
 #include "InitTweak/GenInit.h"             // for genCtorInit
 #include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
+#include "Parser/LinkageSpec.h"            // for Cforall
 #include "ResolvExpr/Alternative.h"        // for AltList, Alternative
 #include "ResolvExpr/AlternativeFinder.h"  // for AlternativeFinder, simpleC...
 …
 #include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
 #include "ResolvExpr/typeops.h"            // for combos
-#include "SynTree/LinkageSpec.h"           // for Cforall
 #include "SynTree/Declaration.h"           // for ObjectDecl
 #include "SynTree/Expression.h"            // for Expression, CastExpr, Name...

src/Tuples/TupleExpansion.cc

-              r3d5701e
+              r9fb8f01
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:45:51 2019
 // Update Count     : 24
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 19 14:39:00 2019
+// Update Count     : 22
 //
 …
 #include "Common/utility.h"       // for CodeLocation
 #include "InitTweak/InitTweak.h"  // for getFunction
 #include "SynTree/LinkageSpec.h"  // for Spec, C, Intrinsic
+#include "Parser/LinkageSpec.h"   // for Spec, C, Intrinsic
 #include "SynTree/Constant.h"     // for Constant
 #include "SynTree/Declaration.h"  // for StructDecl, DeclarationWithType
 …
                 // produce the TupleType which aggregates the types of the exprs
                 std::list< Type * > types;
                 Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex );
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
 …
         const ast::TypeInstType * isTtype( const ast::Type * type ) {
                 if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
                         if ( inst->base && inst->base->kind == ast::TypeDecl::Ttype ) {
+                        if ( inst->base && inst->base->kind == ast::TypeVar::Ttype ) {
                                 return inst;
+                        }

src/cfa.make

-              r3d5701e
+              r9fb8f01
 CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
         $(am__mv) $$depbase.Tpo $$depbase.Plo
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
-AM_V_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_1 =
-AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
-am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS  " $@;
-am__v_NODEJS_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =

src/main.cc

-              r3d5701e
+              r9fb8f01
 // 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 : Fri Aug 23 06:50:08 2019
+// Update Count     : 607
 //
 …
 #include <cstdio>                           // for fopen, FILE, fclose, stdin
 #include <cstdlib>                          // for exit, free, abort, EXIT_F...
 #include <csignal>                          // for signal, SIGABRT, SIGSEGV
+#include <csignal>                         // for signal, SIGABRT, SIGSEGV
 #include <cstring>                          // for index
 #include <fstream>                          // for ofstream
 …
 #include <list>                             // for list
 #include <string>                           // for char_traits, operator<<
-using namespace std;
 #include "CompilationState.h"
 …
 #include "InitTweak/GenInit.h"              // for genInit
 #include "MakeLibCfa.h"                     // for makeLibCfa
+#include "Parser/LinkageSpec.h"             // for Spec, Cforall, Intrinsic
 #include "Parser/ParseNode.h"               // for DeclarationNode, buildList
 #include "Parser/TypedefTable.h"            // for TypedefTable
 …
 #include "ResolvExpr/Resolver.h"            // for resolve
 #include "SymTab/Validate.h"                // for validate
 #include "SynTree/LinkageSpec.h"            // for Spec, Cforall, Intrinsic
+#include "SynTree/TopLvalue.h"              // for assertTopLvalue, clearInn...
 #include "SynTree/Declaration.h"            // for Declaration
 #include "SynTree/Visitor.h"                // for acceptAll
 …
 #include "Virtual/ExpandCasts.h"            // for expandCasts
+using namespace std;
 static void NewPass( const char * const name ) {
 …
 static bool waiting_for_gdb = false;                                    // flag to set cfa-cpp to wait for gdb on start
 static string PreludeDirector = "";
+static std::string PreludeDirector = "";
 static void parse_cmdline( int argc, char *argv[] );
 …
 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;
+                for ( char * p = messages[i]; *p; p += 1 ) {    // find parantheses and +offset
+                for ( char *p = messages[i]; *p; ++p ) {        // find parantheses and +offset
                         if ( *p == '(' ) {
                                 mangled_name = p;
 …
 } // backtrace
+#define SIGPARMS int sig __attribute__(( unused )), siginfo_t * sfp __attribute__(( unused )), ucontext_t * cxt __attribute__(( unused ))
+static void Signal( int sig, void (*handler)(SIGPARMS), int flags ) {
+        struct sigaction act;
+        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
+        act.sa_flags = flags;
+        if ( sigaction( sig, &act, nullptr ) == -1 ) {
+            cerr << "*CFA runtime error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
+            _exit( EXIT_FAILURE );
+        } // if
+} // Signal
+static void sigSegvBusHandler( SIGPARMS ) {
+        if ( sfp->si_addr == nullptr ) {
+                cerr << "Null pointer (nullptr) dereference." << endl;
+        } else {
+                cerr << (sig == SIGSEGV ? "Segment fault" : "Bus error") << " at memory location " << sfp->si_addr << "." << endl
+                         << "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript." << endl;
+        } // if
+static void sigSegvBusHandler( int sig_num ) {
+        cerr << "*CFA runtime error* program cfa-cpp terminated with "
+                 <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
+                 << "." << endl;
         backtrace( 2 );                                                                         // skip first 2 stack frames
+        //_exit( EXIT_FAILURE );
         abort();                                                                                        // cause core dump for debugging
 } // 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 ) {
+static void sigAbortHandler( __attribute__((unused)) int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         Signal( SIGABRT, (void (*)(SIGPARMS))SIG_DFL, SA_SIGINFO );     // reset default signal handler
+        signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
         raise( SIGABRT );                                                                       // reraise SIGABRT
 } // sigAbortHandler
 …
         list< Declaration * > translationUnit;
+        Signal( SIGSEGV, sigSegvBusHandler, SA_SIGINFO );
+        Signal( SIGBUS, sigSegvBusHandler, SA_SIGINFO );
+        Signal( SIGFPE, sigFpeHandler, SA_SIGINFO );
+        Signal( SIGABRT, sigAbortHandler, SA_SIGINFO );
+        // cout << "main" << endl;
+        signal( SIGSEGV, sigSegvBusHandler );
+        signal( SIGBUS, sigSegvBusHandler );
+        signal( SIGABRT, sigAbortHandler );
+        // std::cout << "main" << std::endl;
         // for ( int i = 0; i < argc; i += 1 ) {
         //      cout << '\t' << argv[i] << endl;
+        //      std::cout << '\t' << argv[i] << std::endl;
         // } // for
 …
         if ( waiting_for_gdb ) {
                 cerr << "Waiting for gdb" << endl;
                 cerr << "run :" << endl;
                 cerr << "  gdb attach " << getpid() << endl;
+                std::cerr << "Waiting for gdb" << std::endl;
+                std::cerr << "run :" << std::endl;
+                std::cerr << "  gdb attach " << getpid() << std::endl;
                 raise(SIGSTOP);
         } // if
 …
                 Stats::Time::StopBlock();
+                //std::cerr << "Post-Parse Check" << std::endl;
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 // add the assignment statement after the initialization of a type parameter
                 PASS( "Validate", SymTab::validate( translationUnit, symtabp ) );
 …
                 } // if
+                assertTopLvalue( translationUnit );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
 …
                 } // if
+                assertTopLvalue( translationUnit );
                 PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
                 if ( exprp ) {
 …
                 } // if
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 // fix ObjectDecl - replaces ConstructorInit nodes
                 PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 if ( ctorinitp ) {
                         dump ( translationUnit );
 …
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+                assertTopLvalue( translationUnit );
                 PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                assertTopLvalue( translationUnit );
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
+                assertTopLvalue( translationUnit );
                 if ( tuplep ) {
 …
                 PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
+                assertTopLvalue( translationUnit );
                 PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) );
 …
                         return EXIT_SUCCESS;
                 } // if
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Convert L-Value", GenPoly::convertLvalue( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 if ( bboxp ) {
 …
                 } // if
                 PASS( "Box", GenPoly::box( translationUnit ) );
+                clearInnerLvalue( translationUnit );
+                assertTopLvalue( translationUnit );
                 if ( bcodegenp ) {
 …
                 CodeTools::fillLocations( translationUnit );
+                assertTopLvalue( translationUnit );
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
 …
                 return EXIT_FAILURE;
         } catch ( ... ) {
                 exception_ptr eptr = current_exception();
+                std::exception_ptr eptr = std::current_exception();
                 try {
                         if (eptr) {
                                 rethrow_exception(eptr);
+                                std::rethrow_exception(eptr);
                         } else {
                                 cerr << "Exception Uncaught and Unknown" << endl;
                         } // if
                 } catch(const exception& e) {
                         cerr << "Uncaught Exception \"" << e.what() << "\"\n";
+                                std::cerr << "Exception Uncaught and Unknown" << std::endl;
+                        } // if
+                } catch(const std::exception& e) {
+                        std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
                 } // try
                 return EXIT_FAILURE;
 …
 static const char optstring[] = ":c:ghlLmNnpP:S:twW:D:";
+static const char optstring[] = ":hlLmNnpP:S:twW:D:";
 enum { PreludeDir = 128 };
 static struct option long_opts[] = {
-        { "colors", required_argument, nullptr, 'c' },
-        { "gdb", no_argument, nullptr, 'g' },
         { "help", no_argument, nullptr, 'h' },
         { "libcfa", no_argument, nullptr, 'l' },
 …
         { "statistics", required_argument, nullptr, 'S' },
         { "tree", no_argument, nullptr, 't' },
+        { "gdb", no_argument, nullptr, 'g' },
         { "", no_argument, nullptr, 0 },                                        // -w
         { "", no_argument, nullptr, 0 },                                        // -W
 …
 static const char * description[] = {
+        "diagnostic color: never, always, or auto.",          // -c
+        "wait for gdb to attach",                             // -g
+        "print help message",                                 // -h
+        "generate libcfa.c",                                  // -l
+        "generate line marks",                                // -L
+        "do not replace main",                                // -m
+        "do not generate line marks",                         // -N
+        "do not read prelude",                                // -n
+        "print help message",                                                           // -h
+        "generate libcfa.c",                                                            // -l
+        "generate line marks",                                                          // -L
+        "do not replace main",                                                          // -m
+        "do not generate line marks",                                           // -N
+        "do not read prelude",                                                          // -n
         "generate prototypes for prelude functions",            // -p
         "print",                                              // -P
+        "print",                                                                                        // -P
         "<directory> prelude directory for debug/nodebug",      // no flag
         "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
+        "building cfa standard lib",                          // -t
+        "",                                                   // -w
+        "",                                                   // -W
+        "",                                                   // -D
+        "building cfa standard lib",                                                                    // -t
+        "wait for gdb to attach",                                                                       // -g
+        "",                                                                                                     // -w
+        "",                                                                                                     // -W
+        "",                                                                                                     // -D
 }; // description
 …
         while ( (c = getopt_long( argc, argv, optstring, long_opts, nullptr )) != -1 ) {
                 switch ( c ) {
-                  case 'c':                                                                             // diagnostic colors
-                        if ( strcmp( optarg, "always" ) == 0 ) {
-                                ErrorHelpers::colors = ErrorHelpers::Colors::Always;
-                        } else if ( strcmp( optarg, "never" ) == 0 ) {
-                                ErrorHelpers::colors = ErrorHelpers::Colors::Never;
-                        } else if ( strcmp( optarg, "auto" ) == 0 ) {
-                                ErrorHelpers::colors = ErrorHelpers::Colors::Auto;
-                        } // if
-                        break;
                   case 'h':                                                                             // help message
                         usage( argv );                                                          // no return

tests/.expect/alloc-ERROR.txt

-              r3d5701e
+              r9fb8f01
 alloc.cfa:310:1 error: No reasonable alternatives for expression Applying untyped:
+alloc.cfa:265: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:266: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:267: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:268:1 error: No reasonable alternatives for expression Applying untyped:
   Name: ?=?
 ...to:

tests/.expect/alloc.txt

-              r3d5701e
+              r9fb8f01
 CFA malloc 0xdeadbeef
 CFA alloc 0xdeadbeef
+CFA alloc, fill dededede
+CFA alloc, fill 3
+CFA alloc, fill ffffffff
 C   array calloc, fill 0
 …
 CFA array alloc, no fill
 xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
+CFA array alloc, fill 0xde
+xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede
+CFA array alloc, fill 0xef
+xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef
+CFA array alloc, fill from array
+xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef, 0xefefefef 0xefefefef,
+CFA array alloc, fill 0xff
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 C realloc
 xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef
+C   realloc
+xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
 CFA realloc
 xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0xefefefef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
+xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
 CFA resize array alloc
+CFA resize alloc
 xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
 CFA resize array alloc
 …
 CFA resize array alloc
 xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
-CFA resize array alloc
-xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede
-CFA resize array alloc
-xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
 CFA resize array alloc, fill
+xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
+CFA resize array alloc, fill
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
+CFA resize array alloc, fill
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 C   memalign 42 42.5
 …
 CFA posix_memalign 42 42.5
 CFA posix_memalign 42 42.5
+CFA alloc_align 42 42.5
+CFA alloc_align 42 42.5
+CFA alloc_align fill 0xdededede -0x1.ededededededep+494
+CFA alloc_align fill 42 42.5
+CFA alloc_align 42 42.5
+CFA aligned_alloc 42 42.5
+CFA align_alloc 42 42.5
+CFA align_alloc fill 0xffffffff -nan
 CFA array alloc_align
+CFA array align_alloc
 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
+CFA array alloc_align, fill
+xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494,
+CFA array alloc_align, fill
+42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
+CFA array alloc_align, fill array
+42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
+CFA realloc array alloc_align
+42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
+CFA array align_alloc, fill
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA memset 0xdededede -0x1.ededededededep+494
 CFA memcpy 0xdededede -0x1.ededededededep+494
+CFA memset 0xffffffff -nan
+CFA memcpy 0xffffffff -nan
 CFA array memset
 xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494,
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA array memcpy
 xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494, 0xdededede -0x1.ededededededep+494,
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA new initialize

tests/.expect/attributes.x64.txt

-              r3d5701e
+              r9fb8f01
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
 struct Vad {
     __attribute__ ((unused)) signed int :4;
     __attribute__ ((unused)) signed int :4;
     __attribute__ ((unused,unused)) signed int :6;
+    __attribute__ ((unused)) signed int __anonymous_object27:4;
+    __attribute__ ((unused)) signed int __anonymous_object28:4;
+    __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
 };
 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);

tests/.expect/attributes.x86.txt

-              r3d5701e
+              r9fb8f01
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
 struct Vad {
     __attribute__ ((unused)) signed int :4;
     __attribute__ ((unused)) signed int :4;
     __attribute__ ((unused,unused)) signed int :6;
+    __attribute__ ((unused)) signed int __anonymous_object27:4;
+    __attribute__ ((unused)) signed int __anonymous_object28:4;
+    __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
 };
 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);

tests/.expect/gccExtensions.x64.txt

r3d5701e	r9fb8f01
12	12	asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) : : );
13	13	asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) : );
14		asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ ~~src~~ ] "r" ( _X3dsti_2 ) : "r0" );
	14	asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
15	15	L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" : : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
16	16	double _Complex _X2c1Cd_2;

tests/.expect/gccExtensions.x86.txt

r3d5701e	r9fb8f01
12	12	asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) : : );
13	13	asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) : );
14		asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ ~~src~~ ] "r" ( _X3dsti_2 ) : "r0" );
	14	asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
15	15	L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" : : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
16	16	double _Complex _X2c1Cd_2;

tests/.expect/loopctrl.txt

-              r3d5701e
+              r9fb8f01
+A
 A A A A A A A A A A
-A A A A A A A A A A A
 B B B B B
 C C C C C
 …
 1 2 3 4 5 6 7 8 9
-1 2 3 4 5 6 7 8 9 10
 3 5 7 9
 8 6 4 2
 …
 N N N N N N N N N N
 1 2 3 4 5 6 7 8 9
-1 2 3 4 5 6 7 8 9 10
 9 8 7 6 5 4 3 2 1

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

r3d5701e	r9fb8f01
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

-              r3d5701e
+              r9fb8f01
 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

r3d5701e	r9fb8f01
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/.expect/references.txt

r3d5701e	r9fb8f01
36	36	3
37	37	3 9 { 1., 7. }, [1, 2, 3]
38		4
39	38	Destructing a Y
40	39	Destructing a Y

tests/.expect/time.txt

r3d5701e	r9fb8f01
18	18	Dividing that by 2 gives 2403.5 seconds
19	19	4807 seconds is 1 hours, 20 minutes, 7 seconds
20		~~2020 Jan 5 14:01:40 (GMT)~~
21		~~1970 Jan 5 14:00:00 (GMT)~~
22		~~1973 Jan 2 06:59:00 (GMT)~~

tests/Makefile.am

-              r3d5701e
+              r9fb8f01
 archiveerrors=
+INSTALL_FLAGS=-in-tree
 DEBUG_FLAGS=-debug -O0
 …
 # applies to both programs
-# since automake doesn't have support for CFA we have to
 AM_CFLAGS = $(if $(test), 2> $(test), ) \
         -g \
 …
         -DIN_DIR="${abs_srcdir}/.in/"
+# get the desired cfa to test
+TARGET_CFA = $(if $(filter $(installed),yes), @CFACC_INSTALL@, @CFACC@)
+# adjust CC to current flags
+CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CFACC = $(CC)
+# get local binary for depedencies
+CFACCBIN = @CFACC@
+# adjusted CC but without the actual distcc call
+CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+AM_CFLAGS += ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
+CC = @CFACC@
 PRETTY_PATH=mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 …
 #----------------------------------------------------------------------------------------------------------------
 all-local :
         @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
+        @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
 all-tests :
         @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
+        @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
 clean-local :
 …
 # Use for all tests, make sure the path are correct and all flags are added
+CFACOMPILETEST=$(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGSCFA" | sed 's/-\|\//_/g'))
+CFACOMPILETEST=$(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
+# Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
+CFATEST_STDOUT=$(CFACOMPILETEST) -o $(abspath ${@})
+# Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
+CFATEST_STDERR=$(CFACOMPILETEST) 2> $(abspath ${@})
 #----------------------------------------------------------------------------------------------------------------
 # implicit rule so not all test require a rule
+# split into two steps to support compiling remotely using distcc
+# don't use distcc to do the linking because distcc doesn't do linking
+% : %.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -c -o $(abspath ${@}).o
+        $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
+% : %.cfa $(CFACC)
+        $(CFATEST_STDOUT)
-# implicit rule for c++ test
-# convient for testing the testsuite itself but not actuall used
 % : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
 #------------------------------------------------------------------------------
 # TARGETS WITH CUSTOM FLAGS
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
 #------------------------------------------------------------------------------
+# custom libs
+gmp_FLAGSLD= -lgmp
+# Expected failures
+declarationSpecifier_FLAGS= -CFA -XCFA -p
+gccExtensions_FLAGS= -CFA -XCFA -p
+extension_FLAGS= -CFA -XCFA -p
+attributes_FLAGS= -CFA -XCFA -p
+functions_FLAGS= -CFA -XCFA -p
+KRfunctions_FLAGS= -CFA -XCFA -p
+gmp_FLAGS= -lgmp
 #------------------------------------------------------------------------------
+# Generated code
+GENERATED_CODE = declarationSpecifier gccExtensions extension attributes functions KRfunctions
+$(GENERATED_CODE): % : %.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -CFA -XCFA -p -c -fsyntax-only -o $(abspath ${@})
+# Use for tests where the make command is expected to succeed but the expected.txt should be compared to stderr
+EXPECT_STDERR = builtins/sync warnings/self-assignment
+$(EXPECT_STDERR): % : %.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -c -fsyntax-only 2> $(abspath ${@})
+# Expected failures
+completeTypeError_FLAGS= -DERR1
 #------------------------------------------------------------------------------
 # CUSTOM TARGET
 #------------------------------------------------------------------------------
+# expected failures
+# use custom target since they require a custom define and custom dependencies
+alloc-ERROR : alloc.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 typedefRedef-ERR1 : typedefRedef.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 nested-types-ERR1 : nested-types.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 nested-types-ERR2 : nested-types.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
 raii/memberCtors-ERR1 : raii/memberCtors.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
 raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
 raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+#------------------------------------------------------------------------------
+# Other targets
+#builtins
+builtins/sync: builtins/sync.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only
+# Warnings
+warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only

tests/Makefile.in

-              r3d5701e
+              r9fb8f01
 AWK = @AWK@
 BUILD_IN_TREE_FLAGS = @BUILD_IN_TREE_FLAGS@
+# adjust CC to current flags
+CC = $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CC = @CFACC@
 CCAS = @CCAS@
 CCASDEPMODE = @CCASDEPMODE@
 CCASFLAGS = @CCASFLAGS@
 CCDEPMODE = @CCDEPMODE@
+CFACC = $(CC)
+CFACC_INSTALL = @CFACC_INSTALL@
+CFACC = @CFACC@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@
 …
 LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
         $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(AM_CFLAGS) $(CFAFLAGS) $(CFLAGS)
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CFA = $(am__v_CFA_@AM_V@)
 …
 am__v_CFA_0 = @echo "  CFA     " $@;
 am__v_CFA_1 =
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
 UPPCC = u++
 UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
 …
 am__v_UPP_0 = @echo "  UPP     " $@;
 am__v_UPP_1 =
-AM_V_GOC = $(am__v_GOC_@AM_V@)
-am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
-am__v_GOC_0 = @echo "  GOC     " $@;
-am__v_GOC_1 =
-AM_V_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_1 =
-AM_V_NODEJS = $(am__v_NODEJS_@AM_V@)
-am__v_NODEJS_ = $(am__v_NODEJS_@AM_DEFAULT_V@)
-am__v_NODEJS_0 = @echo "  NODEJS  " $@;
-am__v_NODEJS_1 =
-AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
-am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
-am__v_JAVAC_0 = @echo "  JAVAC   " $@;
-am__v_JAVAC_1 =
 debug = yes
 installed = no
 archiveerrors =
+INSTALL_FLAGS = -in-tree
 DEBUG_FLAGS = -debug -O0
 quick_test = avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes
 …
 # applies to both programs
+# since automake doesn't have support for CFA we have to
+AM_CFLAGS = $(if $(test), 2> $(test), ) \
+        -g \
+        -Wall \
+        -Wno-unused-function \
+        -quiet @CFA_FLAGS@ \
+        -DIN_DIR="${abs_srcdir}/.in/"
+# get the desired cfa to test
+TARGET_CFA = $(if $(filter $(installed),yes), @CFACC_INSTALL@, @CFACC@)
+# get local binary for depedencies
+CFACCBIN = @CFACC@
+# adjusted CC but without the actual distcc call
+CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+AM_CFLAGS = $(if $(test), 2> $(test), ) -g -Wall -Wno-unused-function \
+        -quiet @CFA_FLAGS@ -DIN_DIR="${abs_srcdir}/.in/" \
+        ${DEBUG_FLAGS} ${INSTALL_FLAGS} ${ARCH_FLAGS}
 PRETTY_PATH = mkdir -p $(dir $(abspath ${@})) && cd ${srcdir} &&
 avl_test_SOURCES = avltree/avl_test.cfa avltree/avl0.cfa avltree/avl1.cfa avltree/avl2.cfa avltree/avl3.cfa avltree/avl4.cfa avltree/avl-private.cfa
 …
 # Use for all tests, make sure the path are correct and all flags are added
+CFACOMPILETEST = $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGSCFA" | sed 's/-\|\//_/g'))
+CFACOMPILETEST = $(PRETTY_PATH) $(CFACOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) $($(shell echo "${@}_FLAGS" | sed 's/-\|\//_/g'))
+# Use for tests that either generate an executable, print directyl to stdout or the make command is expected to fail
+CFATEST_STDOUT = $(CFACOMPILETEST) -o $(abspath ${@})
+# Use for tests where the make command is expecte to succeed but the expected.txt should be compared to stderr
+CFATEST_STDERR = $(CFACOMPILETEST) 2> $(abspath ${@})
 #------------------------------------------------------------------------------
 # TARGETS WITH CUSTOM FLAGS
+# TARGET WITH STANDARD RULE BUT CUSTOM FLAGS
 #------------------------------------------------------------------------------
+# custom libs
+gmp_FLAGSLD = -lgmp
+# Expected failures
+declarationSpecifier_FLAGS = -CFA -XCFA -p
+gccExtensions_FLAGS = -CFA -XCFA -p
+extension_FLAGS = -CFA -XCFA -p
+attributes_FLAGS = -CFA -XCFA -p
+functions_FLAGS = -CFA -XCFA -p
+KRfunctions_FLAGS = -CFA -XCFA -p
+gmp_FLAGS = -lgmp
 #------------------------------------------------------------------------------
+# Generated code
+GENERATED_CODE = declarationSpecifier gccExtensions extension attributes functions KRfunctions
+# Use for tests where the make command is expected to succeed but the expected.txt should be compared to stderr
+EXPECT_STDERR = builtins/sync warnings/self-assignment
+# Expected failures
+completeTypeError_FLAGS = -DERR1
 all: all-am
 …
 #----------------------------------------------------------------------------------------------------------------
 all-local :
         @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
+        @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} ${quick_test}
 all-tests :
         @+${TEST_PY} --debug=${debug} --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
+        @+${TEST_PY} --debug=${debug}  --install=${installed} --archive-errors=${archiveerrors} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
 clean-local :
 …
 # implicit rule so not all test require a rule
+# split into two steps to support compiling remotely using distcc
+# don't use distcc to do the linking because distcc doesn't do linking
+% : %.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -c -o $(abspath ${@}).o
+        $(CFACCLOCAL) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g')) $(abspath ${@}).o -o $(abspath ${@})
+# implicit rule for c++ test
+# convient for testing the testsuite itself but not actuall used
+% : %.cfa $(CFACC)
+        $(CFATEST_STDOUT)
 % : %.cpp
         $(PRETTY_PATH) $(CXXCOMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
-$(GENERATED_CODE): % : %.cfa $(CFACCBIN)
-        $(CFACOMPILETEST) -CFA -XCFA -p -c -fsyntax-only -o $(abspath ${@})
-$(EXPECT_STDERR): % : %.cfa $(CFACCBIN)
-        $(CFACOMPILETEST) -c -fsyntax-only 2> $(abspath ${@})
 #------------------------------------------------------------------------------
 # CUSTOM TARGET
 #------------------------------------------------------------------------------
+# expected failures
+# use custom target since they require a custom define and custom dependencies
+alloc-ERROR : alloc.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+typedefRedef-ERR1 : typedefRedef.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+nested-types-ERR1 : nested-types.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+nested-types-ERR2 : nested-types.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
+raii/memberCtors-ERR1 : raii/memberCtors.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/ctor-autogen-ERR1 : raii/ctor-autogen.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/dtor-early-exit-ERR1 : raii/dtor-early-exit.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR1 -c -fsyntax-only -o $(abspath ${@})
+raii/dtor-early-exit-ERR2 : raii/dtor-early-exit.cfa $(CFACCBIN)
+        $(CFACOMPILETEST) -DERR2 -c -fsyntax-only -o $(abspath ${@})
+#------------------------------------------------------------------------------
+# Other targets
+typedefRedef-ERR1: typedefRedef.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+alloc-ERROR: alloc.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+nested-types-ERR1: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+nested-types-ERR2: nested-types.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR2
+raii/memberCtors-ERR1: raii/memberCtors.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+raii/ctor-autogen-ERR1: raii/ctor-autogen.cfa $(CFACC)
+        $(CFATEST_STDOUT) -DERR1
+#builtins
+builtins/sync: builtins/sync.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only
+# Warnings
+warnings/self-assignment: warnings/self-assignment.cfa $(CFACC)
+        $(CFATEST_STDERR) -fsyntax-only
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

tests/alloc.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Nov  6 17:50:52 2018
+// Update Count     : 339
 //
 …
 #include <stdlib.h>                                                                             // posix_memalign
 #include <fstream.hfa>
 #include <stdlib.hfa>                                                                   // access C malloc, realloc
+#include <stdlib.hfa>                                                                           // access C malloc, realloc
 int * foo( int * p, int c ) { return p; }
 …
 int main( void ) {
         size_t dim = 10;
         char fill = '\xde';
         int * p, * p1;
+        char fill = '\xff';
+        int * p;
         // allocation, non-array types
+        // int & r = malloc();
+        // r = 0xdeadbeef;
+        // printf( "C   malloc %#x\n", r );
+        // free( &r );
         p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
         *p = 0xdeadbeef;
 …
         free( p );
         p = alloc_set( fill );                                                          // CFA alloc, fill
+        p = alloc( fill );                                  // CFA alloc, fill
         printf( "CFA alloc, fill %08x\n", *p );
-        free( p );
-        p = alloc_set( 3 );                                                                     // CFA alloc, fill
-        printf( "CFA alloc, fill %d\n", *p );
         free( p );
 …
         free( p );
         p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
+        p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
         printf( "CFA array alloc, fill %#hhx\n", fill );
         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
-        free( p );
-        p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
-        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
-        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
-        printf( "\n" );
         // do not free
-        p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
-        printf( "CFA array alloc, fill from array\n" );
-        for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
-        free( p1 );
-        printf( "\n" );
         // resize, non-array types
 …
         p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
         printf( "C realloc\n" );
         for ( i; dim ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
         // do not free
+        for ( i; dim ) { p[i] = 0xdeadbeef; }
+        printf( "C   realloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
         p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
 …
         p = alloc( p, dim );                                // CFA resize array alloc
         for ( i; dim ) { p[i] = 0xdeadbeef; }
+        printf( "CFA resize alloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        p = alloc( p, 2 * dim );                            // CFA resize array alloc
+        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
         printf( "CFA resize array alloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        // do not free
+        p = alloc( p, 2 * dim );                            // CFA resize array alloc
+        for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }          // fill upper part
+        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        p = alloc( p, dim );                                // CFA array alloc
         printf( "CFA resize array alloc\n" );
+        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        // do not free
+        p = alloc( p, dim );                                // CFA resize array alloc
+        printf( "CFA resize array alloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        // do not free
+        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
+        printf( "CFA resize array alloc\n" );
+        for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        // do not free
+        p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
+        printf( "CFA resize array alloc\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        // do not free
+        p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        free( p );
+        p = 0;
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
+        for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
+        for ( i; dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        p = alloc( p, 2 * dim, fill );                      // CFA array alloc, fill
+        printf( "CFA resize array alloc, fill\n" );
+        for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
+        printf( "\n" );
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
+        printf( "CFA resize array alloc, fill\n" );
+        for ( i; dim ) { printf( "%#x ", p[i] );; }
         printf( "\n" );
         free( p );
 …
         free( stp );
+        stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
+        free( stp );
+        stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
+        free( stp );
+        stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
+        free( stp );
+        stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
+        // do not free
+        stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
+        assert( (uintptr_t)stp % 4096 == 0 );
+        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
+        stp = &(*aligned_alloc( Alignment )){ 42, 42.5 };     // CFA aligned_alloc
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
+        free( stp );
+        stp = &(*align_alloc( Alignment )){ 42, 42.5 };       // CFA align_alloc
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
+        free( stp );
+        stp = align_alloc( Alignment, fill );               // CFA memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
         free( stp );
 …
         printf( "\n" );
         stp = alloc_align( Alignment, dim );                // CFA array memalign
+        stp = align_alloc( Alignment, dim );                // CFA array memalign
         assert( (uintptr_t)stp % Alignment == 0 );
         for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
         printf( "CFA array alloc_align\n" );
+        printf( "CFA array align_alloc\n" );
         for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
         free( stp );
         stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA array alloc_align, fill\n" );
+        stp = align_alloc( Alignment, dim, fill );          // CFA array memalign, fill
+        assert( (uintptr_t)stp % Alignment == 0 );
+        printf( "CFA array align_alloc, fill\n" );
         for ( i; dim ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
-        printf( "\n" );
-        free( stp );
-        stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA array alloc_align, fill\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
-        printf( "\n" );
-        // do not free
-        stp1 = alloc_align_set( Alignment, dim, stp );          // CFA array memalign, fill
-        assert( (uintptr_t)stp % Alignment == 0 );
-        printf( "CFA array alloc_align, fill array\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
-        printf( "\n" );
-        free( stp1 );
-        stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
-        assert( (uintptr_t)stp % 4096 == 0 );
-        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
-        printf( "CFA realloc array alloc_align\n" );
-        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
         free( stp );

tests/builtins/sync.cfa

-              r3d5701e
+              r9fb8f01
 void foo() {
         volatile _Bool * vpB = 0; _Bool vB = 0;
+        volatile char * vpc = 0; char * rpc = 0; char vc = 0;
+        volatile short * vps = 0; short * rps = 0; short vs = 0;
+        volatile int * vpi = 0; int * rpi = 0; int vi = 0;
+        volatile long int * vpl = 0; long int * rpl = 0; long int vl = 0;
+        volatile long long int * vpll = 0; long long int * rpll = 0; long long int vll = 0;
+        #if defined(__SIZEOF_INT128__)
+        volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
+        volatile char * vp1 = 0; char * rp1 = 0; char v1 = 0;
+        volatile short * vp2 = 0; short * rp2 = 0; short v2 = 0;
+        volatile int * vp4 = 0; int * rp4 = 0; int v4 = 0;
+        volatile long long int * vp8 = 0; long long int * rp8 = 0; long long int v8 = 0;
+        #if defined(__SIZEOF_INT128__)
+        volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0;
         #endif
         struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
+        { char ret; ret = __sync_fetch_and_add(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_add(vps, vs); }
+        { int ret; ret = __sync_fetch_and_add(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_add(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_add(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_add(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_fetch_and_sub(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_sub(vps, vs); }
+        { int ret; ret = __sync_fetch_and_sub(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_sub(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_sub(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_sub(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_fetch_and_or(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_or(vps, vs); }
+        { int ret; ret = __sync_fetch_and_or(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_or(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_or(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_or(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_fetch_and_and(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_and(vps, vs); }
+        { int ret; ret = __sync_fetch_and_and(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_and(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_and(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_and(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_fetch_and_xor(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_xor(vps, vs); }
+        { int ret; ret = __sync_fetch_and_xor(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_xor(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_xor(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_xor(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_fetch_and_nand(vpc, vc); }
+        { short ret; ret = __sync_fetch_and_nand(vps, vs); }
+        { int ret; ret = __sync_fetch_and_nand(vpi, vi); }
+        { long int ret; ret = __sync_fetch_and_nand(vpl, vl); }
+        { long long int ret; ret = __sync_fetch_and_nand(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_nand(vplll, vlll); }
+        { __int128 ret; ret = __sync_fetch_and_nand_16(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_add_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_add_and_fetch(vps, vs); }
+        { int ret; ret = __sync_add_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_add_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_sub_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_sub_and_fetch(vps, vs); }
+        { int ret; ret = __sync_sub_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_or_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_or_and_fetch(vps, vs); }
+        { int ret; ret = __sync_or_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_or_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_and_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_and_and_fetch(vps, vs); }
+        { int ret; ret = __sync_and_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_and_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_xor_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_xor_and_fetch(vps, vs); }
+        { int ret; ret = __sync_xor_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
+        #endif
+        { char ret; ret = __sync_nand_and_fetch(vpc, vc); }
+        { short ret; ret = __sync_nand_and_fetch(vps, vs); }
+        { int ret; ret = __sync_nand_and_fetch(vpi, vi); }
+        { long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
+        { long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
+        #endif
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
+        { char ret; ret = __sync_fetch_and_add(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_add_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_add(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_add_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_add(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_add_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_add(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_add(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_fetch_and_sub(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_sub_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_sub(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_sub_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_sub(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_sub_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_sub(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_fetch_and_or(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_or_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_or(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_or_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_or(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_or_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_or(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_or(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_fetch_and_and(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_and_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_and(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_and_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_and(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_and_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_and(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_and(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_fetch_and_xor(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_xor_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_xor(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_xor_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_xor(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_xor_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_xor(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_fetch_and_nand(vp1, v1); }
+        { char ret; ret = __sync_fetch_and_nand_1(vp1, v1); }
+        { short ret; ret = __sync_fetch_and_nand(vp2, v2); }
+        { short ret; ret = __sync_fetch_and_nand_2(vp2, v2); }
+        { int ret; ret = __sync_fetch_and_nand(vp4, v4); }
+        { int ret; ret = __sync_fetch_and_nand_4(vp4, v4); }
+        { long long int ret; ret = __sync_fetch_and_nand(vp8, v8); }
+        { long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); }
+        { __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_add_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_add_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_add_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_add_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_add_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_add_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_add_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_add_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_sub_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_sub_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_sub_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_sub_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_sub_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_sub_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_sub_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_or_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_or_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_or_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_or_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_or_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_or_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_or_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_or_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_and_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_and_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_and_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_and_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_and_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_and_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_and_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_and_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_xor_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_xor_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_xor_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_xor_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_xor_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_xor_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_xor_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); }
+        #endif
+        { char ret; ret = __sync_nand_and_fetch(vp1, v1); }
+        { char ret; ret = __sync_nand_and_fetch_1(vp1, v1); }
+        { short ret; ret = __sync_nand_and_fetch(vp2, v2); }
+        { short ret; ret = __sync_nand_and_fetch_2(vp2, v2); }
+        { int ret; ret = __sync_nand_and_fetch(vp4, v4); }
+        { int ret; ret = __sync_nand_and_fetch_4(vp4, v4); }
+        { long long int ret; ret = __sync_nand_and_fetch(vp8, v8); }
+        { long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); }
+        { __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); }
+        #endif
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap_1(vp1, v1, v1); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vp2, v2, v2); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap_2(vp2, v2, v2); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vp4, v4, v4); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap_4(vp4, v4, v4); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); }
+        { _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); }
         #endif
         { _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
+        { char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
+        { short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
+        { int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
+        { long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
+        { long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
+        { char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); }
+        { char ret; ret = __sync_val_compare_and_swap_1(vp1, v1, v1); }
+        { short ret; ret = __sync_val_compare_and_swap(vp2, v2, v2); }
+        { short ret; ret = __sync_val_compare_and_swap_2(vp2, v2, v2); }
+        { int ret; ret = __sync_val_compare_and_swap(vp4, v4, v4); }
+        { int ret; ret = __sync_val_compare_and_swap_4(vp4, v4, v4); }
+        { long long int ret; ret = __sync_val_compare_and_swap(vp8, v8, v8); }
+        { long long int ret; ret = __sync_val_compare_and_swap_8(vp8, v8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); }
+        { __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); }
         #endif
         { struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
+        { char ret; ret = __sync_lock_test_and_set(vpc, vc); }
+        { short ret; ret = __sync_lock_test_and_set(vps, vs); }
+        { int ret; ret = __sync_lock_test_and_set(vpi, vi); }
+        { long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
+        { long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
+        #endif
+        { __sync_lock_release(vpc); }
+        { __sync_lock_release(vps); }
+        { __sync_lock_release(vpi); }
+        { __sync_lock_release(vpl); }
+        { __sync_lock_release(vpll); }
+        #if defined(__SIZEOF_INT128__)
+        { __sync_lock_release(vplll); }
+        { char ret; ret = __sync_lock_test_and_set(vp1, v1); }
+        { char ret; ret = __sync_lock_test_and_set_1(vp1, v1); }
+        { short ret; ret = __sync_lock_test_and_set(vp2, v2); }
+        { short ret; ret = __sync_lock_test_and_set_2(vp2, v2); }
+        { int ret; ret = __sync_lock_test_and_set(vp4, v4); }
+        { int ret; ret = __sync_lock_test_and_set_4(vp4, v4); }
+        { long long int ret; ret = __sync_lock_test_and_set(vp8, v8); }
+        { long long int ret; ret = __sync_lock_test_and_set_8(vp8, v8); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); }
+        { __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); }
+        #endif
+        { __sync_lock_release(vp1); }
+        { __sync_lock_release_1(vp1); }
+        { __sync_lock_release(vp2); }
+        { __sync_lock_release_2(vp2); }
+        { __sync_lock_release(vp4); }
+        { __sync_lock_release_4(vp4); }
+        { __sync_lock_release(vp8); }
+        { __sync_lock_release_8(vp8); }
+        #if defined(__SIZEOF_INT128__)
+        { __sync_lock_release(vp16); }
+        { __sync_lock_release_16(vp16); }
         #endif
 …
         { _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
         { _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
+        { _Bool ret; ret = __atomic_test_and_set(vp1, v1); }
         { __atomic_clear(vpB, vB); }
+        { __atomic_clear(vpc, vc); }
+        { char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
+        { char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
+        { short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
+        { int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
+        { long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
+        { __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
+        { __atomic_clear(vp1, v1); }
+        { char ret; ret = __atomic_exchange_n(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_exchange_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; __atomic_exchange(vp1, &v1, &ret, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_exchange_n(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_exchange_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; __atomic_exchange(vp2, &v2, &ret, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_exchange_n(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_exchange_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; __atomic_exchange(vp4, &v4, &ret, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_exchange_n(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_exchange_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; __atomic_exchange(vp8, &v8, &ret, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_exchange_n(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_exchange_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; __atomic_exchange(vp16, &v16, &ret, __ATOMIC_SEQ_CST); }
         #endif
         { struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
         { struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
+        { char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
+        { short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
+        { int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
+        { long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
+        { long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
+        { __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_load_1(vp1, __ATOMIC_SEQ_CST); }
+        { char ret; __atomic_load(vp1, &ret, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_load_n(vp2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_load_2(vp2, __ATOMIC_SEQ_CST); }
+        { short ret; __atomic_load(vp2, &ret, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_load_n(vp4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_load_4(vp4, __ATOMIC_SEQ_CST); }
+        { int ret; __atomic_load(vp4, &ret, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_load_n(vp8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); }
+        { long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_load_n(vp16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_load_16(vp16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; __atomic_load(vp16, &ret, __ATOMIC_SEQ_CST); }
         #endif
         { struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
         { struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_1(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vp1, rp1, &v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_2(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vp2, rp2, &v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_4(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vp4, rp4, &v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_n(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_8(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vp8, rp8, &v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { _Bool ret; ret = __atomic_compare_exchange_n(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange_16(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { _Bool ret; ret = __atomic_compare_exchange(vp16, rp16, &v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
         #endif
         { _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
         { _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); }
+        { __atomic_store_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vp1, &v1, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vp2, v2, __ATOMIC_SEQ_CST); }
+        { __atomic_store_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vp2, &v2, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vp4, v4, __ATOMIC_SEQ_CST); }
+        { __atomic_store_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vp4, &v4, __ATOMIC_SEQ_CST); }
+        { __atomic_store_n(vp8, v8, __ATOMIC_SEQ_CST); }
+        { __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); }
         #endif
         { __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
         { __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
+        { long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
+        #endif
+        { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
+        { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
+        { char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_add_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_add_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_add_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_add_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_add_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_add_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_add_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_sub_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_sub_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_sub_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_sub_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_sub_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_sub_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_sub_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_and_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_and_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_and_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_and_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_and_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_and_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_and_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_nand_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_nand_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_nand_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_nand_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_nand_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_nand_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_nand_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_xor_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_xor_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_xor_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_xor_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_xor_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_xor_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_xor_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_or_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_or_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_or_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_or_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_or_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_or_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_or_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_add_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_add(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_add_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_add(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_add_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_add(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_add_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_sub_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_sub(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_sub_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_sub(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_sub_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_sub(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_sub_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_and_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_and(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_and_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_and(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_and_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_and(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_and_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_nand_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_nand(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_nand_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_nand(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_nand_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_nand(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_nand_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_xor_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_xor(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_xor_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_xor(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_xor_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_xor(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_xor_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); }
+        { char ret; ret = __atomic_fetch_or_1(vp1, v1, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_or(vp2, v2, __ATOMIC_SEQ_CST); }
+        { short ret; ret = __atomic_fetch_or_2(vp2, v2, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_or(vp4, v4, __ATOMIC_SEQ_CST); }
+        { int ret; ret = __atomic_fetch_or_4(vp4, v4, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_or(vp8, v8, __ATOMIC_SEQ_CST); }
+        { long long int ret; ret = __atomic_fetch_or_8(vp8, v8, __ATOMIC_SEQ_CST); }
+        #if defined(__SIZEOF_INT128__)
+        { __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); }
+        { __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); }
+        #endif
+        { _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); }
+        { _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vp4); }
         { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
         { __atomic_signal_fence(__ATOMIC_SEQ_CST); }

tests/concurrent/examples/.expect/datingService.txt

-              r3d5701e
+              r9fb8f01
+Girl:17 is dating Boy at 2 with ccode 17
+ Boy:2 is dating Girl 17 with ccode 17
+ Boy:14 is dating Girl 5 with ccode 5
+Girl:5 is dating Boy at 14 with ccode 5
+ Boy:9 is dating Girl 10 with ccode 10
+Girl:10 is dating Boy at 9 with ccode 10
+ Boy:1 is dating Girl 18 with ccode 18
+Girl:18 is dating Boy at 1 with ccode 18
+ Boy:16 is dating Girl 3 with ccode 3
+Girl:3 is dating Boy at 16 with ccode 3
+ Boy:5 is dating Girl 14 with ccode 14
+Girl:14 is dating Boy at 5 with ccode 14
+ Boy:15 is dating Girl 4 with ccode 4
+Girl:4 is dating Boy at 15 with ccode 4
+Girl:0 is dating Boy at 19 with ccode 0
+ Boy:19 is dating Girl 0 with ccode 0
+Girl:9 is dating Boy at 10 with ccode 9
+ Boy:10 is dating Girl 9 with ccode 9
+Girl:11 is dating Boy at 8 with ccode 11
+ Boy:8 is dating Girl 11 with ccode 11
+ Boy:12 is dating Girl 7 with ccode 7
+Girl:7 is dating Boy at 12 with ccode 7
+ Boy:11 is dating Girl 8 with ccode 8
+Girl:8 is dating Boy at 11 with ccode 8
+Girl:16 is dating Boy at 3 with ccode 16
+ Boy:3 is dating Girl 16 with ccode 16
+Girl:15 is dating Boy at 4 with ccode 15
+ Boy:4 is dating Girl 15 with ccode 15
+Girl:19 is dating Boy at 0 with ccode 19
+ Boy:0 is dating Girl 19 with ccode 19
+Girl:2 is dating Boy at 17 with ccode 2
+ Boy:17 is dating Girl 2 with ccode 2
+ Boy:13 is dating Girl 6 with ccode 6
+Girl:6 is dating Boy at 13 with ccode 6
+ Boy:7 is dating Girl 12 with ccode 12
+Girl:12 is dating Boy at 7 with ccode 12
+Girl:13 is dating Boy at 6 with ccode 13
+ Boy:6 is dating Girl 13 with ccode 13
+Girl:1 is dating Boy at 18 with ccode 1
+ Boy:18 is dating Girl 1 with ccode 1

tests/concurrent/examples/boundedBufferEXT.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 16 22:36:34 2020
 // Update Count     : 15
+// Last Modified On : Fri Jun 21 08:19:20 2019
+// Update Count     : 14
 //
 …
         void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) {
                 if ( count == BufferSize ) waitfor( remove : buffer );
+                if ( count == BufferSize ) waitfor( remove, buffer );
                 elements[back] = elem;
                 back = ( back + 1 ) % BufferSize;
 …
         T remove( Buffer(T) & mutex buffer ) with( buffer ) {
                 if ( count == 0 ) waitfor( insert : buffer );
+                if ( count == 0 ) waitfor( insert, buffer );
                 T elem = elements[front];
                 front = ( front + 1 ) % BufferSize;

tests/concurrent/examples/boundedBufferTHREAD.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Apr 18 22:52:12 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 16 23:09:43 2020
 // Update Count     : 25
+// Last Modified On : Fri Jun 21 11:50:12 2019
+// Update Count     : 24
 //
 …
         void main( Buffer & buffer ) with( buffer ) {
                 for () {
                         waitfor( ^?{} : buffer ) {
+                        waitfor( ^?{}, buffer ) {
                                 break;
                         } or when ( count != 20 ) waitfor( insert : buffer ) {
+                        } or when ( count != 20 ) waitfor( insert, buffer ) {
                                 back = (back + 1) % 20;
                                 count += 1;
                         } or when ( count != 0 ) waitfor( remove : buffer ) {
+                        } or when ( count != 0 ) waitfor( remove, buffer ) {
                                 front = (front + 1) % 20;
                                 count -= 1;

tests/concurrent/examples/datingService.cfa

-              r3d5701e
+              r9fb8f01
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 …
                 signal_block( Boys[ccode] );                                    // restart boy to set phone number
         } // if
         //sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
+        sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
         return BoyPhoneNo;
 } // DatingService girl
 …
                 signal_block( Girls[ccode] );                                   // restart girl to set phone number
         } // if
         //sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
+        sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
         return GirlPhoneNo;
 } // DatingService boy

tests/concurrent/examples/gortn.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Feb 20 08:02:37 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 16 22:43:40 2020
 // Update Count     : 5
+// Last Modified On : Fri Jun 21 08:25:03 2019
+// Update Count     : 4
 //
 …
 void main( GoRtn & gortn ) with( gortn ) {
         for () {
                 waitfor( mem1 : gortn ) sout | i;
                 or waitfor( mem2 : gortn ) sout | f;
                 or waitfor( mem3 : gortn ) sout | m.i | m.j;
                 or waitfor( ^?{} : gortn ) break;
+                waitfor( mem1, gortn ) sout | i;
+                or waitfor( mem2, gortn ) sout | f;
+                or waitfor( mem3, gortn ) sout | m.i | m.j;
+                or waitfor( ^?{}, gortn ) break;
+        }
+}

tests/concurrent/examples/quickSort.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Fri Jun 21 08:27:45 2019
+// Update Count     : 172
 //
 …
 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
 …
                         if ( depth > 0 ) {
                                 depth -= 1;
+                                Quicksort lqs = { values, low, right, depth }; // concurrently sort lower half
+                                Quicksort rqs = { values, left, high, depth }; // concurrently sort upper half
+                                // Quicksort lqs = { values, low, right, depth }; // concurrently sort lower half
+                                // sort( values, left, high, depth );           // concurrently sort upper half
+                                Quicksort rqs = { values, low, right, depth }; // concurrently sort upper half
+                                //Quicksort lqs( values, left, high, depth ); // concurrently sort lower half
+                                sort( values, left, high, depth );              // concurrently sort lower half
                         } else {
                                 sort( values, low, right, 0 );                  // sequentially sort lower half
 …
                 processor processors[ (1 << depth) - 1 ] __attribute__(( unused )); // create 2^depth-1 kernel threads
                 int * values = alloc( size );                                   // values to be sorted, too large to put on stack
                 for ( counter; size ) {                                                 // generate unsorted numbers
+                int * values = alloc( size );                           // values to be sorted, too large to put on stack
+                for ( counter; size ) {                                         // generate unsorted numbers
                         values[counter] = size - counter;                       // descending values
-                } // for
-                for ( i; 200 ) {                                                                // random shuffle a few values
-                        swap( values[rand() % size], values[rand() % size] );
                 } // for
+                {
 …
 } // main
-// for depth in 0 1 2 3 4 5 ; do echo "sort 500000000 values with ${depth} depth" ; time -f "%Uu %Ss %E %Mkb" a.out -t 500000000 ${depth} ; done
 // Local Variables: //
 // tab-width: 4 //

tests/concurrent/multi-monitor.cfa

-              r3d5701e
+              r9fb8f01
 void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) {
-        assert(active_thread() == get_monitor(p1)->owner);
-        assert(active_thread() == get_monitor(p2)->owner);
         value += 1;
-        assert(active_thread() == get_monitor(p1)->owner);
-        assert(active_thread() == get_monitor(p2)->owner);
+}

tests/concurrent/preempt.cfa

r3d5701e	r9fb8f01
36	36	if( (counter % 7) == this.value ) {
37	37	__cfaabi_check_preemption();
38		int next = __atomic_add_fetch~~( &counter, 1, __ATOMIC_SEQ_CST~~ );
	38	int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST);
39	39	__cfaabi_check_preemption();
40	40	if( (next % 100) == 0 ) printf("%d\n", (int)next);

tests/concurrent/signal/block.cfa

-              r3d5701e
+              r9fb8f01
 monitor global_data_t {
         $thread * last_thread;
         $thread * last_signaller;
+        thread_desc * last_thread;
+        thread_desc * last_signaller;
 };
 …
         if( !is_empty( cond ) ) {
                 $thread * next = front( cond );
+                thread_desc * next = front( cond );
                 if( ! signal_block( cond ) ) {

tests/concurrent/signal/wait.cfa

r3d5701e	r9fb8f01
98	98	}
99	99
100		__~~atomic_fetch_sub( &waiter_left, 1, __ATOMIC_SEQ_CST~~ );
	100	__sync_fetch_and_sub_4( &waiter_left, 1);
101	101	}
102	102
…	…
109	109	}
110	110
111		__~~atomic_fetch_sub( &waiter_left, 1, __ATOMIC_SEQ_CST~~ );
	111	__sync_fetch_and_sub_4( &waiter_left, 1);
112	112	}
113	113
…	…
120	120	}
121	121
122		__~~atomic_fetch_sub( &waiter_left, 1, __ATOMIC_SEQ_CST~~ );
	122	__sync_fetch_and_sub_4( &waiter_left, 1);
123	123	}
124	124
…	…
131	131	}
132	132
133		__~~atomic_fetch_sub( &waiter_left, 1, __ATOMIC_SEQ_CST~~ );
	133	__sync_fetch_and_sub_4( &waiter_left, 1);
134	134	}
135	135

tests/concurrent/thread.cfa

-              r3d5701e
+              r9fb8f01
 thread Second { semaphore* lock; };
 void ?{}( First  & this, semaphore & lock ) { ((thread&)this){ "Thread 1" }; this.lock = &lock; }
 void ?{}( Second & this, semaphore & lock ) { ((thread&)this){ "Thread 2" }; this.lock = &lock; }
+void ?{}( First  & this, semaphore & lock ) { ((thread&)this){"Thread 1"}; this.lock = &lock; }
+void ?{}( Second & this, semaphore & lock ) { ((thread&)this){"Thread 2"}; this.lock = &lock; }
 void main(First& this) {

tests/concurrent/waitfor/barge.cfa

r3d5701e	r9fb8f01
65	65	yield(random( 10 ));
66	66	this.state = WAITFOR;
67		waitfor(do_call : this) {
	67	waitfor(do_call, this) {
68	68	sout \| i;
69	69	}

tests/concurrent/waitfor/dtor.cfa

r3d5701e	r9fb8f01
47	47	yield(random( 10 ));
48	48	set_state( this, MAIN );
49		waitfor( ^?{} : this ) {
	49	waitfor( ^?{}, this ) {
50	50	set_state( this, AFTER );
51	51	}

tests/concurrent/waitfor/else.cfa

-              r3d5701e
+              r9fb8f01
         sout | "Starting";
         when( false ) waitfor( notcalled : m );
+        when( false ) waitfor( notcalled, m );
         sout | "Step" | i++;
         waitfor( notcalled : m ); or else {
+        waitfor( notcalled, m ); or else {
                 sout | "else called";
+        }
 …
         sout | "Step" | i++;
         when( true ) waitfor( notcalled : m ); or when( true ) else {
+        when( true ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called";
+        }
 …
         sout | "Step" | i++;
         when( false ) waitfor( notcalled : m ); or when( true ) else {
+        when( false ) waitfor( notcalled, m ); or when( true ) else {
                 sout | "else called";
+        }
 …
         sout | "Step" | i++;
         when( false ) waitfor( notcalled : m ); or when( false ) else {
+        when( false ) waitfor( notcalled, m ); or when( false ) else {
                 sout | "else called";
+        }

tests/concurrent/waitfor/parse.cfa

-              r3d5701e
+              r9fb8f01
         //---------------------------------------
         waitfor( f1 : a ) {
+        waitfor( f1, a ) {
 ;
+        }
         //---------------------------------------
         waitfor( f1 : a ) {
+        waitfor( f1, a ) {
 ;
+        }
         waitfor( f2 : a ) {
+        waitfor( f2, a ) {
 ;
+        }
         //---------------------------------------
         when( 1 < 3 ) waitfor( f2 : a, a ) {
+        when( 1 < 3 ) waitfor( f2, a, a ) {
 ;
+        }
 …
         //---------------------------------------
         when( 2 < 3 ) waitfor( f3 : a ) {
+        when( 2 < 3 ) waitfor( f3, a ) {
 ;
+        }
 …
         //---------------------------------------
         when( 3 < 3 ) waitfor( f3 : a, a ) {
+        when( 3 < 3 ) waitfor( f3, a, a ) {
 ;
+        }
 …
         //---------------------------------------
         when( 6 < 3 ) waitfor( f3 : a, a, a ) {
+        when( 6 < 3 ) waitfor( f3, a, a, a ) {
 ;
+        }
         or when( 7 < 3 ) waitfor( f1 : a  ) {
+        or when( 7 < 3 ) waitfor( f1, a  ) {
 ;
+        }
 …
         //---------------------------------------
         when( 8 < 3 ) waitfor( f3 : a, a ) {
+        when( 8 < 3 ) waitfor( f3, a, a ) {
 ;
+        }
         or waitfor( f1 : a  ) {
+        or waitfor( f1, a  ) {
 ;
+        }
 …
         //---------------------------------------
         when( 10 < 3 ) waitfor( f1 : a ) {
+        when( 10 < 3 ) waitfor( f1, a ) {
 ;
+        }
         or waitfor( f2 : a, a ) {
+        or waitfor( f2, a, a ) {
 ;
+        }
 …
+}
+int main() {}
+int main() {
+}

tests/concurrent/waitfor/parse2.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Aug 30 17:53:29 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 16 23:13:37 2020
 // Update Count     : 6
+// Last Modified On : Fri Mar 22 13:42:11 2019
+// Update Count     : 3
 //
 …
+        }
         waitfor( x : z ) {
+        waitfor( x, z ) {
+        }
 …
         or waitfor( y );
         waitfor( x : z );
+        waitfor( x, z );
         or waitfor( y );
 …
         or when( true ) waitfor( y );
         when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) waitfor( y );
 …
+        }
         waitfor( x : z ) {
+        waitfor( x, z ) {
         } or waitfor( y ) {
+        }
 …
         or else;
         when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or else;
 …
+        }
         when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or else {
+        }
 …
         or when( true ) else;
         when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) else;
 …
+        }
         when( true ) waitfor( x : z );
+        when( true ) waitfor( x, z );
         or when( true ) else {
+        }
 …
         or timeout( 3 );
         waitfor( x : z );
+        waitfor( x, z );
         or timeout( 3 );
 …
+        }
         when( true ) waitfor( x : z ) {
+        when( true ) waitfor( x, z ) {
         } or timeout( 3 ) {
+        }
 …
+        }
         when( true ) waitfor( x : z ) {
+        when( true ) waitfor( x, z ) {
         } or when ( true ) timeout( 3 ) {
+        }
 …
         int or, timeout;
         waitfor( timeout : 7 ) 3;
         waitfor( timeout : 7 ) 3; or waitfor( timeout : 7 ) 3;
         when( or ) waitfor( or : ) { 4; } or timeout( 1 ) 3;
         when( 3 ) waitfor( or : 2 ) 4; or else 4;
         when( 3 ) waitfor( or : 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
         when( 3 ) waitfor( or : or ) 3; or when( or ) waitfor( or : timeout ) 4; or else 4;
         when( 3 ) waitfor( or : or ) 3; or waitfor( or : 9 ) 4; or when( or ) timeout( timeout ) 4;
         when( 3 ) waitfor( or : 3 ) 3; or waitfor( or : 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
+        waitfor( timeout, 7 ) 3;
+        waitfor( timeout, 7 ) 3; or waitfor( timeout, 7 ) 3;
+        when( or ) waitfor( or, ) { 4; } or timeout( 1 ) 3;
+        when( 3 ) waitfor( or, 2 ) 4; or else 4;
+        when( 3 ) waitfor( or, 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout;
+        when( 3 ) waitfor( or, or ) 3; or when( or ) waitfor( or, timeout ) 4; or else 4;
+        when( 3 ) waitfor( or, or ) 3; or waitfor( or, 9 ) 4; or when( or ) timeout( timeout ) 4;
+        when( 3 ) waitfor( or, 3 ) 3; or waitfor( or, 7 ) or; or timeout( 1 ) or; or when( 3 ) else or;
         // test else selection

tests/concurrent/waitfor/recurse.cfa

-              r3d5701e
+              r9fb8f01
         rand_yield();
         waitfor( call4 : this );
+        waitfor( call4, this );
         rand_yield();
 …
         rand_yield();
         waitfor( call3 : this );
+        waitfor( call3, this );
         rand_yield();
 …
         rand_yield();
         waitfor( call2 : this );
+        waitfor( call2, this );
         rand_yield();

tests/concurrent/waitfor/statment.cfa

-              r3d5701e
+              r9fb8f01
         while( !done ) {
                    waitfor( get_index : this );
                 or waitfor( call1 : this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
                 or waitfor( call2 : this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
                 or waitfor( call3 : this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
                 or waitfor( call4 : this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
                 or waitfor( call5 : this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
                 or waitfor( call6 : this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
                 or waitfor( call7 : this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
+                   waitfor( get_index, this );
+                or waitfor( call1, this ) { sout | "Statement"; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val; } }
+                or waitfor( call2, this ) { sout | "Statement"; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val; } }
+                or waitfor( call3, this ) { sout | "Statement"; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val; } }
+                or waitfor( call4, this ) { sout | "Statement"; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val; } }
+                or waitfor( call5, this ) { sout | "Statement"; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val; } }
+                or waitfor( call6, this ) { sout | "Statement"; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val; } }
+                or waitfor( call7, this ) { sout | "Statement"; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val; } }
                 done = true;

tests/concurrent/waitfor/when.cfa

-              r3d5701e
+              r9fb8f01
 void arbiter( global_t & mutex this ) {
         for( int i = 0; i < N; i++ ) {
                    when( this.last_call == 6 ) waitfor( call1 : this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
                 or when( this.last_call == 1 ) waitfor( call2 : this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
                 or when( this.last_call == 2 ) waitfor( call3 : this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
                 or when( this.last_call == 3 ) waitfor( call4 : this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
                 or when( this.last_call == 4 ) waitfor( call5 : this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
                 or when( this.last_call == 5 ) waitfor( call6 : this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
+                   when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call; } }
+                or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call; } }
+                or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call; } }
+                or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call; } }
+                or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call; } }
+                or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call; } }
                 sout | this.last_call;

tests/config.py.in

r3d5701e	r9fb8f01
8	8	BUILDDIR = "@abs_builddir@"
9	9	HOSTARCH = "@host_cpu@"
10		~~DISTRIBUTE = @HAS_DISTCC@~~

tests/expression.cfa

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

tests/heap.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Nov  6 17:54:56 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Nov 24 12:34:51 2019
 // Update Count     : 28
+// Last Modified On : Fri Jul 19 08:22:34 2019
+// Update Count     : 19
 //
 …
         enum { NoOfAllocs = 5000, NoOfMmaps = 10 };
         char * locns[NoOfAllocs];
+        size_t amount;
+        enum { limit = 64 * 1024 };                                                     // check alignments up to here
+        int i;
         // check alloc/free
 …
                 size_t s = (i + 1) * 20;
                 char * area = (char *)malloc( s );
                 if ( area == 0p ) abort( "malloc/free out of memory" );
+                if ( area == 0 ) abort( "malloc/free out of memory" );
                 area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
                 area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
 …
                 size_t s = i + 1;                                                               // +1 to make initialization simpler
                 locns[i] = (char *)malloc( s );
                 if ( locns[i] == 0p ) abort( "malloc/free out of memory" );
+                if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
                 locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
 …
                 size_t s = i + default_mmap_start();                    // cross over point
                 char * area = (char *)malloc( s );
                 if ( area == 0p ) abort( "malloc/free out of memory" );
+                if ( area == 0 ) abort( "malloc/free out of memory" );
                 area[0] = '\345'; area[s - 1] = '\345';                 // fill first/last
                 area[malloc_usable_size( area ) - 1] = '\345';  // fill ultimate byte
 …
                 size_t s = i + default_mmap_start();                    // cross over point
                 locns[i] = (char *)malloc( s );
                 if ( locns[i] == 0p ) abort( "malloc/free out of memory" );
+                if ( locns[i] == 0 ) abort( "malloc/free out of memory" );
                 locns[i][0] = '\345'; locns[i][s - 1] = '\345'; // fill first/last
                 locns[i][malloc_usable_size( locns[i] ) - 1] = '\345'; // fill ultimate byte
 …
                 size_t s = (i + 1) * 20;
                 char * area = (char *)calloc( 5, s );
                 if ( area == 0p ) abort( "calloc/free out of memory" );
+                if ( area == 0 ) abort( "calloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ||
                          area[malloc_usable_size( area ) - 1] != '\0' ||
 …
                 size_t s = i + 1;
                 locns[i] = (char *)calloc( 5, s );
                 if ( locns[i] == 0p ) abort( "calloc/free out of memory" );
+                if ( locns[i] == 0 ) abort( "calloc/free out of memory" );
                 if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' ||
                          locns[i][malloc_usable_size( locns[i] ) - 1] != '\0' ||
 …
                 size_t s = i + default_mmap_start();                    // cross over point
                 char * area = (char *)calloc( 1, s );
                 if ( area == 0p ) abort( "calloc/free out of memory" );
+                if ( area == 0 ) abort( "calloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ) abort( "calloc/free corrupt storage4.1" );
                 if ( area[malloc_usable_size( area ) - 1] != '\0' ) abort( "calloc/free corrupt storage4.2" );
 …
                 size_t s = i + default_mmap_start();                    // cross over point
                 locns[i] = (char *)calloc( 1, s );
                 if ( locns[i] == 0p ) abort( "calloc/free out of memory" );
+                if ( locns[i] == 0 ) abort( "calloc/free out of memory" );
                 if ( locns[i][0] != '\0' || locns[i][s - 1] != '\0' ||
                          locns[i][malloc_usable_size( locns[i] ) - 1] != '\0' ||
 …
         // check memalign/free (sbrk)
+        enum { limit = 64 * 1024 };                                                     // check alignments up to here
         for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
                 //sout | alignments[a];
                 for ( s; 1 ~ NoOfAllocs ) {                                             // allocation of size 0 can return null
                         char * area = (char *)memalign( a, s );
                         if ( area == 0p ) abort( "memalign/free out of memory" );
                         //sout | i | area;
+                        if ( area == 0 ) abort( "memalign/free out of memory" );
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, s, area );
                         } // if
                         area[0] = '\345'; area[s - 1] = '\345';         // fill first/last byte
+                        area[0] = '\345'; area[s - 1] = '\345'; // fill first/last byte
                         area[malloc_usable_size( area ) - 1] = '\345'; // fill ultimate byte
                         free( area );
 …
                         size_t s = i + default_mmap_start();            // cross over point
                         char * area = (char *)memalign( a, s );
                         if ( area == 0p ) abort( "memalign/free out of memory" );
                         //sout | i | area;
+                        if ( area == 0 ) abort( "memalign/free out of memory" );
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "memalign/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)s, area );
 …
                 // initial N byte allocation
                 char * area = (char *)calloc( 5, i );
                 if ( area == 0p ) abort( "calloc/realloc/free out of memory" );
+                if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                 if ( area[0] != '\0' || area[i - 1] != '\0' ||
                          area[malloc_usable_size( area ) - 1] != '\0' ||
 …
                 for ( s; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0p ) abort( "calloc/realloc/free out of memory" );
+                        if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                         if ( area[0] != '\0' || area[s - 1] != '\0' ||
                                  area[malloc_usable_size( area ) - 1] != '\0' ||
 …
                 size_t s = i + default_mmap_start();                    // cross over point
                 char * area = (char *)calloc( 1, s );
                 if ( area == 0p ) abort( "calloc/realloc/free out of memory" );
+                if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                 if ( area[0] != '\0' || area[s - 1] != '\0' ||
                          area[malloc_usable_size( area ) - 1] != '\0' ||
 …
                 for ( r; i ~ 256 * 1024 ~ 26 ) {                                // start at initial memory request
                         area = (char *)realloc( area, r );                      // attempt to reuse storage
                         if ( area == 0p ) abort( "calloc/realloc/free out of memory" );
+                        if ( area == 0 ) abort( "calloc/realloc/free out of memory" );
                         if ( area[0] != '\0' || area[r - 1] != '\0' ||
                                  area[malloc_usable_size( area ) - 1] != '\0' ||
 …
         // check memalign/realloc/free
         amount = 2;
+        size_t amount = 2;
         for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
                 // initial N byte allocation
                 char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
                 if ( area == 0p ) abort( "memalign/realloc/free out of memory" ); // no storage ?
                 //sout | alignments[a] | area;
+                if ( area == 0 ) abort( "memalign/realloc/free out of memory" ); // no storage ?
+                //sout | alignments[a] | " " | area;
                 if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                         abort( "memalign/realloc/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
 …
                         if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0p ) abort( "memalign/realloc/free out of memory" ); // no storage ?
                         //sout | i | area;
+                        if ( area == 0 ) abort( "memalign/realloc/free out of memory" ); // no storage ?
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 ) {                          // check for initial alignment
                                 abort( "memalign/realloc/free bad alignment %p", area );
 …
                 for ( s; 1 ~ limit ) {                                                  // allocation of size 0 can return null
                         char * area = (char *)cmemalign( a, 1, s );
                         if ( area == 0p ) abort( "cmemalign/free out of memory" );
                         //sout | i | area;
+                        if ( area == 0 ) abort( "cmemalign/free out of memory" );
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "cmemalign/free bad alignment : cmemalign(%d,%d) = %p", (int)a, s, area );
 …
                 // initial N byte allocation
                 char * area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
                 if ( area == 0p ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
                 //sout | alignments[a] | area;
+                if ( area == 0 ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
+                //sout | alignments[a] | " " | area;
                 if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                         abort( "cmemalign/realloc/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area );
 …
                         if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc/free corrupt storage2" );
                         area = (char *)realloc( area, s );                      // attempt to reuse storage
                         if ( area == 0p ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
                         //sout | i | area;
+                        if ( area == 0 ) abort( "cmemalign/realloc/free out of memory" ); // no storage ?
+                        //sout | i | " " | area;
                         if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
                                 abort( "cmemalign/realloc/free bad alignment %p", area );
 …
                 free( area );
         } // for
-        // check memalign/realloc with align/free
-        amount = 2;
-        for ( a; libAlign() ~= limit ~ a ) {                            // generate powers of 2
-                // initial N byte allocation
-                char * area = (char *)memalign( a, amount );    // aligned N-byte allocation
-                if ( area == 0p ) abort( "memalign/realloc with align/free out of memory" ); // no storage ?
-                //sout | alignments[a] | area | endl;
-                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
-                        abort( "memalign/realloc with align/free bad alignment : memalign(%d,%d) = %p", (int)a, (int)amount, area );
-                } // if
-                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
-                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
-                for ( s; amount ~ 256 * 1024 ) {                                // start at initial memory request
-                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "memalign/realloc/free corrupt storage" );
-                        area = (char *)realloc( area, a * 2, s );       // attempt to reuse storage
-                        if ( area == 0p ) abort( "memalign/realloc with align/free out of memory" ); // no storage ?
-                        //sout | i | area | endl;
-                        if ( (size_t)area % a * 2 != 0 ) {                      // check for initial alignment
-                                abort( "memalign/realloc with align/free bad alignment %p", area );
-                        } // if
-                        area[s - 1] = '\345';                                           // fill last byte
-                } // for
-                free( area );
-        } // for
-        // check cmemalign/realloc with align/free
-        amount = 2;
-        for ( size_t a = libAlign() + libAlign(); a <= limit; a += a ) { // generate powers of 2
-                // initial N byte allocation
-                char *area = (char *)cmemalign( a, 1, amount ); // aligned N-byte allocation
-                if ( area == 0p ) abort( "cmemalign/realloc with align/free out of memory" ); // no storage ?
-                //sout | alignments[a] | area | endl;
-                if ( (size_t)area % a != 0 || malloc_alignment( area ) != a ) { // check for initial alignment
-                        abort( "cmemalign/realloc with align/free bad alignment : cmemalign(%d,%d) = %p", (int)a, (int)amount, area );
-                } // if
-                if ( area[0] != '\0' || area[amount - 1] != '\0' ||
-                         area[malloc_usable_size( area ) - 1] != '\0' ||
-                         ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc with align/free corrupt storage1" );
-                area[0] = '\345'; area[amount - 2] = '\345';    // fill first/penultimate byte
-                // Do not start this loop index at 0 because realloc of 0 bytes frees the storage.
-                for ( int s = amount; s < 256 * 1024; s += 1 ) { // start at initial memory request
-                        if ( area[0] != '\345' || area[s - 2] != '\345' ) abort( "cmemalign/realloc with align/free corrupt storage2" );
-                        area = (char *)realloc( area, a * 2, s );       // attempt to reuse storage
-                        if ( area == 0p ) abort( "cmemalign/realloc with align/free out of memory" ); // no storage ?
-                        //sout | i | area | endl;
-                        if ( (size_t)area % a * 2 != 0 || malloc_alignment( area ) != a * 2 ) { // check for initial alignment
-                                abort( "cmemalign/realloc with align/free bad alignment %p %jd %jd", area, malloc_alignment( area ), a * 2 );
-                        } // if
-                        if ( area[s - 1] != '\0' || area[s - 1] != '\0' ||
-                                 area[malloc_usable_size( area ) - 1] != '\0' ||
-                                 ! malloc_zero_fill( area ) ) abort( "cmemalign/realloc/free corrupt storage3" );
-                        area[s - 1] = '\345';                                           // fill last byte
-                } // for
-                free( area );
-        } // for
         //sout | "worker" | thisTask() | "successful completion";
 } // Worker main

tests/labelledExit.cfa

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Nov  6 17:57:42 2018
+// Update Count     : 4
 //
 …
+        }
-        // all nested control options, labelled exits
-  Comp: {
-          Try: try {
-                  For: for ( ;; ) {
-                          While: while ( true ) {
-                                  Do: do {
-                                          If: if ( true ) {
-                                                  Switch2: switch ( 3 ) {
-                                                          case 3:
-                                                                break Try;
-                                                                break Comp;
-                                                                break For;              continue For;
-                                                                break While;    continue While;
-                                                                break Do;               continue Do;
-                                                                break If;
-                                                                break Switch2;
-                                                        } // switch
-                                                } // if
-                                        } while ( true );
-                                } // while
-                        } // for
-                } finally {} // always executed
-        } // compound
         // 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/linking/withthreads.cfa

r3d5701e	r9fb8f01
34	34	// Local Variables: //
35	35	// tab-width: 4 //
36		// compile-command: "cfa ~~with~~threads.cfa" //
	36	// compile-command: "cfa nothreads.cfa" //
37	37	// End: //

tests/loopctrl.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Wed Aug  8 18:32:59 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec 12 17:55:26 2019
 // Update Count     : 108
+// Last Modified On : Fri Jul 12 12:05:05 2019
+// Update Count     : 106
 //
 …
         for ( 1 ) { sout | "A"; }                                                       sout | nl;
         for ( 10 ) { sout | "A"; }                                                      sout | nl;
-        for ( = 10 ) { sout | "A"; }                                            sout | nl;
         for ( 1 ~= 10 ~ 2 ) { sout | "B"; }                                     sout | nl;
         for ( 10 -~= 1 ~ 2 ) { sout | "C"; }                            sout | nl;
 …
         for ( i; 10 ) { sout | i; }                                                     sout | nl;
-        for ( i; = 10 ) { sout | i; }                                           sout | nl;
         for ( i; 1 ~= 10 ~ 2 ) { sout | i; }                            sout | nl;
         for ( i; 10 -~= 1 ~ 2 ) { sout | i; }                           sout | nl;
 …
         for ( N ) { sout | "N"; }                                                       sout | nl;
         for ( i; N ) { sout | i; }                                                      sout | nl;
-        for ( i; = N ) { sout | i; }                                            sout | nl;
         for ( i; N -~ 0 ) { sout | i; }                                         sout | nl | nl;

tests/nested-types.cfa

-              r3d5701e
+              r9fb8f01
 // 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/settings.py

-              r3d5701e
+              r9fb8f01
         SRCDIR = os.path.abspath(config.SRCDIR)
         BUILDDIR = os.path.abspath(config.BUILDDIR)
-        distribute = config.DISTRIBUTE
         os.chdir(testpath)
 …
                 self.string = "debug" if value else "no debug"
                 self.flags  = """DEBUG_FLAGS=%s""" % ("-debug -O0" if value else "-nodebug -O2")
-                self.path   = "debug" if value else "nodebug"
 class Install:
         def __init__(self, value):
+                if value:
+                        distribute = False
+                self.string = "installed" if value else "in tree"
+                self.flags  = """installed=%s""" % ("yes" if value else "no")
+                self.string = "installed" if value else "in-tree"
+                self.flags  = """INSTALL_FLAGS=%s""" % ("" if value else "-in-tree")
 class Timeouts:
 …
 def init( options ):
         global arch
-        global archive
-        global debug
-        global distcc
         global dry_run
         global generating
+        global make
+        global debug
         global install
         global make
+        global timeout
         global output_width
         global timeout
+        global archive
+        dry_run      = options.dry_run
+        generating   = options.regenerate_expected
+        make         = ['make']
+        debug        = Debug(options.debug)
+        install      = Install(options.install)
         arch         = Architecture(options.arch)
+        timeout      = Timeouts(options.timeout, options.global_timeout)
+        output_width = 24
         archive      = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
-        debug        = Debug(options.debug)
-        dry_run      = options.dry_run # must be called before tools.config_hash()
-        distcc       = "DISTCC_CFA_PATH=~/.cfadistcc/%s/cfa" % tools.config_hash()
-        generating   = options.regenerate_expected
-        install      = Install(options.install)
-        make         = ['make']
-        output_width = 24
-        timeout      = Timeouts(options.timeout, options.global_timeout)
-        # if we distribute, distcc errors will fail tests, use log file for distcc
-        # don't use "'DISTCC_LOG' not in os.environ" because it can be set to ''
-        if distribute and not os.environ.get('DISTCC_LOG'):
-                os.putenv('DISTCC_LOG', os.path.join(BUILDDIR, 'distcc_error.log'))
 def update_make_cmd(force, jobs):
 …
 def validate():
         errf = os.path.join(BUILDDIR, ".validate.err")
         make_ret, out = tools.make( ".validate", error_file = errf, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
+        make_ret, out = tools.make( ".validate", error_file = errf, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
         if make_ret != 0:
                 with open (errf, "r") as myfile:

tests/pybin/tools.py

-              r3d5701e
+              r9fb8f01
 # helper functions to run terminal commands
+def sh(*cmd, timeout = False, output_file = None, input_file = None, input_text = None, error = subprocess.STDOUT, ignore_dry_run = False):
+        try:
+                cmd = list(cmd)
+                if input_file and input_text:
+                        return 401, "Cannot use both text and file inputs"
+                # if this is a dry_run, only print the commands that would be ran
+                if settings.dry_run and not ignore_dry_run:
+                        cmd = "{} cmd: {}".format(os.getcwd(), ' '.join(cmd))
+                        if output_file and not isinstance(output_file, int):
+                                cmd += " > "
+                                cmd += output_file
+                        if error and not isinstance(error, int):
+                                cmd += " 2> "
+                                cmd += error
+                        if input_file and not isinstance(input_file, int) and os.path.isfile(input_file):
+                                cmd += " < "
+                                cmd += input_file
+                        print(cmd)
+                        return 0, None
+                with contextlib.ExitStack() as onexit:
+                        # add input redirection if needed
+                        input_file = openfd(input_file, 'r', onexit, True)
+                        # add output redirection if needed
+                        output_file = openfd(output_file, 'w', onexit, False)
+                        # add error redirection if needed
+                        error = openfd(error, 'w', onexit, False)
+                        # run the desired command
+                        # use with statement to make sure proc is cleaned
+                        # don't use subprocess.run because we want to send SIGABRT on exit
+                        with subprocess.Popen(
+def sh(*cmd, timeout = False, output = None, input = None, error = subprocess.STDOUT):
+        cmd = list(cmd)
+        # if this is a dry_run, only print the commands that would be ran
+        if settings.dry_run :
+                cmd = "{} cmd: {}".format(os.getcwd(), ' '.join(cmd))
+                if output and not isinstance(output, int):
+                        cmd += " > "
+                        cmd += output
+                if error and not isinstance(error, int):
+                        cmd += " 2> "
+                        cmd += error
+                if input and not isinstance(input, int) and os.path.isfile(input):
+                        cmd += " < "
+                        cmd += input
+                print(cmd)
+                return 0, None
+        with contextlib.ExitStack() as onexit:
+                # add input redirection if needed
+                input = openfd(input, 'r', onexit, True)
+                # add output redirection if needed
+                output = openfd(output, 'w', onexit, False)
+                # add error redirection if needed
+                error = openfd(error, 'w', onexit, False)
+                # run the desired command
+                try:
+                        proc = subprocess.run(
                                 cmd,
+                                **({'input' : bytes(input_text, encoding='utf-8')} if input_text else {'stdin' : input_file}),
+                                stdout  = output_file,
+                                stderr  = error
+                        ) as proc:
+                                try:
+                                        out, _ = proc.communicate(
+                                                timeout = settings.timeout.single if timeout else None
+                                        )
+                                        return proc.returncode, out.decode("utf-8") if out else None
+                                except subprocess.TimeoutExpired:
+                                        proc.send_signal(signal.SIGABRT)
+                                        proc.communicate()
+                                        return 124, str(None)
+        except Exception as ex:
+                print ("Unexpected error: %s" % ex)
+                raise
+                                stdin =input,
+                                stdout=output,
+                                stderr=error,
+                                timeout=settings.timeout.single if timeout else None
+                        )
+                        return proc.returncode, proc.stdout.decode("utf-8") if proc.stdout else None
+                except subprocess.TimeoutExpired:
+                        return 124, str(None)
 def is_ascii(fname):
 …
                 return False
         code, out = sh("file %s" % fname, output_file=subprocess.PIPE)
+        code, out = sh("file %s" % fname, output=subprocess.PIPE)
         if code != 0:
                 return False
 …
         if isinstance(files, str ): files = [ files ]
         for file in files:
                 sh( 'rm', '-f', file, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
+                sh( 'rm', '-f', file, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
 # Create 1 or more directory
 …
                 p = os.path.normpath( file )
                 d = os.path.dirname ( p )
                 sh( 'mkdir', '-p', d, output_file=subprocess.DEVNULL, error=subprocess.DEVNULL )
+                sh( 'mkdir', '-p', d, output=subprocess.DEVNULL, error=subprocess.DEVNULL )
 …
                 lhs,
                 rhs,
                 output_file=subprocess.PIPE
+                output=subprocess.PIPE
+        )
 # call make
 def make(target, *, flags = '', output_file = None, error = None, error_file = None, silent = False):
+def make(target, *, flags = '', output = None, error = None, error_file = None, silent = False):
         test_param = """test="%s" """ % (error_file) if error_file else None
         cmd = [
 …
                 settings.debug.flags,
                 settings.install.flags,
-                settings.distcc if settings.distribute else None,
                 flags,
                 target
+        ]
         cmd = [s for s in cmd if s]
         return sh(*cmd, output_file=output_file, error=error)
+        return sh(*cmd, output=output, error=error)
 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
 …
 # cat one file into the other
 def cat(source, dest):
         ret, _ = sh("cat", source, output_file=dest)
+        ret, _ = sh("cat", source, output=dest)
         return ret
 …
                         os.write(int(make_jobs_fds.group(3)), tokens)
                 else :
+                        if settings.distribute:
+                                ret, jstr = sh("distcc", "-j", output_file=subprocess.PIPE, ignore_dry_run=True)
+                                if ret == 0:
+                                        options.jobs = int(jstr.strip())
+                                else :
+                                        options.jobs = multiprocessing.cpu_count()
+                        else:
+                                options.jobs = multiprocessing.cpu_count()
+                        options.jobs = multiprocessing.cpu_count()
         else :
                 force = True
 …
 ################################################################################
-# get hash for given configuration
-def config_hash():
-        path = os.path.normpath(os.path.join(
-                settings.SRCDIR,
-        ))
-        distcc_hash = os.path.join(settings.SRCDIR, '../tools/build/distcc_hash')
-        config = "%s-%s" % (settings.arch.target, settings.debug.path)
-        _, out = sh(distcc_hash, config, output_file=subprocess.PIPE, ignore_dry_run=True)
-        return out.strip()
-# get pretty string for time of day
 def pretty_now():
         ts = time.time()
 …
                 return 1, "ERR No core dump"
         return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output_file=subprocess.PIPE)
+        return sh('gdb', '-n', path, core, '-batch', '-x', cmd, output=subprocess.PIPE)
 def core_archive(dst, name, exe):
         # Get the core dump
+        # Get the files to copy
         core = os.path.join(os.getcwd(), "core" )
         # update the path for this test
         dst  = os.path.join(dst, name)
+        # Uncomment if we want timestamps on coredumps
+        # dst  = os.path.join(dst, "%s_%s" % (name, pretty_now()))
         # make a directory for this test
+        # mkdir makes the parent directory only so add a dummy
+        mkdir(os.path.join(dst, name ))
+        mkdir(os.path.join(dst, "dir"))
         # moves the files
 …
 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

-              r3d5701e
+              r9fb8f01
 // 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 : Tue Dec  4 21:45:53 2018
+// Update Count     : 23
 //
 …
 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/raii/dtor-early-exit.cfa

-              r3d5701e
+              r9fb8f01
+}
-void i() {
-        // potential loop
-        for() {
-                if(true) continue;
-                int t = 0;
+        }
+}
 // TODO: implement __label__ and uncomment these lines
 void computedGoto() {

tests/rational.cfa

-              r3d5701e
+              r9fb8f01
 // 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/references.cfa

-              r3d5701e
+              r9fb8f01
                 f( 3, a + b, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } ); // two rvalue to reference
+        }
+        {
-                int a = 3;
-                int *p = &a;
-                asm (
-                        "incl %[p]\n\t"
-                        : [p] "+m" (*p)
-                );
-                printf("%d\n", a);
+        }
+}

tests/test.py

-              r3d5701e
+              r9fb8f01
 import tempfile
 import time
-import os
-import psutil
-import signal
 ################################################################################
 …
         # build, skipping to next test on error
         with Timed() as comp_dur:
                 make_ret, _ = make( test.target(), output_file=subprocess.DEVNULL, error=out_file, error_file = err_file )
+                make_ret, _ = make( test.target(), output=subprocess.DEVNULL, error=out_file, error_file = err_file )
         run_dur = None
         # run everything in a temp directory to make sure core file are handled properly
         with tempdir():
                 # if the make command succeeds continue otherwise skip to diff
+                # if the make command succeds continue otherwise skip to diff
                 if success(make_ret):
                         with Timed() as run_dur:
                                 if settings.dry_run or is_exe(exe_file):
                                         # run test
                                         retcode, _ = sh(exe_file, output_file=out_file, input_file=in_file, timeout=True)
+                                        retcode, _ = sh(exe_file, output=out_file, input=in_file, timeout=True)
                                 else :
                                         # simply cat the result into the output
 …
         except KeyboardInterrupt:
                 return False, ""
         except Exception as ex:
                 print("Unexpected error in worker thread: %s" % ex, file=sys.stderr)
+        except:
+                print("Unexpected error in worker thread", file=sys.stderr)
                 sys.stderr.flush()
                 return False, ""
 …
 def run_tests(tests, jobs) :
         # clean the sandbox from previous commands
+        make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        # since python prints stacks by default on a interrupt, redo the interrupt handling to be silent
+        def worker_init():
+                def sig_int(signal_num, frame):
+                        pass
+                signal.signal(signal.SIGINT, sig_int)
+        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
         # create the executor for our jobs and handle the signal properly
         pool = multiprocessing.Pool(jobs, worker_init)
+        pool = multiprocessing.Pool(jobs)
         failed = False
-        def stop(x, y):
-                print("Tests interrupted by user", file=sys.stderr)
-                sys.exit(1)
-        signal.signal(signal.SIGINT, stop)
         # for each test to run
 …
         # clean the workspace
         make('clean', output_file=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
         return 1 if failed else 0

tests/time.cfa

-              r3d5701e
+              r9fb8f01
 // Created On       : Tue Mar 27 17:24:56 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jan  5 18:27:37 2020
 // Update Count     : 34
+// Last Modified On : Thu Dec 20 23:09:21 2018
+// Update Count     : 23
 //
 …
         Duration d1 = 3`h, d2 = 2`s, d3 = 3.375`s, d4 = 12`s, d5 = 1`s + 10_000`ns;
         sout | d1 | d2 | d3 | d4 | d5;
+        int i;
         d1 = 0;
         sout | d1 | d2 | d3;
 …
         sout | t;
         t = t + d1;
         sout | t | t`ns;
+        sout | t | t.tv;
         Time t1 = (timespec){ 104_414, 10_000_000 };
         sout | t1 | t1`ns;
         sout | t - t  | t + d5 | t`ns;
         char buf[64];
+        sout | t1 | t1.tv;
+        sout | t - t  | t + d5 | t.tv;
+        char buf[16];
         sout | "yy/mm/dd" | [t, buf]`ymd | nonl;                        // shared buf => separate calls
         sout | "mm/dd/yy" | mm_dd_yy( t, buf ) | nonl;
 …
         sout | "dd/yy/mm" | [t, buf]`dmy;
         Time t2 = { 2001, 7, 4, 0, 0, 1, 0 }, t3 = (timeval){ 994_219_201 };
         sout | t2 | t2`ns | nl | t3 | t3`ns;
+        sout | t2 | t2.tv | nl | t3 | t3.tv;
         sout | nl;
 …
         sout | "Dividing that by 2 gives" | s / 2 | "seconds";
         sout | s | "seconds is" | s`h | "hours," | (s % 1`h)`m | "minutes," | (s % 1`m)`s | "seconds";
-    t1 = (Time){ 2020, 1, 5, 9, 0, 0, 100000000000LL };
-    t2 = (Time){ 1969, 13, 5, 9 };
-    t3 = (Time){ 1970, 25, 366, 48, 120, -120, 60000000000LL };
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t1 );
-    sout | buf;
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t2 );
-    sout | buf;
-    strftime( buf, 128, "%Y %b %e %H:%M:%S (GMT)", t3 );
-    sout | buf;
 } // main

tests/userLiterals.cfa

-              r3d5701e
+              r9fb8f01
 // 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: //

tools/Makefile.in

-              r3d5701e
+              r9fb8f01
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@

tools/catchsig.c

-              r3d5701e
+              r9fb8f01
         printf("Starting...\n");
         sig(SIGHUP);
         sig(SIGINT);
         sig(SIGQUIT);
         sig(SIGILL);
         sig(SIGABRT);
         sig(SIGFPE);
         sig(SIGSEGV);
         sig(SIGPIPE);
         sig(SIGALRM);
         sig(SIGTERM);
         sig(SIGUSR1);
         sig(SIGUSR2);
         sig(SIGCHLD);
         sig(SIGCONT);
         sig(SIGTSTP);
         sig(SIGTTIN);
         sig(SIGTTOU);
+      sig(SIGINT);
+      sig(SIGQUIT);
+      sig(SIGILL);
+      sig(SIGABRT);
+      sig(SIGFPE);
+      sig(SIGSEGV);
+      sig(SIGPIPE);
+      sig(SIGALRM);
+      sig(SIGTERM);
+      sig(SIGUSR1);
+      sig(SIGUSR2);
+      sig(SIGCHLD);
+      sig(SIGCONT);
+      sig(SIGTSTP);
+      sig(SIGTTIN);
+      sig(SIGTTOU);
         while(1);
         return 0;

tools/prettyprinter/Makefile.in

-              r3d5701e
+              r9fb8f01
 CCDEPMODE = @CCDEPMODE@
 CFACC = @CFACC@
-CFACC_INSTALL = @CFACC_INSTALL@
 CFACPP = @CFACPP@
 CFA_BACKEND_CC = @CFA_BACKEND_CC@
 …
 FGREP = @FGREP@
 GREP = @GREP@
-HAS_DISTCC = @HAS_DISTCC@
 HOST_FLAGS = @HOST_FLAGS@
 INSTALL = @INSTALL@

tools/stat.py

r3d5701e	r9fb8f01
17	17	avg = numpy.mean (content)
18	18	std = numpy.std (content)
19		print "median {0:.1f} avg {1:.1f} stddev {2:.1f}".format( med, avg, std )
	19	print "median {0:.1f} avg {1:.1f} stddev {2:.2f}".format( med, avg, std )
20	20
21	21

Context Navigation

Changes in / [3d5701e:9fb8f01]

Legend: